cc: Add tiling raster tile iterators.

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/resources/picture_layer_tiling.h"
 #include "cc/test/fake_picture_layer_tiling_client.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
 
@@ skipping 49 matching lines @@
 
     perf_test::PrintResult("invalidation", "", test_name,
                            num_runs_ / elapsed_.InSecondsF(), "runs/s", true);
   }
 
   void RunUpdateTilePrioritiesStationaryTest(const std::string& test_name,
                                              const gfx::Transform& transform) {
     start_time_ = base::TimeTicks();
     num_runs_ = 0;
 
-    gfx::Size layer_bounds(50 * 256, 50 * 256);
     gfx::Rect viewport_rect(0, 0, 1024, 768);
     do {
       picture_layer_tiling_->UpdateTilePriorities(
           ACTIVE_TREE, viewport_rect, 1.f, num_runs_ + 1);
     } while (DidRun());
 
     perf_test::PrintResult("update_tile_priorities_stationary",
                            "",
                            test_name,
                            num_runs_ / elapsed_.InSecondsF(),
                            "runs/s",
                            true);
   }
 
   void RunUpdateTilePrioritiesScrollingTest(const std::string& test_name,
                                             const gfx::Transform& transform) {
     start_time_ = base::TimeTicks();
     num_runs_ = 0;
 
-    gfx::Size layer_bounds(50 * 256, 50 * 256);
     gfx::Size viewport_size(1024, 768);
     gfx::Rect viewport_rect(viewport_size);
     int xoffsets[] = {10, 0, -10, 0};
     int yoffsets[] = {0, 10, 0, -10};
     int offsetIndex = 0;
     int offsetCount = 0;
     const int maxOffsetCount = 1000;
     do {
       picture_layer_tiling_->UpdateTilePriorities(
           ACTIVE_TREE, viewport_rect, 1.f, num_runs_ + 1);
@@ skipping 10 matching lines @@
     } while (DidRun());
 
     perf_test::PrintResult("update_tile_priorities_scrolling",
                            "",
                            test_name,
                            num_runs_ / elapsed_.InSecondsF(),
                            "runs/s",
                            true);
   }
 
+  void RunTilingRasterTileIteratorTest(const std::string& test_name,
+                                       const gfx::Size& bounds,
+                                       const gfx::Rect& first_viewport,
+                                       const gfx::Rect& second_viewport) {
+    start_time_ = base::TimeTicks();
+    num_runs_ = 0;
+
+    picture_layer_tiling_ =
+        PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    gfx::Rect viewports[2] = {first_viewport, second_viewport};
+
+    do {
+      picture_layer_tiling_->UpdateTilePriorities(
+          ACTIVE_TREE, viewports[num_runs_ % 2], 1.f, num_runs_ + 1);
+      for (PictureLayerTiling::TilingRasterTileIterator it(
+               picture_layer_tiling_.get());
+           it;
+           ++it)
+        continue;
+    } while (DidRun());
+
+    perf_test::PrintResult("tiling_raster_tile_iterator",
+                           "",
+                           test_name,
+                           num_runs_ / elapsed_.InSecondsF(),
+                           "runs/s",
+                           true);
+  }
+
  private:
   FakePictureLayerTilingClient picture_layer_tiling_client_;
   scoped_ptr<PictureLayerTiling> picture_layer_tiling_;
 
   base::TimeTicks start_time_;
   base::TimeDelta elapsed_;
   int num_runs_;
 };
 
 TEST_F(PictureLayerTilingPerfTest, Invalidate) {
@@ skipping 20 matching lines @@
 
   transform.Rotate(10);
   RunUpdateTilePrioritiesStationaryTest("rotation", transform);
   RunUpdateTilePrioritiesScrollingTest("rotation", transform);
 
   transform.ApplyPerspectiveDepth(10);
   RunUpdateTilePrioritiesStationaryTest("perspective", transform);
   RunUpdateTilePrioritiesScrollingTest("perspective", transform);
 }
 
+TEST_F(PictureLayerTilingPerfTest, TilingRasterTileIterator) {
+  RunTilingRasterTileIteratorTest("1k_bounds_100_vp_stationary",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 0, 100, 100));
+  RunTilingRasterTileIteratorTest("1k_bounds_100_vp_moving",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 100, 100, 100));
+  RunTilingRasterTileIteratorTest("1k_bounds_500_vp_stationary",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 0, 500, 500));
+  RunTilingRasterTileIteratorTest("1k_bounds_500_vp_moving",
+                                  gfx::Size(1000, 1000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 100, 500, 500));
+  RunTilingRasterTileIteratorTest("2k_bounds_100_vp_stationary",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 0, 100, 100));
+  RunTilingRasterTileIteratorTest("2k_bounds_100_vp_moving",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 100, 100),
+                                  gfx::Rect(0, 100, 100, 100));
+  RunTilingRasterTileIteratorTest("2k_bounds_500_vp_stationary",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 0, 500, 500));
+  RunTilingRasterTileIteratorTest("2k_bounds_500_vp_moving",
+                                  gfx::Size(2000, 2000),
+                                  gfx::Rect(0, 0, 500, 500),
+                                  gfx::Rect(0, 100, 500, 500));
+}
+
 }  // namespace
 
 }  // namespace cc