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}

7 files changed, 167 insertions, 92 deletions

diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 70c4b11..b90d28d1 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/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)));
   }
 }
 
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 4a555a2..8ae68e1 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/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 {
diff --git a/cc/resources/tiling_set_eviction_queue.cc b/cc/resources/tiling_set_eviction_queue.cc
index fde0a85..f494da3 100644
--- a/cc/resources/tiling_set_eviction_queue.cc
+++ b/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) {
diff --git a/cc/resources/tiling_set_eviction_queue.h b/cc/resources/tiling_set_eviction_queue.h
index f5e2c10..58e5a7d 100644
--- a/cc/resources/tiling_set_eviction_queue.h
+++ b/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_;
   };
 
diff --git a/cc/resources/tiling_set_raster_queue_all.cc b/cc/resources/tiling_set_raster_queue_all.cc
index ba2f115..330f088 100644
--- a/cc/resources/tiling_set_raster_queue_all.cc
+++ b/cc/resources/tiling_set_raster_queue_all.cc
@@ -148,24 +148,25 @@ TilingSetRasterQueueAll::OnePriorityRectIterator::OnePriorityRectIterator()
 
 TilingSetRasterQueueAll::OnePriorityRectIterator::OnePriorityRectIterator(
     PictureLayerTiling* tiling,
-    TilingData* tiling_data)
-    : tiling_(tiling), tiling_data_(tiling_data) {
+    TilingData* tiling_data,
+    PictureLayerTiling::PriorityRectType priority_rect_type)
+    : tiling_(tiling),
+      tiling_data_(tiling_data),
+      priority_rect_type_(priority_rect_type) {
 }
 
 template <typename TilingIteratorType>
 void TilingSetRasterQueueAll::OnePriorityRectIterator::AdvanceToNextTile(
     TilingIteratorType* iterator) {
-  current_tile_ = PrioritizedTile();
-  Tile* tile = nullptr;
-  while (!tile || !TileNeedsRaster(tile)) {
+  bool found_tile = false;
+  while (!found_tile) {
     ++(*iterator);
     if (!(*iterator)) {
-      return;
+      current_tile_ = PrioritizedTile();
+      break;
     }
-    tile = tiling_->TileAt(iterator->index_x(), iterator->index_y());
+    found_tile = GetFirstTileAndCheckIfValid(iterator);
   }
-  tiling_->UpdateRequiredStatesOnTile(tile);
-  current_tile_ = tiling_->MakePrioritizedTile(tile);
 }
 
 template <typename TilingIteratorType>
@@ -176,8 +177,16 @@ bool TilingSetRasterQueueAll::OnePriorityRectIterator::
     current_tile_ = PrioritizedTile();
     return false;
   }
+  // 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())) {
+    current_tile_ = PrioritizedTile();
+    return false;
+  }
   tiling_->UpdateRequiredStatesOnTile(tile);
-  current_tile_ = tiling_->MakePrioritizedTile(tile);
+  current_tile_ = tiling_->MakePrioritizedTile(tile, priority_rect_type_);
   return true;
 }
 
