cc: Add image decode queue functionality to image manager.

cc/tiles/gpu_image_decode_cache.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_GPU_IMAGE_DECODE_CACHE_H_
 #define CC_TILES_GPU_IMAGE_DECODE_CACHE_H_
 
 #include <memory>
 #include <unordered_map>
 #include <vector>
@@ skipping 81 matching lines @@
 //      same ImageDatas (and may need to keep these ImageDatas alive independent
 //      of each other), they hold ImageDatas by scoped_refptr. The scoped_refptr
 //      keeps an ImageData alive while it is present in either the
 //      |persistent_cache_| or |in_use_cache_|.
 //
 class CC_EXPORT GpuImageDecodeCache
     : public ImageDecodeCache,
       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);
   ~GpuImageDecodeCache() override;
 
   // ImageDecodeCache overrides.
 
   // Finds the existing uploaded image for the provided DrawImage. Creates an
   // upload task to upload the image if an exsiting image does not exist.
   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,
                              const DecodedDrawImage& decoded_image) override;
   void ReduceCacheUsage() override;
   void SetShouldAggressivelyFreeResources(
       bool aggressively_free_resources) override;
 
   // MemoryDumpProvider overrides.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
   // base::MemoryCoordinatorClient overrides.
   void OnMemoryStateChange(base::MemoryState state) override;
 
   // Called by Decode / Upload tasks.
   void DecodeImage(const DrawImage& image);
   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.
   void SetCachedBytesLimitForTesting(size_t limit) {
     cached_bytes_limit_ = limit;
   }
   size_t GetBytesUsedForTesting() const { return bytes_used_; }
   size_t GetNumCacheEntriesForTesting() const {
     return persistent_cache_.size();
   }
@@ skipping 15 matching lines @@
     void SetLockedData(std::unique_ptr<base::DiscardableMemory> data);
     void ResetData();
     base::DiscardableMemory* data() const { return data_.get(); }
     void mark_used() { usage_stats_.used = true; }
 
     uint32_t ref_count = 0;
     // Set to true if the image was corrupt and could not be decoded.
     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 {
       int lock_count = 1;
       bool used = false;
       bool first_lock_wasted = false;
     };
 
     void ReportUsageStats() const;
 
@@ skipping 75 matching lines @@
   using InUseCacheKey = uint64_t;
 
   // All private functions should only be called while holding |lock_|. Some
   // functions also require the |context_| lock. These are indicated by
   // additional comments.
 
   // Similar to GetTaskForImageAndRef, but gets the dependent decode task
   // 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);
   void RefImage(const DrawImage& draw_image);
   void UnrefImageInternal(const DrawImage& draw_image);
 
   // Called any time the ownership of an object changed. This includes changes
   // to ref-count or to orphaned status.
   void OwnershipChanged(const DrawImage& draw_image, ImageData* image_data);
 
@@ skipping 49 matching lines @@
 
   // We can't release GPU backed SkImages without holding the context lock,
   // so we add them to this list and defer deletion until the next time the lock
   // is held.
   std::vector<sk_sp<SkImage>> images_pending_deletion_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_GPU_IMAGE_DECODE_CACHE_H_