cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

cc/tiles/software_image_decode_controller.cc

 // Copyright 2015 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/software_image_decode_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
@@ skipping 46 matching lines @@
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SoftwareImageDecodeController* controller,
                       const SoftwareImageDecodeController::ImageKey& image_key,
                       const DrawImage& image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
         image_key_(image_key),
         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",
                  "software", "source_prepare_tiles_id",
                  source_prepare_tiles_id_);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_ref_.get());
     controller_->DecodeImage(image_key_, image_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {
-    controller_->RemovePendingTask(image_key_);
-  }
-
  protected:
   ~ImageDecodeTaskImpl() override {}
 
- private:
+ public:
   SoftwareImageDecodeController* controller_;
   SoftwareImageDecodeController::ImageKey image_key_;
   DrawImage image_;
   skia::RefPtr<const SkImage> image_ref_;
   uint64_t source_prepare_tiles_id_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
   // If the requested filter quality did not require scale, then the adjustment
   // is identity.
   if (key.can_use_original_decode())
     return SkSize::Make(1.f, 1.f);
 
   float x_scale =
@@ skipping 518 matching lines @@
   if (!decoded_image.image() || !CanHandleImage(key))
     return;
 
   if (decoded_image.is_at_raster_decode())
     UnrefAtRasterImage(key);
   else
     UnrefImage(image);
   SanityCheckState(__LINE__, false);
 }
 
+void SoftwareImageDecodeController::CompleteTask(Task* task) {
+  ImageDecodeTaskImpl* decode_task = static_cast<ImageDecodeTaskImpl*>(task);
+  DCHECK(decode_task);
+  RemovePendingTask(decode_task->image_key_);
+}
+
 void SoftwareImageDecodeController::RefAtRasterImage(const ImageKey& key) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::RefAtRasterImage", "key",
                key.ToString());
   DCHECK(at_raster_decoded_images_.Peek(key) !=
          at_raster_decoded_images_.end());
   ++at_raster_decoded_images_ref_counts_[key];
 }
 
 void SoftwareImageDecodeController::UnrefAtRasterImage(const ImageKey& key) {
@@ skipping 305 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc