cc: Simplify task and its derived classes.

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>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/histograms.h"
 #include "cc/debug/devtools_instrumentation.h"
 #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"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 // Flag to indicate whether we should try and detect that
 // 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 {
+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,
                  float contents_scale,
                  const RasterSource::PlaybackSettings& playback_settings,
                  TileResolution tile_resolution,
                  int layer_id,
                  uint64_t source_prepare_tiles_id,
                  const void* 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,
-                 ImageDecodeTask::Vector* dependencies)
-      : RasterTask(dependencies),
+                 Task::Vector* dependencies)
+      : raster_buffer_provider_(raster_buffer_provider),
         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) {}
+        reply_(reply) {
+    dependencies_ = std::move(*dependencies);
+  }
 
   // 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());

[prashant.n, 2016/04/07 09:22:13]

Due to this, we need to keep scheduling and completing functions.

Do you mean moving this calling to say CompletetaskOnWorkerThread function and
calling that in task graph work queue CompleteTask function?

This may need to have locks in resource_pool_ at following lines -

    404 bool memory_usage_above_limit = resource_pool_->memory_usage_bytes() >
    572 DCHECK(resource_pool_);
    579 resource_pool_->CheckBusyResources();
    591 MemoryUsage memory_usage(resource_pool_->memory_usage_bytes(),
    592 resource_pool_->resource_count());
    702 resource_pool_->ReleaseResource(draw_info.resource_, tile->id());
    804 resource_pool_->ReduceResourceUsage();
    840 resource_pool_->TryAcquireResourceWithContentId(tile->invalidated_id());
    846 resource = resource_pool_->AcquireResource(tile->desired_texture_size(),
    918 resource_pool_->ReleaseResource(resource, 0 /* content_id */);
   1062 resource_pool_->ReduceResourceUsage();

If there is any other way, do let me know.

+  }
+
   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());
-  }
+  const Task::Vector& dependencies() const { return dependencies_; }
 
  protected:
   ~RasterTaskImpl() override { DCHECK(!raster_buffer_); }
 
  private:
+  Task::Vector dependencies_;
+  RasterBufferProvider* raster_buffer_provider_;
   const 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_;
@@ skipping 11 matching lines @@
 // 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
 // all task set done task priorities.
 size_t kTileTaskPriorityBase = 10u;
 
 void InsertNodeForTask(TaskGraph* graph,
-                       TileTask* task,
+                       Task* task,
                        uint16_t category,
                        uint16_t priority,
                        size_t dependencies) {
   DCHECK(std::find_if(graph->nodes.begin(), graph->nodes.end(),
                       [task](const TaskGraph::Node& node) {
                         return node.task == task;
                       }) == graph->nodes.end());
   graph->nodes.push_back(
       TaskGraph::Node(task, category, priority, dependencies));
 }
 
 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) {
   size_t dependencies = 0u;
 
   // Determine the TaskCategory for raster tasks - if a task uses GPU, it
   // cannot run concurrently and is assigned
   // TASK_CATEGORY_NONCONCURRENT_FOREGROUND, regardless of its priority.
   // Otherwise its category is based on its priority.
   TaskCategory raster_task_category;
   if (use_gpu_rasterization) {
     raster_task_category = TASK_CATEGORY_NONCONCURRENT_FOREGROUND;
   } else {
     raster_task_category =
         high_priority ? TASK_CATEGORY_FOREGROUND : TASK_CATEGORY_BACKGROUND;
   }
 
   // Determine the TaskCategory for decode tasks. This category is based on
   // the priority of the raster task which depends on it.
   TaskCategory decode_task_category =
       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())
       continue;
 
     dependencies++;
 
     // Add decode task if it doesn't already exists in graph.
     TaskGraph::Node::Vector::iterator decode_it =
         std::find_if(graph->nodes.begin(), graph->nodes.end(),
@@ skipping 15 matching lines @@
       InsertNodeForTask(graph, decode_task, decode_task_category, priority, 0u);
     }
 
     graph->edges.push_back(TaskGraph::Edge(decode_task, raster_task));
   }
 
   InsertNodeForTask(graph, raster_task, raster_task_category, priority,
                     dependencies);
 }
 
