cc: Add ImageManager to keep all the image locking in the same place.

This patch refactors some tile manager code into ImageManager with
an intent of moving all image related stuff (pre-decode images /
checker images) into that class.

R=enne
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_precise_blink_rel

Review-Url: https://codereview.chromium.org/2339703005
Cr-Commit-Position: refs/heads/master@{#418963}

cc/BUILD.gn

@@ -453,6 +453,8 @@ component("cc") {
     "tiles/gpu_image_decode_controller.cc",
     "tiles/gpu_image_decode_controller.h",
     "tiles/image_decode_controller.h",
+    "tiles/image_manager.cc",
+    "tiles/image_manager.h",
     "tiles/mipmap_util.cc",
     "tiles/mipmap_util.h",
     "tiles/picture_layer_tiling.cc",

cc/tiles/image_manager.cc

+// Copyright 2016 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/tiles/image_manager.h"
+
+namespace cc {
+
+ImageManager::ImageManager() = default;
+ImageManager::~ImageManager() = default;
+
+void ImageManager::SetImageDecodeController(ImageDecodeController* controller) {
+  controller_ = controller;
+}
+
+void ImageManager::GetTasksForImagesAndRef(
+    std::vector<DrawImage>* images,
+    std::vector<scoped_refptr<TileTask>>* tasks,
+    const ImageDecodeController::TracingInfo& tracing_info) {
+  DCHECK(controller_);
+  for (auto it = images->begin(); it != images->end();) {
+    scoped_refptr<TileTask> task;
+    bool need_to_unref_when_finished =
+        controller_->GetTaskForImageAndRef(*it, tracing_info, &task);
+    if (task)
+      tasks->push_back(std::move(task));
+
+    if (need_to_unref_when_finished)
+      ++it;
+    else
+      it = images->erase(it);
+  }
+}
+
+void ImageManager::UnrefImages(const std::vector<DrawImage>& images) {
+  DCHECK(controller_);
+  for (auto image : images)
+    controller_->UnrefImage(image);
+}
+
+void ImageManager::ReduceMemoryUsage() {
+  DCHECK(controller_);
+  controller_->ReduceCacheUsage();
+}
+
+}  // namespace cc

cc/tiles/image_manager.h

+// Copyright 2016 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.
+
+#ifndef CC_TILES_IMAGE_MANAGER_H_
+#define CC_TILES_IMAGE_MANAGER_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "cc/base/cc_export.h"
+#include "cc/playback/draw_image.h"
+#include "cc/raster/tile_task.h"
+#include "cc/tiles/image_decode_controller.h"
+
+namespace cc {
+
+class CC_EXPORT ImageManager {
+ public:
+  ImageManager();
+  ~ImageManager();
+
+  void SetImageDecodeController(ImageDecodeController* controller);
+  void GetTasksForImagesAndRef(
+      std::vector<DrawImage>* images,
+      std::vector<scoped_refptr<TileTask>>* tasks,
+      const ImageDecodeController::TracingInfo& tracing_info);
+  void UnrefImages(const std::vector<DrawImage>& images);
+  void ReduceMemoryUsage();
+
+ private:
+  ImageDecodeController* controller_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageManager);
+};
+
+}  // namespace cc
+
+#endif  // CC_TILES_IMAGE_MANAGER_H_

cc/tiles/tile_manager.cc

@@ -361,9 +361,9 @@ void TileManager::FinishTasksAndCleanUp() {
   signals_check_notifier_.Cancel();
   task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  for (auto& draw_image_pair : locked_images_)
-    image_decode_controller_->UnrefImage(draw_image_pair.first);
+  image_manager_.UnrefImages(locked_images_);
   locked_images_.clear();
+  locked_image_tasks_.clear();
 }
 
 void TileManager::SetResources(ResourcePool* resource_pool,
@@ -378,7 +378,7 @@ void TileManager::SetResources(ResourcePool* resource_pool,
   use_gpu_rasterization_ = use_gpu_rasterization;
   scheduled_raster_task_limit_ = scheduled_raster_task_limit;
   resource_pool_ = resource_pool;
-  image_decode_controller_ = image_decode_controller;
+  image_manager_.SetImageDecodeController(image_decode_controller);
   tile_task_manager_ = tile_task_manager;
   raster_buffer_provider_ = raster_buffer_provider;
 }
@@ -836,7 +836,8 @@ void TileManager::ScheduleTasks(
 
   const std::vector<PrioritizedTile>& tiles_to_process_for_images =
       work_to_schedule.tiles_to_process_for_images;
-  std::vector<std::pair<DrawImage, scoped_refptr<TileTask>>> new_locked_images;
+  std::vector<DrawImage> new_locked_images;
+  std::vector<scoped_refptr<TileTask>> new_locked_image_tasks;
   for (const PrioritizedTile& prioritized_tile : tiles_to_process_for_images) {
     Tile* tile = prioritized_tile.tile();
 
@@ -845,45 +846,36 @@ void TileManager::ScheduleTasks(
         tile->enclosing_layer_rect(), tile->contents_scale(), &images);
     ImageDecodeController::TracingInfo tracing_info(
         prepare_tiles_count_, prioritized_tile.priority().priority_bin);
-    for (DrawImage& draw_image : images) {
-      scoped_refptr<TileTask> task;
-      bool need_to_unref_when_finished =
-          image_decode_controller_->GetTaskForImageAndRef(draw_image,
-                                                          tracing_info, &task);
-      // We only care about images that need to be locked (ie they need to be
-      // unreffed later).
-      if (!need_to_unref_when_finished)
-        continue;
-      new_locked_images.emplace_back(draw_image, task);
-
-      // If there's no actual task associated with this image, then we're done.
-      if (!task)
-        continue;
+    image_manager_.GetTasksForImagesAndRef(&images, &new_locked_image_tasks,
+                                           tracing_info);
+    new_locked_images.insert(new_locked_images.end(), images.begin(),
+                             images.end());
+  }
 
-      auto decode_it = std::find_if(graph_.nodes.begin(), graph_.nodes.end(),
-                                    [&task](const TaskGraph::Node& node) {
-                                      return node.task == task.get();
-                                    });
-      // If this task is already in the graph, then we don't have to insert it.
-      if (decode_it != graph_.nodes.end())
-        continue;
+  for (auto& task : new_locked_image_tasks) {
+    auto decode_it = std::find_if(graph_.nodes.begin(), graph_.nodes.end(),
+                                  [&task](const TaskGraph::Node& node) {
+                                    return node.task == task.get();
+                                  });
+    // If this task is already in the graph, then we don't have to insert it.
+    if (decode_it != graph_.nodes.end())
+      continue;
 
-      InsertNodeForDecodeTask(&graph_, task.get(), false, priority++);
-      all_count++;
-      graph_.edges.push_back(TaskGraph::Edge(task.get(), all_done_task.get()));
-    }
+    InsertNodeForDecodeTask(&graph_, task.get(), false, priority++);
+    all_count++;
+    graph_.edges.push_back(TaskGraph::Edge(task.get(), all_done_task.get()));
   }
 
-  for (auto& draw_image_pair : locked_images_)
-    image_decode_controller_->UnrefImage(draw_image_pair.first);
+  image_manager_.UnrefImages(locked_images_);
   // The old locked images have to stay around until past the ScheduleTasks call
   // below, so we do a swap instead of a move.
   locked_images_.swap(new_locked_images);
+  locked_image_tasks_.swap(new_locked_image_tasks);
 
   // We must reduce the amount of unused resources before calling
   // ScheduleTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
-  image_decode_controller_->ReduceCacheUsage();
+  image_manager_.ReduceMemoryUsage();
 
   // Insert nodes for our task completion tasks. We enqueue these using
   // NONCONCURRENT_FOREGROUND category this is the highest prioirty category and
@@ -963,21 +955,12 @@ scoped_refptr<TileTask> TileManager::CreateRasterTask(
 
   // We can skip the image hijack canvas if we have no images.
   playback_settings.use_image_hijack_canvas = !images.empty();
+
+  // Get the tasks for the required images.
   ImageDecodeController::TracingInfo tracing_info(
       prepare_tiles_count_, prioritized_tile.priority().priority_bin);
-  for (auto it = images.begin(); it != images.end();) {
-    scoped_refptr<TileTask> task;
-    bool need_to_unref_when_finished =
-        image_decode_controller_->GetTaskForImageAndRef(*it, tracing_info,
-                                                        &task);
-    if (task)
-      decode_tasks.push_back(task);
-
-    if (need_to_unref_when_finished)
-      ++it;
-    else
-      it = images.erase(it);
-  }
+  image_manager_.GetTasksForImagesAndRef(&images, &decode_tasks, tracing_info);
+
   bool supports_concurrent_execution = !use_gpu_rasterization_;
   std::unique_ptr<RasterBuffer> raster_buffer =
       raster_buffer_provider_->AcquireBufferForRaster(
@@ -1006,8 +989,7 @@ void TileManager::OnRasterTaskCompleted(
   // Unref all the images.
   auto images_it = scheduled_draw_images_.find(tile->id());
   const std::vector<DrawImage>& images = images_it->second;
-  for (const auto& image : images)
-    image_decode_controller_->UnrefImage(image);
+  image_manager_.UnrefImages(images);
   scheduled_draw_images_.erase(images_it);
 
   if (was_canceled) {
@@ -1157,15 +1139,15 @@ void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   // If we're not in SMOOTHNESS_TAKES_PRIORITY  mode, we should unlock all
   // images since we're technically going idle here at least for this frame.
   if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY) {
-    for (auto& draw_image_pair : locked_images_)
-      image_decode_controller_->UnrefImage(draw_image_pair.first);
+    image_manager_.UnrefImages(locked_images_);
     locked_images_.clear();
+    locked_image_tasks_.clear();
   }
 
   FreeResourcesForReleasedTiles();
 
   resource_pool_->ReduceResourceUsage();
-  image_decode_controller_->ReduceCacheUsage();
+  image_manager_.ReduceMemoryUsage();
 
   signals_.all_tile_tasks_completed = true;
   signals_check_notifier_.Schedule();

cc/tiles/tile_manager.h

@@ -22,7 +22,7 @@
 #include "cc/resources/memory_history.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/tiles/eviction_tile_priority_queue.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_manager.h"
 #include "cc/tiles/raster_tile_priority_queue.h"
 #include "cc/tiles/tile.h"
 #include "cc/tiles/tile_draw_info.h"
@@ -38,6 +38,7 @@ class TracedValue;
 namespace cc {
 class PictureLayerImpl;
 class ResourceProvider;
+class ImageDecodeController;
 
 class CC_EXPORT TileManagerClient {
  public:
@@ -312,7 +313,7 @@ class CC_EXPORT TileManager {
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
   bool did_oom_on_last_assign_;
 
-  ImageDecodeController* image_decode_controller_;
+  ImageManager image_manager_;
 
   RasterTaskCompletionStats flush_stats_;
 
@@ -337,7 +338,8 @@ class CC_EXPORT TileManager {
   uint64_t next_tile_id_;
 
   std::unordered_map<Tile::Id, std::vector<DrawImage>> scheduled_draw_images_;
-  std::vector<std::pair<DrawImage, scoped_refptr<TileTask>>> locked_images_;
+  std::vector<DrawImage> locked_images_;
+  std::vector<scoped_refptr<TileTask>> locked_image_tasks_;
 
   base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;