cc: Implement geometry-based tile 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 1545 matching lines @@
 
     if (iterators_[index] && iterators_[index].get_type() == tile_type)
       break;
     ++current_stage_;
   }
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator()
     : layer_(nullptr),
       tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES),
+      layer_has_twin_layer_(false),
       current_category_(PictureLayerTiling::EVENTUALLY),
       current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
       current_tiling_(0u) {
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
     PictureLayerImpl* layer,
     TreePriority tree_priority)
     : layer_(layer),
       tree_priority_(tree_priority),
+      layer_has_twin_layer_(!!layer->GetPendingOrActiveTwinLayer()),
       current_category_(PictureLayerTiling::EVENTUALLY),
       current_tiling_range_type_(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES),
       current_tiling_(0u) {
   // Early out if the layer has no tilings.
   if (!layer_->tilings_ || !layer_->tilings_->num_tilings())
     return;
 
   current_tiling_ = CurrentTilingRange().start - 1u;
   do {
     if (!AdvanceToNextTiling())
       break;
 
     current_iterator_ = PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(CurrentTilingIndex()),
-        tree_priority,
-        current_category_);
+        layer_->tilings_->tiling_at(CurrentTilingIndex()), tree_priority,
+        current_category_, layer_has_twin_layer_);
   } 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_);
+        layer_->tilings_->tiling_at(CurrentTilingIndex()), tree_priority_,
+        current_category_, layer_has_twin_layer_);
   }
   return *this;
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::operator bool() const {
   return !!current_iterator_;
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextCategory() {
   switch (current_category_) {
@@ skipping 77 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