-class TaskSetFinishedTaskImpl : public TileTask {
+class TaskSetFinishedTaskImpl : public Task {
  public:
   explicit TaskSetFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
       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 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 {}
 
   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 484 matching lines @@
 
   // Track the number of dependents for each *_done task.
   size_t required_for_activate_count = 0;
   size_t required_for_draw_count = 0;
   size_t all_count = 0;
 
   size_t priority = kTileTaskPriorityBase;
 
   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
   // are added in order of priority, highest priority task first.
   for (auto& prioritized_tile : tiles_that_need_to_be_rasterized) {
     Tile* tile = prioritized_tile.tile();
 
     DCHECK(tile->draw_info().requires_resource());
     DCHECK(!tile->draw_info().resource_);
 
     if (!tile->raster_task_)
       tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
-    RasterTask* task = tile->raster_task_.get();
+    RasterTaskImpl* task =
+        static_cast<RasterTaskImpl*>(tile->raster_task_.get());
     DCHECK(!task->HasCompleted());
 
     if (tile->required_for_activation()) {
       required_for_activate_count++;
       graph_.edges.push_back(
           TaskGraph::Edge(task, required_for_activation_done_task.get()));
     }
     if (tile->required_for_draw()) {
       required_for_draw_count++;
       graph_.edges.push_back(
@@ skipping 45 matching lines @@
       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;
 
   TRACE_EVENT_ASYNC_STEP_INTO1("cc", "ScheduledTasks", this, "running", "state",
                                ScheduledTasksStateAsValue());
 }
 
-scoped_refptr<RasterTask> TileManager::CreateRasterTask(
+scoped_refptr<Task> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile) {
   Tile* tile = prioritized_tile.tile();
 
   // Get the resource.
   uint64_t resource_content_id = 0;
   Resource* resource = nullptr;
   if (use_partial_raster_ && tile->invalidated_id()) {
     // TODO(danakj): For resources that are in use, we should still grab them
     // and copy from them instead of rastering everything. crbug.com/492754
     resource =
         resource_pool_->TryAcquireResourceWithContentId(tile->invalidated_id());
   }
   if (resource) {
     resource_content_id = tile->invalidated_id();
     DCHECK_EQ(DetermineResourceFormat(tile), resource->format());
   } else {
     resource = resource_pool_->AcquireResource(tile->desired_texture_size(),
                                                DetermineResourceFormat(tile));
   }
 
   // For LOW_RESOLUTION tiles, we don't draw or predecode images.
   RasterSource::PlaybackSettings playback_settings;
   playback_settings.skip_images =
       prioritized_tile.priority().resolution == LOW_RESOLUTION;
 
   // Create and queue all image decode tasks that this tile depends on.
-  ImageDecodeTask::Vector decode_tasks;
+  Task::Vector decode_tasks;
   std::vector<DrawImage>& images = scheduled_draw_images_[tile->id()];
   images.clear();
   if (!playback_settings.skip_images) {
     prioritized_tile.raster_source()->GetDiscardableImagesInRect(
         tile->enclosing_layer_rect(), tile->contents_scale(), &images);
   }
 
   // TODO(vmpstr): We should disable image hijack canvas in
   // |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);
 
     if (need_to_unref_when_finished)
       ++it;
     else
       it = images.erase(it);
   }
 
   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));
 }
 
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     Resource* resource,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
@@ skipping 235 matching lines @@
   state->SetBoolean("ready_to_activate", signals_.ready_to_activate);
   state->SetBoolean("ready_to_draw", signals_.ready_to_draw);
   state->SetBoolean("all_tile_tasks_completed",
                     signals_.all_tile_tasks_completed);
   state->EndDictionary();
   return std::move(state);
 }
 
 // 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(),
       base::Bind(callback, task_set_finished_weak_ptr_factory_.GetWeakPtr())));
 }
 
 TileManager::MemoryUsage::MemoryUsage()
     : memory_bytes_(0), resource_count_(0) {}
 
 TileManager::MemoryUsage::MemoryUsage(size_t memory_bytes,
@@ skipping 63 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