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 d86642eb74c592db7a29d92c78edba2599653cb5..8a01ba0bc316d6912ad99c410187b6fdff1321e4 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -25,7 +25,6 @@
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/raster/task_category.h"
-#include "cc/raster/tile_task_runner.h"
 #include "cc/tiles/tile.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
@@ -41,7 +40,7 @@ DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
-class RasterTaskImpl : public RasterTask {
+class RasterTaskImpl : public Task {
  public:
   RasterTaskImpl(Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
@@ -58,8 +57,8 @@ class RasterTaskImpl : public RasterTask {
                  uint64_t resource_content_id,
                  int source_frame_number,
                  std::unique_ptr<RasterBuffer> raster_buffer,
-                 ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies),
+                 Task::Vector* dependencies)
+      : Task(dependencies),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(content_rect),
@@ -75,7 +74,7 @@ class RasterTaskImpl : public RasterTask {
         resource_content_id_(resource_content_id),
         source_frame_number_(source_frame_number),
         raster_buffer_(std::move(raster_buffer)) {
-    SetTaskTypeId(TASK_TYPE_RASTER);
+    SetTaskType(TASK_TYPE_RASTER);
   }
 
   // Overridden from Task:
@@ -133,7 +132,7 @@ const size_t kAllDoneTaskPriority = 3u;
 size_t kTileTaskPriorityBase = 10u;
 
 void InsertNodeForTask(TaskGraph* graph,
-                       TileTask* task,
+                       Task* task,
                        uint16_t category,
                        uint16_t priority,
                        size_t dependencies) {
@@ -146,15 +145,20 @@ void InsertNodeForTask(TaskGraph* graph,
 }
 
 void InsertNodeForDecodeTask(TaskGraph* graph,
-                             ImageDecodeTask* task,
+                             Task* task,
                              uint16_t category,
                              uint16_t priority) {
   uint32_t dependency_count = 0u;
-  auto* dependency = task->dependency().get();
-  if (dependency && !dependency->HasCompleted()) {
-    InsertNodeForDecodeTask(graph, dependency, category, priority);
-    graph->edges.push_back(TaskGraph::Edge(dependency, task));
-    dependency_count = 1u;
+
+  if (task->dependencies().size()) {
+    DCHECK_EQ(task->dependencies().size(), 1u);
+    Task* dependency = task->dependencies()[0].get();
+
+    if (!dependency->HasCompleted()) {
+      InsertNodeForDecodeTask(graph, dependency, category, priority);
+      graph->edges.push_back(TaskGraph::Edge(dependency, task));
+      dependency_count = 1u;
+    }
   }
   InsertNodeForTask(graph, task, task->SupportsConcurrentExecution()
                                      ? category
@@ -163,8 +167,8 @@ void InsertNodeForDecodeTask(TaskGraph* graph,
 }
 
 void InsertNodesForRasterTask(TaskGraph* graph,
-                              RasterTask* raster_task,
-                              const ImageDecodeTask::Vector& decode_tasks,
+                              Task* raster_task,
+                              const Task::Vector& decode_tasks,
                               size_t priority,
                               bool use_gpu_rasterization,
                               bool high_priority) {
@@ -188,9 +192,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 (Task::Vector::const_iterator it = decode_tasks.begin();
        it != decode_tasks.end(); ++it) {
-    ImageDecodeTask* decode_task = it->get();
+    Task* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())
@@ -227,7 +231,7 @@ void InsertNodesForRasterTask(TaskGraph* graph,
                     dependencies);
 }
 
-class TaskSetFinishedTaskImpl : public TileTask {
+class TaskSetFinishedTaskImpl : public Task {
  public:
   explicit TaskSetFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
@@ -741,13 +745,12 @@ void TileManager::ScheduleTasks(
 
   graph_.Reset();
 
-  scoped_refptr<TileTask> required_for_activation_done_task =
+  scoped_refptr<Task> required_for_activation_done_task =
       CreateTaskSetFinishedTask(
           &TileManager::DidFinishRunningTileTasksRequiredForActivation);
-  scoped_refptr<TileTask> required_for_draw_done_task =
-      CreateTaskSetFinishedTask(
-          &TileManager::DidFinishRunningTileTasksRequiredForDraw);
-  scoped_refptr<TileTask> all_done_task =
+  scoped_refptr<Task> required_for_draw_done_task = CreateTaskSetFinishedTask(
+      &TileManager::DidFinishRunningTileTasksRequiredForDraw);
+  scoped_refptr<Task> all_done_task =
       CreateTaskSetFinishedTask(&TileManager::DidFinishRunningAllTileTasks);
 
   // Build a new task queue containing all task currently needed. Tasks
@@ -761,7 +764,7 @@ void TileManager::ScheduleTasks(
     if (!tile->raster_task_)
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
-    RasterTask* task = tile->raster_task_.get();
+    Task* task = tile->raster_task_.get();
     DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
@@ -827,7 +830,7 @@ void TileManager::ScheduleTasks(
                                ScheduledTasksStateAsValue());
 }
 
-scoped_refptr<RasterTask> TileManager::CreateRasterTask(
+scoped_refptr<Task> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
 
@@ -854,7 +857,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;
+  Task::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   images.clear();
   if (!playback_settings.skip_images) {
@@ -866,7 +869,7 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
   // |playback_settings| here if |images| is empty.
 
   for (auto it = images.begin(); it != images.end();) {
-    scoped_refptr<ImageDecodeTask> task;
+    scoped_refptr<Task> task;
     bool need_to_unref_when_finished =
         image_decode_controller_->GetTaskForImageAndRef(
             *it, prepare_tiles_count_, &task);
@@ -896,7 +899,7 @@ void TileManager::CheckAndProcessCompletedTasks() {
   tile_task_worker_pool_->CollectCompletedTasks(&completed_tasks);
 
   for (auto task : completed_tasks) {
-    switch (task->GetTaskTypeId()) {
+    switch (task->GetTaskType()) {
       case TASK_TYPE_IMAGE_DECODE:
         image_decode_controller_->ImageDecodeTaskCompleted(task.get());
         break;
@@ -906,9 +909,12 @@ void TileManager::CheckAndProcessCompletedTasks() {
       case TASK_TYPE_RASTER:
         RasterTaskCompleted(task.get());
         break;
+      default:
+        // Do nothing for other types of tasks.
+        break;
     }
 
-    static_cast<TileTask*>(task.get())->DidComplete();
+    task->DidComplete();
   }
 
   completed_tasks.clear();
@@ -1166,7 +1172,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<Task> TileManager::CreateTaskSetFinishedTask(
     void (TileManager::*callback)()) {
   return make_scoped_refptr(new TaskSetFinishedTaskImpl(
       task_runner_.get(),