cc: Add image decode queue functionality to image manager.

cc/tiles/image_controller.h

Index: cc/tiles/image_controller.h
diff --git a/cc/tiles/image_controller.h b/cc/tiles/image_controller.h
index d64282f8e9040c09d0deee671c90e529fa5cb3b8..8a53edc89bee589750f08fa9a847b831ba5c32e0 100644
--- a/cc/tiles/image_controller.h
+++ b/cc/tiles/image_controller.h
@@ -5,11 +5,15 @@
 #ifndef CC_TILES_IMAGE_CONTROLLER_H_
 #define CC_TILES_IMAGE_CONTROLLER_H_
 
+#include <set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/simple_thread.h"
 #include "cc/base/cc_export.h"
+#include "cc/base/unique_notifier.h"
 #include "cc/playback/draw_image.h"
 #include "cc/raster/tile_task.h"
 #include "cc/tiles/image_decode_cache.h"
@@ -18,7 +22,11 @@ namespace cc {
 
 class CC_EXPORT ImageController {
  public:
-  ImageController();
+  using ImageDecodeRequestId = uint64_t;
+  using ImageDecodedCallback = base::Callback<void(ImageDecodeRequestId)>;
+  explicit ImageController(
+      base::SequencedTaskRunner* origin_task_runner,
+      scoped_refptr<base::SequencedTaskRunner> worker_task_runner);
   ~ImageController();
 
   void SetImageDecodeCache(ImageDecodeCache* cache);
@@ -32,10 +40,58 @@ class CC_EXPORT ImageController {
       std::vector<DrawImage> predecode_images,
       const ImageDecodeCache::TracingInfo& tracing_info);
 
+  ImageDecodeRequestId QueueImageDecode(sk_sp<const SkImage> image,
+                                        const ImageDecodedCallback& callback);
+  void NotifyFrameFinished();
+
  private:
+  struct ImageDecodeRequest {
+    ImageDecodeRequest();
+    ImageDecodeRequest(ImageDecodeRequestId id,
+                       const DrawImage& draw_image,
+                       const ImageDecodedCallback& callback,
+                       scoped_refptr<TileTask> task,
+                       bool need_unref);
+    ImageDecodeRequest(ImageDecodeRequest&& other);
+    ImageDecodeRequest(const ImageDecodeRequest& other);
+    ~ImageDecodeRequest();
+
+    ImageDecodeRequest& operator=(ImageDecodeRequest&& other);
+    ImageDecodeRequest& operator=(const ImageDecodeRequest& other);
+
+    ImageDecodeRequestId id;
+    DrawImage draw_image;
+    ImageDecodedCallback callback;
+    scoped_refptr<TileTask> task;
+    bool need_unref;
+  };
+
+  void ResumeWorkerTasks();
+  void StopWorkerTasks();
+
+  // Called from the worker thread.
+  void ProcessNextImageDecodeOnWorkerThread();
+
+  void ImageDecodeCompleted(ImageDecodeRequestId id);
+
   ImageDecodeCache* cache_ = nullptr;
   std::vector<DrawImage> predecode_locked_images_;
 
+  static ImageDecodeRequestId s_next_image_decode_queue_id_;
+  std::map<ImageDecodeRequestId, ImageDecodeRequest> image_decode_queue_;
+  std::map<ImageDecodeRequestId, ImageDecodeRequest>
+      requests_needing_completion_;
+  std::vector<std::pair<DrawImage, int>> requested_locked_images_;
+
+  base::SequencedTaskRunner* origin_task_runner_ = nullptr;
+  base::Lock lock_;

[ericrk, 2017/01/04 07:48:31]

nit: can you indicate which variables can be accessed with/without locking? It
seems like the general pattern for most of these is only to initialize at setup
or when no tasks are running, but it would be good to indicate this more
clearly.

[vmpstr, 2017/01/06 01:19:03]

Done.

+
+  scoped_refptr<base::SequencedTaskRunner> worker_task_runner_;
+
+  bool abort_tasks_ = false;
+
+  base::WeakPtrFactory<ImageController> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageController);
 };