cc: Change tile manager perftest to use layers.

Before this patch, the tile manager perftest would directly register
the tiles into tile manager in order to test. This provided accurate
numbers with regards to the number of tiles we had registered, but
it also coupled the knowledge that tile manager deals with tiles
directly.

This patch adds a bit of indirection to the perftest to create layers
that have tiles, and then call manage tiles. This decouples tile manager
from the perftest in the sense that the tile manager is free to choose
what it does with layers/tiles as the perftest better represents the
real world.

NOTE TO PERF SHERIFFS
---------------------

Please note that this changes TileManager perftest. In particular,
any changes in graphs to cc_perftests.manage_tiles should be
disregarded. This patch completely reworks the perftest, so
the results are not comparable to previous results.

Review URL: https://codereview.chromium.org/284553002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@270922 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 182 insertions, 182 deletions

diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 1c04d07..9868a4e 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -17,7 +17,6 @@
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/raster_worker_pool.h"
-#include "cc/resources/rasterizer_delegate.h"
 #include "cc/resources/tile.h"
 #include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -1616,4 +1615,11 @@ bool TileManager::EvictionTileIterator::EvictionOrderComparator::operator()(
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
+void TileManager::SetRasterizersForTesting(Rasterizer* rasterizer,
+                                           Rasterizer* gpu_rasterizer) {
+  Rasterizer* rasterizers[2] = {rasterizer, gpu_rasterizer};
+  rasterizer_delegate_ =
+      RasterizerDelegate::Create(this, rasterizers, arraysize(rasterizers));
+}
+
 }  // namespace cc
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index beca880..8008b33 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -22,6 +22,7 @@
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/prioritized_tile_set.h"
 #include "cc/resources/rasterizer.h"
+#include "cc/resources/rasterizer_delegate.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 
@@ -224,6 +225,11 @@ class CC_EXPORT TileManager : public RasterizerClient,
     }
   }
 
+  void SetRasterizersForTesting(Rasterizer* rasterizer,
+                                Rasterizer* gpu_rasterizer);
+
+  void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); }
+
  protected:
   TileManager(TileManagerClient* client,
               ResourcePool* resource_pool,
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 3f12461..7f427fb6 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -30,186 +30,61 @@ static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
-class TileManagerPerfTest : public testing::Test {
+class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
  public:
-  typedef std::vector<std::pair<scoped_refptr<Tile>, ManagedTileBin> >
-      TileBinVector;
-
-  TileManagerPerfTest()
-      : timer_(kWarmupRuns,
-               base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
-               kTimeCheckInterval) {}
-
-  // Overridden from testing::Test:
-  virtual void SetUp() OVERRIDE {
-    output_surface_ = FakeOutputSurface::Create3d();
-    CHECK(output_surface_->BindToClient(&output_surface_client_));
-
-    shared_bitmap_manager_.reset(new TestSharedBitmapManager());
-    resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1,
-        false);
-    resource_pool_ = ResourcePool::Create(
-        resource_provider_.get(), GL_TEXTURE_2D, RGBA_8888);
-    tile_manager_ = make_scoped_ptr(
-        new FakeTileManager(&tile_manager_client_, resource_pool_.get()));
-    picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
-  }
-
-  GlobalStateThatImpactsTilePriority GlobalStateForTest() {
-    GlobalStateThatImpactsTilePriority state;
-    gfx::Size tile_size = settings_.default_tile_size;
-    state.soft_memory_limit_in_bytes =
-        10000u * 4u *
-        static_cast<size_t>(tile_size.width() * tile_size.height());
-    state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes;
-    state.num_resources_limit = 10000;
-    state.memory_limit_policy = ALLOW_ANYTHING;
-    state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
-    return state;
-  }
-
-  virtual void TearDown() OVERRIDE {
-    tile_manager_.reset(NULL);
-    picture_pile_ = NULL;
-  }
-
-  TilePriority GetTilePriorityFromBin(ManagedTileBin bin) {
-    switch (bin) {
-      case NOW_AND_READY_TO_DRAW_BIN:
-      case NOW_BIN:
-        return TilePriorityForNowBin();
-      case SOON_BIN:
-        return TilePriorityForSoonBin();
-      case EVENTUALLY_AND_ACTIVE_BIN:
-      case EVENTUALLY_BIN:
-        return TilePriorityForEventualBin();
-      case AT_LAST_BIN:
-      case AT_LAST_AND_ACTIVE_BIN:
-      case NEVER_BIN:
-        return TilePriority();
-      default:
-        NOTREACHED();
-        return TilePriority();
+  // Overridden from Rasterizer:
+  virtual void SetClient(RasterizerClient* client) OVERRIDE {}
+  virtual void Shutdown() OVERRIDE {}
+  virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE {
+    for (RasterTaskQueue::Item::Vector::const_iterator it =
+             queue->items.begin();
+         it != queue->items.end();
+         ++it) {
+      RasterTask* task = it->task;
+
+      task->WillSchedule();
+      task->ScheduleOnOriginThread(this);
+      task->DidSchedule();
+
+      completed_tasks_.push_back(task);
     }
   }
+  virtual void CheckForCompletedTasks() OVERRIDE {
+    for (RasterTask::Vector::iterator it = completed_tasks_.begin();
+         it != completed_tasks_.end();
+         ++it) {
+      RasterTask* task = it->get();
 
-  ManagedTileBin GetNextBin(ManagedTileBin bin) {
-    switch (bin) {
-      case NOW_AND_READY_TO_DRAW_BIN:
-      case NOW_BIN:
-        return SOON_BIN;
-      case SOON_BIN:
-        return EVENTUALLY_BIN;
-      case EVENTUALLY_AND_ACTIVE_BIN:
-      case EVENTUALLY_BIN:
-        return NEVER_BIN;
-      case AT_LAST_BIN:
-      case AT_LAST_AND_ACTIVE_BIN:
-      case NEVER_BIN:
-        return NOW_BIN;
-      default:
-        NOTREACHED();
-        return NEVER_BIN;
-    }
-  }
+      task->WillComplete();
+      task->CompleteOnOriginThread(this);
+      task->DidComplete();
 
-  void CreateBinTiles(int count, ManagedTileBin bin, TileBinVector* tiles) {
-    for (int i = 0; i < count; ++i) {
-      scoped_refptr<Tile> tile =
-          tile_manager_->CreateTile(picture_pile_.get(),
-                                    settings_.default_tile_size,
-                                    gfx::Rect(),
-                                    gfx::Rect(),
-                                    1.0,
-                                    0,
-                                    0,
-                                    Tile::USE_LCD_TEXT);
-      tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
-      tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));
-      tiles->push_back(std::make_pair(tile, bin));
+      task->RunReplyOnOriginThread();
     }
+    completed_tasks_.clear();
   }
 
-  void CreateTiles(int count, TileBinVector* tiles) {
-    // Roughly an equal amount of all bins.
-    int count_per_bin = count / NUM_BINS;
-    CreateBinTiles(count_per_bin, NOW_BIN, tiles);
-    CreateBinTiles(count_per_bin, SOON_BIN, tiles);
-    CreateBinTiles(count_per_bin, EVENTUALLY_BIN, tiles);
-    CreateBinTiles(count - 3 * count_per_bin, NEVER_BIN, tiles);
-  }
-
-  void RunManageTilesTest(const std::string& test_name,
-                          unsigned tile_count,
-                          int priority_change_percent) {
-    DCHECK_GE(tile_count, 100u);
-    DCHECK_GE(priority_change_percent, 0);
-    DCHECK_LE(priority_change_percent, 100);
-    TileBinVector tiles;
-    CreateTiles(tile_count, &tiles);
-    timer_.Reset();
-    do {
-      if (priority_change_percent > 0) {
-        for (unsigned i = 0; i < tile_count;
-             i += 100 / priority_change_percent) {
-          Tile* tile = tiles[i].first.get();
-          ManagedTileBin bin = GetNextBin(tiles[i].second);
-          tile->SetPriority(ACTIVE_TREE, GetTilePriorityFromBin(bin));
-          tile->SetPriority(PENDING_TREE, GetTilePriorityFromBin(bin));
-          tiles[i].second = bin;
-        }
-      }
-
-      GlobalStateThatImpactsTilePriority global_state(GlobalStateForTest());
-      resource_pool_->SetResourceUsageLimits(
-          global_state.soft_memory_limit_in_bytes,
-          0,
-          global_state.num_resources_limit);
-      tile_manager_->ManageTiles(global_state);
-      tile_manager_->UpdateVisibleTiles();
-      timer_.NextLap();
-    } while (!timer_.HasTimeLimitExpired());
-
-    perf_test::PrintResult(
-        "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
+  // Overridden from RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) OVERRIDE {
+    return NULL;
   }
+  virtual void ReleaseCanvasForRaster(RasterTask* task) OVERRIDE {}
 
  private:
-  FakeTileManagerClient tile_manager_client_;
-  LayerTreeSettings settings_;
-  scoped_ptr<FakeTileManager> tile_manager_;
-  scoped_refptr<FakePicturePileImpl> picture_pile_;
-  FakeOutputSurfaceClient output_surface_client_;
-  scoped_ptr<FakeOutputSurface> output_surface_;
-  scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
-  scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<ResourcePool> resource_pool_;
-  LapTimer timer_;
+  RasterTask::Vector completed_tasks_;
 };
+base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
+    LAZY_INSTANCE_INITIALIZER;
 
-TEST_F(TileManagerPerfTest, ManageTiles) {
-  RunManageTilesTest("100_0", 100, 0);
-  RunManageTilesTest("1000_0", 1000, 0);
-  RunManageTilesTest("10000_0", 10000, 0);
-  RunManageTilesTest("100_10", 100, 10);
-  RunManageTilesTest("1000_10", 1000, 10);
-  RunManageTilesTest("10000_10", 10000, 10);
-  RunManageTilesTest("100_100", 100, 100);
-  RunManageTilesTest("1000_100", 1000, 100);
-  RunManageTilesTest("10000_100", 10000, 100);
-}
-
-class TileManagerTileIteratorPerfTest : public testing::Test,
-                                        public TileManagerClient {
+class TileManagerPerfTest : public testing::Test, public TileManagerClient {
  public:
-  TileManagerTileIteratorPerfTest()
+  TileManagerPerfTest()
       : memory_limit_policy_(ALLOW_ANYTHING),
         max_tiles_(10000),
         ready_to_activate_(false),
         id_(7),
         proxy_(base::MessageLoopProxy::current()),
-        host_impl_(ImplSidePaintingSettings(),
+        host_impl_(ImplSidePaintingSettings(10000),
                    &proxy_,
                    &shared_bitmap_manager_),
         timer_(kWarmupRuns,
@@ -233,6 +108,7 @@ class TileManagerTileIteratorPerfTest : public testing::Test,
   }
 
   virtual void SetUp() OVERRIDE {
+    picture_pile_ = FakePicturePileImpl::CreateInfiniteFilledPile();
     InitializeRenderer();
     SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES);
   }
@@ -240,6 +116,8 @@ class TileManagerTileIteratorPerfTest : public testing::Test,
   virtual void InitializeRenderer() {
     host_impl_.InitializeRenderer(
         FakeOutputSurface::Create3d().PassAs<OutputSurface>());
+    tile_manager()->SetRasterizersForTesting(g_fake_rasterizer.Pointer(),
+                                             g_fake_rasterizer.Pointer());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
@@ -256,16 +134,16 @@ class TileManagerTileIteratorPerfTest : public testing::Test,
   void ActivateTree() {
     host_impl_.ActivatePendingTree();
     CHECK(!host_impl_.pending_tree());
-    pending_layer_ = NULL;
-    active_layer_ = static_cast<FakePictureLayerImpl*>(
+    pending_root_layer_ = NULL;
+    active_root_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.active_tree()->LayerById(id_));
   }
 
   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
                                           const gfx::Size& tile_size) {
     SetupDefaultTrees(layer_bounds);
-    pending_layer_->set_fixed_tile_size(tile_size);
-    active_layer_->set_fixed_tile_size(tile_size);
+    pending_root_layer_->set_fixed_tile_size(tile_size);
+    active_root_layer_->set_fixed_tile_size(tile_size);
   }
 
   void SetupTrees(scoped_refptr<PicturePileImpl> pending_pile,
@@ -286,20 +164,21 @@ class TileManagerTileIteratorPerfTest : public testing::Test,
     pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
-    pending_layer_ = static_cast<FakePictureLayerImpl*>(
+    pending_root_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
-    pending_layer_->DoPostCommitInitializationIfNeeded();
+    pending_root_layer_->DoPostCommitInitializationIfNeeded();
   }
 
   void CreateHighLowResAndSetAllTilesVisible() {
     // Active layer must get updated first so pending layer can share from it.
-    active_layer_->CreateDefaultTilingsAndTiles();
-    active_layer_->SetAllTilesVisible();
-    pending_layer_->CreateDefaultTilingsAndTiles();
-    pending_layer_->SetAllTilesVisible();
+    active_root_layer_->CreateDefaultTilingsAndTiles();
+    active_root_layer_->SetAllTilesVisible();
+    pending_root_layer_->CreateDefaultTilingsAndTiles();
+    pending_root_layer_->SetAllTilesVisible();
   }
 
-  void RunTest(const std::string& test_name, int tile_count) {
+  void RunRasterIteratorTest(const std::string& test_name,
+                             unsigned tile_count) {
     timer_.Reset();
     do {
       int count = tile_count;
@@ -321,6 +200,98 @@ class TileManagerTileIteratorPerfTest : public testing::Test,
                            true);
   }
 
+  std::vector<LayerImpl*> CreateLayers(int layer_count,
+                                       int tiles_per_layer_count) {
+    // Compute the width/height required for high res to get
+    // tiles_per_layer_count tiles.
+    float width = std::sqrt(static_cast<float>(tiles_per_layer_count));
+    float height = tiles_per_layer_count / width;
+
+    // Adjust the width and height to account for the fact that tiles
+    // are bigger than 1x1. Also, account for the fact that that we
+    // will be creating one high res and one low res tiling. That is,
+    // width and height should be smaller by sqrt(1 + low_res_scale).
+    // This gives us _approximately_ correct counts.
+    width *= settings_.default_tile_size.width() /
+             std::sqrt(1 + settings_.low_res_contents_scale_factor);
+    height *= settings_.default_tile_size.height() /
+              std::sqrt(1 + settings_.low_res_contents_scale_factor);
+
+    // Ensure that we start with blank trees and no tiles.
+    host_impl_.ResetTreesForTesting();
+    tile_manager()->CleanUpReleasedTilesForTesting();
+
+    gfx::Size layer_bounds(width, height);
+    gfx::Size viewport(width / 5, height / 5);
+    host_impl_.SetViewportSize(viewport);
+    SetupDefaultTreesWithFixedTileSize(layer_bounds,
+                                       settings_.default_tile_size);
+
+    active_root_layer_->CreateDefaultTilingsAndTiles();
+    pending_root_layer_->CreateDefaultTilingsAndTiles();
+
+    std::vector<LayerImpl*> layers;
+
+    // Pending layer counts as one layer.
+    layers.push_back(pending_root_layer_);
+    int next_id = id_ + 1;
+
+    // Create the rest of the layers as children of the root layer.
+    while (static_cast<int>(layers.size()) < layer_count) {
+      scoped_ptr<FakePictureLayerImpl> layer =
+          FakePictureLayerImpl::CreateWithPile(
+              host_impl_.pending_tree(), next_id, picture_pile_);
+      layer->SetBounds(layer_bounds);
+      layers.push_back(layer.get());
+      pending_root_layer_->AddChild(layer.PassAs<LayerImpl>());
+
+      FakePictureLayerImpl* fake_layer =
+          static_cast<FakePictureLayerImpl*>(layers.back());
+
+      fake_layer->SetDrawsContent(true);
+      fake_layer->DoPostCommitInitializationIfNeeded();
+      fake_layer->CreateDefaultTilingsAndTiles();
+      ++next_id;
+    }
+
+    return layers;
+  }
+
+  GlobalStateThatImpactsTilePriority GlobalStateForTest() {
+    GlobalStateThatImpactsTilePriority state;
+    gfx::Size tile_size = settings_.default_tile_size;
+    state.soft_memory_limit_in_bytes =
+        10000u * 4u *
+        static_cast<size_t>(tile_size.width() * tile_size.height());
+    state.hard_memory_limit_in_bytes = state.soft_memory_limit_in_bytes;
+    state.num_resources_limit = 10000;
+    state.memory_limit_policy = ALLOW_ANYTHING;
+    state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
+    return state;
+  }
+
+  void RunManageTilesTest(const std::string& test_name,
+                          int layer_count,
+                          int approximate_tile_count_per_layer) {
+    std::vector<LayerImpl*> layers =
+        CreateLayers(layer_count, approximate_tile_count_per_layer);
+    timer_.Reset();
+    do {
+      host_impl_.UpdateCurrentFrameTime();
+      for (unsigned i = 0; i < layers.size(); ++i)
+        layers[i]->UpdateTilePriorities();
+
+      GlobalStateThatImpactsTilePriority global_state(GlobalStateForTest());
+      tile_manager()->ManageTiles(global_state);
+      tile_manager()->UpdateVisibleTiles();
+      timer_.NextLap();
+      host_impl_.ResetCurrentFrameTimeForNextFrame();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult(
+        "manage_tiles", "", test_name, timer_.LapsPerSecond(), "runs/s", true);
+  }
+
   // TileManagerClient implementation.
   virtual void NotifyReadyToActivate() OVERRIDE { ready_to_activate_ = true; }
   virtual void NotifyTileInitialized(const Tile* tile) OVERRIDE {}
@@ -337,20 +308,37 @@ class TileManagerTileIteratorPerfTest : public testing::Test,
   int id_;
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
-  FakePictureLayerImpl* pending_layer_;
-  FakePictureLayerImpl* active_layer_;
+  FakePictureLayerImpl* pending_root_layer_;
+  FakePictureLayerImpl* active_root_layer_;
   LapTimer timer_;
+  scoped_refptr<FakePicturePileImpl> picture_pile_;
+  LayerTreeSettings settings_;
 };
 
-TEST_F(TileManagerTileIteratorPerfTest, RasterTileIterator) {
+TEST_F(TileManagerPerfTest, ManageTiles) {
+  RunManageTilesTest("1_100", 1, 100);
+  RunManageTilesTest("1_500", 1, 500);
+  RunManageTilesTest("1_1000", 1, 1000);
+  RunManageTilesTest("5_100", 5, 100);
+  RunManageTilesTest("5_500", 5, 500);
+  RunManageTilesTest("5_1000", 5, 1000);
+  RunManageTilesTest("10_100", 10, 100);
+  RunManageTilesTest("10_500", 10, 500);
+  RunManageTilesTest("10_1000", 10, 1000);
+  RunManageTilesTest("100_100", 100, 100);
+  RunManageTilesTest("100_500", 100, 500);
+  RunManageTilesTest("100_1000", 100, 1000);
+}
+
+TEST_F(TileManagerPerfTest, RasterTileIterator) {
   SetupDefaultTrees(gfx::Size(10000, 10000));
-  active_layer_->CreateDefaultTilingsAndTiles();
-  pending_layer_->CreateDefaultTilingsAndTiles();
+  active_root_layer_->CreateDefaultTilingsAndTiles();
+  pending_root_layer_->CreateDefaultTilingsAndTiles();
 
-  RunTest("2_16", 16);
-  RunTest("2_32", 32);
-  RunTest("2_64", 64);
-  RunTest("2_128", 128);
+  RunRasterIteratorTest("2_16", 16);
+  RunRasterIteratorTest("2_32", 32);
+  RunRasterIteratorTest("2_64", 64);
+  RunRasterIteratorTest("2_128", 128);
 }
 
 }  // namespace