cc: Add image decode queue functionality to image manager.

cc/tiles/gpu_image_decode_cache.h

Index: cc/tiles/gpu_image_decode_cache.h
diff --git a/cc/tiles/gpu_image_decode_cache.h b/cc/tiles/gpu_image_decode_cache.h
index 34f8dca4c394d1cf8d805d06d66904377ebf3630..08dd6602a8387d82aec4c503444550ef758aa50d 100644
--- a/cc/tiles/gpu_image_decode_cache.h
+++ b/cc/tiles/gpu_image_decode_cache.h
@@ -99,6 +99,8 @@ class CC_EXPORT GpuImageDecodeCache
       public base::trace_event::MemoryDumpProvider,
       public base::MemoryCoordinatorClient {
  public:
+  enum class DecodeTaskType { PART_OF_UPLOAD_TASK, STAND_ALONE_DECODE_TASK };

[enne (OOO), 2017/01/03 21:15:25]

I'm not sure I understand this distinction.  Shouldn't an out of raster decode
also be uploaded?

[vmpstr, 2017/01/03 21:40:34]

Eventually it would be (at raster/tile management). The distinction is that when
we use GetTaskForImageAndRef, what we get back is actually an upload task and it
has a dependency of the decode task. For this to happen, we do extra reffing of
the decode task, because we know that the upload task will unref it.

Since this image queue is only requesting a decode task and not an upload task,
it has to skip these extra refs (so that the behavior is the same as the
software image decode cache). Thus, these are the names. The _decode_ task
itself is either a part of the upload task, or it's a stand alone decode task.

[enne (OOO), 2017/01/03 21:49:42]

Maybe my question is more fundamental? Why is the image queue only requesting a
decode task and not an upload task.  It's going to want to be uploaded
eventually, right?

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

I think the problem here is that the upload task needs to take the worker
context lock, and could contend with other rasterization / upload tasks. This is
more of an issue as the stand alone tasks here are run in their own queue, not
in the tile task worker pool. The worker pool ensures that multiple tasks don't
contend for the worker context lock, but we don't get that for the stand alone
tasks.

I guess the question is whether these tasks *should* actually go in the worker
pool. I think vmpstr@ decided not to do this, as putting them in that pool
requires that they either be marked as low priority, in which case they may not
run until raster has become idle, delaying them longer than a parallel,
always-running, queue. Alternately, they could be scheduled normally, but that
would cause them to block other raster tasks, defeating the purpose of
checkerboarding.

The compromise here was to do the decode in parallel on its own queue, but to
leave the upload as part of the eventual raster task, which allows for it to be
more intelligently scheduled.

I guess there is some concern (maybe on Android), that this change may introduce
another parallel thread?

+
   explicit GpuImageDecodeCache(ContextProvider* context,
                                ResourceFormat decode_format,
                                size_t max_gpu_image_bytes);
@@ -111,6 +113,9 @@ class CC_EXPORT GpuImageDecodeCache
   bool GetTaskForImageAndRef(const DrawImage& image,
                              const TracingInfo& tracing_info,
                              scoped_refptr<TileTask>* task) override;
+  bool GetOutOfRasterDecodeTaskForImageAndRef(
+      const DrawImage& image,
+      scoped_refptr<TileTask>* task) override;
   void UnrefImage(const DrawImage& image) override;
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& draw_image) override;
   void DrawWithImageFinished(const DrawImage& image,
@@ -131,7 +136,8 @@ class CC_EXPORT GpuImageDecodeCache
   void UploadImage(const DrawImage& image);
 
   // Called by Decode / Upload tasks when tasks are finished.
-  void OnImageDecodeTaskCompleted(const DrawImage& image);
+  void OnImageDecodeTaskCompleted(const DrawImage& image,
+                                  DecodeTaskType task_type);
   void OnImageUploadTaskCompleted(const DrawImage& image);
 
   // For testing only.
@@ -167,6 +173,9 @@ class CC_EXPORT GpuImageDecodeCache
     bool decode_failure = false;
     // If non-null, this is the pending decode task for this image.
     scoped_refptr<TileTask> task;
+    // Similar to above, but only is generated if there is no associated upload
+    // generated for this task (ie, this is an out-of-raster request for decode.
+    scoped_refptr<TileTask> stand_alone_task;
 
    private:
     struct UsageStats {
@@ -262,7 +271,15 @@ class CC_EXPORT GpuImageDecodeCache
   // rather than the upload task, if necessary.
   scoped_refptr<TileTask> GetImageDecodeTaskAndRef(
       const DrawImage& image,
-      const TracingInfo& tracing_info);
+      const TracingInfo& tracing_info,
+      DecodeTaskType task_type);
+
+  // Note that this function behaves as if it was public (all of the same locks
+  // need to be acquired).
+  bool GetTaskForImageAndRefInternal(const DrawImage& image,
+                                     const TracingInfo& tracing_info,
+                                     DecodeTaskType task_type,
+                                     scoped_refptr<TileTask>* task);
 
   void RefImageDecode(const DrawImage& draw_image);
   void UnrefImageDecode(const DrawImage& draw_image);