cc: Pass priority rect information from iterators to tilings.

As each tiling iterator in raster and eviction queues iterates one
priority rect, those iterators know the priority rect for tiles. Thus
picture layer tilings compute priority rects only because iterators do
not pass that information to tilings. Therefore, unnecessary priority
rect computation can be avoided by passing priority rect information
from iterators to tilings.

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

Cr-Commit-Position: refs/heads/master@{#330061}

cc/resources/picture_layer_tiling.cc

@@ -806,7 +806,9 @@ void PictureLayerTiling::UpdateRequiredStatesOnTile(Tile* tile) const {
   tile->set_required_for_draw(IsTileRequiredForDraw(tile));
 }
 
-PrioritizedTile PictureLayerTiling::MakePrioritizedTile(Tile* tile) const {
+PrioritizedTile PictureLayerTiling::MakePrioritizedTile(
+    Tile* tile,
+    PriorityRectType priority_rect_type) const {
   DCHECK(tile);
   DCHECK(
       raster_source()->CoversRect(tile->content_rect(), tile->contents_scale()))
@@ -814,7 +816,8 @@ PrioritizedTile PictureLayerTiling::MakePrioritizedTile(Tile* tile) const {
       << gfx::ScaleToEnclosingRect(tile->content_rect(),
                                    1.f / tile->contents_scale()).ToString();
 
-  return PrioritizedTile(tile, raster_source(), ComputePriorityForTile(tile),
+  return PrioritizedTile(tile, raster_source(),
+                         ComputePriorityForTile(tile, priority_rect_type),
                          IsTileOccluded(tile));
 }
 
@@ -822,53 +825,83 @@ std::map<const Tile*, PrioritizedTile>
 PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
-    UpdateRequiredStatesOnTile(key_tile_pair.second);
+    Tile* tile = key_tile_pair.second;
+    UpdateRequiredStatesOnTile(tile);
     PrioritizedTile prioritized_tile =
-        MakePrioritizedTile(key_tile_pair.second);
+        MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile));
     result.insert(std::make_pair(prioritized_tile.tile(), prioritized_tile));
   }
   return result;
 }
 
 TilePriority PictureLayerTiling::ComputePriorityForTile(
-    const Tile* tile) const {
+    const Tile* tile,
+    PriorityRectType priority_rect_type) const {
   // TODO(vmpstr): See if this can be moved to iterators.
   TilePriority::PriorityBin max_tile_priority_bin =
       client_->GetMaxTilePriorityBin();
 
+  DCHECK_EQ(ComputePriorityRectTypeForTile(tile), priority_rect_type);
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
-  gfx::Rect tile_bounds =
-      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
 
-  if (max_tile_priority_bin <= TilePriority::NOW &&
-      current_visible_rect_.Intersects(tile_bounds)) {
-    return TilePriority(resolution_, TilePriority::NOW, 0);
-  }
+  TilePriority::PriorityBin priority_bin = max_tile_priority_bin;
 
-  if (max_tile_priority_bin <= TilePriority::SOON &&
-      pending_visible_rect().Intersects(tile_bounds)) {
-    return TilePriority(resolution_, TilePriority::SOON, 0);
+  switch (priority_rect_type) {
+    case VISIBLE_RECT:
+      return TilePriority(resolution_, priority_bin, 0);
+    case PENDING_VISIBLE_RECT:
+      if (max_tile_priority_bin <= TilePriority::SOON)
+        return TilePriority(resolution_, TilePriority::SOON, 0);
+      priority_bin = TilePriority::EVENTUALLY;
+      break;
+    case SKEWPORT_RECT:
+    case SOON_BORDER_RECT:
+      if (max_tile_priority_bin <= TilePriority::SOON)
+        priority_bin = TilePriority::SOON;
+      break;
+    case EVENTUALLY_RECT:
+      priority_bin = TilePriority::EVENTUALLY;
+      break;
   }
 
+  gfx::Rect tile_bounds =
+      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
   DCHECK_GT(current_content_to_screen_scale_, 0.f);
   float distance_to_visible =
       current_visible_rect_.ManhattanInternalDistance(tile_bounds) *
       current_content_to_screen_scale_;
 
-  if (max_tile_priority_bin <= TilePriority::SOON &&
-      (current_soon_border_rect_.Intersects(tile_bounds) ||
-       current_skewport_rect_.Intersects(tile_bounds))) {
-    return TilePriority(resolution_, TilePriority::SOON, distance_to_visible);
-  }
+  return TilePriority(resolution_, priority_bin, distance_to_visible);
+}
+
+PictureLayerTiling::PriorityRectType
+PictureLayerTiling::ComputePriorityRectTypeForTile(const Tile* tile) const {
+  DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
+  gfx::Rect tile_bounds =
+      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
+
+  if (current_visible_rect_.Intersects(tile_bounds))
+    return VISIBLE_RECT;
+
+  if (pending_visible_rect().Intersects(tile_bounds))
+    return PENDING_VISIBLE_RECT;
+
+  if (current_skewport_rect_.Intersects(tile_bounds))
+    return SKEWPORT_RECT;
+
+  if (current_soon_border_rect_.Intersects(tile_bounds))
+    return SOON_BORDER_RECT;
 
-  return TilePriority(resolution_, TilePriority::EVENTUALLY,
-                      distance_to_visible);
+  DCHECK(current_eventually_rect_.Intersects(tile_bounds));
+  return EVENTUALLY_RECT;
 }
 
 void PictureLayerTiling::GetAllPrioritizedTilesForTracing(
     std::vector<PrioritizedTile>* prioritized_tiles) const {
   for (const auto& tile_pair : tiles_) {
-    prioritized_tiles->push_back(MakePrioritizedTile(tile_pair.second));
+    Tile* tile = tile_pair.second;
+    prioritized_tiles->push_back(
+        MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile)));
   }
 }
 

cc/resources/picture_layer_tiling.h

@@ -212,6 +212,19 @@ class CC_EXPORT PictureLayerTiling {
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
 
+  // PENDING VISIBLE RECT refers to the visible rect that will become current
+  // upon activation (ie, the pending tree's visible rect). Tiles in this
+  // region that are not part of the current visible rect are all handled
+  // here. Note that when processing a pending tree, this rect is the same as
+  // the visible rect so no tiles are processed in this case.
+  enum PriorityRectType {
+    VISIBLE_RECT,
+    PENDING_VISIBLE_RECT,
+    SKEWPORT_RECT,
+    SOON_BORDER_RECT,
+    EVENTUALLY_RECT
+  };
+
   using TileMapKey = std::pair<int, int>;
   using TileMap = base::ScopedPtrHashMap<TileMapKey, ScopedTilePtr>;
 
@@ -272,8 +285,13 @@ class CC_EXPORT PictureLayerTiling {
   bool ShouldCreateTileAt(int i, int j) const;
   bool IsTileOccluded(const Tile* tile) const;
   void UpdateRequiredStatesOnTile(Tile* tile) const;
-  PrioritizedTile MakePrioritizedTile(Tile* tile) const;
-  TilePriority ComputePriorityForTile(const Tile* tile) const;
+  PrioritizedTile MakePrioritizedTile(
+      Tile* tile,
+      PriorityRectType priority_rect_type) const;
+  TilePriority ComputePriorityForTile(
+      const Tile* tile,
+      PriorityRectType priority_rect_type) const;
+  PriorityRectType ComputePriorityRectTypeForTile(const Tile* tile) const;
   bool has_visible_rect_tiles() const { return has_visible_rect_tiles_; }
   bool has_skewport_rect_tiles() const { return has_skewport_rect_tiles_; }
   bool has_soon_border_rect_tiles() const {

cc/resources/tiling_set_eviction_queue.cc

@@ -188,10 +188,10 @@ TilingSetEvictionQueue::EvictionRectIterator::EvictionRectIterator()
 TilingSetEvictionQueue::EvictionRectIterator::EvictionRectIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree,
-    bool skip_pending_visible_rect)
+    PictureLayerTiling::PriorityRectType priority_rect_type)
     : tilings_(tilings),
       tree_(tree),
-      skip_pending_visible_rect_(skip_pending_visible_rect),
+      priority_rect_type_(priority_rect_type),
       tiling_index_(0) {
 }
 
@@ -219,12 +219,16 @@ bool TilingSetEvictionQueue::EvictionRectIterator::GetFirstTileAndCheckIfValid(
   // If there's nothing to evict, return false.
   if (!tile || !tile->draw_info().has_resource())
     return false;
-  if (skip_pending_visible_rect_ &&
+  // After the pending visible rect has been processed, we must return false
+  // for pending visible rect tiles as tiling iterators do not ignore those
+  // tiles.
+  if (priority_rect_type_ > PictureLayerTiling::PENDING_VISIBLE_RECT &&
       tiling->pending_visible_rect().Intersects(tile->content_rect())) {
     return false;
   }
   (*tilings_)[tiling_index_]->UpdateRequiredStatesOnTile(tile);
-  prioritized_tile_ = (*tilings_)[tiling_index_]->MakePrioritizedTile(tile);
+  prioritized_tile_ = (*tilings_)[tiling_index_]->MakePrioritizedTile(
+      tile, priority_rect_type_);
   // In other cases, the tile we got is a viable candidate, return true.
   return true;
 }
@@ -233,9 +237,7 @@ bool TilingSetEvictionQueue::EvictionRectIterator::GetFirstTileAndCheckIfValid(
 TilingSetEvictionQueue::EventuallyTilingIterator::EventuallyTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
-    : EvictionRectIterator(tilings,
-                           tree,
-                           true /* skip_pending_visible_rect */) {
+    : EvictionRectIterator(tilings, tree, PictureLayerTiling::EVENTUALLY_RECT) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_eventually_rect_tiles()) {
@@ -287,7 +289,7 @@ TilingSetEvictionQueue::SoonBorderTilingIterator::SoonBorderTilingIterator(
     WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           true /* skip_pending_visible_rect */) {
+                           PictureLayerTiling::SOON_BORDER_RECT) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_soon_border_rect_tiles()) {
@@ -337,9 +339,7 @@ TilingSetEvictionQueue::SoonBorderTilingIterator&
 TilingSetEvictionQueue::SkewportTilingIterator::SkewportTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
-    : EvictionRectIterator(tilings,
-                           tree,
-                           true /* skip_pending_visible_rect */) {
+    : EvictionRectIterator(tilings, tree, PictureLayerTiling::SKEWPORT_RECT) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_skewport_rect_tiles()) {
@@ -392,7 +392,7 @@ TilingSetEvictionQueue::PendingVisibleTilingIterator::
                                  bool return_required_for_activation_tiles)
     : EvictionRectIterator(tilings,
                            tree,
-                           false /* skip_pending_visible_rect */),
+                           PictureLayerTiling::PENDING_VISIBLE_RECT),
       return_required_for_activation_tiles_(
           return_required_for_activation_tiles) {
   // Find the first tiling with a tile.
@@ -456,9 +456,7 @@ TilingSetEvictionQueue::VisibleTilingIterator::VisibleTilingIterator(
     WhichTree tree,
     bool return_occluded_tiles,
     bool return_required_for_activation_tiles)
-    : EvictionRectIterator(tilings,
-                           tree,
-                           false /* skip_pending_visible_rect */),
+    : EvictionRectIterator(tilings, tree, PictureLayerTiling::VISIBLE_RECT),
       return_occluded_tiles_(return_occluded_tiles),
       return_required_for_activation_tiles_(
           return_required_for_activation_tiles) {

cc/resources/tiling_set_eviction_queue.h

@@ -91,9 +91,10 @@ class CC_EXPORT TilingSetEvictionQueue {
   class EvictionRectIterator {
    public:
     EvictionRectIterator();
-    EvictionRectIterator(std::vector<PictureLayerTiling*>* tilings,
-                         WhichTree tree,
-                         bool skip_pending_visible_rect);
+    EvictionRectIterator(
+        std::vector<PictureLayerTiling*>* tilings,
+        WhichTree tree,
+        PictureLayerTiling::PriorityRectType priority_rect_type);
 
     bool done() const { return !prioritized_tile_.tile(); }
     const PrioritizedTile& operator*() const { return prioritized_tile_; }
@@ -109,7 +110,7 @@ class CC_EXPORT TilingSetEvictionQueue {
     PrioritizedTile prioritized_tile_;
     std::vector<PictureLayerTiling*>* tilings_;
     WhichTree tree_;
-    bool skip_pending_visible_rect_;
+    PictureLayerTiling::PriorityRectType priority_rect_type_;
     size_t tiling_index_;
   };
 

cc/resources/tiling_set_raster_queue_all.h

@@ -31,8 +31,10 @@ class CC_EXPORT TilingSetRasterQueueAll {
   class OnePriorityRectIterator {
    public:
     OnePriorityRectIterator();
-    OnePriorityRectIterator(PictureLayerTiling* tiling,
-                            TilingData* tiling_data);
+    OnePriorityRectIterator(
+        PictureLayerTiling* tiling,
+        TilingData* tiling_data,
+        PictureLayerTiling::PriorityRectType priority_rect_type);
 
     bool done() const { return !current_tile_.tile(); }
     const PrioritizedTile& operator*() const { return current_tile_; }
@@ -51,6 +53,7 @@ class CC_EXPORT TilingSetRasterQueueAll {
     PrioritizedTile current_tile_;
     PictureLayerTiling* tiling_;
     TilingData* tiling_data_;
+    PictureLayerTiling::PriorityRectType priority_rect_type_;
   };
 
   // Iterates over visible rect only, left to right top to bottom order.
@@ -131,13 +134,13 @@ class CC_EXPORT TilingSetRasterQueueAll {
     const PrioritizedTile& operator*() const { return current_tile_; }
     TilePriority::PriorityBin type() const {
       switch (phase_) {
-        case VISIBLE_RECT:
+        case Phase::VISIBLE_RECT:
           return TilePriority::NOW;
-        case PENDING_VISIBLE_RECT:
-        case SKEWPORT_RECT:
-        case SOON_BORDER_RECT:
+        case Phase::PENDING_VISIBLE_RECT:
+        case Phase::SKEWPORT_RECT:
+        case Phase::SOON_BORDER_RECT:
           return TilePriority::SOON;
-        case EVENTUALLY_RECT:
+        case Phase::EVENTUALLY_RECT:
           return TilePriority::EVENTUALLY;
       }
       NOTREACHED();
@@ -147,18 +150,7 @@ class CC_EXPORT TilingSetRasterQueueAll {
     TilingIterator& operator++();
 
    private:
-    // PENDING VISIBLE RECT refers to the visible rect that will become current
-    // upon activation (ie, the pending tree's visible rect). Tiles in this
-    // region that are not part of the current visible rect are all handled
-    // here. Note that when processing a pending tree, this rect is the same as
-    // the visible rect so no tiles are processed in this case.
-    enum Phase {
-      VISIBLE_RECT,
-      PENDING_VISIBLE_RECT,
-      SKEWPORT_RECT,
-      SOON_BORDER_RECT,
-      EVENTUALLY_RECT
-    };
+    using Phase = PictureLayerTiling::PriorityRectType;
 
     void AdvancePhase();
 

cc/resources/tiling_set_raster_queue_required.cc

@@ -104,7 +104,8 @@ TilingSetRasterQueueRequired::TilingIterator::TilingIterator(
   if (tile && tile->draw_info().NeedsRaster() &&
       !tiling_->IsTileOccluded(tile)) {
     tiling_->UpdateRequiredStatesOnTile(tile);
-    current_tile_ = tiling_->MakePrioritizedTile(tile);
+    current_tile_ = tiling_->MakePrioritizedTile(
+        tile, tiling_->ComputePriorityRectTypeForTile(tile));
     return;
   }
   ++(*this);
@@ -143,7 +144,8 @@ TilingSetRasterQueueRequired::TilingIterator&
   }
 
   tiling_->UpdateRequiredStatesOnTile(tile);
-  current_tile_ = tiling_->MakePrioritizedTile(tile);
+  current_tile_ = tiling_->MakePrioritizedTile(
+      tile, tiling_->ComputePriorityRectTypeForTile(tile));
   return *this;
 }