cc: Do not ignore layers without valid priorities during 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 1567 matching lines @@
 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,
+    const PictureLayerImpl* twin_layer,

[vmpstr, 2014/10/31 15:35:49]

layer itself has access to the twin, let's just get it there so that we don't
have to pass extra parameters.

[USE eero AT chromium.org, 2014/11/04 17:47:57]

Done.

     TreePriority tree_priority)
     : layer_(layer),
       tree_priority_(tree_priority),
+      use_tile_priority_rects_(layer->HasValidTilePriorities()),
+      use_twin_tile_priority_rects_(twin_layer &&
+                                    twin_layer->HasValidTilePriorities()),
       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_);
+        current_category_,
+        use_tile_priority_rects_,
+        use_twin_tile_priority_rects_);
   } 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_);
+        current_category_,
+        use_tile_priority_rects_,
+        use_twin_tile_priority_rects_);
   }
   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