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 "cc/debug/devtools_instrumentation.h"
 #include "cc/raster/tile_task_runner.h"
 #include "skia/ext/refptr.h"
 
 namespace cc {
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
         image_(image),
         image_ref_(skia::SharePtr(image.image())),
-        source_prepare_tiles_id_(source_prepare_tiles_id) {}
+        source_prepare_tiles_id_(source_prepare_tiles_id) {
+    SetTaskTypeId(kImageDecodeTaskTypeId);
+  }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_ref_.get());
     controller_->DecodeImage(image_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {
-    controller_->RemovePendingTaskForImage(image_);
-  }
-
  protected:
   ~ImageDecodeTaskImpl() 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(ImageDecodeTaskImpl);
 };
 
 GpuImageDecodeController::GpuImageDecodeController() {}
 
@@ skipping 26 matching lines @@
 
 DecodedDrawImage GpuImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
 }
 
 void GpuImageDecodeController::DrawWithImageFinished(
     const DrawImage& image,
     const DecodedDrawImage& decoded_image) {}
 
+void GpuImageDecodeController::CompleteTask(Task* task) {
+  ImageDecodeTaskImpl* decode_task = static_cast<ImageDecodeTaskImpl*>(task);
+  DCHECK(decode_task);
+  RemovePendingTaskForImage(decode_task->image_);
+}
+
 void GpuImageDecodeController::ReduceCacheUsage() {}
 
 void GpuImageDecodeController::DecodeImage(const DrawImage& image) {
   image.image()->preroll();
   base::AutoLock lock(lock_);
   prerolled_images_.insert(image.image()->uniqueID());
 }
 
 void GpuImageDecodeController::RemovePendingTaskForImage(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   pending_image_tasks_.erase(image.image()->uniqueID());
 }
 
 }  // namespace cc