cc: Simplify task and its derived classes.

cc/tiles/tile_manager.cc

Index: cc/tiles/tile_manager.cc
diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index e950484d16003df35daf1d6aad08dec849c8f4d7..1d9b9b5bf286866b9642c2f31b0d22b2585f0679 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -41,7 +41,7 @@ DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
-class RasterTaskImpl : public RasterTask {
+class RasterTaskImpl : public DependencyTask {
  public:
   RasterTaskImpl(const Resource* resource,
                  scoped_refptr<DisplayListRasterSource> raster_source,
@@ -58,8 +58,8 @@ class RasterTaskImpl : public RasterTask {
                  uint64_t resource_content_id,
                  int source_frame_number,
                  const base::Callback<void(bool)>& reply,
-                 ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies),
+                 DependencyTask::Vector* dependencies)
+      : DependencyTask(dependencies),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(content_rect),
@@ -76,7 +76,7 @@ class RasterTaskImpl : public RasterTask {
         source_frame_number_(source_frame_number),
         reply_(reply) {}
 
-  // Overridden from Task:
+  // Overridden from DependencyTask:
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
@@ -96,13 +96,13 @@ class RasterTaskImpl : public RasterTask {
                              contents_scale_, include_images_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {
+  void ScheduleOnOriginThread(DependencyTaskClient* client) override {
     DCHECK(!raster_buffer_);
     raster_buffer_ = client->AcquireBufferForRaster(
         resource_, resource_content_id_, previous_content_id_);
   }
-  void CompleteOnOriginThread(TileTaskClient* client) override {
+
+  void CompleteOnOriginThread(DependencyTaskClient* client) override {
     client->ReleaseBufferForRaster(std::move(raster_buffer_));
     reply_.Run(!HasFinishedRunning());
   }
@@ -142,7 +142,7 @@ const size_t kAllDoneTaskPriority = 3u;
 size_t kTileTaskPriorityBase = 10u;
 
 void InsertNodeForTask(TaskGraph* graph,
-                       TileTask* task,
+                       DependencyTask* task,
                        uint16_t category,
                        uint16_t priority,
                        size_t dependencies) {
@@ -155,8 +155,8 @@ void InsertNodeForTask(TaskGraph* graph,
 }
 
 void InsertNodesForRasterTask(TaskGraph* graph,
-                              RasterTask* raster_task,
-                              const ImageDecodeTask::Vector& decode_tasks,
+                              DependencyTask* raster_task,
+                              const DependencyTask::Vector& decode_tasks,
                               size_t priority,
                               bool use_gpu_rasterization,
                               bool high_priority) {
@@ -180,9 +180,9 @@ void InsertNodesForRasterTask(TaskGraph* graph,
       high_priority ? TASK_CATEGORY_FOREGROUND : TASK_CATEGORY_BACKGROUND;
 
   // Insert image decode tasks.
-  for (ImageDecodeTask::Vector::const_iterator it = decode_tasks.begin();
+  for (DependencyTask::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end(); ++it) {
-    ImageDecodeTask* decode_task = it->get();
+    DependencyTask* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())
@@ -214,7 +214,7 @@ void InsertNodesForRasterTask(TaskGraph* graph,
                     dependencies);
 }
 
-class TaskSetFinishedTaskImpl : public TileTask {
+class TaskSetFinishedTaskImpl : public DependencyTask {
  public:
   explicit TaskSetFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
@@ -222,16 +222,14 @@ class TaskSetFinishedTaskImpl : public TileTask {
       : task_runner_(task_runner),
         on_task_set_finished_callback_(on_task_set_finished_callback) {}
 
-  // Overridden from Task:
+  // Overridden from DependencyTask:
+  void ScheduleOnOriginThread(DependencyTaskClient* client) override {}
+  void CompleteOnOriginThread(DependencyTaskClient* client) override {}
   void RunOnWorkerThread() override {
     TRACE_EVENT0("cc", "TaskSetFinishedTaskImpl::RunOnWorkerThread");
     TaskSetFinished();
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {}
-
  protected:
   ~TaskSetFinishedTaskImpl() override {}
 
@@ -736,13 +734,13 @@ void TileManager::ScheduleTasks(
 
   graph_.Reset();
 
-  scoped_refptr<TileTask> required_for_activation_done_task =
+  scoped_refptr<DependencyTask> required_for_activation_done_task =
       CreateTaskSetFinishedTask(
           &TileManager::DidFinishRunningTileTasksRequiredForActivation);
-  scoped_refptr<TileTask> required_for_draw_done_task =
+  scoped_refptr<DependencyTask> required_for_draw_done_task =
       CreateTaskSetFinishedTask(
           &TileManager::DidFinishRunningTileTasksRequiredForDraw);
-  scoped_refptr<TileTask> all_done_task =
+  scoped_refptr<DependencyTask> all_done_task =
       CreateTaskSetFinishedTask(&TileManager::DidFinishRunningAllTileTasks);
 
   // Build a new task queue containing all task currently needed. Tasks
@@ -756,7 +754,7 @@ void TileManager::ScheduleTasks(
     if (!tile->raster_task_)
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
-    RasterTask* task = tile->raster_task_.get();
+    DependencyTask* task = tile->raster_task_.get();
     DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
@@ -818,7 +816,7 @@ void TileManager::ScheduleTasks(
                                ScheduledTasksStateAsValue());
 }
 
-scoped_refptr<RasterTask> TileManager::CreateRasterTask(
+scoped_refptr<DependencyTask> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
 
@@ -844,7 +842,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
       prioritized_tile.priority().resolution != LOW_RESOLUTION;
 
   // Create and queue all image decode tasks that this tile depends on.
-  ImageDecodeTask::Vector decode_tasks;
+  DependencyTask::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   images.clear();
   if (include_images) {
@@ -853,7 +851,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
   }
 
   for (auto it = images.begin(); it != images.end();) {
-    scoped_refptr<ImageDecodeTask> task;
+    scoped_refptr<DependencyTask> task;
     bool need_to_unref_when_finished =
         image_decode_controller_->GetTaskForImageAndRef(
             *it, prepare_tiles_count_, &task);
@@ -1127,7 +1125,7 @@ TileManager::ScheduledTasksStateAsValue() const {
 
 // Utility function that can be used to create a "Task set finished" task that
 // posts |callback| to |task_runner| when run.
-scoped_refptr<TileTask> TileManager::CreateTaskSetFinishedTask(
+scoped_refptr<DependencyTask> TileManager::CreateTaskSetFinishedTask(
     void (TileManager::*callback)()) {
   return make_scoped_refptr(new TaskSetFinishedTaskImpl(
       task_runner_.get(),