cc: Decode images once in tile manager

Decode images only once while the layer still exists. If the
pixel ref was already decoded, then we don't decode it again
while the layer is still active

BUG=247067

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

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

4 files changed, 45 insertions, 56 deletions

diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 3cb51ea..8710e09 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -204,12 +204,10 @@ class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   ImageDecodeWorkerPoolTaskImpl(skia::LazyPixelRef* pixel_ref,
                                 int layer_id,
-                                RenderingStatsInstrumentation* rendering_stats,
-                                const RasterWorkerPool::Task::Reply& reply)
+                                RenderingStatsInstrumentation* rendering_stats)
       : pixel_ref_(pixel_ref),
         layer_id_(layer_id),
-        rendering_stats_(rendering_stats),
-        reply_(reply) {}
+        rendering_stats_(rendering_stats) {}
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnThread(unsigned thread_index) OVERRIDE {
@@ -221,9 +219,7 @@ class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
     base::TimeDelta duration = rendering_stats_->EndRecording(start_time);
     rendering_stats_->AddDeferredImageDecode(duration);
   }
-  virtual void DispatchCompletionCallback() OVERRIDE {
-    reply_.Run();
-  }
+  virtual void DispatchCompletionCallback() OVERRIDE {}
 
  protected:
   virtual ~ImageDecodeWorkerPoolTaskImpl() {}
@@ -232,7 +228,6 @@ class ImageDecodeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
   skia::LazyPixelRef* pixel_ref_;
   int layer_id_;
   RenderingStatsInstrumentation* rendering_stats_;
-  const RasterWorkerPool::Task::Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeWorkerPoolTaskImpl);
 };
