cc: Use more explicit names for CHROMIUM_image based rasterizer implementations.

Note: thie will also change the name of some of our
raster_worker_pool_* performance tests.

BUG=
R=vmpstr@chromium.org

Review URL: https://codereview.chromium.org/584393003

Cr-Commit-Position: refs/heads/master@{#296208}

cc/BUILD.gn

@@ -326,12 +326,8 @@ component("cc") {
     "resources/eviction_tile_priority_queue.h",
     "resources/gpu_raster_worker_pool.cc",
     "resources/gpu_raster_worker_pool.h",
-    "resources/image_copy_raster_worker_pool.cc",
-    "resources/image_copy_raster_worker_pool.h",
     "resources/image_layer_updater.cc",
     "resources/image_layer_updater.h",
-    "resources/image_raster_worker_pool.cc",
-    "resources/image_raster_worker_pool.h",
     "resources/layer_painter.h",
     "resources/layer_quad.cc",
     "resources/layer_quad.h",
@@ -343,16 +339,18 @@ component("cc") {
     "resources/managed_tile_state.h",
     "resources/memory_history.cc",
     "resources/memory_history.h",
+    "resources/one_copy_raster_worker_pool.cc",
+    "resources/one_copy_raster_worker_pool.h",
     "resources/picture.cc",
     "resources/picture.h",
     "resources/picture_layer_tiling.cc",
     "resources/picture_layer_tiling.h",
     "resources/picture_layer_tiling_set.cc",
     "resources/picture_layer_tiling_set.h",
-    "resources/picture_pile_base.cc",
-    "resources/picture_pile_base.h",
     "resources/picture_pile.cc",
     "resources/picture_pile.h",
+    "resources/picture_pile_base.cc",
+    "resources/picture_pile_base.h",
     "resources/picture_pile_impl.cc",
     "resources/picture_pile_impl.h",
     "resources/pixel_buffer_raster_worker_pool.cc",
@@ -366,8 +364,6 @@ component("cc") {
     "resources/prioritized_tile_set.h",
     "resources/priority_calculator.cc",
     "resources/priority_calculator.h",
-    "resources/rasterizer.cc",
-    "resources/rasterizer.h",
     "resources/raster_buffer.cc",
     "resources/raster_buffer.h",
     "resources/raster_mode.cc",
@@ -376,19 +372,21 @@ component("cc") {
     "resources/raster_tile_priority_queue.h",
     "resources/raster_worker_pool.cc",
     "resources/raster_worker_pool.h",
+    "resources/rasterizer.cc",
+    "resources/rasterizer.h",
     "resources/release_callback.h",
     "resources/resource.cc",
+    "resources/resource.h",
     "resources/resource_format.cc",
     "resources/resource_format.h",
-    "resources/resource.h",
     "resources/resource_pool.cc",
     "resources/resource_pool.h",
     "resources/resource_provider.cc",
     "resources/resource_provider.h",
     "resources/resource_update.cc",
+    "resources/resource_update.h",
     "resources/resource_update_controller.cc",
     "resources/resource_update_controller.h",
-    "resources/resource_update.h",
     "resources/resource_update_queue.cc",
     "resources/resource_update_queue.h",
     "resources/returned_resource.h",
@@ -410,9 +408,9 @@ component("cc") {
     "resources/task_graph_runner.cc",
     "resources/task_graph_runner.h",
     "resources/texture_mailbox.cc",
+    "resources/texture_mailbox.h",
     "resources/texture_mailbox_deleter.cc",
     "resources/texture_mailbox_deleter.h",
-    "resources/texture_mailbox.h",
     "resources/texture_uploader.cc",
     "resources/texture_uploader.h",
     "resources/tile.cc",
@@ -430,6 +428,8 @@ component("cc") {
     "resources/ui_resource_request.h",
     "resources/video_resource_updater.cc",
     "resources/video_resource_updater.h",
+    "resources/zero_copy_raster_worker_pool.cc",
+    "resources/zero_copy_raster_worker_pool.h",
     "scheduler/delay_based_time_source.cc",
     "scheduler/delay_based_time_source.h",
     "scheduler/draw_result.h",

cc/cc.gyp

@@ -354,12 +354,8 @@
         'resources/eviction_tile_priority_queue.h',
         'resources/gpu_raster_worker_pool.cc',
         'resources/gpu_raster_worker_pool.h',
-        'resources/image_copy_raster_worker_pool.cc',
-        'resources/image_copy_raster_worker_pool.h',
         'resources/image_layer_updater.cc',
         'resources/image_layer_updater.h',
-        'resources/image_raster_worker_pool.cc',
-        'resources/image_raster_worker_pool.h',
         'resources/layer_painter.h',
         'resources/layer_quad.cc',
         'resources/layer_quad.h',
@@ -371,16 +367,18 @@
         'resources/managed_tile_state.h',
         'resources/memory_history.cc',
         'resources/memory_history.h',
+        'resources/one_copy_raster_worker_pool.cc',
+        'resources/one_copy_raster_worker_pool.h',
         'resources/picture.cc',
         'resources/picture.h',
         'resources/picture_layer_tiling.cc',
         'resources/picture_layer_tiling.h',
         'resources/picture_layer_tiling_set.cc',
         'resources/picture_layer_tiling_set.h',
-        'resources/picture_pile_base.cc',
-        'resources/picture_pile_base.h',
         'resources/picture_pile.cc',
         'resources/picture_pile.h',
+        'resources/picture_pile_base.cc',
+        'resources/picture_pile_base.h',
         'resources/picture_pile_impl.cc',
         'resources/picture_pile_impl.h',
         'resources/pixel_buffer_raster_worker_pool.cc',
@@ -394,8 +392,6 @@
         'resources/prioritized_tile_set.h',
         'resources/priority_calculator.cc',
         'resources/priority_calculator.h',
-        'resources/rasterizer.cc',
-        'resources/rasterizer.h',
         'resources/raster_buffer.cc',
         'resources/raster_buffer.h',
         'resources/raster_mode.cc',
@@ -404,19 +400,21 @@
         'resources/raster_tile_priority_queue.h',
         'resources/raster_worker_pool.cc',
         'resources/raster_worker_pool.h',
+        'resources/rasterizer.cc',
+        'resources/rasterizer.h',
         'resources/release_callback.h',
         'resources/resource.cc',
+        'resources/resource.h',
         'resources/resource_format.cc',
         'resources/resource_format.h',
-        'resources/resource.h',
         'resources/resource_pool.cc',
         'resources/resource_pool.h',
         'resources/resource_provider.cc',
         'resources/resource_provider.h',
         'resources/resource_update.cc',
+        'resources/resource_update.h',
         'resources/resource_update_controller.cc',
         'resources/resource_update_controller.h',
-        'resources/resource_update.h',
         'resources/resource_update_queue.cc',
         'resources/resource_update_queue.h',
         'resources/returned_resource.h',
@@ -438,9 +436,9 @@
         'resources/task_graph_runner.cc',
         'resources/task_graph_runner.h',
         'resources/texture_mailbox.cc',
+        'resources/texture_mailbox.h',
         'resources/texture_mailbox_deleter.cc',
         'resources/texture_mailbox_deleter.h',
-        'resources/texture_mailbox.h',
         'resources/texture_uploader.cc',
         'resources/texture_uploader.h',
         'resources/tile.cc',
@@ -458,6 +456,8 @@
         'resources/ui_resource_request.h',
         'resources/video_resource_updater.cc',
         'resources/video_resource_updater.h',
+        'resources/zero_copy_raster_worker_pool.cc',
+        'resources/zero_copy_raster_worker_pool.h',
         'scheduler/delay_based_time_source.cc',
         'scheduler/delay_based_time_source.h',
         'scheduler/draw_result.h',

cc/resources/image_copy_raster_worker_pool.cc → cc/resources/one_copy_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/image_copy_raster_worker_pool.h"
+#include "cc/resources/one_copy_raster_worker_pool.h"
 
 #include <algorithm>
 
@@ -84,21 +84,21 @@ class RasterBufferImpl : public RasterBuffer {
 }  // namespace
 
 // static
-scoped_ptr<RasterWorkerPool> ImageCopyRasterWorkerPool::Create(
+scoped_ptr<RasterWorkerPool> OneCopyRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     ResourcePool* resource_pool) {
   return make_scoped_ptr<RasterWorkerPool>(
-      new ImageCopyRasterWorkerPool(task_runner,
-                                    task_graph_runner,
-                                    context_provider,
-                                    resource_provider,
-                                    resource_pool));
+      new OneCopyRasterWorkerPool(task_runner,
+                                  task_graph_runner,
+                                  context_provider,
+                                  resource_provider,
+                                  resource_pool));
 }
 
-ImageCopyRasterWorkerPool::ImageCopyRasterWorkerPool(
+OneCopyRasterWorkerPool::OneCopyRasterWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
@@ -114,25 +114,27 @@ ImageCopyRasterWorkerPool::ImageCopyRasterWorkerPool(
   DCHECK(context_provider_);
 }
 
-ImageCopyRasterWorkerPool::~ImageCopyRasterWorkerPool() {
+OneCopyRasterWorkerPool::~OneCopyRasterWorkerPool() {
 }
 
-Rasterizer* ImageCopyRasterWorkerPool::AsRasterizer() { return this; }
+Rasterizer* OneCopyRasterWorkerPool::AsRasterizer() {
+  return this;
+}
 
-void ImageCopyRasterWorkerPool::SetClient(RasterizerClient* client) {
+void OneCopyRasterWorkerPool::SetClient(RasterizerClient* client) {
   client_ = client;
 }
 
-void ImageCopyRasterWorkerPool::Shutdown() {
-  TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::Shutdown");
+void OneCopyRasterWorkerPool::Shutdown() {
+  TRACE_EVENT0("cc", "OneCopyRasterWorkerPool::Shutdown");
 
   TaskGraph empty;
   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
 }
 
-void ImageCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
-  TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::ScheduleTasks");
+void OneCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
+  TRACE_EVENT0("cc", "OneCopyRasterWorkerPool::ScheduleTasks");
 
   if (raster_pending_.none())
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
@@ -154,7 +156,7 @@ void ImageCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
     new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
         task_runner_.get(),
-        base::Bind(&ImageCopyRasterWorkerPool::OnRasterFinished,
+        base::Bind(&OneCopyRasterWorkerPool::OnRasterFinished,
                    raster_finished_weak_ptr_factory_.GetWeakPtr(),
                    task_set));
   }
@@ -201,8 +203,8 @@ void ImageCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
       "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
 }
 
-void ImageCopyRasterWorkerPool::CheckForCompletedTasks() {
-  TRACE_EVENT0("cc", "ImageCopyRasterWorkerPool::CheckForCompletedTasks");
+void OneCopyRasterWorkerPool::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "OneCopyRasterWorkerPool::CheckForCompletedTasks");
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
@@ -222,23 +224,21 @@ void ImageCopyRasterWorkerPool::CheckForCompletedTasks() {
   context_provider_->ContextGL()->ShallowFlushCHROMIUM();
 }
 
-scoped_ptr<RasterBuffer> ImageCopyRasterWorkerPool::AcquireBufferForRaster(
+scoped_ptr<RasterBuffer> OneCopyRasterWorkerPool::AcquireBufferForRaster(
     const Resource* resource) {
   DCHECK_EQ(resource->format(), resource_pool_->resource_format());
   return make_scoped_ptr<RasterBuffer>(
       new RasterBufferImpl(resource_provider_, resource_pool_, resource));
 }
 
-void ImageCopyRasterWorkerPool::ReleaseBufferForRaster(
+void OneCopyRasterWorkerPool::ReleaseBufferForRaster(
     scoped_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
-void ImageCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
-  TRACE_EVENT1("cc",
-               "ImageCopyRasterWorkerPool::OnRasterFinished",
-               "task_set",
-               task_set);
+void OneCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
+  TRACE_EVENT1(
+      "cc", "OneCopyRasterWorkerPool::OnRasterFinished", "task_set", task_set);
 
   DCHECK(raster_pending_[task_set]);
   raster_pending_[task_set] = false;
@@ -252,7 +252,7 @@ void ImageCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
-ImageCopyRasterWorkerPool::StateAsValue() const {
+OneCopyRasterWorkerPool::StateAsValue() const {
   scoped_refptr<base::debug::TracedValue> state =
       new base::debug::TracedValue();
 
@@ -266,7 +266,7 @@ ImageCopyRasterWorkerPool::StateAsValue() const {
 
   return state;
 }
-void ImageCopyRasterWorkerPool::StagingStateAsValueInto(
+void OneCopyRasterWorkerPool::StagingStateAsValueInto(
     base::debug::TracedValue* staging_state) const {
   staging_state->SetInteger("staging_resource_count",
                             resource_pool_->total_resource_count());

cc/resources/image_copy_raster_worker_pool.h → cc/resources/one_copy_raster_worker_pool.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CC_RESOURCES_IMAGE_COPY_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_IMAGE_COPY_RASTER_WORKER_POOL_H_
+#ifndef CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
+#define CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
 
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
@@ -23,11 +23,11 @@ class ResourcePool;
 class ResourceProvider;
 class ScopedResource;
 
-class CC_EXPORT ImageCopyRasterWorkerPool : public RasterWorkerPool,
-                                            public Rasterizer,
-                                            public RasterizerTaskClient {
+class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
+                                          public Rasterizer,
+                                          public RasterizerTaskClient {
  public:
-  virtual ~ImageCopyRasterWorkerPool();
+  virtual ~OneCopyRasterWorkerPool();
 
   static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
@@ -51,11 +51,11 @@ class CC_EXPORT ImageCopyRasterWorkerPool : public RasterWorkerPool,
   virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
 
  protected:
-  ImageCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
-                            TaskGraphRunner* task_graph_runner,
-                            ContextProvider* context_provider,
-                            ResourceProvider* resource_provider,
-                            ResourcePool* resource_pool);
+  OneCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
+                          TaskGraphRunner* task_graph_runner,
+                          ContextProvider* context_provider,
+                          ResourceProvider* resource_provider,
+                          ResourcePool* resource_pool);
 
  private:
   void OnRasterFinished(TaskSet task_set);
@@ -77,12 +77,12 @@ class CC_EXPORT ImageCopyRasterWorkerPool : public RasterWorkerPool,
   TaskGraph graph_;
   Task::Vector completed_tasks_;
 
-  base::WeakPtrFactory<ImageCopyRasterWorkerPool>
+  base::WeakPtrFactory<OneCopyRasterWorkerPool>
       raster_finished_weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(ImageCopyRasterWorkerPool);
+  DISALLOW_COPY_AND_ASSIGN(OneCopyRasterWorkerPool);
 };
 
 }  // namespace cc
 
-#endif  // CC_RESOURCES_IMAGE_COPY_RASTER_WORKER_POOL_H_
+#endif  // CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_

cc/resources/raster_worker_pool_perftest.cc

@@ -9,14 +9,14 @@
 #include "cc/debug/lap_timer.h"
 #include "cc/output/context_provider.h"
 #include "cc/resources/gpu_raster_worker_pool.h"
-#include "cc/resources/image_copy_raster_worker_pool.h"
-#include "cc/resources/image_raster_worker_pool.h"
+#include "cc/resources/one_copy_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/raster_buffer.h"
 #include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
+#include "cc/resources/zero_copy_raster_worker_pool.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_context_support.h"
@@ -94,8 +94,8 @@ class PerfContextProvider : public ContextProvider {
 
 enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
-  RASTER_WORKER_POOL_TYPE_IMAGE,
-  RASTER_WORKER_POOL_TYPE_IMAGE_COPY,
+  RASTER_WORKER_POOL_TYPE_ZERO_COPY,
+  RASTER_WORKER_POOL_TYPE_ONE_COPY,
   RASTER_WORKER_POOL_TYPE_GPU
 };
 
@@ -250,19 +250,19 @@ class RasterWorkerPoolPerfTest
             resource_provider_.get(),
             std::numeric_limits<size_t>::max());
         break;
-      case RASTER_WORKER_POOL_TYPE_IMAGE:
+      case RASTER_WORKER_POOL_TYPE_ZERO_COPY:
         raster_worker_pool_ =
-            ImageRasterWorkerPool::Create(task_runner_.get(),
-                                          task_graph_runner_.get(),
-                                          resource_provider_.get());
+            ZeroCopyRasterWorkerPool::Create(task_runner_.get(),
+                                             task_graph_runner_.get(),
+                                             resource_provider_.get());
         break;
-      case RASTER_WORKER_POOL_TYPE_IMAGE_COPY:
+      case RASTER_WORKER_POOL_TYPE_ONE_COPY:
         raster_worker_pool_ =
-            ImageCopyRasterWorkerPool::Create(task_runner_.get(),
-                                              task_graph_runner_.get(),
-                                              context_provider_.get(),
-                                              resource_provider_.get(),
-                                              staging_resource_pool_.get());
+            OneCopyRasterWorkerPool::Create(task_runner_.get(),
+                                            task_graph_runner_.get(),
+                                            context_provider_.get(),
+                                            resource_provider_.get(),
+                                            staging_resource_pool_.get());
         break;
       case RASTER_WORKER_POOL_TYPE_GPU:
         raster_worker_pool_ =
@@ -402,10 +402,10 @@ class RasterWorkerPoolPerfTest
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
         return std::string("_pixel_raster_worker_pool");
-      case RASTER_WORKER_POOL_TYPE_IMAGE:
-        return std::string("_image_raster_worker_pool");
-      case RASTER_WORKER_POOL_TYPE_IMAGE_COPY:
-        return std::string("_image_copy_raster_worker_pool");
+      case RASTER_WORKER_POOL_TYPE_ZERO_COPY:
+        return std::string("_zero_copy_raster_worker_pool");
+      case RASTER_WORKER_POOL_TYPE_ONE_COPY:
+        return std::string("_one_copy_raster_worker_pool");
       case RASTER_WORKER_POOL_TYPE_GPU:
         return std::string("_gpu_raster_worker_pool");
     }
@@ -446,8 +446,8 @@ TEST_P(RasterWorkerPoolPerfTest, ScheduleAndExecuteTasks) {
 INSTANTIATE_TEST_CASE_P(RasterWorkerPoolPerfTests,
                         RasterWorkerPoolPerfTest,
                         ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
-                                          RASTER_WORKER_POOL_TYPE_IMAGE,
-                                          RASTER_WORKER_POOL_TYPE_IMAGE_COPY,
+                                          RASTER_WORKER_POOL_TYPE_ZERO_COPY,
+                                          RASTER_WORKER_POOL_TYPE_ONE_COPY,
                                           RASTER_WORKER_POOL_TYPE_GPU));
 
 class RasterWorkerPoolCommonPerfTest : public RasterWorkerPoolPerfTestBase,

cc/resources/raster_worker_pool_unittest.cc

@@ -9,8 +9,7 @@
 
 #include "base/cancelable_callback.h"
 #include "cc/resources/gpu_raster_worker_pool.h"
-#include "cc/resources/image_copy_raster_worker_pool.h"
-#include "cc/resources/image_raster_worker_pool.h"
+#include "cc/resources/one_copy_raster_worker_pool.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
@@ -19,6 +18,7 @@
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
+#include "cc/resources/zero_copy_raster_worker_pool.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_output_surface_client.h"
 #include "cc/test/test_shared_bitmap_manager.h"
@@ -35,8 +35,8 @@ const size_t kLargeResourceDimension = 1000U;
 
 enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
-  RASTER_WORKER_POOL_TYPE_IMAGE,
-  RASTER_WORKER_POOL_TYPE_IMAGE_COPY,
+  RASTER_WORKER_POOL_TYPE_ZERO_COPY,
+  RASTER_WORKER_POOL_TYPE_ONE_COPY,
   RASTER_WORKER_POOL_TYPE_GPU
 };
 
@@ -148,14 +148,14 @@ class RasterWorkerPoolTest
             resource_provider_.get(),
             kMaxTransferBufferUsageBytes);
         break;
-      case RASTER_WORKER_POOL_TYPE_IMAGE:
-        raster_worker_pool_ = ImageRasterWorkerPool::Create(
+      case RASTER_WORKER_POOL_TYPE_ZERO_COPY:
+        raster_worker_pool_ = ZeroCopyRasterWorkerPool::Create(
             base::MessageLoopProxy::current().get(),
             RasterWorkerPool::GetTaskGraphRunner(),
             resource_provider_.get());
         break;
-      case RASTER_WORKER_POOL_TYPE_IMAGE_COPY:
-        raster_worker_pool_ = ImageCopyRasterWorkerPool::Create(
+      case RASTER_WORKER_POOL_TYPE_ONE_COPY:
+        raster_worker_pool_ = OneCopyRasterWorkerPool::Create(
             base::MessageLoopProxy::current().get(),
             RasterWorkerPool::GetTaskGraphRunner(),
             context_provider_.get(),
@@ -371,8 +371,8 @@ TEST_P(RasterWorkerPoolTest, LargeResources) {
 INSTANTIATE_TEST_CASE_P(RasterWorkerPoolTests,
                         RasterWorkerPoolTest,
                         ::testing::Values(RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER,
-                                          RASTER_WORKER_POOL_TYPE_IMAGE,
-                                          RASTER_WORKER_POOL_TYPE_IMAGE_COPY,
+                                          RASTER_WORKER_POOL_TYPE_ZERO_COPY,
+                                          RASTER_WORKER_POOL_TYPE_ONE_COPY,
                                           RASTER_WORKER_POOL_TYPE_GPU));
 
 }  // namespace

cc/resources/image_raster_worker_pool.cc → cc/resources/zero_copy_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/image_raster_worker_pool.h"
+#include "cc/resources/zero_copy_raster_worker_pool.h"
 
 #include <algorithm>
 
@@ -65,15 +65,15 @@ class RasterBufferImpl : public RasterBuffer {
 }  // namespace
 
 // static
-scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
+scoped_ptr<RasterWorkerPool> ZeroCopyRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider) {
-  return make_scoped_ptr<RasterWorkerPool>(new ImageRasterWorkerPool(
+  return make_scoped_ptr<RasterWorkerPool>(new ZeroCopyRasterWorkerPool(
       task_runner, task_graph_runner, resource_provider));
 }
 
-ImageRasterWorkerPool::ImageRasterWorkerPool(
+ZeroCopyRasterWorkerPool::ZeroCopyRasterWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider)
@@ -81,26 +81,30 @@ ImageRasterWorkerPool::ImageRasterWorkerPool(
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner->GetNamespaceToken()),
       resource_provider_(resource_provider),
-      raster_finished_weak_ptr_factory_(this) {}
+      raster_finished_weak_ptr_factory_(this) {
+}
 
-ImageRasterWorkerPool::~ImageRasterWorkerPool() {}
+ZeroCopyRasterWorkerPool::~ZeroCopyRasterWorkerPool() {
+}
 
-Rasterizer* ImageRasterWorkerPool::AsRasterizer() { return this; }
+Rasterizer* ZeroCopyRasterWorkerPool::AsRasterizer() {
+  return this;
+}
 
-void ImageRasterWorkerPool::SetClient(RasterizerClient* client) {
+void ZeroCopyRasterWorkerPool::SetClient(RasterizerClient* client) {
   client_ = client;
 }
 
-void ImageRasterWorkerPool::Shutdown() {
-  TRACE_EVENT0("cc", "ImageRasterWorkerPool::Shutdown");
+void ZeroCopyRasterWorkerPool::Shutdown() {
+  TRACE_EVENT0("cc", "ZeroCopyRasterWorkerPool::Shutdown");
 
   TaskGraph empty;
   task_graph_runner_->ScheduleTasks(namespace_token_, &empty);
   task_graph_runner_->WaitForTasksToFinishRunning(namespace_token_);
 }
 
-void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
-  TRACE_EVENT0("cc", "ImageRasterWorkerPool::ScheduleTasks");
+void ZeroCopyRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
+  TRACE_EVENT0("cc", "ZeroCopyRasterWorkerPool::ScheduleTasks");
 
   if (raster_pending_.none())
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
@@ -122,7 +126,7 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   for (TaskSet task_set = 0; task_set < kNumberOfTaskSets; ++task_set) {
     new_raster_finished_tasks[task_set] = CreateRasterFinishedTask(
         task_runner_.get(),
-        base::Bind(&ImageRasterWorkerPool::OnRasterFinished,
+        base::Bind(&ZeroCopyRasterWorkerPool::OnRasterFinished,
                    raster_finished_weak_ptr_factory_.GetWeakPtr(),
                    task_set));
   }
@@ -165,8 +169,8 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
       "cc", "ScheduledTasks", this, "rasterizing", "state", StateAsValue());
 }
 
-void ImageRasterWorkerPool::CheckForCompletedTasks() {
-  TRACE_EVENT0("cc", "ImageRasterWorkerPool::CheckForCompletedTasks");
+void ZeroCopyRasterWorkerPool::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "ZeroCopyRasterWorkerPool::CheckForCompletedTasks");
 
   task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                             &completed_tasks_);
@@ -184,7 +188,7 @@ void ImageRasterWorkerPool::CheckForCompletedTasks() {
   completed_tasks_.clear();
 }
 
-scoped_ptr<RasterBuffer> ImageRasterWorkerPool::AcquireBufferForRaster(
+scoped_ptr<RasterBuffer> ZeroCopyRasterWorkerPool::AcquireBufferForRaster(
     const Resource* resource) {
   // RasterBuffer implementation depends on an image having been acquired for
   // the resource.
@@ -194,14 +198,14 @@ scoped_ptr<RasterBuffer> ImageRasterWorkerPool::AcquireBufferForRaster(
       new RasterBufferImpl(resource_provider_, resource));
 }
 
-void ImageRasterWorkerPool::ReleaseBufferForRaster(
+void ZeroCopyRasterWorkerPool::ReleaseBufferForRaster(
     scoped_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
-void ImageRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
+void ZeroCopyRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
   TRACE_EVENT1(
-      "cc", "ImageRasterWorkerPool::OnRasterFinished", "task_set", task_set);
+      "cc", "ZeroCopyRasterWorkerPool::OnRasterFinished", "task_set", task_set);
 
   DCHECK(raster_pending_[task_set]);
   raster_pending_[task_set] = false;
@@ -215,7 +219,7 @@ void ImageRasterWorkerPool::OnRasterFinished(TaskSet task_set) {
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
-ImageRasterWorkerPool::StateAsValue() const {
+ZeroCopyRasterWorkerPool::StateAsValue() const {
   scoped_refptr<base::debug::TracedValue> state =
       new base::debug::TracedValue();
 

cc/resources/image_raster_worker_pool.h → cc/resources/zero_copy_raster_worker_pool.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CC_RESOURCES_IMAGE_RASTER_WORKER_POOL_H_
-#define CC_RESOURCES_IMAGE_RASTER_WORKER_POOL_H_
+#ifndef CC_RESOURCES_ZERO_COPY_RASTER_WORKER_POOL_H_
+#define CC_RESOURCES_ZERO_COPY_RASTER_WORKER_POOL_H_
 
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
@@ -19,11 +19,11 @@ class ConvertableToTraceFormat;
 namespace cc {
 class ResourceProvider;
 
-class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
-                                        public Rasterizer,
-                                        public RasterizerTaskClient {
+class CC_EXPORT ZeroCopyRasterWorkerPool : public RasterWorkerPool,
+                                           public Rasterizer,
+                                           public RasterizerTaskClient {
  public:
-  virtual ~ImageRasterWorkerPool();
+  virtual ~ZeroCopyRasterWorkerPool();
 
   static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
@@ -45,9 +45,9 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
   virtual void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) OVERRIDE;
 
  protected:
-  ImageRasterWorkerPool(base::SequencedTaskRunner* task_runner,
-                        TaskGraphRunner* task_graph_runner,
-                        ResourceProvider* resource_provider);
+  ZeroCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
+                           TaskGraphRunner* task_graph_runner,
+                           ResourceProvider* resource_provider);
 
  private:
   void OnRasterFinished(TaskSet task_set);
@@ -68,11 +68,12 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
   TaskGraph graph_;
   Task::Vector completed_tasks_;
 
-  base::WeakPtrFactory<ImageRasterWorkerPool> raster_finished_weak_ptr_factory_;
+  base::WeakPtrFactory<ZeroCopyRasterWorkerPool>
+      raster_finished_weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(ImageRasterWorkerPool);
+  DISALLOW_COPY_AND_ASSIGN(ZeroCopyRasterWorkerPool);
 };
 
 }  // namespace cc
 
-#endif  // CC_RESOURCES_IMAGE_RASTER_WORKER_POOL_H_
+#endif  // CC_RESOURCES_ZERO_COPY_RASTER_WORKER_POOL_H_

cc/trees/layer_tree_host_impl.cc

@@ -48,9 +48,8 @@
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/gpu_raster_worker_pool.h"
-#include "cc/resources/image_copy_raster_worker_pool.h"
-#include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/memory_history.h"
+#include "cc/resources/one_copy_raster_worker_pool.h"
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/prioritized_resource_manager.h"
@@ -59,6 +58,7 @@
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/resources/ui_resource_bitmap.h"
+#include "cc/resources/zero_copy_raster_worker_pool.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
@@ -1976,7 +1976,7 @@ void LayerTreeHostImpl::CreateAndSetTileManager() {
         GpuRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
                                     context_provider,
                                     resource_provider_.get());
-  } else if (UseOneCopyTextureUpload() && context_provider) {
+  } else if (UseOneCopyRasterizer() && context_provider) {
     // We need to create a staging resource pool when using copy rasterizer.
     staging_resource_pool_ =
         ResourcePool::Create(resource_provider_.get(),
@@ -1987,13 +1987,13 @@ void LayerTreeHostImpl::CreateAndSetTileManager() {
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
 
-    raster_worker_pool_ = ImageCopyRasterWorkerPool::Create(
-        proxy_->ImplThreadTaskRunner(),
-        RasterWorkerPool::GetTaskGraphRunner(),
-        context_provider,
-        resource_provider_.get(),
-        staging_resource_pool_.get());
-  } else if (!UseZeroCopyTextureUpload() && context_provider) {
+    raster_worker_pool_ =
+        OneCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
+                                        RasterWorkerPool::GetTaskGraphRunner(),
+                                        context_provider,
+                                        resource_provider_.get(),
+                                        staging_resource_pool_.get());
+  } else if (!UseZeroCopyRasterizer() && context_provider) {
     resource_pool_ = ResourcePool::Create(
         resource_provider_.get(),
         GL_TEXTURE_2D,
@@ -2012,9 +2012,9 @@ void LayerTreeHostImpl::CreateAndSetTileManager() {
                              resource_provider_->best_texture_format());
 
     raster_worker_pool_ =
-        ImageRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
-                                      RasterWorkerPool::GetTaskGraphRunner(),
-                                      resource_provider_.get());
+        ZeroCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
+                                         RasterWorkerPool::GetTaskGraphRunner(),
+                                         resource_provider_.get());
   }
 
   tile_manager_ =
@@ -2041,7 +2041,7 @@ bool LayerTreeHostImpl::UsePendingTreeForSync() const {
   return settings_.impl_side_painting;
 }
 
-bool LayerTreeHostImpl::UseZeroCopyTextureUpload() const {
+bool LayerTreeHostImpl::UseZeroCopyRasterizer() const {
   // Note: we use zero-copy by default when the renderer is using
   // shared memory resources.
   return (settings_.use_zero_copy ||
@@ -2049,7 +2049,7 @@ bool LayerTreeHostImpl::UseZeroCopyTextureUpload() const {
          GetRendererCapabilities().using_map_image;
 }
 
-bool LayerTreeHostImpl::UseOneCopyTextureUpload() const {
+bool LayerTreeHostImpl::UseOneCopyRasterizer() const {
   // Sync query support is required by one-copy rasterizer.
   return settings_.use_one_copy && GetRendererCapabilities().using_map_image &&
          resource_provider_->use_sync_query();

cc/trees/layer_tree_host_impl.h

@@ -519,8 +519,8 @@ class CC_EXPORT LayerTreeHostImpl
   void EnforceZeroBudget(bool zero_budget);
 
   bool UsePendingTreeForSync() const;
-  bool UseZeroCopyTextureUpload() const;
-  bool UseOneCopyTextureUpload() const;
+  bool UseZeroCopyRasterizer() const;
+  bool UseOneCopyRasterizer() const;
 
   void ScrollViewportBy(gfx::Vector2dF scroll_delta);
   void AnimatePageScale(base::TimeTicks monotonic_time);