cc: Add image decode queue functionality to image manager.

cc/tiles/gpu_image_decode_cache.cc

 // 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/gpu_image_decode_cache.h"
 
 #include <inttypes.h>
 
 #include "base/debug/alias.h"
 #include "base/memory/discardable_memory_allocator.h"
@@ skipping 131 matching lines @@
 GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(InUseCacheEntry&&) =
     default;
 GpuImageDecodeCache::InUseCacheEntry::~InUseCacheEntry() = default;
 
 // Task which decodes an image and stores the result in discardable memory.
 // This task does not use GPU resources and can be run on any thread.
 class ImageDecodeTaskImpl : public TileTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeCache* cache,
                       const DrawImage& draw_image,
-                      const ImageDecodeCache::TracingInfo& tracing_info)
+                      const ImageDecodeCache::TracingInfo& tracing_info,
+                      GpuImageDecodeCache::DecodeTaskType task_type)
       : TileTask(true),
         cache_(cache),
         image_(draw_image),
-        tracing_info_(tracing_info) {
+        tracing_info_(tracing_info),
+        task_type_(task_type) {
     DCHECK(!SkipImage(draw_image));
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", tracing_info_.prepare_tiles_id);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_.image().get(),
         devtools_instrumentation::ScopedImageDecodeTask::GPU);
     cache_->DecodeImage(image_);
   }
 
   // Overridden from TileTask:
   void OnTaskCompleted() override {
-    cache_->OnImageDecodeTaskCompleted(image_);
+    cache_->OnImageDecodeTaskCompleted(image_, task_type_);
   }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   GpuImageDecodeCache* cache_;
   DrawImage image_;
   const ImageDecodeCache::TracingInfo tracing_info_;
