cc: Simplify Task and its derived classes.

cc/tiles/gpu_image_decode_controller.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_controller.h"
 
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
@@ skipping 39 matching lines @@
   params.fMatrix = draw_image.matrix();
   params.fQuality = draw_image.filter_quality();
 
   return params;
 }
 
 }  // namespace
 
 // 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 ImageDecodeTask {
+class ImageDecodeTaskImpl : public TileTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       uint64_t source_prepare_tiles_id)
-      : controller_(controller),
+      : TileTask(true),
+        controller_(controller),
         image_(draw_image),
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
@@ skipping 14 matching lines @@
   DrawImage image_;
   skia::RefPtr<const SkImage> image_ref_;
   const uint64_t source_prepare_tiles_id_;
 
   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 ImageDecodeTask {
+class ImageUploadTaskImpl : public TileTask {
  public:
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
-                      scoped_refptr<ImageDecodeTask> decode_dependency,
+                      scoped_refptr<TileTask> decode_dependency,
                       uint64_t source_prepare_tiles_id)
-      : ImageDecodeTask(std::move(decode_dependency)),
+      : TileTask(false),
         controller_(controller),
         image_(draw_image),
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
+    dependencies_.push_back(std::move(decode_dependency));
   }
 
   // Override from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     controller_->UploadImage(image_);
   }
 
   void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
   void CompleteOnOriginThread(RasterBufferProvider* provider) override {
     controller_->UploadTaskCompleted(image_);
   }
 
-  // Override from ImageDecodeTask:
-  bool SupportsConcurrentExecution() const override { return false; }
-
  protected:
   ~ImageUploadTaskImpl() override {}
 
  private:
   GpuImageDecodeController* controller_;
   DrawImage image_;
   skia::RefPtr<const SkImage> image_ref_;
   uint64_t source_prepare_tiles_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
@@ skipping 28 matching lines @@
 
 GpuImageDecodeController::~GpuImageDecodeController() {
   // SetShouldAggressivelyFreeResources will zero our limits and free all
   // outstanding image memory.
   SetShouldAggressivelyFreeResources(true);
 }
 
 bool GpuImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& draw_image,
     uint64_t prepare_tiles_id,
-    scoped_refptr<ImageDecodeTask>* task) {
+    scoped_refptr<TileTask>* task) {
   if (SkipImage(draw_image)) {
     *task = nullptr;
     return false;
   }
 
   base::AutoLock lock(lock_);
   const auto image_id = draw_image.image()->uniqueID();
 
   auto found = image_data_.Get(image_id);
   if (found != image_data_.end()) {
     ImageData* image_data = found->second.get();
     if (image_data->is_at_raster) {
       // Image is at-raster, just return, this usage will be at-raster as well.
       *task = nullptr;
       return false;
     }
 
     if (image_data->upload.image) {
       // The image is already uploaded, ref and return.
       RefImage(draw_image);
       *task = nullptr;
       return true;
     }
   }
 
   // We didn't have a pre-uploaded image, so we need an upload task. Try to find
   // an existing one.
-  scoped_refptr<ImageDecodeTask>& existing_task =
+  scoped_refptr<TileTask>& existing_task =
       pending_image_upload_tasks_[image_id];
   if (existing_task) {
     // We had an existing upload task, ref the image and return the task.
     RefImage(draw_image);
     *task = existing_task;
     return true;
   }
 
   // We will be creating a new upload task. If necessary, create a placeholder
   // ImageData to hold the result.
@@ skipping 164 matching lines @@
 
   // 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<ImageDecodeTask>
-GpuImageDecodeController::GetImageDecodeTaskAndRef(const DrawImage& draw_image,
-                                                   uint64_t prepare_tiles_id) {
+scoped_refptr<TileTask> GpuImageDecodeController::GetImageDecodeTaskAndRef(
+    const DrawImage& draw_image,
+    uint64_t prepare_tiles_id) {
   lock_.AssertAcquired();
 
   const uint32_t image_id = draw_image.image()->uniqueID();
 
   // This ref is kept alive while an upload task may need this decode. We
   // release this ref in UploadTaskCompleted.
   RefImageDecode(draw_image);
 
   auto found = image_data_.Peek(image_id);
   if (found != image_data_.end() && found->second->decode.is_locked) {
     // We should never be creating a decode task for an at raster image.
     DCHECK(!found->second->is_at_raster);
     // We should never be creating a decode for an already-uploaded image.
     DCHECK(!found->second->upload.image);
     return nullptr;
   }
 
   // We didn't have an existing locked image, create a task to lock or decode.
-  scoped_refptr<ImageDecodeTask>& existing_task =
+  scoped_refptr<TileTask>& existing_task =
       pending_image_decode_tasks_[image_id];
   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, prepare_tiles_id));
   }
   return existing_task;
 }
@@ skipping 312 matching lines @@
 }
 
 SkImageInfo GpuImageDecodeController::CreateImageInfoForDrawImage(
     const DrawImage& draw_image) const {
   return SkImageInfo::Make(
       draw_image.image()->width(), draw_image.image()->height(),
       ResourceFormatToClosestSkColorType(format_), kPremul_SkAlphaType);
 }
 
 }  // namespace cc