cc: Drop skip_shared_out_of_order_tiles field from TilingSetEvictionQueue.

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 {
 
 TilingSetEvictionQueue::TilingSetEvictionQueue(
-    PictureLayerTilingSet* tiling_set,
-    bool skip_shared_out_of_order_tiles)
+    PictureLayerTilingSet* tiling_set)
     : tree_(tiling_set->tree()),
-      skip_shared_out_of_order_tiles_(skip_shared_out_of_order_tiles),
       phase_(EVENTUALLY_RECT),
       current_tile_(nullptr) {
   // Early out if the layer has no tilings.
   if (!tiling_set->num_tilings())
     return;
   GenerateTilingOrder(tiling_set);
-  eventually_iterator_ = EventuallyTilingIterator(
-      &tilings_, tree_, skip_shared_out_of_order_tiles_);
+  eventually_iterator_ = EventuallyTilingIterator(&tilings_, tree_);
   if (eventually_iterator_.done()) {
     AdvancePhase();
     return;
   }
   current_tile_ = *eventually_iterator_;
 }
 
 TilingSetEvictionQueue::~TilingSetEvictionQueue() {
 }
 
@@ skipping 44 matching lines @@
 void TilingSetEvictionQueue::AdvancePhase() {
   current_tile_ = nullptr;
   while (!current_tile_ &&
          phase_ != VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_UNOCCLUDED) {
     phase_ = static_cast<Phase>(phase_ + 1);
     switch (phase_) {
       case EVENTUALLY_RECT:
         NOTREACHED();
         break;
       case SOON_BORDER_RECT:
-        soon_iterator_ = SoonBorderTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_);
+        soon_iterator_ = SoonBorderTilingIterator(&tilings_, tree_);
         if (!soon_iterator_.done())
           current_tile_ = *soon_iterator_;
         break;
       case SKEWPORT_RECT:
-        skewport_iterator_ = SkewportTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_);
+        skewport_iterator_ = SkewportTilingIterator(&tilings_, tree_);
         if (!skewport_iterator_.done())
           current_tile_ = *skewport_iterator_;
         break;
       case PENDING_VISIBLE_RECT:
         pending_visible_iterator_ = PendingVisibleTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_,
-            false /* return required for activation tiles */);
+            &tilings_, tree_, false /* return required for activation tiles */);
         if (!pending_visible_iterator_.done())
           current_tile_ = *pending_visible_iterator_;
         break;
       case PENDING_VISIBLE_RECT_REQUIRED_FOR_ACTIVATION:
         pending_visible_iterator_ = PendingVisibleTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_,
-            true /* return required for activation tiles */);
+            &tilings_, tree_, true /* return required for activation tiles */);
         if (!pending_visible_iterator_.done())
           current_tile_ = *pending_visible_iterator_;
         break;
       case VISIBLE_RECT_OCCLUDED:
         visible_iterator_ = VisibleTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_,
-            true /* return occluded tiles */,
+            &tilings_, tree_, true /* return occluded tiles */,
             false /* return required for activation tiles */);
         if (!visible_iterator_.done())
           current_tile_ = *visible_iterator_;
         break;
       case VISIBLE_RECT_UNOCCLUDED:
         visible_iterator_ = VisibleTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_,
-            false /* return occluded tiles */,
+            &tilings_, tree_, false /* return occluded tiles */,
             false /* return required for activation tiles */);
         if (!visible_iterator_.done())
           current_tile_ = *visible_iterator_;
         break;
       case VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_OCCLUDED:
         visible_iterator_ = VisibleTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_,