+  const GpuImageDecodeCache::DecodeTaskType task_type_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 // Task which creates an image from decoded data. Typically this involves
 // uploading data to the GPU, which requires this task be run on the non-
 // concurrent thread.
 class ImageUploadTaskImpl : public TileTask {
  public:
   ImageUploadTaskImpl(GpuImageDecodeCache* cache,
@@ skipping 181 matching lines @@
   // It is safe to unregister, even if we didn't register in the constructor.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
   // Unregister this component with memory_coordinator::ClientRegistry.
   base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
 bool GpuImageDecodeCache::GetTaskForImageAndRef(const DrawImage& draw_image,
                                                 const TracingInfo& tracing_info,
                                                 scoped_refptr<TileTask>* task) {
+  return GetTaskForImageAndRefInternal(
+      draw_image, tracing_info, DecodeTaskType::PART_OF_UPLOAD_TASK, task);
+}
+
+bool GpuImageDecodeCache::GetOutOfRasterDecodeTaskForImageAndRef(
+    const DrawImage& draw_image,
+    scoped_refptr<TileTask>* task) {
+  return GetTaskForImageAndRefInternal(
+      draw_image, TracingInfo(), DecodeTaskType::STAND_ALONE_DECODE_TASK, task);
+}
+
+bool GpuImageDecodeCache::GetTaskForImageAndRefInternal(
+    const DrawImage& draw_image,
+    const TracingInfo& tracing_info,
+    DecodeTaskType task_type,
+    scoped_refptr<TileTask>* task) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::GetTaskForImageAndRef");
   if (SkipImage(draw_image)) {
     *task = nullptr;
     return false;
   }
 
   base::AutoLock lock(lock_);
   const auto image_id = draw_image.image()->uniqueID();
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   scoped_refptr<ImageData> new_data;
   if (!image_data) {
     // We need an ImageData, create one now.
     new_data = CreateImageData(draw_image);
     image_data = new_data.get();
   } else if (image_data->is_at_raster) {
     // Image is at-raster, just return, this usage will be at-raster as well.
     *task = nullptr;
     return false;
   } else if (image_data->decode.decode_failure) {
     // We have already tried and failed to decode this image, so just return.
     *task = nullptr;
     return false;
   } else if (image_data->upload.image()) {
     // The image is already uploaded, ref and return.
     RefImage(draw_image);
     *task = nullptr;
     return true;
-  } else if (image_data->upload.task) {
+  } else if (task_type == DecodeTaskType::PART_OF_UPLOAD_TASK &&
+             image_data->upload.task) {
     // We had an existing upload task, ref the image and return the task.
     RefImage(draw_image);
     *task = image_data->upload.task;
     return true;
+  } else if (task_type == DecodeTaskType::STAND_ALONE_DECODE_TASK &&
+             image_data->decode.stand_alone_task) {
+    // We had an existing out of raster task, ref the image and return the task.
+    RefImage(draw_image);
+    *task = image_data->decode.stand_alone_task;
+    return true;
   }
 
   // Ensure that the image we're about to decode/upload will fit in memory.
   if (!EnsureCapacity(image_data->size)) {
     // Image will not fit, do an at-raster decode.
     *task = nullptr;
     return false;
   }
 
   // If we had to create new image data, add it to our map now that we know it
   // will fit.
   if (new_data)
     persistent_cache_.Put(image_id, std::move(new_data));
 
-  // Ref image and create a upload and decode tasks. We will release this ref
-  // in UploadTaskCompleted.
-  RefImage(draw_image);
-  *task = make_scoped_refptr(new ImageUploadTaskImpl(
-      this, draw_image, GetImageDecodeTaskAndRef(draw_image, tracing_info),
-      tracing_info));
-  image_data->upload.task = *task;
+  if (task_type == DecodeTaskType::PART_OF_UPLOAD_TASK) {
+    // Ref image and create a upload and decode tasks. We will release this ref
+    // in UploadTaskCompleted.
+    RefImage(draw_image);
+    *task = make_scoped_refptr(new ImageUploadTaskImpl(
+        this, draw_image,
+        GetImageDecodeTaskAndRef(draw_image, tracing_info, task_type),
+        tracing_info));
+    image_data->upload.task = *task;
+  } else {
+    *task = GetImageDecodeTaskAndRef(draw_image, tracing_info, task_type);
+  }
 
   // Ref the image again - this ref is owned by the caller, and it is their
   // responsibility to release it by calling UnrefImage.
   RefImage(draw_image);
   return true;
 }
 
 void GpuImageDecodeCache::UnrefImage(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::UnrefImage");
@@ skipping 193 matching lines @@
                "GpuImageDecodeCache::UploadImage");
   ContextProvider::ScopedContextLock context_lock(context_);
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(!image_data->is_at_raster);
   UploadImageIfNecessary(draw_image, image_data);
 }
 
 void GpuImageDecodeCache::OnImageDecodeTaskCompleted(
-    const DrawImage& draw_image) {
+    const DrawImage& draw_image,
+    DecodeTaskType task_type) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::OnImageDecodeTaskCompleted");
   base::AutoLock lock(lock_);
   // Decode task is complete, remove our reference to it.
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
-  DCHECK(image_data->decode.task);
-  image_data->decode.task = nullptr;
+  if (task_type == DecodeTaskType::PART_OF_UPLOAD_TASK) {
+    DCHECK(image_data->decode.task);
+    image_data->decode.task = nullptr;
+  } else {
+    DCHECK(task_type == DecodeTaskType::STAND_ALONE_DECODE_TASK);
+    DCHECK(image_data->decode.stand_alone_task);
+    image_data->decode.stand_alone_task = nullptr;
+  }
 
   // While the decode task is active, we keep a ref on the decoded data.
   // Release that ref now.
   UnrefImageDecode(draw_image);
 }
 
 void GpuImageDecodeCache::OnImageUploadTaskCompleted(
     const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::OnImageUploadTaskCompleted");
   base::AutoLock lock(lock_);
   // Upload task is complete, remove our reference to it.
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(image_data->upload.task);
   image_data->upload.task = nullptr;
 
   // While the upload task is active, we keep a ref on both the image it will be
   // populating, as well as the decode it needs to populate it. Release these
   // refs now.
   UnrefImageDecode(draw_image);
   UnrefImageInternal(draw_image);
 }
 
 // Checks if an existing image decode exists. If not, returns a task to produce
 // the requested decode.
 scoped_refptr<TileTask> GpuImageDecodeCache::GetImageDecodeTaskAndRef(
     const DrawImage& draw_image,
-    const TracingInfo& tracing_info) {
+    const TracingInfo& tracing_info,
+    DecodeTaskType task_type) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::GetImageDecodeTaskAndRef");
   lock_.AssertAcquired();
 
   // This ref is kept alive while an upload task may need this decode. We
   // release this ref in UploadTaskCompleted.
