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 2af48b5fcf490ad6517bf2b493e9586a9f54efd9..2ab6189dc2b005b7bda803510e62bad3b84a2ebb 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc
@@ -44,7 +44,7 @@ DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
 
 class RasterTaskImpl : public RasterTask {
  public:
-  RasterTaskImpl(const Resource* resource,
+  RasterTaskImpl(Resource* resource,
                  scoped_refptr<RasterSource> raster_source,
                  const gfx::Rect& content_rect,
                  const gfx::Rect& invalid_content_rect,
@@ -53,12 +53,12 @@ class RasterTaskImpl : public RasterTask {
                  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,
                  ImageDecodeTask::Vector* dependencies)
       : RasterTask(dependencies),
         resource_(resource),
@@ -75,7 +75,9 @@ class RasterTaskImpl : public RasterTask {
         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)) {
+    SetTaskTypeId(kRasterTaskTypeId);
+  }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
@@ -97,22 +99,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_); }
+  ~RasterTaskImpl() override {}
 
- private:
-  const Resource* resource_;
+ public:
+  Resource* resource_;
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
@@ -121,14 +112,14 @@ class RasterTaskImpl : public RasterTask {
   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);
 };
 
@@ -233,10 +224,6 @@ class TaskSetFinishedTaskImpl : public TileTask {
     TaskSetFinished();
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {}
-
  protected:
   ~TaskSetFinishedTaskImpl() override {}
 
@@ -292,7 +279,7 @@ TileManager::TileManager(TileManagerClient* client,
       use_partial_raster_(use_partial_raster),
       use_gpu_rasterization_(false),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
-      did_check_for_completed_tasks_since_last_schedule_tasks_(true),
+      did_check_and_process_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       more_tiles_need_prepare_check_notifier_(
           task_runner_.get(),
@@ -324,7 +311,7 @@ void TileManager::FinishTasksAndCleanUp() {
   // |orphan_tasks_|.
   orphan_tasks_.clear();
 
-  tile_task_runner_->CheckForCompletedTasks();
+  CheckAndProcessCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
@@ -434,12 +421,10 @@ bool TileManager::PrepareTiles(
   signals_.reset();
   global_state_ = state;
 
-  // We need to call CheckForCompletedTasks() once in-between each call
+  // We need to call CheckAndProcessCompletedTasks() 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_runner_->CheckForCompletedTasks();
-    did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
-  }
+  if (!did_check_and_process_completed_tasks_since_last_schedule_tasks_)
+    CheckAndProcessCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
@@ -474,9 +459,7 @@ void TileManager::Flush() {
     return;
   }
 
-  tile_task_runner_->CheckForCompletedTasks();
-
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  CheckAndProcessCompletedTasks();
 
   TRACE_EVENT_INSTANT1("cc", "DidFlush", TRACE_EVENT_SCOPE_THREAD, "stats",
                        RasterTaskCompletionStatsAsValue(flush_stats_));
@@ -718,7 +701,7 @@ void TileManager::ScheduleTasks(
   TRACE_EVENT1("cc", "TileManager::ScheduleTasks", "count",
                tiles_that_need_to_be_rasterized.size());
 
-  DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
+  DCHECK(did_check_and_process_completed_tasks_since_last_schedule_tasks_);
 
   if (!has_scheduled_tile_tasks_) {
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
@@ -821,7 +804,7 @@ void TileManager::ScheduleTasks(
   required_for_draw_done_task_ = std::move(required_for_draw_done_task);
   all_done_task_ = std::move(all_done_task);
 
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
+  did_check_and_process_completed_tasks_since_last_schedule_tasks_ = false;
 
   TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
                                ScheduledTasksStateAsValue());
@@ -879,25 +862,45 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
       it = images.erase(it);
   }
 
+  std::unique_ptr<RasterBuffer> raster_buffer =
+      tile_task_runner_->AsTileTaskClient()->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));
+      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));
 }
 
-void TileManager::OnRasterTaskCompleted(
-    Tile::Id tile_id,
-    Resource* resource,
-    bool was_canceled) {
-  DCHECK(tiles_.find(tile_id) != tiles_.end());
+void TileManager::CheckAndProcessCompletedTasks() {
+  Task::Vector completed_tasks;
+  tile_task_runner_->CollectCompletedTasks(&completed_tasks);
+
+  for (auto task : completed_tasks) {
+    if (task->GetTaskTypeId() == kImageDecodeTaskTypeId) {
+      image_decode_controller_->CompleteTask(task.get());
+    } else if (task->GetTaskTypeId() == kRasterTaskTypeId) {
+      RasterTaskImpl* raster_task = static_cast<RasterTaskImpl*>(task.get());
+      DCHECK(raster_task);
+      CompleteRasterTask(raster_task->tile_, raster_task->resource_,
+                         !raster_task->HasFinishedRunning());
+    }
+
+    static_cast<TileTask*>(task.get())->DidComplete();
+  }
+
+  completed_tasks.clear();
+
+  did_check_and_process_completed_tasks_since_last_schedule_tasks_ = true;
+}
+
+void TileManager::CompleteRasterTask(Tile* tile,
+                                     Resource* resource,
+                                     bool was_canceled) {
+  DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
-  Tile* tile = tiles_[tile_id];
   TileDrawInfo& draw_info = tile->draw_info();
   DCHECK(tile->raster_task_.get());
   orphan_tasks_.push_back(tile->raster_task_);
@@ -992,8 +995,7 @@ bool TileManager::IsReadyToDraw() const {
 
 void TileManager::CheckAndIssueSignals() {
   TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals");
-  tile_task_runner_->CheckForCompletedTasks();
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  CheckAndProcessCompletedTasks();
 
   // Ready to activate.
   if (signals_.ready_to_activate && !signals_.did_notify_ready_to_activate) {
@@ -1032,8 +1034,7 @@ void TileManager::CheckAndIssueSignals() {
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
-  tile_task_runner_->CheckForCompletedTasks();
-  did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  CheckAndProcessCompletedTasks();
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.