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 68408e4ded02b983d804ccd6e9f0bfea2b3a7abc..e2888b2a765b3d8fb81e28d6367c35360c61982e 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -23,7 +23,6 @@
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
-#include "cc/raster/raster_buffer.h"
 #include "cc/raster/task_category.h"
 #include "cc/raster/tile_task_runner.h"
 #include "cc/tiles/tile.h"
@@ -41,9 +40,10 @@ DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
-class RasterTaskImpl : public RasterTask {
+class RasterTaskImpl : public Task {
  public:
-  RasterTaskImpl(const Resource* resource,
+  RasterTaskImpl(RasterBufferProvider* raster_buffer_provider,
+                 const Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
                  const gfx::Rect& content_rect,
                  const gfx::Rect& invalid_content_rect,
@@ -57,9 +57,8 @@ class RasterTaskImpl : public RasterTask {
                  uint64_t previous_content_id,
                  uint64_t resource_content_id,
                  int source_frame_number,
-                 const base::Callback<void(bool)>& reply,
-                 ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies),
+                 const base::Callback<void(bool)>& reply)
+      : raster_buffer_provider_(raster_buffer_provider),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(content_rect),
@@ -77,6 +76,19 @@ class RasterTaskImpl : public RasterTask {
         reply_(reply) {}
 
   // Overridden from Task:
+  void ScheduleOnOriginThread() override {
+    DCHECK(raster_buffer_provider_);
+    DCHECK(!raster_buffer_);
+    raster_buffer_ = raster_buffer_provider_->AcquireBufferForRaster(
+        resource_, resource_content_id_, previous_content_id_);
+  }
+
+  void CompleteOnOriginThread() override {
+    DCHECK(raster_buffer_provider_);
+    raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer_));
+    reply_.Run(!HasFinishedRunning());
+  }
+
   void RunOnWorkerThread() override {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
@@ -96,21 +108,11 @@ class RasterTaskImpl : public RasterTask {
                              contents_scale_, playback_settings_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {
-    DCHECK(!raster_buffer_);
-    raster_buffer_ = client->AcquireBufferForRaster(
-        resource_, resource_content_id_, previous_content_id_);
-  }
-  void CompleteOnOriginThread(TileTaskClient* client) override {
-    client->ReleaseBufferForRaster(std::move(raster_buffer_));
-    reply_.Run(!HasFinishedRunning());
-  }
-
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
+  RasterBufferProvider* raster_buffer_provider_;
   const Resource* resource_;
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
@@ -142,7 +144,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) {
@@ -155,8 +157,8 @@ void InsertNodeForTask(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) {
@@ -180,9 +182,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())
@@ -218,7 +220,7 @@ void InsertNodesForRasterTask(TaskGraph* graph,
                     dependencies);
 }
 
-class TaskSetFinishedTaskImpl : public TileTask {
+class TaskSetFinishedTaskImpl : public Task {
  public:
   explicit TaskSetFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
@@ -227,15 +229,13 @@ class TaskSetFinishedTaskImpl : public TileTask {
         on_task_set_finished_callback_(on_task_set_finished_callback) {}
 
   // Overridden from Task:
+  void ScheduleOnOriginThread() override {}
+  void CompleteOnOriginThread() 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 {}
 
@@ -740,13 +740,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
@@ -757,10 +756,11 @@ void TileManager::ScheduleTasks(
     DCHECK(tile->draw_info().requires_resource());
     DCHECK(!tile->draw_info().resource_);
 
+    Task::Vector dependencies;
     if (!tile->raster_task_)
-      tile->raster_task_ = CreateRasterTask(prioritized_tile);
+      tile->raster_task_ = CreateRasterTask(prioritized_tile, &dependencies);

[prashant.n, 2016/04/06 14:59:47]

When same tile is rescheduled, this will pose incorrect dependencies.

 
-    RasterTask* task = tile->raster_task_.get();
+    Task* task = tile->raster_task_.get();
     DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
@@ -782,7 +782,7 @@ void TileManager::ScheduleTasks(
     bool high_priority =
         tile->required_for_draw() || tile->required_for_activation() ||
         prioritized_tile.priority().priority_bin == TilePriority::NOW;
-    InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++,
+    InsertNodesForRasterTask(&graph_, task, dependencies, priority++,
                              use_gpu_rasterization_, high_priority);
   }
 
@@ -826,9 +826,11 @@ void TileManager::ScheduleTasks(
                                ScheduledTasksStateAsValue());
 }
 
-scoped_refptr<RasterTask> TileManager::CreateRasterTask(
-    const PrioritizedTile& prioritized_tile) {
+scoped_refptr<Task> TileManager::CreateRasterTask(
+    const PrioritizedTile& prioritized_tile,
+    Task::Vector* dependencies) {
   Tile* tile = prioritized_tile.tile();
+  DCHECK(dependencies);
 
   // Get the resource.
   uint64_t resource_content_id = 0;
@@ -853,7 +855,6 @@ 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;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   images.clear();
   if (!playback_settings.skip_images) {
@@ -865,12 +866,12 @@ 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);
     if (task)
-      decode_tasks.push_back(task);
+      dependencies->push_back(task);
 
     if (need_to_unref_when_finished)
       ++it;
@@ -879,15 +880,14 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
   }
 
   return make_scoped_refptr(new RasterTaskImpl(
-      resource, prioritized_tile.raster_source(), tile->content_rect(),
-      tile->invalidated_content_rect(), tile->contents_scale(),
-      playback_settings, prioritized_tile.priority().resolution,
-      tile->layer_id(), prepare_tiles_count_, static_cast<const void*>(tile),
-      tile->id(), tile->invalidated_id(), resource_content_id,
-      tile->source_frame_number(),
+      tile_task_runner_, resource, prioritized_tile.raster_source(),
+      tile->content_rect(), tile->invalidated_content_rect(),
+      tile->contents_scale(), playback_settings,
+      prioritized_tile.priority().resolution, tile->layer_id(),
+      prepare_tiles_count_, static_cast<const void*>(tile), tile->id(),
+      tile->invalidated_id(), resource_content_id, tile->source_frame_number(),
       base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
-                 tile->id(), resource),
-      &decode_tasks));
+                 tile->id(), resource)));
 }
 
 void TileManager::OnRasterTaskCompleted(
@@ -1140,7 +1140,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(),