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 68408e4ded02b983d804ccd6e9f0bfea2b3a7abc..124d64cd63a79fc58fc149b5d3ba2a95dd68ffe6 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 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,
@@ -57,7 +57,7 @@ class RasterTaskImpl : public RasterTask {
                  uint64_t previous_content_id,
                  uint64_t resource_content_id,
                  int source_frame_number,
-                 const base::Callback<void(bool)>& reply,
+                 scoped_ptr<RasterBuffer> raster_buffer,
                  ImageDecodeTask::Vector* dependencies)
       : RasterTask(dependencies),
         resource_(resource),
@@ -74,7 +74,7 @@ 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)) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
@@ -96,22 +96,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_;
@@ -125,9 +114,9 @@ class RasterTaskImpl : public RasterTask {
   uint64_t previous_content_id_;
   uint64_t resource_content_id_;
   int source_frame_number_;
-  const base::Callback<void(bool)> reply_;
   scoped_ptr<RasterBuffer> raster_buffer_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
@@ -187,7 +176,6 @@ void InsertNodesForRasterTask(TaskGraph* graph,
     // Skip if already decoded.
     if (decode_task->HasCompleted())
       continue;
-
     dependencies++;
 
     // Add decode task if it doesn't already exists in graph.
@@ -232,10 +220,6 @@ class TaskSetFinishedTaskImpl : public TileTask {
     TaskSetFinished();
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(TileTaskClient* client) override {}
-  void CompleteOnOriginThread(TileTaskClient* client) override {}
-
  protected:
   ~TaskSetFinishedTaskImpl() override {}
 
@@ -323,7 +307,7 @@ void TileManager::FinishTasksAndCleanUp() {
   // |orphan_tasks_|.
   orphan_tasks_.clear();
 
-  tile_task_runner_->CheckForCompletedTasks();
+  CheckForCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
@@ -436,7 +420,7 @@ 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_runner_->CheckForCompletedTasks();
+    CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
@@ -473,7 +457,7 @@ void TileManager::Flush() {
     return;
   }
 
-  tile_task_runner_->CheckForCompletedTasks();
+  CheckForCompletedTasks();
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
@@ -757,8 +741,10 @@ void TileManager::ScheduleTasks(
     DCHECK(tile->draw_info().requires_resource());
     DCHECK(!tile->draw_info().resource_);
 
-    if (!tile->raster_task_)
+    if (!tile->raster_task_) {
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
+      raster_tasks_.push_back(tile->raster_task_);
+    }
 
     RasterTask* task = tile->raster_task_.get();
     DCHECK(!task->HasCompleted());
@@ -829,7 +815,6 @@ void TileManager::ScheduleTasks(
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
-
   // Get the resource.
   uint64_t resource_content_id = 0;
   Resource* resource = nullptr;
@@ -878,22 +863,42 @@ scoped_refptr<RasterTask> TileManager::CreateRasterTask(
       it = images.erase(it);
   }
 
+  scoped_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->source_frame_number(), std::move(raster_buffer), &decode_tasks));
+}
+
+void TileManager::CheckForCompletedTasks() {
+  Task::Vector completed_tasks;
+  tile_task_runner_->CollectCompletedTasks(&completed_tasks);
+
+  for (auto task : completed_tasks) {

[vmpstr, 2016/04/08 18:59:16]

auto& task? or auto* task? depending on what completed_tasks is.

+    Task::Vector::iterator it =
+        std::find(raster_tasks_.begin(), raster_tasks_.end(), task);

[vmpstr, 2016/04/08 18:59:16]

This is a n^2 loop... how's the performance here if we have a lot of tasks?

+    if (it != raster_tasks_.end()) {
+      raster_tasks_.erase(it);
+      RasterTaskImpl* raster_task = static_cast<RasterTaskImpl*>(task.get());
+      DCHECK(raster_task);
+      CompleteRasterTask(raster_task->new_content_id_, raster_task->resource_,
+                         !raster_task->HasFinishedRunning());
+    }
+
+    static_cast<TileTask*>(task.get())->DidComplete();
+  }
+
+  completed_tasks.clear();
 }
 
-void TileManager::OnRasterTaskCompleted(
-    Tile::Id tile_id,
-    Resource* resource,
-    bool was_canceled) {
+void TileManager::CompleteRasterTask(Tile::Id tile_id,
+                                     Resource* resource,
+                                     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
@@ -991,7 +996,7 @@ bool TileManager::IsReadyToDraw() const {
 
 void TileManager::CheckAndIssueSignals() {
   TRACE_EVENT0("cc", "TileManager::CheckAndIssueSignals");
-  tile_task_runner_->CheckForCompletedTasks();
+  CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // Ready to activate.
@@ -1031,7 +1036,7 @@ void TileManager::CheckAndIssueSignals() {
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
-  tile_task_runner_->CheckForCompletedTasks();
+  CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // When OOM, keep re-assigning memory until we reach a steady state