cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

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 58fc640d8ddabec0022996ae04e2099c2d801543..e757f11d230ab5726c7c75fc219b0672ff7c608d 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -43,7 +43,7 @@ DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
 
 class RasterTaskImpl : public TileTask {
  public:
-  RasterTaskImpl(const Resource* resource,
+  RasterTaskImpl(Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
                  const gfx::Rect& content_rect,
                  const gfx::Rect& invalid_content_rect,
@@ -52,15 +52,17 @@ class RasterTaskImpl : public TileTask {
                  TileResolution tile_resolution,
                  int layer_id,
                  uint64_t source_prepare_tiles_id,
-                 const void* tile,
+                 Tile* tile,
                  uint64_t new_content_id,
                  uint64_t previous_content_id,
                  uint64_t resource_content_id,
                  int source_frame_number,
-                 const base::Callback<void(bool)>& reply,
+                 std::unique_ptr<RasterBuffer> raster_buffer,
                  TileTask::Vector* dependencies,
                  bool supports_concurrent_execution)
-      : TileTask(supports_concurrent_execution, dependencies),
+      : TileTask(TileTask::Type::RASTER,
+                 supports_concurrent_execution,
+                 dependencies),
         resource_(resource),
         raster_source_(std::move(raster_source)),
         content_rect_(content_rect),
@@ -75,7 +77,7 @@ class RasterTaskImpl : public TileTask {
         previous_content_id_(previous_content_id),
         resource_content_id_(resource_content_id),
         source_frame_number_(source_frame_number),
-        reply_(reply) {}
+        raster_buffer_(std::move(raster_buffer)) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
@@ -97,22 +99,13 @@ class RasterTaskImpl : public TileTask {
                              contents_scale_, playback_settings_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(RasterBufferProvider* provider) override {
-    DCHECK(!raster_buffer_);
-    raster_buffer_ = provider->AcquireBufferForRaster(
-        resource_, resource_content_id_, previous_content_id_);
-  }
-  void CompleteOnOriginThread(RasterBufferProvider* provider) override {
-    provider->ReleaseBufferForRaster(std::move(raster_buffer_));
-    reply_.Run(!state().IsFinished());
-  }
-
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
- private:
-  const Resource* resource_;
+  // TODO(prashant.n) Move this class from unnamed namespace to
+  // tile_task_manager.cc and use friend class. crbug.com/599863.
+ public:
+  Resource* resource_;
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
@@ -121,14 +114,14 @@ class RasterTaskImpl : public TileTask {
   TileResolution tile_resolution_;
   int layer_id_;
   uint64_t source_prepare_tiles_id_;
-  const void* tile_;
+  Tile* tile_;
   uint64_t new_content_id_;
   uint64_t previous_content_id_;
   uint64_t resource_content_id_;
   int source_frame_number_;
-  const base::Callback<void(bool)> reply_;
   std::unique_ptr<RasterBuffer> raster_buffer_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
@@ -188,7 +181,7 @@ void InsertNodeForDecodeTask(TaskGraph* graph,
   if (task->dependencies().size()) {
     DCHECK_EQ(task->dependencies().size(), 1u);
     auto* dependency = task->dependencies()[0].get();
-    if (!dependency->HasCompleted()) {
+    if (!dependency->state().IsCompleted()) {
       InsertNodeForDecodeTask(graph, dependency, use_foreground_category,
                               priority);
       graph->edges.push_back(TaskGraph::Edge(dependency, task));
@@ -213,7 +206,7 @@ void InsertNodesForRasterTask(TaskGraph* graph,
     TileTask* decode_task = it->get();
 
     // Skip if already decoded.
-    if (decode_task->HasCompleted())
+    if (decode_task->state().IsCompleted())
       continue;
 
     dependencies++;
@@ -256,7 +249,7 @@ class TaskSetFinishedTaskImpl : public TileTask {
   explicit TaskSetFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& on_task_set_finished_callback)
-      : TileTask(true),
+      : TileTask(TileTask::Type::DEFAULT, true),
         task_runner_(task_runner),
         on_task_set_finished_callback_(on_task_set_finished_callback) {}
 
@@ -266,10 +259,6 @@ class TaskSetFinishedTaskImpl : public TileTask {
     TaskSetFinished();
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
-  void CompleteOnOriginThread(RasterBufferProvider* provider) override {}
-
  protected:
   ~TaskSetFinishedTaskImpl() override {}
 
@@ -357,7 +346,7 @@ void TileManager::FinishTasksAndCleanUp() {
   // |orphan_tasks_|.
   orphan_tasks_.clear();
 
-  tile_task_manager_->CheckForCompletedTasks();
+  CheckForCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
@@ -469,10 +458,8 @@ bool TileManager::PrepareTiles(
 
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
-  if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
-    tile_task_manager_->CheckForCompletedTasks();
-    did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
-  }
+  if (!did_check_for_completed_tasks_since_last_schedule_tasks_)
+    CheckForCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
@@ -507,9 +494,7 @@ void TileManager::Flush() {
     return;
   }
 
-  tile_task_manager_->CheckForCompletedTasks();
-
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  CheckForCompletedTasks();
 
   TRACE_EVENT_INSTANT1("cc", "DidFlush", TRACE_EVENT_SCOPE_THREAD, "stats",
                        RasterTaskCompletionStatsAsValue(flush_stats_));
@@ -795,7 +780,7 @@ void TileManager::ScheduleTasks(
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
     TileTask* task = tile->raster_task_.get();
-    DCHECK(!task->HasCompleted());
+    DCHECK(!task->state().IsCompleted());
 
     if (tile->required_for_activation()) {
       required_for_activate_count++;
@@ -915,57 +900,88 @@ scoped_refptr<TileTask> TileManager::CreateRasterTask(
   }
 
   bool supports_concurrent_execution = !use_gpu_rasterization_;
+  std::unique_ptr<RasterBuffer> raster_buffer =
+      tile_task_manager_->GetRasterBufferProvider()->AcquireBufferForRaster(
+          resource, resource_content_id, tile->invalidated_id());
   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(),
-      base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
-                 tile->id(), resource),
-      &decode_tasks, supports_concurrent_execution));
+      tile->layer_id(), prepare_tiles_count_, tile, tile->id(),
+      tile->invalidated_id(), resource_content_id, tile->source_frame_number(),
+      std::move(raster_buffer), &decode_tasks, supports_concurrent_execution));
 }
 
-void TileManager::OnRasterTaskCompleted(
-    Tile::Id tile_id,
-    Resource* resource,
-    bool was_canceled) {
-  DCHECK(tiles_.find(tile_id) != tiles_.end());
+void TileManager::CheckForCompletedTasks() {
+  Task::Vector completed_tasks;
+  tile_task_manager_->CollectCompletedTasks(&completed_tasks);
+
+  for (auto task : completed_tasks) {
+    TileTask* tile_task = static_cast<TileTask*>(task.get());
+    switch (tile_task->type()) {
+      case TileTask::Type::RASTER:
+        OnRasterTaskCompleted(tile_task);
+        break;
+      case TileTask::Type::IMAGE_DECODE:
+        image_decode_controller_->OnImageDecodeTaskCompleted(tile_task);
+        break;
+      case TileTask::Type::IMAGE_UPLOAD:
+        image_decode_controller_->OnImageUploadTaskCompleted(tile_task);
+        break;
+      case TileTask::Type::DEFAULT:
+        // Do nothing.
+        break;
+      default:
+        NOTREACHED();
+    }
 
-  Tile* tile = tiles_[tile_id];
-  TileDrawInfo& draw_info = tile->draw_info();
-  DCHECK(tile->raster_task_.get());
-  orphan_tasks_.push_back(tile->raster_task_);
-  tile->raster_task_ = nullptr;
+    task->state().DidComplete();
+  }
+
+  completed_tasks.clear();
+  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+}
+
+void TileManager::OnRasterTaskCompleted(TileTask* task) {
+  DCHECK(task);
+  RasterTaskImpl* raster_task = static_cast<RasterTaskImpl*>(task);
+  tile_task_manager_->GetRasterBufferProvider()->ReleaseBufferForRaster(
+      std::move(raster_task->raster_buffer_));
+
+  DCHECK(tiles_.find(raster_task->tile_->id()) != tiles_.end());
+  TileDrawInfo& draw_info = raster_task->tile_->draw_info();
+  DCHECK(raster_task->tile_->raster_task_.get());
+  orphan_tasks_.push_back(raster_task->tile_->raster_task_);
+  raster_task->tile_->raster_task_ = nullptr;
 
   // Unref all the images.
-  auto images_it = scheduled_draw_images_.find(tile->id());
+  auto images_it = scheduled_draw_images_.find(raster_task->tile_->id());
   const std::vector<DrawImage>& images = images_it->second;
   for (const auto& image : images)
     image_decode_controller_->UnrefImage(image);
   scheduled_draw_images_.erase(images_it);
 
-  if (was_canceled) {
+  if (raster_task->state().IsCanceled()) {
     ++flush_stats_.canceled_count;
     // TODO(ericrk): If more partial raster work is done in the future, it may
     // be worth returning the resource to the pool with its previous ID (not
     // currently tracked). crrev.com/1370333002/#ps40001 has a possible method
     // of achieving this.
-    resource_pool_->ReleaseResource(resource, 0 /* content_id */);
+    resource_pool_->ReleaseResource(raster_task->resource_, 0 /* content_id */);
     return;
   }
 
   ++flush_stats_.completed_count;
 
   draw_info.set_use_resource();
-  draw_info.resource_ = resource;
-  draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
+  draw_info.resource_ = raster_task->resource_;
+  draw_info.contents_swizzled_ =
+      DetermineResourceRequiresSwizzle(raster_task->tile_);
 
   DCHECK(draw_info.IsReadyToDraw());
   draw_info.set_was_ever_ready_to_draw();
 
-  client_->NotifyTileStateChanged(tile);
+  client_->NotifyTileStateChanged(raster_task->tile_);
 }
 
 ScopedTilePtr TileManager::CreateTile(const Tile::CreateInfo& info,
@@ -1028,8 +1044,7 @@ bool TileManager::IsReadyToDraw() const {
 
 void TileManager::CheckAndIssueSignals() {
   TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals");
-  tile_task_manager_->CheckForCompletedTasks();
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  CheckForCompletedTasks();
 
   // Ready to activate.
   if (signals_.ready_to_activate && !signals_.did_notify_ready_to_activate) {
@@ -1068,8 +1083,7 @@ void TileManager::CheckAndIssueSignals() {
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
-  tile_task_manager_->CheckForCompletedTasks();
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  CheckForCompletedTasks();
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.