cc: Use reverse spiral iterator in tiling eviction.

cc/layers/picture_layer_impl.cc

 // Copyright 2012 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 "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 1542 matching lines @@
     TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type;
 
     if (iterators_[index] && iterators_[index].get_type() == tile_type)
       break;
     ++current_stage_;
   }
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator()
     : layer_(nullptr),
-      tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES),
       current_category_(PictureLayerTiling::EVENTUALLY),
       current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
       current_tiling_(0u) {
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
-    PictureLayerImpl* layer,
-    TreePriority tree_priority)
+    PictureLayerImpl* layer)
     : layer_(layer),
-      tree_priority_(tree_priority),
       current_category_(PictureLayerTiling::EVENTUALLY),
       current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
       current_tiling_(CurrentTilingRange().start - 1u) {
   // TODO(vmpstr): Once tile priorities are determined by the iterators, ensure
   // that layers that don't have valid tile priorities have lowest priorities so
   // they evict their tiles first (crbug.com/381704)
   DCHECK(layer_->tilings_);
   do {
     if (!AdvanceToNextTiling())
       break;
 
     current_iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
         layer_->tilings_->tiling_at(CurrentTilingIndex()),
-        tree_priority,
         current_category_);
   } while (!current_iterator_);
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::~LayerEvictionTileIterator() {
 }
 
 Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() {
   DCHECK(*this);
   return *current_iterator_;
 }
 
 const Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() const {
   DCHECK(*this);
   return *current_iterator_;
 }
 
 PictureLayerImpl::LayerEvictionTileIterator&
 PictureLayerImpl::LayerEvictionTileIterator::
 operator++() {
   DCHECK(*this);
   ++current_iterator_;
   while (!current_iterator_) {
     if (!AdvanceToNextTiling())
       break;
 
     current_iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
         layer_->tilings_->tiling_at(CurrentTilingIndex()),
-        tree_priority_,
         current_category_);
   }
   return *this;
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::operator bool() const {
   return !!current_iterator_;
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextCategory() {
   switch (current_category_) {
     case PictureLayerTiling::EVENTUALLY:
-      current_category_ =
-          PictureLayerTiling::EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION;
-      return true;
-    case PictureLayerTiling::EVENTUALLY_AND_REQUIRED_FOR_ACTIVATION:
       current_category_ = PictureLayerTiling::SOON;
       return true;
     case PictureLayerTiling::SOON:
-      current_category_ = PictureLayerTiling::SOON_AND_REQUIRED_FOR_ACTIVATION;
-      return true;
-    case PictureLayerTiling::SOON_AND_REQUIRED_FOR_ACTIVATION:
       current_category_ = PictureLayerTiling::NOW;
       return true;
     case PictureLayerTiling::NOW:
       current_category_ = PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION;
       return true;
     case PictureLayerTiling::NOW_AND_REQUIRED_FOR_ACTIVATION:
       return false;
   }
   NOTREACHED();
   return false;
@@ skipping 56 matching lines @@
       PictureLayerTilingSet::TilingRange tiling_range = CurrentTilingRange();
       size_t current_tiling_range_offset = current_tiling_ - tiling_range.start;
       return tiling_range.end - 1 - current_tiling_range_offset;
     }
   }
   NOTREACHED();
   return 0;
 }
 
 }  // namespace cc