cc: Optimize picture layer tiling raster tile iterator.

This patch ensures that we only create tiling data iterators when
we visit the corresponding region.

Relevant perf data from a macbook:

Before:
tiling_raster_tile_iterator_construct:
0_0_100x100= 5828515 runs/s
50_0_100x100= 5530272 runs/s
100_0_100x100= 2730390 runs/s
150_0_100x100= 3735413.25 runs/s

tiling_raster_tile_iterator_construct_and_iterate:
32_100x100= 576050 runs/s
32_500x500= 601867.5625 runs/s
64_100x100= 353348.21875 runs/s
64_500x500= 362777.46875 runs/s

After:
tiling_raster_tile_iterator_construct:
0_0_100x100= 7913765 runs/s (+36%)
50_0_100x100= 7875735 runs/s (+42%)
100_0_100x100= 3382876.5 runs/s (+23%)
150_0_100x100= 5191805 runs/s (+39%)

tiling_raster_tile_iterator_construct_and_iterate:
32_100x100= 599836.6875 runs/s (+4%)
32_500x500= 629638.75 runs/s (+5%)
64_100x100= 357503.9375 runs/s (+<1%)
64_500x500= 372805.71875 runs/s (+3%)

R=reveman

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

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

cc/resources/picture_layer_tiling.cc

@@ -77,6 +77,10 @@ PictureLayerTiling::PictureLayerTiling(float contents_scale,
       client_(client),
       tiling_data_(gfx::Size(), gfx::Size(), true),
       last_impl_frame_time_in_seconds_(0.0),
+      has_visible_rect_tiles_(false),
+      has_skewport_rect_tiles_(false),
+      has_soon_border_rect_tiles_(false),
+      has_eventually_rect_tiles_(false),
       eviction_tiles_cache_valid_(false),
       eviction_cache_tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES) {
   gfx::Size content_bounds =
@@ -489,6 +493,7 @@ void PictureLayerTiling::UpdateTilePriorities(
 
   // Assign now priority to all visible tiles.
   bool include_borders = true;
+  has_visible_rect_tiles_ = false;
   for (TilingData::Iterator iter(
            &tiling_data_, visible_rect_in_content_space, include_borders);
        iter;
@@ -496,6 +501,7 @@ void PictureLayerTiling::UpdateTilePriorities(
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
+    has_visible_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     tile->SetPriority(tree, now_priority);
@@ -515,6 +521,7 @@ void PictureLayerTiling::UpdateTilePriorities(
   }
 
   // Assign soon priority to skewport tiles.
+  has_skewport_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, skewport, visible_rect_in_content_space);
        iter;
@@ -522,6 +529,7 @@ void PictureLayerTiling::UpdateTilePriorities(
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
+    has_skewport_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     gfx::Rect tile_bounds =
@@ -536,6 +544,7 @@ void PictureLayerTiling::UpdateTilePriorities(
   }
 
   // Assign eventually priority to interest rect tiles.
+  has_eventually_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, eventually_rect, skewport);
        iter;
@@ -543,6 +552,7 @@ void PictureLayerTiling::UpdateTilePriorities(
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
+    has_eventually_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     gfx::Rect tile_bounds =
@@ -560,6 +570,7 @@ void PictureLayerTiling::UpdateTilePriorities(
   gfx::Rect soon_border_rect = visible_rect_in_content_space;
   float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale;
   soon_border_rect.Inset(-border, -border, -border, -border);
+  has_soon_border_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, soon_border_rect, skewport);
        iter;
@@ -567,6 +578,7 @@ void PictureLayerTiling::UpdateTilePriorities(
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
+    has_soon_border_rect_tiles_ = true;
     Tile* tile = find->second.get();
 
     TilePriority priority(resolution_,
@@ -839,21 +851,15 @@ PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     PictureLayerTiling* tiling,
     WhichTree tree)
-    : tiling_(tiling),
-      phase_(VISIBLE_RECT),
-      visible_rect_in_content_space_(tiling_->current_visible_rect_),
-      skewport_in_content_space_(tiling_->current_skewport_rect_),
-      eventually_rect_in_content_space_(tiling_->current_eventually_rect_),
-      soon_border_rect_in_content_space_(tiling_->current_soon_border_rect_),
-      tree_(tree),
-      current_tile_(NULL),
-      visible_iterator_(&tiling->tiling_data_,
-                        visible_rect_in_content_space_,
-                        true /* include_borders */),
-      spiral_iterator_(&tiling->tiling_data_,
-                       skewport_in_content_space_,
-                       visible_rect_in_content_space_,
-                       visible_rect_in_content_space_) {
+    : tiling_(tiling), phase_(VISIBLE_RECT), tree_(tree), current_tile_(NULL) {
+  if (!tiling_->has_visible_rect_tiles_) {
+    AdvancePhase();
+    return;
+  }
+
+  visible_iterator_ = TilingData::Iterator(&tiling_->tiling_data_,
+                                           tiling_->current_visible_rect_,
+                                           true /* include_borders */);
   if (!visible_iterator_) {
     AdvancePhase();
     return;
@@ -872,19 +878,42 @@ void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
 
   do {
     phase_ = static_cast<Phase>(phase_ + 1);
+    switch (phase_) {
+      case VISIBLE_RECT:
+        NOTREACHED();
+        return;
+      case SKEWPORT_RECT:
+        if (!tiling_->has_skewport_rect_tiles_)
+          continue;
+
+        spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+            &tiling_->tiling_data_,
+            tiling_->current_skewport_rect_,
+            tiling_->current_visible_rect_,
+            tiling_->current_visible_rect_);
+        break;
+      case SOON_BORDER_RECT:
+        if (!tiling_->has_soon_border_rect_tiles_)
+          continue;
+
+        spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+            &tiling_->tiling_data_,
+            tiling_->current_soon_border_rect_,
+            tiling_->current_skewport_rect_,
+            tiling_->current_visible_rect_);
+        break;
+      case EVENTUALLY_RECT:
+        if (!tiling_->has_eventually_rect_tiles_) {
+          current_tile_ = NULL;
+          return;
+        }
 
-    if (phase_ == SOON_BORDER_RECT) {
-      spiral_iterator_ = TilingData::SpiralDifferenceIterator(
-          &tiling_->tiling_data_,
-          soon_border_rect_in_content_space_,
-          skewport_in_content_space_,
-          visible_rect_in_content_space_);
-    } else if (phase_ == EVENTUALLY_RECT) {
-      spiral_iterator_ = TilingData::SpiralDifferenceIterator(
-          &tiling_->tiling_data_,
-          eventually_rect_in_content_space_,
-          skewport_in_content_space_,
-          soon_border_rect_in_content_space_);
+        spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+            &tiling_->tiling_data_,
+            tiling_->current_eventually_rect_,
+            tiling_->current_skewport_rect_,
+            tiling_->current_soon_border_rect_);
+        break;
     }
 
     while (spiral_iterator_) {

cc/resources/picture_layer_tiling.h

@@ -73,16 +73,6 @@ class CC_EXPORT PictureLayerTiling {
 
     TilingRasterTileIterator& operator++();
 
-    gfx::Rect TileBounds() const {
-      DCHECK(*this);
-      if (phase_ == VISIBLE_RECT) {
-        return tiling_->tiling_data_.TileBounds(visible_iterator_.index_x(),
-                                                visible_iterator_.index_y());
-      }
-      return tiling_->tiling_data_.TileBounds(spiral_iterator_.index_x(),
-                                              spiral_iterator_.index_y());
-    }
-
    private:
     enum Phase {
       VISIBLE_RECT,
@@ -100,10 +90,6 @@ class CC_EXPORT PictureLayerTiling {
     PictureLayerTiling* tiling_;
 
     Phase phase_;
-    gfx::Rect visible_rect_in_content_space_;
-    gfx::Rect skewport_in_content_space_;
-    gfx::Rect eventually_rect_in_content_space_;
-    gfx::Rect soon_border_rect_in_content_space_;
     WhichTree tree_;
 
     Tile* current_tile_;
@@ -324,6 +310,11 @@ class CC_EXPORT PictureLayerTiling {
   gfx::Rect current_soon_border_rect_;
   gfx::Rect current_eventually_rect_;
 
+  bool has_visible_rect_tiles_;
+  bool has_skewport_rect_tiles_;
+  bool has_soon_border_rect_tiles_;
+  bool has_eventually_rect_tiles_;
+
   std::vector<Tile*> eviction_tiles_cache_;
   bool eviction_tiles_cache_valid_;
   TreePriority eviction_cache_tree_priority_;