cc: Optimize TileManager::CleanUpReleasedTiles.

cc/resources/tile_manager.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/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 259 matching lines @@
 void TileManager::FreeResourcesForReleasedTiles() {
   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
        it != released_tiles_.end();
        ++it) {
     Tile* tile = *it;
     FreeResourcesForTile(tile);
   }
 }
 
 void TileManager::CleanUpReleasedTiles() {
-  std::vector<Tile*>::iterator it = released_tiles_.begin();
-  while (it != released_tiles_.end()) {
-    Tile* tile = *it;
-
+  std::vector<Tile*> tiles_to_retain;

[enne (OOO), 2015/04/07 23:04:48]

Should you reserve this to be the number of tiles in released_tiles to avoid
unneeded allocations?

[vmpstr, 2015/04/07 23:10:23]

I'm not sure it's worth it, since the number of tiles that have a raster task is
bounded by a small number typically, and push_back is amortized constant. Number
of released tiles is technically not bounded on the other hand.

+  for (auto* tile : released_tiles_) {
     if (tile->HasRasterTask()) {
-      ++it;
+      tiles_to_retain.push_back(tile);
       continue;
     }
 
     DCHECK(!tile->HasResource());
     DCHECK(tiles_.find(tile->id()) != tiles_.end());
     tiles_.erase(tile->id());
 
     LayerCountMap::iterator layer_it =
         used_layer_counts_.find(tile->layer_id());
     DCHECK_GT(layer_it->second, 0);
     if (--layer_it->second == 0) {
       used_layer_counts_.erase(layer_it);
       image_decode_tasks_.erase(tile->layer_id());
     }
 
     delete tile;
-    it = released_tiles_.erase(it);
   }
+  released_tiles_.swap(tiles_to_retain);
 }
 
 void TileManager::DidFinishRunningTileTasks(TaskSet task_set) {
   TRACE_EVENT1("cc", "TileManager::DidFinishRunningTileTasks", "task_set",
                TaskSetName(task_set));
 
   switch (task_set) {
     case ALL: {
       bool memory_usage_above_limit =
           resource_pool_->total_memory_usage_bytes() >
@@ skipping 655 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc