cc: Speed up CleanUpImageDecodeTasks a bit.

This patch keeps the state of used layers and updates it in register
and unregister tile. This eliminates the need for CleanUpImageDecodeTasks.

This also provides a fix to the memory limits in the perftest, so by
comparison the performance should drop significantly. However, this is
only because the perftests are now properly testing the full
ManageTiles code path. The patch to remove CleanUpImageDecodeTasks
actually improves performance by about 15%.

BUG=283777
R=reveman@chromium.org,tomhudson@chromium.org

Review URL: https://chromiumcodereview.appspot.com/23757024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@221638 0039d316-1c4b-4281-b951-d872f2087c98

cc/resources/tile_manager.cc

@@ -190,6 +190,7 @@ void TileManager::RegisterTile(Tile* tile) {
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile;
+  used_layer_counts_[tile->layer_id()]++;
   prioritized_tiles_dirty_ = true;
 }
 
@@ -198,6 +199,14 @@ void TileManager::UnregisterTile(Tile* tile) {
 
   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());
+  }
+
   prioritized_tiles_dirty_ = true;
 }
 
@@ -369,7 +378,6 @@ void TileManager::ManageTiles() {
   TileVector tiles_that_need_to_be_rasterized;
   AssignGpuMemoryToTiles(GetPrioritizedTileSet(),
                          &tiles_that_need_to_be_rasterized);
-  CleanUpUnusedImageDecodeTasks();
 
   // Finally, schedule rasterizer tasks.
   ScheduleTasks(tiles_that_need_to_be_rasterized);
@@ -620,33 +628,6 @@ void TileManager::AssignGpuMemoryToTiles(
       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.
-  std::vector<int> unused_layers;
-  for (LayerPixelRefTaskMap::iterator it = image_decode_tasks_.begin();
-       it != image_decode_tasks_.end();
-       ++it) {
-    if (used_layers.find(it->first) == used_layers.end())
-      unused_layers.push_back(it->first);
-  }
-
-  // Erase unused layers from |image_decode_tasks_|.
-  for (std::vector<int>::iterator it = unused_layers.begin();
-       it != unused_layers.end();
-       ++it) {
-    image_decode_tasks_.erase(*it);
-  }
-}
-
 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.tile_versions[mode].resource_) {

cc/resources/tile_manager.h

@@ -93,6 +93,9 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
       ++resources_releasable_;
     }
   }
+  RasterWorkerPool* RasterWorkerPoolForTesting() {
+    return raster_worker_pool_.get();
+  }
 
  protected:
   TileManager(TileManagerClient* client,
@@ -138,7 +141,6 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
       bool was_canceled);
 
   RasterMode DetermineRasterMode(const Tile* tile) const;
-  void CleanUpUnusedImageDecodeTasks();
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
@@ -176,6 +178,9 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
   LayerPixelRefTaskMap image_decode_tasks_;
 
+  typedef base::hash_map<int, int> LayerCountMap;
+  LayerCountMap used_layer_counts_;
+
   RasterTaskCompletionStats update_visible_tiles_stats_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);

cc/resources/tile_manager_perftest.cc

@@ -46,7 +46,9 @@ class TileManagerPerfTest : public testing::Test {
     GlobalStateThatImpactsTilePriority state;
     gfx::Size tile_size = settings_.default_tile_size;
     state.memory_limit_in_bytes =
-        10000 * 4 * tile_size.width() * tile_size.height();
+        10000u * 4u *
+        static_cast<size_t>(tile_size.width() * tile_size.height());
+    state.num_resources_limit = 10000;
     state.memory_limit_policy = ALLOW_ANYTHING;
     state.tree_priority = SMOOTHNESS_TAKES_PRIORITY;
 
@@ -148,6 +150,7 @@ class TileManagerPerfTest : public testing::Test {
       }
 
       tile_manager_->ManageTiles();
+      tile_manager_->CheckForCompletedTasks();
       timer_.NextLap();
     } while (!timer_.HasTimeLimitExpired());
 

cc/test/fake_tile_manager.cc

@@ -74,4 +74,8 @@ bool FakeTileManager::HasBeenAssignedMemory(Tile* tile) {
                    tile) != tiles_for_raster.end();
 }
 
+void FakeTileManager::CheckForCompletedTasks() {
+  RasterWorkerPoolForTesting()->CheckForCompletedTasks();
+}
+
 }  // namespace cc

cc/test/fake_tile_manager.h

@@ -21,6 +21,8 @@ class FakeTileManager : public TileManager {
   bool HasBeenAssignedMemory(Tile* tile);
   void AssignMemoryToTiles();
 
+  void CheckForCompletedTasks();
+
   virtual ~FakeTileManager();
 
   std::vector<Tile*> tiles_for_raster;