-            true /* return occluded tiles */,
+            &tilings_, tree_, true /* return occluded tiles */,
             true /* return required for activation tiles */);
         if (!visible_iterator_.done())
           current_tile_ = *visible_iterator_;
         break;
       case VISIBLE_RECT_REQUIRED_FOR_ACTIVATION_UNOCCLUDED:
         visible_iterator_ = VisibleTilingIterator(
-            &tilings_, tree_, skip_shared_out_of_order_tiles_,
-            false /* return occluded tiles */,
+            &tilings_, tree_, false /* return occluded tiles */,
             true /* return required for activation tiles */);
         if (!visible_iterator_.done())
           current_tile_ = *visible_iterator_;
         break;
     }
   }
 }
 
 bool TilingSetEvictionQueue::IsEmpty() const {
   return !current_tile_;
@@ skipping 45 matching lines @@
   }
   if (!current_tile_)
     AdvancePhase();
 }
 
 // EvictionRectIterator
 TilingSetEvictionQueue::EvictionRectIterator::EvictionRectIterator()
     : tile_(nullptr),
       tilings_(nullptr),
       tree_(ACTIVE_TREE),
-      skip_shared_out_of_order_tiles_(false),
       tiling_index_(0) {
 }
 
 TilingSetEvictionQueue::EvictionRectIterator::EvictionRectIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree,
-    bool skip_shared_out_of_order_tiles,
     bool skip_pending_visible_rect)
     : tile_(nullptr),
       tilings_(tilings),
       tree_(tree),
-      skip_shared_out_of_order_tiles_(skip_shared_out_of_order_tiles),
       skip_pending_visible_rect_(skip_pending_visible_rect),
       tiling_index_(0) {
 }
 
 template <typename TilingIteratorType>
 bool TilingSetEvictionQueue::EvictionRectIterator::AdvanceToNextTile(
     TilingIteratorType* iterator) {
   bool found_tile = false;
   while (!found_tile) {
     ++(*iterator);
@@ skipping 19 matching lines @@
     return false;
   }
   (*tilings_)[tiling_index_]->UpdateTileAndTwinPriority(tile_);
   // 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,
-    bool skip_shared_out_of_order_tiles)
+    WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           skip_shared_out_of_order_tiles,
                            true /* skip_pending_visible_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(),
@@ skipping 29 matching lines @@
     found_tile = GetFirstTileAndCheckIfValid(&iterator_);
     if (!found_tile)
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // SoonBorderTilingIterator
 TilingSetEvictionQueue::SoonBorderTilingIterator::SoonBorderTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
-    WhichTree tree,
-    bool skip_shared_out_of_order_tiles)
+    WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           skip_shared_out_of_order_tiles,
                            true /* skip_pending_visible_rect */) {
   // 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(),
@@ skipping 29 matching lines @@
     found_tile = GetFirstTileAndCheckIfValid(&iterator_);
     if (!found_tile)
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // SkewportTilingIterator
 TilingSetEvictionQueue::SkewportTilingIterator::SkewportTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
-    WhichTree tree,
-    bool skip_shared_out_of_order_tiles)
+    WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
-                           skip_shared_out_of_order_tiles,
                            true /* skip_pending_visible_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(),
@@ skipping 30 matching lines @@
     if (!found_tile)
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // PendingVisibleIterator
 TilingSetEvictionQueue::PendingVisibleTilingIterator::
     PendingVisibleTilingIterator(std::vector<PictureLayerTiling*>* tilings,
                                  WhichTree tree,
-                                 bool skip_shared_out_of_order_tiles,
                                  bool return_required_for_activation_tiles)
     : EvictionRectIterator(tilings,
                            tree,
-                           skip_shared_out_of_order_tiles,
                            false /* skip_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_) {
@@ skipping 42 matching lines @@
     TileMatchesRequiredFlags(const Tile* tile) const {
   bool activation_flag_matches =
       tile->required_for_activation() == return_required_for_activation_tiles_;
   return activation_flag_matches;
 }
 
 // VisibleTilingIterator
 TilingSetEvictionQueue::VisibleTilingIterator::VisibleTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree,
-    bool skip_shared_out_of_order_tiles,
     bool return_occluded_tiles,
     bool return_required_for_activation_tiles)
     : EvictionRectIterator(tilings,
                            tree,
-                           skip_shared_out_of_order_tiles,
                            false /* skip_pending_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;
     }
@@ skipping 45 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