cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

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 49 matching lines @@
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
         image_(draw_image),
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
+    SetTaskTypeId(TASK_TYPE_IMAGE_DECODE);
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     controller_->DecodeImage(image_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {
-    controller_->DecodeTaskCompleted(image_);
-  }
-
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
+  friend class GpuImageDecodeController;
+
   GpuImageDecodeController* controller_;
   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 {
  public:
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       scoped_refptr<ImageDecodeTask> decode_dependency,
                       uint64_t source_prepare_tiles_id)
       : ImageDecodeTask(std::move(decode_dependency)),
         controller_(controller),
         image_(draw_image),
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
+    SetTaskTypeId(TASK_TYPE_IMAGE_UPLOAD);
     DCHECK(!SkipImage(draw_image));
   }
 
   // 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(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {
-    controller_->UploadTaskCompleted(image_);
-  }
-
   // Override from ImageDecodeTask:
   bool SupportsConcurrentExecution() const override { return false; }
 
  protected:
   ~ImageUploadTaskImpl() override {}
 
  private:
+  friend class GpuImageDecodeController;
+
   GpuImageDecodeController* controller_;
   DrawImage image_;
   skia::RefPtr<const SkImage> image_ref_;
   uint64_t source_prepare_tiles_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
 };
 
 GpuImageDecodeController::DecodedImageData::DecodedImageData()
     : ref_count(0), is_locked(false), decode_failure(false) {}
@@ skipping 194 matching lines @@
 
     // We are holding the context lock, so finish cleaning up deleted images
     // now.
     DeletePendingImages();
   } else {
     base::AutoLock lock(lock_);
     cached_bytes_limit_ = kMaxGpuImageBytes;
   }
 }
 
+void GpuImageDecodeController::ImageDecodeTaskCompleted(Task* task) {
+  base::AutoLock lock(lock_);
+  ImageDecodeTaskImpl* decode_task = static_cast<ImageDecodeTaskImpl*>(task);
+  DCHECK(decode_task);
+  // Decode task is complete, remove it from our list of pending tasks.
+  pending_image_decode_tasks_.erase(decode_task->image_.image()->uniqueID());
+
+  // While the decode task is active, we keep a ref on the decoded data.
+  // Release that ref now.
+  UnrefImageDecode(decode_task->image_);
+}
+
+void GpuImageDecodeController::ImageUploadTaskCompleted(Task* task) {
+  base::AutoLock lock(lock_);
+  ImageUploadTaskImpl* upload_task = static_cast<ImageUploadTaskImpl*>(task);
+  DCHECK(upload_task);
+  // Upload task is complete, remove it from our list of pending tasks.
+  pending_image_upload_tasks_.erase(upload_task->image_.image()->uniqueID());
+
+  // 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(upload_task->image_);
+  UnrefImageInternal(upload_task->image_);
+}
+
 void GpuImageDecodeController::DecodeImage(const DrawImage& draw_image) {
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(draw_image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   DCHECK(!found->second->is_at_raster);
   DecodeImageIfNecessary(draw_image, found->second.get());
 }
 
 void GpuImageDecodeController::UploadImage(const DrawImage& draw_image) {
   ContextProvider::ScopedContextLock context_lock(context_);
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(draw_image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   DCHECK(!found->second->is_at_raster);
   UploadImageIfNecessary(draw_image, found->second.get());
 }
 
-void GpuImageDecodeController::DecodeTaskCompleted(
-    const DrawImage& draw_image) {
-  base::AutoLock lock(lock_);
-  // Decode task is complete, remove it from our list of pending tasks.
-  pending_image_decode_tasks_.erase(draw_image.image()->uniqueID());
-
-  // While the decode task is active, we keep a ref on the decoded data.
-  // Release that ref now.
-  UnrefImageDecode(draw_image);
-}
-
-void GpuImageDecodeController::UploadTaskCompleted(
-    const DrawImage& draw_image) {
-  base::AutoLock lock(lock_);
-  // Upload task is complete, remove it from our list of pending tasks.
-  pending_image_upload_tasks_.erase(draw_image.image()->uniqueID());
-
-  // 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) {
   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
@@ skipping 336 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