cc: Simplify Task and its derived classes.

cc/tiles/gpu_image_decode_controller.cc

Index: cc/tiles/gpu_image_decode_controller.cc
diff --git a/cc/tiles/gpu_image_decode_controller.cc b/cc/tiles/gpu_image_decode_controller.cc
index ce494063699f53f2a25094edf640e1b4e79ba175..4ef58e16691c310fba7b1140defd5b60644050f6 100644
--- a/cc/tiles/gpu_image_decode_controller.cc
+++ b/cc/tiles/gpu_image_decode_controller.cc
@@ -11,7 +11,7 @@
 #include "base/thread_task_runner_handle.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
-#include "cc/raster/tile_task_runner.h"
+#include "cc/raster/task.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu_image_decode_controller.h"
@@ -57,7 +57,7 @@ SkImage::DeferredTextureImageUsageParams ParamsFromDrawImage(
 
 // 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 Task {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
@@ -67,7 +67,7 @@ class ImageDecodeTaskImpl : public ImageDecodeTask {
         image_ref_(skia::SharePtr(draw_image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
     DCHECK(!SkipImage(draw_image));
-    SetTaskTypeId(TASK_TYPE_IMAGE_DECODE);
+    SetTaskType(TASK_TYPE_IMAGE_DECODE);
   }
 
   // Overridden from Task:
@@ -94,31 +94,30 @@ class ImageDecodeTaskImpl : public ImageDecodeTask {
 // 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 Task {
  public:
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
-                      scoped_refptr<ImageDecodeTask> decode_dependency,
+                      scoped_refptr<Task> decode_dependency,
                       uint64_t source_prepare_tiles_id)
-      : ImageDecodeTask(std::move(decode_dependency)),
+      : Task(),
         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);
+    dependencies_.push_back(std::move(decode_dependency));
+    SetTaskType(TASK_TYPE_IMAGE_UPLOAD);
     DCHECK(!SkipImage(draw_image));
   }
 
   // Override from Task:
+  bool SupportsConcurrentExecution() const override { return false; }
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
     controller_->UploadImage(image_);
   }
 
-  // Override from ImageDecodeTask:
-  bool SupportsConcurrentExecution() const override { return false; }
-
  protected:
   ~ImageUploadTaskImpl() override {}
 
@@ -169,7 +168,7 @@ GpuImageDecodeController::~GpuImageDecodeController() {
 bool GpuImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& draw_image,
     uint64_t prepare_tiles_id,
-    scoped_refptr<ImageDecodeTask>* task) {
+    scoped_refptr<Task>* task) {
   if (SkipImage(draw_image)) {
     *task = nullptr;
     return false;
@@ -197,8 +196,7 @@ bool GpuImageDecodeController::GetTaskForImageAndRef(
 
   // 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 =
-      pending_image_upload_tasks_[image_id];
+  scoped_refptr<Task>& 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);
@@ -384,9 +382,9 @@ void GpuImageDecodeController::UploadImage(const DrawImage& 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<Task> GpuImageDecodeController::GetImageDecodeTaskAndRef(
+    const DrawImage& draw_image,
+    uint64_t prepare_tiles_id) {
   lock_.AssertAcquired();
 
   const uint32_t image_id = draw_image.image()->uniqueID();
@@ -405,8 +403,7 @@ GpuImageDecodeController::GetImageDecodeTaskAndRef(const DrawImage& draw_image,
   }
 
   // We didn't have an existing locked image, create a task to lock or decode.
-  scoped_refptr<ImageDecodeTask>& existing_task =
-      pending_image_decode_tasks_[image_id];
+  scoped_refptr<Task>& 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.