cc: Change tile manager perftest to use layers.

cc/resources/tile_manager_perftest.cc

Index: cc/resources/tile_manager_perftest.cc
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index 3f12461640300668a2470a8bd5c4a040e8b88772..7f427fb6a835b7d56f043c21dfa0b92a65ece9dd 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