-  RefImageDecode(draw_image);
+  if (task_type == DecodeTaskType::PART_OF_UPLOAD_TASK)
+    RefImageDecode(draw_image);
 
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   if (image_data->decode.is_locked()) {
     // We should never be creating a decode task for an at raster image.
     DCHECK(!image_data->is_at_raster);
     // We should never be creating a decode for an already-uploaded image.
     DCHECK(!image_data->upload.image());
     return nullptr;
   }
 
   // We didn't have an existing locked image, create a task to lock or decode.
-  scoped_refptr<TileTask>& existing_task = image_data->decode.task;
+  scoped_refptr<TileTask>& existing_task =

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

I assume we can't end up decoding an image twice in parallel by enqueuing a
normal decode of an image that is already has a pending stand alone image? Once
we have decided to checkerboard an image, I assume that we just keep using the
checkerboarded version until the decode task completes?

Can you add a DCHECK to ensure that if we are PART_OF_UPLOAD_TASK then
stand_alone_task is nullptr?

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

That's not necessarily true, since which image is requested is up to the
developer (this is for a js controller image decoding). For image
checkerboarding I agree that that should be case, but I think in general it
doesn't have to be. You're right that we would decode twice, but that's still
possible :(

When adding image checkering, we can add specific dchecks for that. Does that
sound OK?

[ericrk, 2017/01/09 21:07:27]

Sounds good to me - there's probably something we could do to make it so that an
image which is in the process of being decoded doesn't have a second task
started (short-circuits)... can you open a bug for looking into this.

+      (task_type == DecodeTaskType::PART_OF_UPLOAD_TASK)
+          ? image_data->decode.task
+          : image_data->decode.stand_alone_task;
   if (!existing_task) {
     // Ref image decode and create a decode task. This ref will be released in
     // DecodeTaskCompleted.
     RefImageDecode(draw_image);
     existing_task = make_scoped_refptr(
-        new ImageDecodeTaskImpl(this, draw_image, tracing_info));
+        new ImageDecodeTaskImpl(this, draw_image, tracing_info, task_type));
   }
   return existing_task;
 }
 
 void GpuImageDecodeCache::RefImageDecode(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "GpuImageDecodeCache::RefImageDecode");
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
@@ skipping 126 matching lines @@
   if (image_data->upload.ref_count == 0 && image_data->upload.budgeted &&
       !image_data->upload.image()) {
     DCHECK_GE(bytes_used_, image_data->size);
     bytes_used_ -= image_data->size;
     image_data->upload.budgeted = false;
   }
 
   // We should unlock the discardable memory for the image in two cases:
   // 1) The image is no longer being used (no decode or upload refs).
   // 2) This is a GPU backed image that has already been uploaded (no decode
-  //    refs).
+  //    refs, and we actually already have an image).
   bool should_unlock_discardable =
-      !has_any_refs || (image_data->mode == DecodedDataMode::GPU &&
-                        !image_data->decode.ref_count);
+      !has_any_refs ||
+      (image_data->mode == DecodedDataMode::GPU &&
+       !image_data->decode.ref_count && image_data->upload.image());
 
   if (should_unlock_discardable && image_data->decode.is_locked()) {
     DCHECK(image_data->decode.data());
     image_data->decode.Unlock();
   }
 
 #if DCHECK_IS_ON()
   // Sanity check the above logic.
   if (image_data->upload.image()) {
     DCHECK(image_data->is_at_raster || image_data->upload.budgeted);
@@ skipping 357 matching lines @@
       EnsureCapacity(0);
       break;
     }
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc