cc: Speed up CleanUpImageDecodeTasks a bit.

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 172 matching lines @@
       global_state_.memory_limit_in_bytes,
       global_state_.unused_memory_limit_in_bytes,
       global_state_.num_resources_limit);
 }
 
 void TileManager::RegisterTile(Tile* tile) {
   DCHECK(!tile->required_for_activation());
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
+  used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
 }
 
 void TileManager::UnregisterTile(Tile* tile) {
   FreeResourcesForTile(tile);
 
   DCHECK(tiles_.find(tile->id()) != tiles_.end());
   tiles_.erase(tile->id());
+
+  DCHECK_GT(used_layer_counts_[tile->layer_id()], 0);
+  used_layer_counts_[tile->layer_id()]--;
+
   prioritized_tiles_dirty_ = true;
 }
 
 void TileManager::DidChangeTilePriority(Tile* tile) {
   prioritized_tiles_dirty_ = true;
 }
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return GlobalState().tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
@@ skipping 406 matching lines @@
   memory_stats_from_last_assign_.bytes_unreleasable =
       bytes_allocatable - bytes_releasable_;
   memory_stats_from_last_assign_.bytes_over =
       bytes_that_exceeded_memory_budget;
 }
 
 void TileManager::CleanUpUnusedImageDecodeTasks() {
   if (image_decode_tasks_.empty())
     return;
 
-  // Calculate a set of layers that are used by at least one tile.
-  base::hash_set<int> used_layers;
-  for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-    used_layers.insert(it->second->layer_id());
-
-  // Now calculate the set of layers in |image_decode_tasks_| that are not used
-  // by any tile.
+  // Unused layers are layers whose use count is zero.
   std::vector<int> unused_layers;
-  for (LayerPixelRefTaskMap::iterator it = image_decode_tasks_.begin();
-       it != image_decode_tasks_.end();
+  for (LayerCountMap::iterator it = used_layer_counts_.begin();
+       it != used_layer_counts_.end();
        ++it) {
-    if (used_layers.find(it->first) == used_layers.end())
+    if (it->second == 0)
       unused_layers.push_back(it->first);
   }
 
-  // Erase unused layers from |image_decode_tasks_|.
+  // Erase unused layers from |image_decode_tasks_| and from
+  // |used_layer_counts_|.
   for (std::vector<int>::iterator it = unused_layers.begin();
        it != unused_layers.end();
        ++it) {
     image_decode_tasks_.erase(*it);
+    used_layer_counts_.erase(*it);

[reveman, 2013/09/04 21:25:17]

can we move these two lines to UnregisterTile and remove this function
completely?

[vmpstr, 2013/09/04 22:03:49]

Good idea. Done.

   }
 }
 
 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.tile_versions[mode].resource_) {
     resource_pool_->ReleaseResource(
         mts.tile_versions[mode].resource_.Pass());
 
     DCHECK_GE(bytes_releasable_, tile->bytes_consumed_if_allocated());
@@ skipping 78 matching lines @@
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
           tile->tile_size_.size(),
           raster_worker_pool_->GetResourceFormat());
   const Resource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   RasterWorkerPool::Task::Set decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];

[vmpstr, 2013/09/04 19:36:40]

This is the line that prevents the early out from triggering in basically all
but very few (degenerate) situations.

   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
        iter; ++iter) {
     skia::LazyPixelRef* pixel_ref = *iter;
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
     if (decode_task_it != existing_pixel_refs.end()) {
@@ skipping 90 matching lines @@
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc