cc: Optimize picture layer tiling raster tile iterator.

cc/resources/picture_layer_tiling.cc

 // Copyright 2012 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 <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 59 matching lines @@
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale,
                                        const gfx::Size& layer_bounds,
                                        PictureLayerTilingClient* client)
     : contents_scale_(contents_scale),
       layer_bounds_(layer_bounds),
       resolution_(NON_IDEAL_RESOLUTION),
       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 =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   DCHECK(!gfx::ToFlooredSize(
       gfx::ScaleSize(layer_bounds, contents_scale)).IsEmpty()) <<
       "Tiling created with scale too small as contents become empty." <<
       " Layer bounds: " << layer_bounds.ToString() <<
@@ skipping 392 matching lines @@
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
   eviction_tiles_cache_valid_ = false;
 
   TilePriority now_priority(resolution_, TilePriority::NOW, 0);
   float content_to_screen_scale =
       1.0f / (contents_scale_ * ideal_contents_scale);
 
   // 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;
        ++iter) {
     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);
 
     // Set whether tile is occluded or not.
     bool is_occluded = false;
     if (occlusion_tracker) {
       gfx::Rect tile_query_rect = ScaleToEnclosingRect(
           IntersectRects(tile->content_rect(), visible_rect_in_content_space),
           1.0f / contents_scale_);
       // TODO(vmpstr): Remove render_target and draw_transform from the
       // parameters so they can be hidden from the tiling.
       is_occluded = occlusion_tracker->Occluded(
           render_target, tile_query_rect, draw_transform);
     }
     tile->set_is_occluded(tree, is_occluded);
   }
 
   // Assign soon priority to skewport tiles.
+  has_skewport_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, skewport, visible_rect_in_content_space);
        iter;
        ++iter) {
     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 =
         tiling_data_.TileBounds(iter.index_x(), iter.index_y());
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
 
     TilePriority priority(resolution_, TilePriority::SOON, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
   // Assign eventually priority to interest rect tiles.
+  has_eventually_rect_tiles_ = false;
   for (TilingData::DifferenceIterator iter(
            &tiling_data_, eventually_rect, skewport);
        iter;
        ++iter) {
     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 =
         tiling_data_.TileBounds(iter.index_x(), iter.index_y());
 
     float distance_to_visible =
         visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
         content_to_screen_scale;
     TilePriority priority(
         resolution_, TilePriority::EVENTUALLY, distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
   // Upgrade the priority on border tiles to be SOON.
   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;
        ++iter) {
     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_,
                           TilePriority::SOON,
                           tile->priority(tree).distance_to_visible);
     tile->SetPriority(tree, priority);
   }
 
   // Update iteration rects.
   current_visible_rect_ = visible_rect_in_content_space;
@@ skipping 254 matching lines @@
 }
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
     : tiling_(NULL), current_tile_(NULL) {}
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     PictureLayerTiling* tiling,
     WhichTree tree)
     : tiling_(tiling),
       type_(TilePriority::NOW),
-      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_),
       skewport_processed_(false) {
+  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;
   }
 
   current_tile_ =
       tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
   if (!current_tile_ || !TileNeedsRaster(current_tile_))
     ++(*this);
 }
 
 PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
 
 void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
   DCHECK_LT(type_, TilePriority::EVENTUALLY);
 
   do {
     if (type_ == TilePriority::SOON && !skewport_processed_)
       skewport_processed_ = true;
     else
       type_ = static_cast<TilePriority::PriorityBin>(type_ + 1);
 
-    if (type_ == TilePriority::SOON && skewport_processed_) {
+    if (type_ == TilePriority::SOON && !skewport_processed_) {
+      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_);
+    } else if (type_ == TilePriority::SOON && skewport_processed_) {
+      if (!tiling_->has_soon_border_rect_tiles_)
+        continue;
+
       spiral_iterator_ = TilingData::SpiralDifferenceIterator(
           &tiling_->tiling_data_,
-          soon_border_rect_in_content_space_,
-          skewport_in_content_space_,
-          visible_rect_in_content_space_);
+          tiling_->current_soon_border_rect_,
+          tiling_->current_skewport_rect_,
+          tiling_->current_visible_rect_);
     } else if (type_ == TilePriority::EVENTUALLY) {
+      if (!tiling_->has_eventually_rect_tiles_) {
+        current_tile_ = NULL;
+        return;
+      }
+
       spiral_iterator_ = TilingData::SpiralDifferenceIterator(
           &tiling_->tiling_data_,
-          eventually_rect_in_content_space_,
-          skewport_in_content_space_,
-          soon_border_rect_in_content_space_);
+          tiling_->current_eventually_rect_,
+          tiling_->current_skewport_rect_,
+          tiling_->current_soon_border_rect_);
     }

[reveman, 2014/07/24 13:09:23]

This actually made the code a bit easier for me to understand but I think it
could be made a bit cleaner. Would it make sense to add an enum for the phases
that this iterator goes through? So you could just "phase + 1" to advance and
use a switch case instead of all these elseifs. The enum names might be enough
to describe what is happening here and the comments I asked for in the other
patch might not even be needed.

 
     while (spiral_iterator_) {
       current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(),
                                       spiral_iterator_.index_y());
       if (current_tile_ && TileNeedsRaster(current_tile_))
         break;
       ++spiral_iterator_;
     }
 
     if (!spiral_iterator_ && type_ == TilePriority::EVENTUALLY) {
@@ skipping 78 matching lines @@
   DCHECK(*this);
   do {
     ++tile_iterator_;
   } while (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
            (!(*tile_iterator_)->HasResources()));
 
   return *this;
 }
 
 }  // namespace cc