cc: Pass priority rect information from iterators to tilings.

cc/resources/tiling_set_eviction_queue.cc

 // Copyright 2014 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 <utility>
 
 #include "cc/resources/tiling_set_eviction_queue.h"
 
 namespace cc {
 
@@ skipping 180 matching lines @@
 TilingSetEvictionQueue::EvictionRectIterator::EvictionRectIterator()
     : tile_(nullptr),
       tilings_(nullptr),
       tree_(ACTIVE_TREE),
       tiling_index_(0) {
 }
 
 TilingSetEvictionQueue::EvictionRectIterator::EvictionRectIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree,
-    bool skip_pending_visible_rect)
+    PictureLayerTiling::PriorityRect priority_rect)
     : tile_(nullptr),
       tilings_(tilings),
       tree_(tree),
-      skip_pending_visible_rect_(skip_pending_visible_rect),
+      priority_rect_(priority_rect),
       tiling_index_(0) {
 }
 
 template <typename TilingIteratorType>
 bool TilingSetEvictionQueue::EvictionRectIterator::AdvanceToNextTile(
     TilingIteratorType* iterator) {
   bool found_tile = false;
   while (!found_tile) {
     ++(*iterator);
     if (!(*iterator)) {
       tile_ = nullptr;
       break;
     }
     found_tile = GetFirstTileAndCheckIfValid(iterator);
   }
   return found_tile;
 }
 
 template <typename TilingIteratorType>
 bool TilingSetEvictionQueue::EvictionRectIterator::GetFirstTileAndCheckIfValid(
     TilingIteratorType* iterator) {
   PictureLayerTiling* tiling = (*tilings_)[tiling_index_];
   tile_ = tiling->TileAt(iterator->index_x(), iterator->index_y());
   // If there's nothing to evict, return false.
   if (!tile_ || !tile_->HasResource())
     return false;
-  if (skip_pending_visible_rect_ &&
+  if (priority_rect_ > PictureLayerTiling::PriorityRect::PENDING_VISIBLE_RECT &&

[vmpstr, 2015/05/05 18:04:02]

Can you leave a comment here, just something explaining that we need to skip
this rect for all priorities after we process the pending visible rect. 

[USE eero AT chromium.org, 2015/05/06 12:05:20]

Done.

       tiling->pending_visible_rect().Intersects(tile_->content_rect())) {
     return false;
   }
-  (*tilings_)[tiling_index_]->UpdateTilePriority(tile_);
+  (*tilings_)[tiling_index_]->UpdateTilePriority(tile_, priority_rect_);
   // In other cases, the tile we got is a viable candidate, return true.
   return true;
 }
 
 // EventuallyTilingIterator
 TilingSetEvictionQueue::EventuallyTilingIterator::EventuallyTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           true /* skip_pending_visible_rect */) {
+                           PictureLayerTiling::PriorityRect::EVENTUALLY_RECT) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_eventually_rect_tiles()) {
       ++tiling_index_;
       continue;
     }
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_eventually_rect(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
@@ skipping 31 matching lines @@
   }
   return *this;
 }
 
 // SoonBorderTilingIterator
 TilingSetEvictionQueue::SoonBorderTilingIterator::SoonBorderTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           true /* skip_pending_visible_rect */) {
+                           PictureLayerTiling::PriorityRect::SOON_BORDER_RECT) {

[vmpstr, 2015/05/05 18:04:01]

The PriorityRect:: part is not needed here, unless you wanna make it an enum
class

[USE eero AT chromium.org, 2015/05/06 12:05:20]

I do not want to make it an enum. But I thought that I have to in order to be
able to use PriorityRectType as a TilingSetRasterQueueAll TilingIterator phase.
Apparently I do not have to, but I forget to remove PriorityRect:: part. Sorry
for that.

Thus, removed.

   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_soon_border_rect_tiles()) {
       ++tiling_index_;
       continue;
     }
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_soon_border_rect(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
@@ skipping 31 matching lines @@
   }
   return *this;
 }
 
 // SkewportTilingIterator
 TilingSetEvictionQueue::SkewportTilingIterator::SkewportTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           true /* skip_pending_visible_rect */) {
+                           PictureLayerTiling::PriorityRect::SKEWPORT_RECT) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_skewport_rect_tiles()) {
       ++tiling_index_;
       continue;
     }
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
         (*tilings_)[tiling_index_]->current_visible_rect(),
@@ skipping 30 matching lines @@
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // PendingVisibleIterator
 TilingSetEvictionQueue::PendingVisibleTilingIterator::
     PendingVisibleTilingIterator(std::vector<PictureLayerTiling*>* tilings,
                                  WhichTree tree,
                                  bool return_required_for_activation_tiles)
-    : EvictionRectIterator(tilings,
-                           tree,
-                           false /* skip_pending_visible_rect */),
+    : EvictionRectIterator(
+          tilings,
+          tree,
+          PictureLayerTiling::PriorityRect::PENDING_VISIBLE_RECT),
       return_required_for_activation_tiles_(
           return_required_for_activation_tiles) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     iterator_ = TilingData::DifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->pending_visible_rect(),
         (*tilings_)[tiling_index_]->current_visible_rect());
     if (!iterator_) {
       ++tiling_index_;
@@ skipping 45 matching lines @@
 }
 
 // VisibleTilingIterator
 TilingSetEvictionQueue::VisibleTilingIterator::VisibleTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree,
     bool return_occluded_tiles,
     bool return_required_for_activation_tiles)
     : EvictionRectIterator(tilings,
                            tree,
-                           false /* skip_pending_visible_rect */),
+                           PictureLayerTiling::PriorityRect::VISIBLE_RECT),
       return_occluded_tiles_(return_occluded_tiles),
       return_required_for_activation_tiles_(
           return_required_for_activation_tiles) {
   // Find the first tiling with a tile.
   while (tiling_index_ < tilings_->size()) {
     if (!(*tilings_)[tiling_index_]->has_visible_rect_tiles()) {
       ++tiling_index_;
       continue;
     }
     iterator_ = TilingData::Iterator(
@@ skipping 44 matching lines @@
 
 bool TilingSetEvictionQueue::VisibleTilingIterator::TileMatchesRequiredFlags(
     const Tile* tile) const {
   bool activation_flag_matches =
       tile->required_for_activation() == return_required_for_activation_tiles_;
   bool occluded_flag_matches = tile->is_occluded() == return_occluded_tiles_;
   return activation_flag_matches && occluded_flag_matches;
 }
 
 }  // namespace cc