@@ -384,12 +379,10 @@ RasterWorkerPool::RasterTask RasterWorkerPool::CreateRasterTask(
 RasterWorkerPool::Task RasterWorkerPool::CreateImageDecodeTask(
     skia::LazyPixelRef* pixel_ref,
     int layer_id,
-    RenderingStatsInstrumentation* stats_instrumentation,
-    const Task::Reply& reply) {
+    RenderingStatsInstrumentation* stats_instrumentation) {
   return Task(new ImageDecodeWorkerPoolTaskImpl(pixel_ref,
                                                 layer_id,
-                                                stats_instrumentation,
-                                                reply));
+                                                stats_instrumentation));
 }
 
 RasterWorkerPool::RasterWorkerPool(ResourceProvider* resource_provider,
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 5485fec..0af49e5 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -220,8 +220,7 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   static Task CreateImageDecodeTask(
       skia::LazyPixelRef* pixel_ref,
       int layer_id,
-      RenderingStatsInstrumentation* stats_instrumentation,
-      const Task::Reply& reply);
+      RenderingStatsInstrumentation* stats_instrumentation);
 
  protected:
   class RootTask {
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index 3ebfbe8..388034f 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -128,6 +128,7 @@ TileManager::~TileManager() {
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
+  CleanUpUnusedImageDecodeTasks();
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_->Shutdown();
@@ -287,6 +288,7 @@ void TileManager::ManageTiles() {
   AssignBinsToTiles();
   SortTiles();
   AssignGpuMemoryToTiles();
+  CleanUpUnusedImageDecodeTasks();
 
   // This could have changed after AssignGpuMemoryToTiles.
   if (AreTilesRequiredForActivationReady())
@@ -561,6 +563,30 @@ void TileManager::AssignGpuMemoryToTiles() {
       bytes_that_exceeded_memory_budget_in_now_bin;
 }
 
+void TileManager::CleanUpUnusedImageDecodeTasks() {
+  // Calculate a set of layers that are used by at least one tile.
+  base::hash_set<int> used_layers;
+  for (TileVector::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
+    used_layers.insert((*it)->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_) {
@@ -587,7 +613,6 @@ void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
 void TileManager::ScheduleTasks() {
   TRACE_EVENT0("cc", "TileManager::ScheduleTasks");
   RasterWorkerPool::RasterTask::Queue tasks;
-  PixelRefSet decoded_images;
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
@@ -603,7 +628,7 @@ void TileManager::ScheduleTasks() {
     DCHECK(!tile_version.resource_);
 
     if (tile_version.raster_task_.is_null())
-      tile_version.raster_task_ = CreateRasterTask(tile, &decoded_images);
+      tile_version.raster_task_ = CreateRasterTask(tile);
 
     tasks.Append(tile_version.raster_task_, tile->required_for_activation());
   }
@@ -621,19 +646,7 @@ RasterWorkerPool::Task TileManager::CreateImageDecodeTask(
   return RasterWorkerPool::CreateImageDecodeTask(
       pixel_ref,
       tile->layer_id(),
-      rendering_stats_instrumentation_,
-      base::Bind(&TileManager::OnImageDecodeTaskCompleted,
-                 base::Unretained(this),
-                 make_scoped_refptr(tile),
-                 pixel_ref->getGenerationID()));
-}
-
-void TileManager::OnImageDecodeTaskCompleted(scoped_refptr<Tile> tile,
-                                             uint32_t pixel_ref_id) {
-  TRACE_EVENT0("cc", "TileManager::OnImageDecodeTaskCompleted");
-  DCHECK(pending_decode_tasks_.find(pixel_ref_id) !=
-         pending_decode_tasks_.end());
-  pending_decode_tasks_.erase(pixel_ref_id);
+      rendering_stats_instrumentation_);
 }
 
 RasterTaskMetadata TileManager::GetRasterTaskMetadata(
@@ -649,9 +662,7 @@ RasterTaskMetadata TileManager::GetRasterTaskMetadata(
   return metadata;
 }
 
-RasterWorkerPool::RasterTask TileManager::CreateRasterTask(
-    Tile* tile,
-    PixelRefSet* decoded_images) {
+RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   TRACE_EVENT0("cc", "TileManager::CreateRasterTask");
 
   ManagedTileState& mts = tile->managed_state();
@@ -663,6 +674,7 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(
 
   // 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()];
   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
@@ -671,26 +683,17 @@ RasterWorkerPool::RasterTask TileManager::CreateRasterTask(
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
-    PixelRefMap::iterator decode_task_it = pending_decode_tasks_.find(id);
-    if (decode_task_it != pending_decode_tasks_.end()) {
+    PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
+    if (decode_task_it != existing_pixel_refs.end()) {
       decode_tasks.Insert(decode_task_it->second);
       continue;
     }
 
-    if (decoded_images->find(id) != decoded_images->end())
-      continue;
-
-    if (pixel_ref->MaybeDecoded()) {
-      decoded_images->insert(id);
-      rendering_stats_instrumentation_->IncrementDeferredImageCacheHitCount();
-      continue;
-    }
-
     // Create and append new image decode task for this pixel ref.
     RasterWorkerPool::Task decode_task = CreateImageDecodeTask(
         tile, pixel_ref);
     decode_tasks.Insert(decode_task);
-    pending_decode_tasks_[id] = decode_task;
+    existing_pixel_refs[id] = decode_task;
   }
 
   RasterTaskMetadata metadata = GetRasterTaskMetadata(*tile);
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 4c87af0..599f7ec 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -62,8 +62,6 @@ scoped_ptr<base::Value> TileManagerBinPriorityAsValue(
 // created, and unregister from the manager when they are deleted.
 class CC_EXPORT TileManager : public RasterWorkerPoolClient {
  public:
-  typedef base::hash_set<uint32_t> PixelRefSet;
-
   static scoped_ptr<TileManager> Create(
       TileManagerClient* client,
       ResourceProvider* resource_provider,
@@ -117,10 +115,6 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   virtual void ScheduleTasks();
 
  private:
-  // Task callbacks.
-  void OnImageDecodeTaskCompleted(
-      scoped_refptr<Tile> tile,
-      uint32_t pixel_ref_id);
   void OnRasterTaskCompleted(
       scoped_refptr<Tile> tile,
       scoped_ptr<ResourcePool::Resource> resource,
@@ -131,6 +125,7 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   void AssignBinsToTiles();
   void SortTiles();
   RasterMode DetermineRasterMode(const Tile* tile) const;
+  void CleanUpUnusedImageDecodeTasks();
   void AssignGpuMemoryToTiles();
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
@@ -138,9 +133,7 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   RasterWorkerPool::Task CreateImageDecodeTask(
       Tile* tile, skia::LazyPixelRef* pixel_ref);
   RasterTaskMetadata GetRasterTaskMetadata(const Tile& tile) const;
-  RasterWorkerPool::RasterTask CreateRasterTask(
-      Tile* tile,
-      PixelRefSet* decoded_images);
+  RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
   void DidFinishTileInitialization(Tile* tile);
   void DidTileTreeBinChange(Tile* tile,
                             TileManagerBin new_tree_bin,
@@ -159,9 +152,6 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
   typedef std::set<Tile*> TileSet;
   TileSet tiles_that_need_to_be_initialized_for_activation_;
 
-  typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefMap;
-  PixelRefMap pending_decode_tasks_;
-
   bool ever_exceeded_memory_budget_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
@@ -172,6 +162,10 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient {
 
   GLenum texture_format_;
 
+  typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefTaskMap;
+  typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
+  LayerPixelRefTaskMap image_decode_tasks_;
+
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };