cc: Add tiling eviction iterator perftests.

cc/resources/picture_layer_tiling_perftest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/debug/lap_timer.h"
 #include "cc/resources/picture_layer_tiling.h"
+#include "cc/resources/resource_provider.h"
+#include "cc/resources/scoped_resource.h"
+#include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_output_surface_client.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
+#include "cc/test/test_context_provider.h"
+#include "cc/test/test_shared_bitmap_manager.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 
 namespace cc {
 
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
 class PictureLayerTilingPerfTest : public testing::Test {
  public:
   PictureLayerTilingPerfTest()
       : timer_(kWarmupRuns,
                base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
-               kTimeCheckInterval) {}
+               kTimeCheckInterval),
+        context_provider_(TestContextProvider::Create()) {
+    output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+    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).Pass();
+  }
 
   virtual void SetUp() OVERRIDE {
     picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
     picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
     picture_layer_tiling_ = PictureLayerTiling::Create(
         1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
     picture_layer_tiling_->CreateAllTilesForTesting();
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 122 matching lines @@
     } while (!timer_.HasTimeLimitExpired());
 
     perf_test::PrintResult("tiling_raster_tile_iterator_construct_and_iterate",
                            "",
                            test_name,
                            timer_.LapsPerSecond(),
                            "runs/s",
                            true);
   }
 
+  void RunEvictionIteratorConstructTest(const std::string& test_name,
+                                        const gfx::Rect& viewport) {
+    gfx::Size bounds(viewport.size());
+    picture_layer_tiling_ =
+        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_->UpdateTilePriorities(
+        ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
+
+    timer_.Reset();
+    TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
+                                 SMOOTHNESS_TAKES_PRIORITY,
+                                 NEW_CONTENT_TAKES_PRIORITY};
+    int priority_count = 0;
+    do {
+      PictureLayerTiling::TilingEvictionTileIterator it(
+          picture_layer_tiling_.get(), priorities[priority_count]);
+      priority_count = (priority_count + 1) % arraysize(priorities);
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult("tiling_eviction_tile_iterator_construct",
+                           "",
+                           test_name,
+                           timer_.LapsPerSecond(),
+                           "runs/s",
+                           true);
+  }
+
+  void RunEvictionIteratorConstructAndIterateTest(const std::string& test_name,
+                                                  int num_tiles,
+                                                  const gfx::Rect& viewport) {
+    gfx::Size bounds(10000, 10000);
+    picture_layer_tiling_ =
+        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_->UpdateTilePriorities(
+        ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
+
+    TreePriority priorities[] = {SAME_PRIORITY_FOR_BOTH_TREES,
+                                 SMOOTHNESS_TAKES_PRIORITY,
+                                 NEW_CONTENT_TAKES_PRIORITY};
+
+    // Ensure all tiles have resources.
+    std::vector<Tile*> all_tiles = picture_layer_tiling_->AllTilesForTesting();
+    for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
+         tile_it != all_tiles.end();
+         ++tile_it) {
+      Tile* tile = *tile_it;
+      ManagedTileState::TileVersion& tile_version =
+          tile->GetTileVersionForTesting(tile->GetRasterModeForTesting());
+      tile_version.SetResourceForTesting(
+          ScopedResource::Create(resource_provider_.get()).Pass());
+    }
+
+    int priority_count = 0;
+    timer_.Reset();
+    do {
+      int count = num_tiles;
+      PictureLayerTiling::TilingEvictionTileIterator it(
+          picture_layer_tiling_.get(), priorities[priority_count]);
+      while (count--) {
+        ASSERT_TRUE(it) << "count: " << count;
+        ASSERT_TRUE(*it != NULL) << "count: " << count;
+        ++it;
+      }
+      priority_count = (priority_count + 1) % arraysize(priorities);
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    // Remove all resources from tiles to make sure the tile version destructor
+    // doesn't complain.
+    for (std::vector<Tile*>::iterator tile_it = all_tiles.begin();
+         tile_it != all_tiles.end();
+         ++tile_it) {
+      Tile* tile = *tile_it;
+      ManagedTileState::TileVersion& tile_version =
+          tile->GetTileVersionForTesting(tile->GetRasterModeForTesting());
+      tile_version.SetResourceForTesting(scoped_ptr<ScopedResource>());
+    }
+
+    perf_test::PrintResult(
+        "tiling_eviction_tile_iterator_construct_and_iterate",
+        "",
+        test_name,
+        timer_.LapsPerSecond(),
+        "runs/s",
+        true);
+  }
+
  private:
   FakePictureLayerTilingClient picture_layer_tiling_client_;
   scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
 
   LapTimer timer_;
+
+  scoped_refptr<ContextProvider> context_provider_;
+  FakeOutputSurfaceClient output_surface_client_;
+  scoped_ptr<FakeOutputSurface> output_surface_;
+  scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
+  scoped_ptr<ResourceProvider> resource_provider_;
 };
 
 TEST_F(PictureLayerTilingPerfTest, Invalidate) {
   Region one_tile(gfx::Rect(256, 256));
   RunInvalidateTest("1x1", one_tile);
 
   Region half_region(gfx::Rect(25 * 256, 50 * 256));
   RunInvalidateTest("25x50", half_region);
 
   Region full_region(gfx::Rect(50 * 256, 50 * 256));
@@ skipping 32 matching lines @@
   RunRasterIteratorConstructAndIterateTest(
       "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
   RunRasterIteratorConstructAndIterateTest(
       "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
   RunRasterIteratorConstructAndIterateTest(
       "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
   RunRasterIteratorConstructAndIterateTest(
       "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
 }
 
+TEST_F(PictureLayerTilingPerfTest, TilingEvictionTileIteratorConstruct) {
+  RunEvictionIteratorConstructTest("0_0_100x100", gfx::Rect(0, 0, 100, 100));
+  RunEvictionIteratorConstructTest("50_0_100x100", gfx::Rect(50, 0, 100, 100));
+  RunEvictionIteratorConstructTest("100_0_100x100",
+                                   gfx::Rect(100, 0, 100, 100));
+  RunEvictionIteratorConstructTest("150_0_100x100",
+                                   gfx::Rect(150, 0, 100, 100));
+}
+
+TEST_F(PictureLayerTilingPerfTest,
+       TilingEvictionTileIteratorConstructAndIterate) {
+  RunEvictionIteratorConstructAndIterateTest(
+      "32_100x100", 32, gfx::Rect(0, 0, 100, 100));
+  RunEvictionIteratorConstructAndIterateTest(
+      "32_500x500", 32, gfx::Rect(0, 0, 500, 500));
+  RunEvictionIteratorConstructAndIterateTest(
+      "64_100x100", 64, gfx::Rect(0, 0, 100, 100));
+  RunEvictionIteratorConstructAndIterateTest(
+      "64_500x500", 64, gfx::Rect(0, 0, 500, 500));
+}
+
 }  // namespace
 
 }  // namespace cc