cc: Only create tiling eviction iterators as they are required.

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 "base/time/time.h"
@@ skipping 1549 matching lines @@
       iteration_stage_(TilePriority::EVENTUALLY),
       required_for_activation_(false),
       layer_(NULL) {}
 
 PictureLayerImpl::LayerEvictionTileIterator::LayerEvictionTileIterator(
     PictureLayerImpl* layer,
     TreePriority tree_priority)
     : iterator_index_(0),
       iteration_stage_(TilePriority::EVENTUALLY),
       required_for_activation_(false),
-      layer_(layer) {
+      layer_(layer),
+      tree_priority_(tree_priority) {
   // Early out if the layer has no tilings.
   // 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)
   if (!layer_->tilings_ || !layer_->tilings_->num_tilings())
     return;
 
   size_t high_res_tiling_index = layer_->tilings_->num_tilings();
   size_t low_res_tiling_index = layer_->tilings_->num_tilings();
   for (size_t i = 0; i < layer_->tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = layer_->tilings_->tiling_at(i);
     if (tiling->resolution() == HIGH_RESOLUTION)
       high_res_tiling_index = i;
     else if (tiling->resolution() == LOW_RESOLUTION)
       low_res_tiling_index = i;
   }
 
   iterators_.reserve(layer_->tilings_->num_tilings());
+  tilings_.reserve(layer_->tilings_->num_tilings());
 
   // Higher resolution non-ideal goes first.
-  for (size_t i = 0; i < high_res_tiling_index; ++i) {
-    iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(i), tree_priority));
-  }
+  for (size_t i = 0; i < high_res_tiling_index; ++i)
+    tilings_.push_back(layer_->tilings_->tiling_at(i));
 
   // Lower resolution non-ideal goes next.
   for (size_t i = layer_->tilings_->num_tilings() - 1;
        i > high_res_tiling_index;
        --i) {
     PictureLayerTiling* tiling = layer_->tilings_->tiling_at(i);
     if (tiling->resolution() == LOW_RESOLUTION)
       continue;
 
-    iterators_.push_back(
-        PictureLayerTiling::TilingEvictionTileIterator(tiling, tree_priority));
+    tilings_.push_back(tiling);
   }
 
   // Now, put the low res tiling if we have one.
-  if (low_res_tiling_index < layer_->tilings_->num_tilings()) {
-    iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(low_res_tiling_index), tree_priority));
-  }
+  if (low_res_tiling_index < layer_->tilings_->num_tilings())
+    tilings_.push_back(layer_->tilings_->tiling_at(low_res_tiling_index));
 
   // Finally, put the high res tiling if we have one.
-  if (high_res_tiling_index < layer_->tilings_->num_tilings()) {
-    iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
-        layer_->tilings_->tiling_at(high_res_tiling_index), tree_priority));
-  }
+  if (high_res_tiling_index < layer_->tilings_->num_tilings())
+    tilings_.push_back(layer_->tilings_->tiling_at(high_res_tiling_index));
 
-  DCHECK_GT(iterators_.size(), 0u);
+  DCHECK_GT(tilings_.size(), 0u);
 
+  EnsureCurrentIteratorCreated();
   if (!iterators_[iterator_index_] ||
       !IsCorrectType(&iterators_[iterator_index_])) {
     AdvanceToNextIterator();
   }
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::~LayerEvictionTileIterator() {}
 
 Tile* PictureLayerImpl::LayerEvictionTileIterator::operator*() {
   DCHECK(*this);
@@ skipping 14 matching lines @@
       !IsCorrectType(&iterators_[iterator_index_])) {
     AdvanceToNextIterator();
   }
   return *this;
 }
 
 void PictureLayerImpl::LayerEvictionTileIterator::AdvanceToNextIterator() {
   ++iterator_index_;
 
   while (true) {
-    while (iterator_index_ < iterators_.size()) {
+    while (iterator_index_ < tilings_.size()) {
+      EnsureCurrentIteratorCreated();
       if (iterators_[iterator_index_] &&
           IsCorrectType(&iterators_[iterator_index_])) {
         return;
       }
       ++iterator_index_;
     }
 
     // If we're NOW and required_for_activation, then this was the last pass
     // through the iterators.
     if (iteration_stage_ == TilePriority::NOW && required_for_activation_)
       break;
 
     if (!required_for_activation_) {
       required_for_activation_ = true;
     } else {
       required_for_activation_ = false;
       iteration_stage_ =
           static_cast<TilePriority::PriorityBin>(iteration_stage_ - 1);
     }
     iterator_index_ = 0;
   }
 }
 
 PictureLayerImpl::LayerEvictionTileIterator::operator bool() const {
-  return iterator_index_ < iterators_.size();
+  return iterator_index_ < tilings_.size();
 }
 
 bool PictureLayerImpl::LayerEvictionTileIterator::IsCorrectType(
     PictureLayerTiling::TilingEvictionTileIterator* it) const {
   return it->get_type() == iteration_stage_ &&
          (**it)->required_for_activation() == required_for_activation_;
 }
 
+void
+PictureLayerImpl::LayerEvictionTileIterator::EnsureCurrentIteratorCreated() {
+  if (iterator_index_ < iterators_.size())
+    return;
+
+  DCHECK_EQ(iterator_index_, iterators_.size());
+  DCHECK_LT(iterator_index_, tilings_.size());
+
+  iterators_.push_back(PictureLayerTiling::TilingEvictionTileIterator(
+      tilings_[iterator_index_], tree_priority_));
+}
+
 }  // namespace cc