cc: Add image decode queue functionality to image manager.

cc/tiles/image_controller.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_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"
 
 namespace cc {
 
 class CC_EXPORT ImageController {
  public:
-  ImageController();
+  using ImageDecodeRequestId = uint64_t;
+  using ImageDecodedCallback = base::Callback<void(ImageDecodeRequestId)>;
+  explicit ImageController(base::SequencedTaskRunner* task_runner);
   ~ImageController();
 
   void SetImageDecodeCache(ImageDecodeCache* cache);
   void GetTasksForImagesAndRef(
       std::vector<DrawImage>* images,
       std::vector<scoped_refptr<TileTask>>* tasks,
       const ImageDecodeCache::TracingInfo& tracing_info);
   void UnrefImages(const std::vector<DrawImage>& images);
   void ReduceMemoryUsage();
   std::vector<scoped_refptr<TileTask>> SetPredecodeImages(
       std::vector<DrawImage> predecode_images,
       const ImageDecodeCache::TracingInfo& tracing_info);
 
+  ImageDecodeRequestId QueueImageDecode(sk_sp<const SkImage> image,
+                                        const ImageDecodedCallback& callback);
+  void NotifyFrameFinished();
+
+  // Called from the worker thread.
+  void ProcessImageDecodes();
+
  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 StartWorkerThread();
+  void StopWorkerThread();
+
+  void ImageDecodeCompleted(ImageDecodeRequestId id);
+
   ImageDecodeCache* cache_ = nullptr;
   std::vector<DrawImage> predecode_locked_images_;
 
   // Debugging information for crbug.com/650234.
   size_t num_times_cache_was_set_ = 0;
 
+  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* task_runner_ = nullptr;
+  base::Lock lock_;
+  base::ConditionVariable work_available_cv_;
+  std::unique_ptr<base::SimpleThread> worker_thread_;
+
+  bool shutdown_ = true;
+
+  base::WeakPtrFactory<ImageController> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(ImageController);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_IMAGE_CONTROLLER_H_