cc: Remove vectors from tiling eviction tile iterator.

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 812 matching lines @@
     cache->previous_result = result;
   return result;
 }
 
 void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
     TreePriority tree_priority) {
   if (eviction_tiles_cache_valid_ &&
       eviction_cache_tree_priority_ == tree_priority)
     return;
 
-  eviction_tiles_cache_.clear();
-  eviction_tiles_cache_.reserve(tiles_.size());
+  eventually_eviction_tiles_.clear();
+  soon_eviction_tiles_.clear();
+  now_required_for_activation_eviction_tiles_.clear();
+  now_not_required_for_activation_eviction_tiles_.clear();
+
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     // TODO(vmpstr): This should update the priority if UpdateTilePriorities
     // changes not to do this.
-    eviction_tiles_cache_.push_back(it->second);
+    Tile* tile = it->second;
+    const TilePriority& priority =
+        tile->priority_for_tree_priority(tree_priority);
+    switch (priority.priority_bin) {
+      case TilePriority::EVENTUALLY:
+        eventually_eviction_tiles_.push_back(tile);
+        break;
+      case TilePriority::SOON:
+        soon_eviction_tiles_.push_back(tile);
+        break;
+      case TilePriority::NOW:
+        if (tile->required_for_activation())
+          now_required_for_activation_eviction_tiles_.push_back(tile);
+        else
+          now_not_required_for_activation_eviction_tiles_.push_back(tile);
+        break;
+    }
   }
 
-  std::sort(eviction_tiles_cache_.begin(),
-            eviction_tiles_cache_.end(),
-            TileEvictionOrder(tree_priority));
+  // TODO(vmpstr): Do this lazily. One option is to have a "sorted" flag that
+  // can be updated for each of the queues.
+  TileEvictionOrder sort_order(tree_priority);
+  std::sort(eventually_eviction_tiles_.begin(),
+            eventually_eviction_tiles_.end(),
+            sort_order);
+  std::sort(
+      soon_eviction_tiles_.begin(), soon_eviction_tiles_.end(), sort_order);
+  std::sort(now_required_for_activation_eviction_tiles_.begin(),
+            now_required_for_activation_eviction_tiles_.end(),
+            sort_order);
+  std::sort(now_not_required_for_activation_eviction_tiles_.begin(),
+            now_not_required_for_activation_eviction_tiles_.end(),
+            sort_order);
+
   eviction_tiles_cache_valid_ = true;
   eviction_cache_tree_priority_ = tree_priority;
 }
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
     : tiling_(NULL), current_tile_(NULL) {}
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     PictureLayerTiling* tiling,
     WhichTree tree)
@@ skipping 109 matching lines @@
         }
         next_index = spiral_iterator_.index();
         break;
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
   return *this;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
-    : tiling_(NULL) {
+    : tiling_(NULL), eviction_tiles_(NULL) {
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
-    TreePriority tree_priority)
-    : tiling_(tiling), tree_priority_(tree_priority) {
+    TreePriority tree_priority,
+    TilePriority::PriorityBin type,
+    bool required_for_activation)
+    : tiling_(tiling), tree_priority_(tree_priority), eviction_tiles_(NULL) {
+  if (required_for_activation && type != TilePriority::NOW)

[reveman, 2014/08/01 17:54:47]

could this be a DCHECK?

[vmpstr, 2014/08/01 19:39:50]

No, this can't be a dcheck since we pass all 6 stages here, and I would like to
not rely on the fact that 2 of those should always be empty.

[reveman, 2014/08/04 14:56:17]

Acknowledged.

+    return;
+
   tiling_->UpdateEvictionCacheIfNeeded(tree_priority_);
-  tile_iterator_ = tiling_->eviction_tiles_cache_.begin();
-  if (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
+  switch (type) {
+    case TilePriority::EVENTUALLY:
+      eviction_tiles_ = &tiling_->eventually_eviction_tiles_;
+      break;
+    case TilePriority::SOON:
+      eviction_tiles_ = &tiling_->soon_eviction_tiles_;
+      break;
+    case TilePriority::NOW:
+      if (required_for_activation)
+        eviction_tiles_ = &tiling_->now_required_for_activation_eviction_tiles_;
+      else
+        eviction_tiles_ =
+            &tiling_->now_not_required_for_activation_eviction_tiles_;
+      break;
+  }
+  DCHECK(eviction_tiles_);
+  tile_iterator_ = eviction_tiles_->begin();
+  if (tile_iterator_ != eviction_tiles_->end() &&
       !(*tile_iterator_)->HasResources()) {
     ++(*this);
   }
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::~TilingEvictionTileIterator() {}
 
 PictureLayerTiling::TilingEvictionTileIterator::operator bool() const {
-  return tiling_ && tile_iterator_ != tiling_->eviction_tiles_cache_.end();
+  return eviction_tiles_ && tile_iterator_ != eviction_tiles_->end();

[reveman, 2014/08/01 17:54:47]

remove eviction_tiles_ check if you can DCHECK above.

 }
 
 Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() {
   DCHECK(*this);
   return *tile_iterator_;
 }
 
 const Tile* PictureLayerTiling::TilingEvictionTileIterator::operator*() const {
   DCHECK(*this);
   return *tile_iterator_;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator&
 PictureLayerTiling::TilingEvictionTileIterator::
 operator++() {
   DCHECK(*this);
   do {
     ++tile_iterator_;
-  } while (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
+  } while (tile_iterator_ != eviction_tiles_->end() &&
            (!(*tile_iterator_)->HasResources()));
 
   return *this;
 }
 
 }  // namespace cc