cc: Rename DirectRasterWorkerPool to GpuRasterWorkerPool

cc/resources/direct_raster_worker_pool.cc

-// Copyright 2014 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/resources/direct_raster_worker_pool.h"
-
-#include "base/debug/trace_event.h"
-#include "cc/output/context_provider.h"
-#include "cc/resources/resource.h"
-#include "cc/resources/resource_provider.h"
-#include "gpu/command_buffer/client/gles2_interface.h"
-#include "third_party/skia/include/gpu/GrContext.h"
-
-namespace cc {
-
-// static
-scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create(
-    base::SequencedTaskRunner* task_runner,
-    ResourceProvider* resource_provider,
-    ContextProvider* context_provider) {
-  return make_scoped_ptr<RasterWorkerPool>(new DirectRasterWorkerPool(
-      task_runner, resource_provider, context_provider));
-}
-
-DirectRasterWorkerPool::DirectRasterWorkerPool(
-    base::SequencedTaskRunner* task_runner,
-    ResourceProvider* resource_provider,
-    ContextProvider* context_provider)
-    : task_runner_(task_runner),
-      task_graph_runner_(new TaskGraphRunner),
-      namespace_token_(task_graph_runner_->GetNamespaceToken()),
-      resource_provider_(resource_provider),
-      context_provider_(context_provider),
-      run_tasks_on_origin_thread_pending_(false),
-      raster_tasks_pending_(false),
-      raster_tasks_required_for_activation_pending_(false),
-      raster_finished_weak_ptr_factory_(this),
-      weak_ptr_factory_(this) {}
-
-DirectRasterWorkerPool::~DirectRasterWorkerPool() {
-  DCHECK_EQ(0u, completed_tasks_.size());
-}
-
-Rasterizer* DirectRasterWorkerPool::AsRasterizer() { return this; }
-
-void DirectRasterWorkerPool::SetClient(RasterizerClient* client) {
-  client_ = client;
-}
-
-void DirectRasterWorkerPool::Shutdown() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::Shutdown");
-
-  TaskGraph empty;
-  task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
-  task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
-}
-
-void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::ScheduleTasks");
-
-  DCHECK_EQ(queue->required_for_activation_count,
-            static_cast<size_t>(
-                std::count_if(queue->items.begin(),
-                              queue->items.end(),
-                              RasterTaskQueue::Item::IsRequiredForActivation)));
-
-  raster_tasks_pending_ = true;
-  raster_tasks_required_for_activation_pending_ = true;
-
-  unsigned priority = kRasterTaskPriorityBase;
-
-  graph_.Reset();
-
-  // Cancel existing OnRasterFinished callbacks.
-  raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
-
-  scoped_refptr<RasterizerTask>
-      new_raster_required_for_activation_finished_task(
-          CreateRasterRequiredForActivationFinishedTask(
-              queue->required_for_activation_count,
-              task_runner_.get(),
-              base::Bind(&DirectRasterWorkerPool::
-                             OnRasterRequiredForActivationFinished,
-                         raster_finished_weak_ptr_factory_.GetWeakPtr())));
-  scoped_refptr<RasterizerTask> new_raster_finished_task(
-      CreateRasterFinishedTask(
-          task_runner_.get(),
-          base::Bind(&DirectRasterWorkerPool::OnRasterFinished,
-                     raster_finished_weak_ptr_factory_.GetWeakPtr())));
-
-  for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
-       it != queue->items.end();
-       ++it) {
-    const RasterTaskQueue::Item& item = *it;
-    RasterTask* task = item.task;
-    DCHECK(!task->HasCompleted());
-
-    if (item.required_for_activation) {
-      graph_.edges.push_back(TaskGraph::Edge(
-          task, new_raster_required_for_activation_finished_task.get()));
-    }
-
-    InsertNodesForRasterTask(&graph_, task, task->dependencies(), priority++);
-
-    graph_.edges.push_back(
-        TaskGraph::Edge(task, new_raster_finished_task.get()));
-  }
-
-  InsertNodeForTask(&graph_,
-                    new_raster_required_for_activation_finished_task.get(),
-                    kRasterRequiredForActivationFinishedTaskPriority,
-                    queue->required_for_activation_count);
-  InsertNodeForTask(&graph_,
-                    new_raster_finished_task.get(),
-                    kRasterFinishedTaskPriority,
-                    queue->items.size());
-
-  ScheduleTasksOnOriginThread(this, &graph_);
-  task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
-
-  ScheduleRunTasksOnOriginThread();
-
-  raster_finished_task_ = new_raster_finished_task;
-  raster_required_for_activation_finished_task_ =
-      new_raster_required_for_activation_finished_task;
-}
-
-void DirectRasterWorkerPool::CheckForCompletedTasks() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
-
-  task_graph_runner_->CollectCompletedTasks(namespace_token_,
-                                            &completed_tasks_);
-  for (Task::Vector::const_iterator it = completed_tasks_.begin();
-       it != completed_tasks_.end();
-       ++it) {
-    RasterizerTask* task = static_cast<RasterizerTask*>(it->get());
-
-    task->WillComplete();
-    task->CompleteOnOriginThread(this);
-    task->DidComplete();
-
-    task->RunReplyOnOriginThread();
-  }
-  completed_tasks_.clear();
-}
-
-SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) {
-  return resource_provider_->MapDirectRasterBuffer(task->resource()->id());
-}
-
-void DirectRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
-  resource_provider_->UnmapDirectRasterBuffer(task->resource()->id());
-}
-
-void DirectRasterWorkerPool::OnRasterFinished() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::OnRasterFinished");
-
-  DCHECK(raster_tasks_pending_);
-  raster_tasks_pending_ = false;
-  client_->DidFinishRunningTasks();
-}
-
-void DirectRasterWorkerPool::OnRasterRequiredForActivationFinished() {
-  TRACE_EVENT0("cc",
-               "DirectRasterWorkerPool::OnRasterRequiredForActivationFinished");
-
-  DCHECK(raster_tasks_required_for_activation_pending_);
-  raster_tasks_required_for_activation_pending_ = false;
-  client_->DidFinishRunningTasksRequiredForActivation();
-}
-
-void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() {
-  if (run_tasks_on_origin_thread_pending_)
-    return;
-
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread,
-                 weak_ptr_factory_.GetWeakPtr()));
-  run_tasks_on_origin_thread_pending_ = true;
-}
-
-void DirectRasterWorkerPool::RunTasksOnOriginThread() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::RunTasksOnOriginThread");
-
-  DCHECK(run_tasks_on_origin_thread_pending_);
-  run_tasks_on_origin_thread_pending_ = false;
-
-  if (context_provider_) {
-    DCHECK(context_provider_->ContextGL());
-    // TODO(alokp): Use a trace macro to push/pop markers.
-    // Using push/pop functions directly incurs cost to evaluate function
-    // arguments even when tracing is disabled.
-    context_provider_->ContextGL()->PushGroupMarkerEXT(
-        0, "DirectRasterWorkerPool::RunTasksOnOriginThread");
-
-    GrContext* gr_context = context_provider_->GrContext();
-    // TODO(alokp): Implement TestContextProvider::GrContext().
-    if (gr_context)
-      gr_context->resetContext();
-  }
-
-  task_graph_runner_->RunUntilIdle();
-
-  if (context_provider_) {
-    GrContext* gr_context = context_provider_->GrContext();
-    // TODO(alokp): Implement TestContextProvider::GrContext().
-    if (gr_context)
-      gr_context->flush();
-
-    context_provider_->ContextGL()->PopGroupMarkerEXT();
-  }
-}
-
-}  // namespace cc