cc: Rename DirectRasterWorkerPool to GpuRasterWorkerPool

cc/resources/gpu_raster_worker_pool.cc

Index: cc/resources/gpu_raster_worker_pool.cc
diff --git a/cc/resources/direct_raster_worker_pool.cc b/cc/resources/gpu_raster_worker_pool.cc
similarity index 74%
rename from cc/resources/direct_raster_worker_pool.cc
rename to cc/resources/gpu_raster_worker_pool.cc
index 4bd0c55c7399c12618e86e6d1a65a01dfab2764c..5c7f2820c96fd040d39d47c01e6f8a7e912d0add 100644
--- a/cc/resources/direct_raster_worker_pool.cc
+++ b/cc/resources/gpu_raster_worker_pool.cc
@@ -2,7 +2,7 @@
 // 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 "cc/resources/gpu_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/output/context_provider.h"
@@ -14,18 +14,17 @@
 namespace cc {
 
 // static
-scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create(
+scoped_ptr<RasterWorkerPool> GpuRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider) {
-  return make_scoped_ptr<RasterWorkerPool>(new DirectRasterWorkerPool(
+  return make_scoped_ptr<RasterWorkerPool>(new GpuRasterWorkerPool(
       task_runner, resource_provider, context_provider));
 }
 
-DirectRasterWorkerPool::DirectRasterWorkerPool(
-    base::SequencedTaskRunner* task_runner,
-    ResourceProvider* resource_provider,
-    ContextProvider* context_provider)
+GpuRasterWorkerPool::GpuRasterWorkerPool(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()),
@@ -35,28 +34,31 @@ DirectRasterWorkerPool::DirectRasterWorkerPool(
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false),
       raster_finished_weak_ptr_factory_(this),
-      weak_ptr_factory_(this) {}
+      weak_ptr_factory_(this) {
+}
 
-DirectRasterWorkerPool::~DirectRasterWorkerPool() {
+GpuRasterWorkerPool::~GpuRasterWorkerPool() {
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
-Rasterizer* DirectRasterWorkerPool::AsRasterizer() { return this; }
+Rasterizer* GpuRasterWorkerPool::AsRasterizer() {
+  return this;
+}
 
-void DirectRasterWorkerPool::SetClient(RasterizerClient* client) {
+void GpuRasterWorkerPool::SetClient(RasterizerClient* client) {
   client_ = client;
 }
 
-void DirectRasterWorkerPool::Shutdown() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::Shutdown");
+void GpuRasterWorkerPool::Shutdown() {
+  TRACE_EVENT0("cc", "GpuRasterWorkerPool::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");
+void GpuRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
+  TRACE_EVENT0("cc", "GpuRasterWorkerPool::ScheduleTasks");
 
   DCHECK_EQ(queue->required_for_activation_count,
             static_cast<size_t>(
@@ -79,13 +81,13 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
           CreateRasterRequiredForActivationFinishedTask(
               queue->required_for_activation_count,
               task_runner_.get(),
-              base::Bind(&DirectRasterWorkerPool::
-                             OnRasterRequiredForActivationFinished,
-                         raster_finished_weak_ptr_factory_.GetWeakPtr())));
+              base::Bind(
+                  &GpuRasterWorkerPool::OnRasterRequiredForActivationFinished,
+                  raster_finished_weak_ptr_factory_.GetWeakPtr())));
   scoped_refptr<RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
-          base::Bind(&DirectRasterWorkerPool::OnRasterFinished,
+          base::Bind(&GpuRasterWorkerPool::OnRasterFinished,
                      raster_finished_weak_ptr_factory_.GetWeakPtr())));
 
   for (RasterTaskQueue::Item::Vector::const_iterator it = queue->items.begin();
@@ -125,8 +127,8 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
       new_raster_required_for_activation_finished_task;
 }
 
-void DirectRasterWorkerPool::CheckForCompletedTasks() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
+void GpuRasterWorkerPool::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "GpuRasterWorkerPool::CheckForCompletedTasks");
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
@@ -144,44 +146,44 @@ void DirectRasterWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) {
+SkCanvas* GpuRasterWorkerPool::AcquireCanvasForRaster(RasterTask* task) {
   return resource_provider_->MapDirectRasterBuffer(task->resource()->id());

[reveman, 2014/06/27 15:47:53]

Can we rename RasterBuffer API too in this patch? ie. Map/UnmapGrRasterBuffer to
match GrContext()..

[sohanjg, 2014/06/30 08:46:19]

Done.
Have updated it as Map/UnmapGpuRasterBuffer to be consistent with
GpuRasterWorkerPool naming. or do you think this may create confusion with GPU
memory buffers used in zero/one-copy implementation ? 

 }
 
-void DirectRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
+void GpuRasterWorkerPool::ReleaseCanvasForRaster(RasterTask* task) {
   resource_provider_->UnmapDirectRasterBuffer(task->resource()->id());
 }
 
-void DirectRasterWorkerPool::OnRasterFinished() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::OnRasterFinished");
+void GpuRasterWorkerPool::OnRasterFinished() {
+  TRACE_EVENT0("cc", "GpuRasterWorkerPool::OnRasterFinished");
 
   DCHECK(raster_tasks_pending_);
   raster_tasks_pending_ = false;
   client_->DidFinishRunningTasks();
 }
 
-void DirectRasterWorkerPool::OnRasterRequiredForActivationFinished() {
+void GpuRasterWorkerPool::OnRasterRequiredForActivationFinished() {
   TRACE_EVENT0("cc",
-               "DirectRasterWorkerPool::OnRasterRequiredForActivationFinished");
+               "GpuRasterWorkerPool::OnRasterRequiredForActivationFinished");
 
   DCHECK(raster_tasks_required_for_activation_pending_);
   raster_tasks_required_for_activation_pending_ = false;
   client_->DidFinishRunningTasksRequiredForActivation();
 }
 
-void DirectRasterWorkerPool::ScheduleRunTasksOnOriginThread() {
+void GpuRasterWorkerPool::ScheduleRunTasksOnOriginThread() {
   if (run_tasks_on_origin_thread_pending_)
     return;
 
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DirectRasterWorkerPool::RunTasksOnOriginThread,
+      base::Bind(&GpuRasterWorkerPool::RunTasksOnOriginThread,
                  weak_ptr_factory_.GetWeakPtr()));
   run_tasks_on_origin_thread_pending_ = true;
 }
 
-void DirectRasterWorkerPool::RunTasksOnOriginThread() {
-  TRACE_EVENT0("cc", "DirectRasterWorkerPool::RunTasksOnOriginThread");
+void GpuRasterWorkerPool::RunTasksOnOriginThread() {
+  TRACE_EVENT0("cc", "GpuRasterWorkerPool::RunTasksOnOriginThread");
 
   DCHECK(run_tasks_on_origin_thread_pending_);
   run_tasks_on_origin_thread_pending_ = false;
@@ -192,7 +194,7 @@ void DirectRasterWorkerPool::RunTasksOnOriginThread() {
     // Using push/pop functions directly incurs cost to evaluate function
     // arguments even when tracing is disabled.
     context_provider_->ContextGL()->PushGroupMarkerEXT(
-        0, "DirectRasterWorkerPool::RunTasksOnOriginThread");
+        0, "GpuRasterWorkerPool::RunTasksOnOriginThread");
 
     GrContext* gr_context = context_provider_->GrContext();
     // TODO(alokp): Implement TestContextProvider::GrContext().