cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

cc/tiles/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/tile_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 26 matching lines @@
 // a tile is of solid color.
 const bool kUseColorEstimator = true;
 
 DEFINE_SCOPED_UMA_HISTOGRAM_AREA_TIMER(
     ScopedRasterTaskTimer,
     "Compositing.%s.RasterTask.RasterUs",
     "Compositing.%s.RasterTask.RasterPixelsPerMs");
 
 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,
                  float contents_scale,
                  const RasterSource::PlaybackSettings& playback_settings,
                  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),
         raster_source_(std::move(raster_source)),
         content_rect_(content_rect),
         invalid_content_rect_(invalid_content_rect),
         contents_scale_(contents_scale),
         playback_settings_(playback_settings),
         tile_resolution_(tile_resolution),
         layer_id_(layer_id),
         source_prepare_tiles_id_(source_prepare_tiles_id),
         tile_(tile),
         new_content_id_(new_content_id),
         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 {
     TRACE_EVENT1("cc", "RasterizerTaskImpl::RunOnWorkerThread",
                  "source_prepare_tiles_id", source_prepare_tiles_id_);
 
     DCHECK(raster_source_.get());
     DCHECK(raster_buffer_);
 
     frame_viewer_instrumentation::ScopedRasterTask raster_task(
         tile_, tile_resolution_, source_frame_number_, layer_id_);
     ScopedRasterTaskTimer timer;
     timer.SetArea(content_rect_.size().GetArea());
 
     DCHECK(raster_source_);
 
     raster_buffer_->Playback(raster_source_.get(), content_rect_,
                              invalid_content_rect_, new_content_id_,
                              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 {}
 
- protected:
-  ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
-
- private:
-  const Resource* resource_;
+ public:
+  Resource* resource_;
   scoped_refptr<RasterSource> raster_source_;
   gfx::Rect content_rect_;
   gfx::Rect invalid_content_rect_;
   float contents_scale_;
   RasterSource::PlaybackSettings playback_settings_;
   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);
 };
 
 // Task priorities that make sure that the task set done tasks run before any
 // other remaining tasks.
 const size_t kRequiredForActivationDoneTaskPriority = 1u;
 const size_t kRequiredForDrawDoneTaskPriority = 2u;
 const size_t kAllDoneTaskPriority = 3u;
 
 // For correctness, |kTileTaskPriorityBase| must be greater than
@@ skipping 84 matching lines @@
       const base::Closure& on_task_set_finished_callback)
       : task_runner_(task_runner),
         on_task_set_finished_callback_(on_task_set_finished_callback) {}
 
   // Overridden from Task:
   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 {}
 
   void TaskSetFinished() {
     task_runner_->PostTask(FROM_HERE, on_task_set_finished_callback_);
   }
 
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::Closure on_task_set_finished_callback_;
@@ skipping 35 matching lines @@
                          size_t scheduled_raster_task_limit,
                          bool use_partial_raster)
     : client_(client),
       task_runner_(std::move(task_runner)),
       resource_pool_(nullptr),
       tile_task_runner_(nullptr),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       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(),
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_.get(),
                               base::Bind(&TileManager::CheckAndIssueSignals,
                                          base::Unretained(this))),
       has_scheduled_tile_tasks_(false),
       prepare_tiles_count_(0u),
@@ skipping 11 matching lines @@
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   // This cancels tasks if possible, finishes pending tasks, and release any
   // uninitialized resources.
   tile_task_runner_->Shutdown();
 
   // Now that all tasks have been finished, we can clear any
   // |orphan_tasks_|.
   orphan_tasks_.clear();
 
-  tile_task_runner_->CheckForCompletedTasks();
+  CheckAndProcessCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
   tile_task_runner_ = nullptr;
   resource_pool_ = nullptr;
   more_tiles_need_prepare_check_notifier_.Cancel();
   signals_check_notifier_.Cancel();
   task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 }
@@ skipping 89 matching lines @@
 
   if (!tile_task_runner_) {
     TRACE_EVENT_INSTANT0("cc", "PrepareTiles aborted",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   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();
 
   PrioritizedTileVector tiles_that_need_to_be_rasterized;
   std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   AssignGpuMemoryToTiles(raster_priority_queue.get(),
                          scheduled_raster_task_limit_,
@@ skipping 14 matching lines @@
 }
 
 void TileManager::Flush() {
   TRACE_EVENT0("cc", "TileManager::Flush");
 
   if (!tile_task_runner_) {
     TRACE_EVENT_INSTANT0("cc", "Flush aborted", TRACE_EVENT_SCOPE_THREAD);
     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_));
   flush_stats_ = RasterTaskCompletionStats();
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 TileManager::BasicStateAsValue() const {
   std::unique_ptr<base::trace_event::TracedValue> value(
       new base::trace_event::TracedValue());
@@ skipping 221 matching lines @@
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     client_->NotifyTileStateChanged(tile);
 }
 
 void TileManager::ScheduleTasks(
     const PrioritizedTileVector& tiles_that_need_to_be_rasterized) {
   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);
   }
 
   // Cancel existing OnTaskSetFinished callbacks.
   task_set_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
   // Even when scheduling an empty set of tiles, the TTWP does some work, and
   // will always trigger a DidFinishRunningTileTasks notification. Because of
@@ skipping 82 matching lines @@
   // allowed to keep around unreferenced raster tasks after ScheduleTasks() has
   // been called.
   orphan_tasks_.clear();
 
   // It's also now safe to replace our *_done_task_ tasks.
   required_for_activation_done_task_ =
       std::move(required_for_activation_done_task);
   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());
 }
 
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
 
   // Get the resource.
@@ skipping 37 matching lines @@
             *it, prepare_tiles_count_, &task);
     if (task)
       decode_tasks.push_back(task);
 
     if (need_to_unref_when_finished)
       ++it;
     else
       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);
 
-  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;
+  for (auto task : completed_tasks) {
+    if (task->GetTaskTypeId() == kImageDecodeTaskTypeId) {
+      image_decode_controller_->ProcessCompletedTask(task.get());
+    } else if (task->GetTaskTypeId() == kRasterTaskTypeId) {
+      ProcessCompletedRasterTask(task.get());
+    }
+
+    static_cast<TileTask*>(task.get())->DidComplete();
+  }
+
+  completed_tasks.clear();
+
+  did_check_and_process_completed_tasks_since_last_schedule_tasks_ = true;
+}
+
+void TileManager::ProcessCompletedRasterTask(Task* task) {
+  DCHECK(task);
+  RasterTaskImpl* raster_task = static_cast<RasterTaskImpl*>(task);
+  tile_task_runner_->AsTileTaskClient()->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) {
+  // Task was cancelled.
+  if (!raster_task->HasFinishedRunning()) {
     ++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,
                                       int layer_id,
                                       int source_frame_number,
                                       int flags) {
   // We need to have a tile task worker pool to do anything meaningful with
   // tiles.
   DCHECK(tile_task_runner_);
   ScopedTilePtr tile(
@@ skipping 42 matching lines @@
 }
 
 bool TileManager::IsReadyToDraw() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToDraw");
   return AreRequiredTilesReadyToDraw(
       RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW);
 }
 
 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) {
     signals_.ready_to_activate = false;
     if (IsReadyToActivate()) {
       TRACE_EVENT0("disabled-by-default-cc.debug",
                    "TileManager::CheckAndIssueSignals - ready to activate");
       signals_.did_notify_ready_to_activate = true;
       client_->NotifyReadyToActivate();
     }
@@ skipping 18 matching lines @@
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
           "TileManager::CheckAndIssueSignals - all tile tasks completed");
       signals_.did_notify_all_tile_tasks_completed = true;
       client_->NotifyAllTileTasksCompleted();
     }
   }
 }
 
 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.
   PrioritizedTileVector tiles_that_need_to_be_rasterized;
   std::unique_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   AssignGpuMemoryToTiles(raster_priority_queue.get(),
                          scheduled_raster_task_limit_,
                          &tiles_that_need_to_be_rasterized);
@@ skipping 171 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc