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

cc/tiles/image_manager.cc

Index: cc/tiles/image_manager.cc
diff --git a/cc/tiles/image_manager.cc b/cc/tiles/image_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cb11e9ec19266ae01c1577b07fb3b2dfe7e13996
--- /dev/null
+++ b/cc/tiles/image_manager.cc
@@ -0,0 +1,46 @@
+// 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;

[enne (OOO), 2016/09/15 17:42:15]

This is an awkward API.  I realize that the image decode controller you get is
created elsewhere.  But, what happens when this changes? Should this be a const
constructor arg and then you create a new image manager?

[vmpstr, 2016/09/15 18:16:35]

So you're absolutely right that this can change. For example when we fallback
from ganesh to sw, this would be a new controller. What I'm trying to do here is
isolate common code from the IDC which is specific to gpu/sw. 

When we create TileManager (which owns this ImageManager), we don't actually
have an image decode controller, it gets created later and we get a
TileManager::SetResources call... I think it makes sense that this class handles
the fact that old controller is gone and a new one is set. WDYT?

[enne (OOO), 2016/09/15 18:27:02]

Ok, that's fine if you want to just handle it here when this class has members
where it matters.

+}
+
+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