cc/resources/image_raster_worker_pool.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/image_raster_worker_pool.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/debug/trace_event_argument.h"
   9 #include "cc/debug/traced_value.h"
  10 #include "cc/resources/resource.h"
  11
  12 namespace cc {
  13
  14 // static
  15 scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
  16     base::SequencedTaskRunner* task_runner,
  17     TaskGraphRunner* task_graph_runner,
  18     ResourceProvider* resource_provider) {
  19   return make_scoped_ptr<RasterWorkerPool>(new ImageRasterWorkerPool(
  20       task_runner, task_graph_runner, resource_provider));
  21 }
  22
  23 ImageRasterWorkerPool::ImageRasterWorkerPool(
  24     base::SequencedTaskRunner* task_runner,
  25     TaskGraphRunner* task_graph_runner,
  26     ResourceProvider* resource_provider)
  27     : task_runner_(task_runner),
  28       task_graph_runner_(task_graph_runner),
  29       namespace_token_(task_graph_runner->GetNamespaceToken()),
  30       resource_provider_(resource_provider),
  31       raster_tasks_pending_(false),
  32       raster_tasks_required_for_activation_pending_(false),
  33       raster_finished_weak_ptr_factory_(this) {}
  34
  35 ImageRasterWorkerPool::~ImageRasterWorkerPool() {}
  36
  37 Rasterizer* ImageRasterWorkerPool::AsRasterizer() { return this; }
  38
  39 void ImageRasterWorkerPool::SetClient(RasterizerClient* client) {
  40   client_ = client;
  41 }
  42
  43 void ImageRasterWorkerPool::Shutdown() {
  44   TRACE_EVENT0("cc", "ImageRasterWorkerPool::Shutdown");
  45
  46   TaskGraph empty;
  47   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
  48   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
  49 }
  50
  51 void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
  52   TRACE_EVENT0("cc", "ImageRasterWorkerPool::ScheduleTasks");
  53
  54   DCHECK_EQ(queue->required_for_activation_count,
  55             static_cast<size_t>(
  56                 std::count_if(queue->items.begin(),
  57                               queue->items.end(),
  58                               RasterTaskQueue::Item::IsRequiredForActivation)));
  59
  60   if (!raster_tasks_pending_)
  61     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
  62
  63   raster_tasks_pending_ = true;
  64   raster_tasks_required_for_activation_pending_ = true;
  65
  66   unsigned priority = kRasterTaskPriorityBase;
  67
  68   graph_.Reset();
  69
  70   // Cancel existing OnRasterFinished callbacks.
  71   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
  72
  73   scoped_refptr<RasterizerTask>
  74       new_raster_required_for_activation_finished_task(
  75           CreateRasterRequiredForActivationFinishedTask(
  76               queue->required_for_activation_count,
  77               task_runner_.get(),
  78               base::Bind(
  79                   &ImageRasterWorkerPool::OnRasterRequiredForActivationFinished,
  80                   raster_finished_weak_ptr_factory_.GetWeakPtr())));
  81   scoped_refptr<RasterizerTask> new_raster_finished_task(
  82       CreateRasterFinishedTask(
  83           task_runner_.get(),
  84           base::Bind(&ImageRasterWorkerPool::OnRasterFinished,
  85                      raster_finished_weak_ptr_factory_.GetWeakPtr())));
  86
  87   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
  88        it != queue->items.end();
  89        ++it) {
  90     const RasterTaskQueue::Item& item = *it;
  91     RasterTask* task = item.task;
  92     DCHECK(!task->HasCompleted());
  93
  94     if (item.required_for_activation) {
  95       graph_.edges.push_back(TaskGraph::Edge(
  96           task, new_raster_required_for_activation_finished_task.get()));
  97     }
  98
  99     InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
 100
 101     graph_.edges.push_back(
 102         TaskGraph::Edge(task, new_raster_finished_task.get()));
 103   }
 104
 105   InsertNodeForTask(&graph_,
 106                     new_raster_required_for_activation_finished_task.get(),
 107                     kRasterRequiredForActivationFinishedTaskPriority,
 108                     queue->required_for_activation_count);
 109   InsertNodeForTask(&graph_,
 110                     new_raster_finished_task.get(),
 111                     kRasterFinishedTaskPriority,
 112                     queue->items.size());
 113
 114   ScheduleTasksOnOriginThread(this, &graph_);
 115   task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
 116
 117   raster_finished_task_ = new_raster_finished_task;
 118   raster_required_for_activation_finished_task_ =
 119       new_raster_required_for_activation_finished_task;
 120
 121   TRACE_EVENT_ASYNC_STEP_INTO1(
 122       "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
 123 }
 124
 125 void ImageRasterWorkerPool::CheckForCompletedTasks() {
 126   TRACE_EVENT0("cc", "ImageRasterWorkerPool::CheckForCompletedTasks");
 127
 128   task_graph_runner_->CollectCompletedTasks(namespace_token_,
 129                                             &completed_tasks_);
 130   for (Task::Vector::const_iterator it = completed_tasks_.begin();
 131        it != completed_tasks_.end();
 132        ++it) {
 133     RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
 134
 135     task->WillComplete();
 136     task->CompleteOnOriginThread(this);
 137     task->DidComplete();
 138
 139     task->RunReplyOnOriginThread();
 140   }
 141   completed_tasks_.clear();
 142 }
 143
 144 SkCanvas* ImageRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) {
 145   return resource_provider_->MapImageRasterBuffer(task->resource()->id());
 146 }
 147
 148 void ImageRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
 149   resource_provider_->UnmapImageRasterBuffer(task->resource()->id());
 150
 151   // Map/UnmapImageRasterBuffer provides direct access to the memory used by the
 152   // GPU. Read lock fences are required to ensure that we're not trying to map a
 153   // resource that is currently in-use by the GPU.
 154   resource_provider_->EnableReadLockFences(task->resource()->id());
 155 }
 156
 157 void ImageRasterWorkerPool::OnRasterFinished() {
 158   TRACE_EVENT0("cc", "ImageRasterWorkerPool::OnRasterFinished");
 159
 160   DCHECK(raster_tasks_pending_);
 161   raster_tasks_pending_ = false;
 162   TRACE_EVENT_ASYNC_END0("cc", "ScheduledTasks", this);
 163   client_->DidFinishRunningTasks();
 164 }
 165
 166 void ImageRasterWorkerPool::OnRasterRequiredForActivationFinished() {
 167   TRACE_EVENT0("cc",
 168                "ImageRasterWorkerPool::OnRasterRequiredForActivationFinished");
 169
 170   DCHECK(raster_tasks_required_for_activation_pending_);
 171   raster_tasks_required_for_activation_pending_ = false;
 172   TRACE_EVENT_ASYNC_STEP_INTO1(
 173       "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
 174   client_->DidFinishRunningTasksRequiredForActivation();
 175 }
 176
 177 scoped_refptr<base::debug::ConvertableToTraceFormat>
 178 ImageRasterWorkerPool::StateAsValue() const {
 179   scoped_refptr<base::debug::TracedValue> state =
 180       new base::debug::TracedValue();
 181
 182   state->SetBoolean("tasks_required_for_activation_pending",
 183                     raster_tasks_required_for_activation_pending_);
 184   return state;
 185 }
 186
 187 }  // namespace cc