@@ -185,7 +194,9 @@ bool TilingSetRasterQueueAll::OnePriorityRectIterator::
 TilingSetRasterQueueAll::VisibleTilingIterator::VisibleTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data) {
+    : OnePriorityRectIterator(tiling,
+                              tiling_data,
+                              PictureLayerTiling::VISIBLE_RECT) {
   if (!tiling_->has_visible_rect_tiles())
     return;
   iterator_ =
@@ -208,7 +219,9 @@ TilingSetRasterQueueAll::VisibleTilingIterator&
 TilingSetRasterQueueAll::PendingVisibleTilingIterator::
     PendingVisibleTilingIterator(PictureLayerTiling* tiling,
                                  TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data) {
+    : OnePriorityRectIterator(tiling,
+                              tiling_data,
+                              PictureLayerTiling::PENDING_VISIBLE_RECT) {
   iterator_ = TilingData::DifferenceIterator(tiling_data_,
                                              tiling_->pending_visible_rect(),
                                              tiling_->current_visible_rect());
@@ -229,7 +242,9 @@ TilingSetRasterQueueAll::PendingVisibleTilingIterator&
 TilingSetRasterQueueAll::SkewportTilingIterator::SkewportTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data),
+    : OnePriorityRectIterator(tiling,
+                              tiling_data,
+                              PictureLayerTiling::SKEWPORT_RECT),
       pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_skewport_rect_tiles())
     return;
@@ -242,6 +257,8 @@ TilingSetRasterQueueAll::SkewportTilingIterator::SkewportTilingIterator(
     ++(*this);
     return;
   }
+  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid
+  // does the same checking.
   if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
@@ -250,6 +267,8 @@ TilingSetRasterQueueAll::SkewportTilingIterator&
     TilingSetRasterQueueAll::SkewportTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
+  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid called
+  // by AdvanceToNextTile does the same checking.
   while (!done()) {
     if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
       break;
@@ -262,7 +281,9 @@ TilingSetRasterQueueAll::SkewportTilingIterator&
 TilingSetRasterQueueAll::SoonBorderTilingIterator::SoonBorderTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data),
+    : OnePriorityRectIterator(tiling,
+                              tiling_data,
+                              PictureLayerTiling::SOON_BORDER_RECT),
       pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_soon_border_rect_tiles())
     return;
@@ -275,6 +296,8 @@ TilingSetRasterQueueAll::SoonBorderTilingIterator::SoonBorderTilingIterator(
     ++(*this);
     return;
   }
+  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid
+  // does the same checking.
   if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
@@ -283,6 +306,8 @@ TilingSetRasterQueueAll::SoonBorderTilingIterator&
     TilingSetRasterQueueAll::SoonBorderTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
+  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid called
+  // by AdvanceToNextTile does the same checking.
   while (!done()) {
     if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
       break;
@@ -295,7 +320,9 @@ TilingSetRasterQueueAll::SoonBorderTilingIterator&
 TilingSetRasterQueueAll::EventuallyTilingIterator::EventuallyTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : OnePriorityRectIterator(tiling, tiling_data),
+    : OnePriorityRectIterator(tiling,
+                              tiling_data,
+                              PictureLayerTiling::EVENTUALLY_RECT),
       pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_eventually_rect_tiles())
     return;
@@ -308,6 +335,8 @@ TilingSetRasterQueueAll::EventuallyTilingIterator::EventuallyTilingIterator(
     ++(*this);
     return;
   }
+  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid
+  // does the same checking.
   if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
@@ -316,6 +345,8 @@ TilingSetRasterQueueAll::EventuallyTilingIterator&
     TilingSetRasterQueueAll::EventuallyTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
+  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid called
+  // by AdvanceToNextTile does the same checking.
   while (!done()) {
     if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
       break;
@@ -331,7 +362,7 @@ TilingSetRasterQueueAll::TilingIterator::TilingIterator() : tiling_(nullptr) {
 TilingSetRasterQueueAll::TilingIterator::TilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : tiling_(tiling), tiling_data_(tiling_data), phase_(VISIBLE_RECT) {
+    : tiling_(tiling), tiling_data_(tiling_data), phase_(Phase::VISIBLE_RECT) {
   visible_iterator_ = VisibleTilingIterator(tiling_, tiling_data_);
   if (visible_iterator_.done()) {
     AdvancePhase();
@@ -344,32 +375,32 @@ TilingSetRasterQueueAll::TilingIterator::~TilingIterator() {
 }
 
 void TilingSetRasterQueueAll::TilingIterator::AdvancePhase() {
-  DCHECK_LT(phase_, EVENTUALLY_RECT);
+  DCHECK_LT(phase_, Phase::EVENTUALLY_RECT);
 
   current_tile_ = PrioritizedTile();
-  while (!current_tile_.tile() && phase_ < EVENTUALLY_RECT) {
+  while (!current_tile_.tile() && phase_ < Phase::EVENTUALLY_RECT) {
     phase_ = static_cast<Phase>(phase_ + 1);
     switch (phase_) {
-      case VISIBLE_RECT:
+      case Phase::VISIBLE_RECT:
         NOTREACHED();
         return;
-      case PENDING_VISIBLE_RECT:
+      case Phase::PENDING_VISIBLE_RECT:
         pending_visible_iterator_ =
             PendingVisibleTilingIterator(tiling_, tiling_data_);
         if (!pending_visible_iterator_.done())
           current_tile_ = *pending_visible_iterator_;
         break;
-      case SKEWPORT_RECT:
+      case Phase::SKEWPORT_RECT:
         skewport_iterator_ = SkewportTilingIterator(tiling_, tiling_data_);
         if (!skewport_iterator_.done())
           current_tile_ = *skewport_iterator_;
         break;
-      case SOON_BORDER_RECT:
+      case Phase::SOON_BORDER_RECT:
         soon_border_iterator_ = SoonBorderTilingIterator(tiling_, tiling_data_);
         if (!soon_border_iterator_.done())
           current_tile_ = *soon_border_iterator_;
         break;
-      case EVENTUALLY_RECT:
+      case Phase::EVENTUALLY_RECT:
         eventually_iterator_ = EventuallyTilingIterator(tiling_, tiling_data_);
         if (!eventually_iterator_.done())
           current_tile_ = *eventually_iterator_;
@@ -382,7 +413,7 @@ TilingSetRasterQueueAll::TilingIterator&
     TilingSetRasterQueueAll::TilingIterator::
     operator++() {
   switch (phase_) {
-    case VISIBLE_RECT:
+    case Phase::VISIBLE_RECT:
       ++visible_iterator_;
       if (visible_iterator_.done()) {
         AdvancePhase();
@@ -390,7 +421,7 @@ TilingSetRasterQueueAll::TilingIterator&
       }
       current_tile_ = *visible_iterator_;
       break;
-    case PENDING_VISIBLE_RECT:
+    case Phase::PENDING_VISIBLE_RECT:
       ++pending_visible_iterator_;
       if (pending_visible_iterator_.done()) {
         AdvancePhase();
@@ -398,7 +429,7 @@ TilingSetRasterQueueAll::TilingIterator&
       }
       current_tile_ = *pending_visible_iterator_;
       break;
-    case SKEWPORT_RECT:
+    case Phase::SKEWPORT_RECT:
       ++skewport_iterator_;
       if (skewport_iterator_.done()) {
         AdvancePhase();
@@ -406,7 +437,7 @@ TilingSetRasterQueueAll::TilingIterator&
       }
       current_tile_ = *skewport_iterator_;
       break;
-    case SOON_BORDER_RECT:
+    case Phase::SOON_BORDER_RECT:
       ++soon_border_iterator_;
       if (soon_border_iterator_.done()) {
         AdvancePhase();
@@ -414,7 +445,7 @@ TilingSetRasterQueueAll::TilingIterator&
       }
       current_tile_ = *soon_border_iterator_;
       break;
-    case EVENTUALLY_RECT:
+    case Phase::EVENTUALLY_RECT:
       ++eventually_iterator_;
       if (eventually_iterator_.done()) {
         current_tile_ = PrioritizedTile();
diff --git a/cc/resources/tiling_set_raster_queue_all.h b/cc/resources/tiling_set_raster_queue_all.h
index dd3a7a8..8c8b012 100644
--- a/cc/resources/tiling_set_raster_queue_all.h
+++ b/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();
 
diff --git a/cc/resources/tiling_set_raster_queue_required.cc b/cc/resources/tiling_set_raster_queue_required.cc
index 19c2c81..f95cd42 100644
--- a/cc/resources/tiling_set_raster_queue_required.cc
+++ b/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;
 }