cc: Implement tile iteration order based on pyramid sequence. [old]

cc/tiles/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 <stddef.h>
 
 #include <utility>
 
 #include "cc/tiles/tiling_set_eviction_queue.h"
 
@@ skipping 235 matching lines @@
   // 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(),
-        (*tilings_)[tiling_index_]->current_soon_border_rect());
+        (*tilings_)[tiling_index_]->current_soon_border_rect(),
+        TilingData::IsPyramidSequenceEnabled());
     if (!iterator_) {
       ++tiling_index_;
       continue;
     }
     break;
   }
   if (tiling_index_ >= tilings_->size())
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_))
     ++(*this);
 }
 
 TilingSetEvictionQueue::EventuallyTilingIterator&
     TilingSetEvictionQueue::EventuallyTilingIterator::
     operator++() {
   bool found_tile = AdvanceToNextTile(&iterator_);
   while (!found_tile && (tiling_index_ + 1) < tilings_->size()) {
     ++tiling_index_;
     if (!(*tilings_)[tiling_index_]->has_eventually_rect_tiles())
       continue;
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_eventually_rect(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
-        (*tilings_)[tiling_index_]->current_soon_border_rect());
+        (*tilings_)[tiling_index_]->current_soon_border_rect(),
+        TilingData::IsPyramidSequenceEnabled());
     if (!iterator_)
       continue;
     found_tile = GetFirstTileAndCheckIfValid(&iterator_);
     if (!found_tile)
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // SoonBorderTilingIterator
 TilingSetEvictionQueue::SoonBorderTilingIterator::SoonBorderTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
     : EvictionRectIterator(tilings,
                            tree,
                            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()) {
       ++tiling_index_;
       continue;
     }
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_soon_border_rect(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
-        (*tilings_)[tiling_index_]->current_visible_rect());
+        (*tilings_)[tiling_index_]->current_visible_rect(),
+        TilingData::IsPyramidSequenceEnabled());
     if (!iterator_) {
       ++tiling_index_;
       continue;
     }
     break;
   }
   if (tiling_index_ >= tilings_->size())
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_))
     ++(*this);
 }
 
 TilingSetEvictionQueue::SoonBorderTilingIterator&
     TilingSetEvictionQueue::SoonBorderTilingIterator::
     operator++() {
   bool found_tile = AdvanceToNextTile(&iterator_);
   while (!found_tile && (tiling_index_ + 1) < tilings_->size()) {
     ++tiling_index_;
     if (!(*tilings_)[tiling_index_]->has_soon_border_rect_tiles())
       continue;
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_soon_border_rect(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
-        (*tilings_)[tiling_index_]->current_visible_rect());
+        (*tilings_)[tiling_index_]->current_visible_rect(),
+        TilingData::IsPyramidSequenceEnabled());
     if (!iterator_)
       continue;
     found_tile = GetFirstTileAndCheckIfValid(&iterator_);
     if (!found_tile)
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // SkewportTilingIterator
 TilingSetEvictionQueue::SkewportTilingIterator::SkewportTilingIterator(
     std::vector<PictureLayerTiling*>* tilings,
     WhichTree tree)
     : 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()) {
       ++tiling_index_;
       continue;
     }
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
         (*tilings_)[tiling_index_]->current_visible_rect(),
-        (*tilings_)[tiling_index_]->current_visible_rect());
+        (*tilings_)[tiling_index_]->current_visible_rect(),
+        TilingData::IsPyramidSequenceEnabled());
     if (!iterator_) {
       ++tiling_index_;
       continue;
     }
     break;
   }
   if (tiling_index_ >= tilings_->size())
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_))
     ++(*this);
 }
 
 TilingSetEvictionQueue::SkewportTilingIterator&
     TilingSetEvictionQueue::SkewportTilingIterator::
     operator++() {
   bool found_tile = AdvanceToNextTile(&iterator_);
   while (!found_tile && (tiling_index_ + 1) < tilings_->size()) {
     ++tiling_index_;
     if (!(*tilings_)[tiling_index_]->has_skewport_rect_tiles())
       continue;
     iterator_ = TilingData::ReverseSpiralDifferenceIterator(
         (*tilings_)[tiling_index_]->tiling_data(),
         (*tilings_)[tiling_index_]->current_skewport_rect(),
         (*tilings_)[tiling_index_]->current_visible_rect(),
-        (*tilings_)[tiling_index_]->current_visible_rect());
+        (*tilings_)[tiling_index_]->current_visible_rect(),
+        TilingData::IsPyramidSequenceEnabled());
     if (!iterator_)
       continue;
     found_tile = GetFirstTileAndCheckIfValid(&iterator_);
     if (!found_tile)
       found_tile = AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // PendingVisibleIterator
@@ skipping 125 matching lines @@
 
 bool TilingSetEvictionQueue::VisibleTilingIterator::TileMatchesRequiredFlags(
     const PrioritizedTile& tile) const {
   bool activation_flag_matches = tile.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