cc: Separate RasterWorkerPool interface from implementation details.

RasterWorkerPool class has a lot of implementation specific details
that the tile manager and the delegate should not be affected by.
Moving implementation specific parts into a separate class and file
makes it clear what is part of the interface used by the tile
manager and what are details of the implementation. ie. changes to
implementation specific files alone should not affect or require
changes to the tile manager.

BUG=269841

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@263120 0039d316-1c4b-4281-b951-d872f2087c98

cc/cc.gyp

@@ -366,8 +366,10 @@
         'resources/raster_mode.h',
         'resources/raster_worker_pool.cc',
         'resources/raster_worker_pool.h',
-        'resources/raster_worker_pool_delegate.cc',
-        'resources/raster_worker_pool_delegate.h',
+        'resources/rasterizer.cc',
+        'resources/rasterizer.h',
+        'resources/rasterizer_delegate.cc',
+        'resources/rasterizer_delegate.h',
         'resources/release_callback.h',
         'resources/resource.cc',
         'resources/resource.h',

cc/resources/direct_raster_worker_pool.cc

@@ -14,11 +14,11 @@
 namespace cc {
 
 // static
-scoped_ptr<DirectRasterWorkerPool> DirectRasterWorkerPool::Create(
+scoped_ptr<RasterWorkerPool> DirectRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     ResourceProvider* resource_provider,
     ContextProvider* context_provider) {
-  return make_scoped_ptr(new DirectRasterWorkerPool(
+  return make_scoped_ptr<RasterWorkerPool>(new DirectRasterWorkerPool(
       task_runner, resource_provider, context_provider));
 }
 
@@ -39,7 +39,9 @@ DirectRasterWorkerPool::~DirectRasterWorkerPool() {
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
-void DirectRasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
+Rasterizer* DirectRasterWorkerPool::AsRasterizer() { return this; }
+
+void DirectRasterWorkerPool::SetClient(RasterizerClient* client) {
   client_ = client;
 }
 
@@ -58,7 +60,7 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<internal::WorkerPoolTask>
+  scoped_refptr<internal::RasterizerTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
               queue->required_for_activation_count,
@@ -66,7 +68,7 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
               base::Bind(&DirectRasterWorkerPool::
                              OnRasterRequiredForActivationFinished,
                          raster_finished_weak_ptr_factory_.GetWeakPtr())));
-  scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
+  scoped_refptr<internal::RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&DirectRasterWorkerPool::OnRasterFinished,
@@ -81,7 +83,7 @@ void DirectRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
              raster_tasks_.items.begin();
          it != raster_tasks_.items.end();
          ++it) {
-      internal::RasterWorkerPoolTask* task = it->task;
+      internal::RasterTask* task = it->task;
 
       if (std::find_if(queue->items.begin(),
                        queue->items.end(),
@@ -111,11 +113,11 @@ ResourceFormat DirectRasterWorkerPool::GetResourceFormat() const {
 void DirectRasterWorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "DirectRasterWorkerPool::CheckForCompletedTasks");
 
-  for (internal::WorkerPoolTask::Vector::const_iterator it =
+  for (internal::RasterizerTask::Vector::const_iterator it =
            completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
-    internal::WorkerPoolTask* task = it->get();
+    internal::RasterizerTask* task = it->get();
 
     task->RunReplyOnOriginThread();
   }
@@ -123,15 +125,13 @@ void DirectRasterWorkerPool::CheckForCompletedTasks() {
 }
 
 SkCanvas* DirectRasterWorkerPool::AcquireCanvasForRaster(
-    internal::WorkerPoolTask* task,
-    const Resource* resource) {
-  return resource_provider_->MapDirectRasterBuffer(resource->id());
+    internal::RasterTask* task) {
+  return resource_provider_->MapDirectRasterBuffer(task->resource()->id());
 }
 
 void DirectRasterWorkerPool::ReleaseCanvasForRaster(
-    internal::WorkerPoolTask* task,
-    const Resource* resource) {
-  resource_provider_->UnmapDirectRasterBuffer(resource->id());
+    internal::RasterTask* task) {
+  resource_provider_->UnmapDirectRasterBuffer(task->resource()->id());
 }
 
 void DirectRasterWorkerPool::OnRasterFinished() {
@@ -186,15 +186,15 @@ void DirectRasterWorkerPool::RunTasksOnOriginThread() {
              raster_tasks_.items.begin();
          it != raster_tasks_.items.end();
          ++it) {
-      internal::RasterWorkerPoolTask* task = it->task;
+      internal::RasterTask* task = it->task;
       DCHECK(!task->HasCompleted());
 
       // First need to run all dependencies.
-      for (internal::WorkerPoolTask::Vector::const_iterator it =
+      for (internal::ImageDecodeTask::Vector::const_iterator it =
                task->dependencies().begin();
            it != task->dependencies().end();
            ++it) {
-        internal::WorkerPoolTask* dependency = it->get();
+        internal::ImageDecodeTask* dependency = it->get();
         if (dependency->HasCompleted())
           continue;
 
@@ -218,7 +218,7 @@ void DirectRasterWorkerPool::RunTasksOnOriginThread() {
 }
 
 void DirectRasterWorkerPool::RunTaskOnOriginThread(
-    internal::WorkerPoolTask* task) {
+    internal::RasterizerTask* task) {
   task->WillSchedule();
   task->ScheduleOnOriginThread(this);
   task->DidSchedule();

cc/resources/direct_raster_worker_pool.h

@@ -7,49 +7,51 @@
 
 #include "base/memory/weak_ptr.h"
 #include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 
 namespace cc {
 class ContextProvider;
 class ResourceProvider;
 
 class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool,
-                                         public internal::WorkerPoolTaskClient {
+                                         public Rasterizer,
+                                         public internal::RasterizerTaskClient {
  public:
   virtual ~DirectRasterWorkerPool();
 
-  static scoped_ptr<DirectRasterWorkerPool> Create(
+  static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
       ResourceProvider* resource_provider,
       ContextProvider* context_provider);
 
   // Overridden from RasterWorkerPool:
-  virtual void SetClient(RasterWorkerPoolClient* client) OVERRIDE;
+  virtual Rasterizer* AsRasterizer() OVERRIDE;
+
+  // Overridden from Rasterizer:
+  virtual void SetClient(RasterizerClient* client) OVERRIDE;
   virtual void Shutdown() OVERRIDE {}
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
   virtual unsigned GetResourceTarget() const OVERRIDE;
   virtual ResourceFormat GetResourceFormat() const OVERRIDE;
   virtual void CheckForCompletedTasks() OVERRIDE;
 
-  // Overridden from internal::WorkerPoolTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::WorkerPoolTask* task,
-                                           const Resource* resource) OVERRIDE;
-  virtual void ReleaseCanvasForRaster(internal::WorkerPoolTask* task,
-                                      const Resource* resource) OVERRIDE;
+  // Overridden from internal::RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task) OVERRIDE;
+  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE;
 
- protected:
+ private:
   DirectRasterWorkerPool(base::SequencedTaskRunner* task_runner,
                          ResourceProvider* resource_provider,
                          ContextProvider* context_provider);
 
- private:
   void OnRasterFinished();
   void OnRasterRequiredForActivationFinished();
   void ScheduleRunTasksOnOriginThread();
   void RunTasksOnOriginThread();
-  void RunTaskOnOriginThread(internal::WorkerPoolTask* task);
+  void RunTaskOnOriginThread(internal::RasterizerTask* task);
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  RasterWorkerPoolClient* client_;
+  RasterizerClient* client_;
   ResourceProvider* resource_provider_;
   ContextProvider* context_provider_;
 
@@ -63,11 +65,11 @@ class CC_EXPORT DirectRasterWorkerPool : public RasterWorkerPool,
   base::WeakPtrFactory<DirectRasterWorkerPool>
       raster_finished_weak_ptr_factory_;
 
-  scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
-  scoped_refptr<internal::WorkerPoolTask>
+  scoped_refptr<internal::RasterizerTask> raster_finished_task_;
+  scoped_refptr<internal::RasterizerTask>
       raster_required_for_activation_finished_task_;
 
-  internal::WorkerPoolTask::Vector completed_tasks_;
+  internal::RasterizerTask::Vector completed_tasks_;
 
   base::WeakPtrFactory<DirectRasterWorkerPool> weak_ptr_factory_;
 

cc/resources/image_raster_worker_pool.cc

@@ -11,12 +11,13 @@
 namespace cc {
 
 // static
-scoped_ptr<ImageRasterWorkerPool> ImageRasterWorkerPool::Create(
+scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
+    internal::TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     unsigned texture_target) {
-  return make_scoped_ptr(new ImageRasterWorkerPool(
-      task_runner, GetTaskGraphRunner(), resource_provider, texture_target));
+  return make_scoped_ptr<RasterWorkerPool>(new ImageRasterWorkerPool(
+      task_runner, task_graph_runner, resource_provider, texture_target));
 }
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
@@ -35,7 +36,9 @@ ImageRasterWorkerPool::ImageRasterWorkerPool(
 
 ImageRasterWorkerPool::~ImageRasterWorkerPool() {}
 
-void ImageRasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
+Rasterizer* ImageRasterWorkerPool::AsRasterizer() { return this; }
+
+void ImageRasterWorkerPool::SetClient(RasterizerClient* client) {
   client_ = client;
 }
 
@@ -69,7 +72,7 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   // Cancel existing OnRasterFinished callbacks.
   raster_finished_weak_ptr_factory_.InvalidateWeakPtrs();
 
-  scoped_refptr<internal::WorkerPoolTask>
+  scoped_refptr<internal::RasterizerTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
               queue->required_for_activation_count,
@@ -77,7 +80,7 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
               base::Bind(
                   &ImageRasterWorkerPool::OnRasterRequiredForActivationFinished,
                   raster_finished_weak_ptr_factory_.GetWeakPtr())));
-  scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
+  scoped_refptr<internal::RasterizerTask> new_raster_finished_task(
       CreateRasterFinishedTask(
           task_runner_.get(),
           base::Bind(&ImageRasterWorkerPool::OnRasterFinished,
@@ -87,7 +90,7 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
        it != queue->items.end();
        ++it) {
     const RasterTaskQueue::Item& item = *it;
-    internal::RasterWorkerPoolTask* task = item.task;
+    internal::RasterTask* task = item.task;
     DCHECK(!task->HasCompleted());
 
     if (item.required_for_activation) {
@@ -142,8 +145,8 @@ void ImageRasterWorkerPool::CheckForCompletedTasks() {
   for (internal::Task::Vector::const_iterator it = completed_tasks_.begin();
        it != completed_tasks_.end();
        ++it) {
-    internal::WorkerPoolTask* task =
-        static_cast<internal::WorkerPoolTask*>(it->get());
+    internal::RasterizerTask* task =
+        static_cast<internal::RasterizerTask*>(it->get());
 
     task->WillComplete();
     task->CompleteOnOriginThread(this);
@@ -155,15 +158,12 @@ void ImageRasterWorkerPool::CheckForCompletedTasks() {
 }
 
 SkCanvas* ImageRasterWorkerPool::AcquireCanvasForRaster(
-    internal::WorkerPoolTask* task,
-    const Resource* resource) {
-  return resource_provider_->MapImageRasterBuffer(resource->id());
+    internal::RasterTask* task) {
+  return resource_provider_->MapImageRasterBuffer(task->resource()->id());
 }
 
-void ImageRasterWorkerPool::ReleaseCanvasForRaster(
-    internal::WorkerPoolTask* task,
-    const Resource* resource) {
-  resource_provider_->UnmapImageRasterBuffer(resource->id());
+void ImageRasterWorkerPool::ReleaseCanvasForRaster(internal::RasterTask* task) {
+  resource_provider_->UnmapImageRasterBuffer(task->resource()->id());
 }
 
 void ImageRasterWorkerPool::OnRasterFinished() {

cc/resources/image_raster_worker_pool.h

@@ -8,33 +8,37 @@
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 
 namespace cc {
 class ResourceProvider;
 
 class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
-                                        public internal::WorkerPoolTaskClient {
+                                        public Rasterizer,
+                                        public internal::RasterizerTaskClient {
  public:
   virtual ~ImageRasterWorkerPool();
 
-  static scoped_ptr<ImageRasterWorkerPool> Create(
+  static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
+      internal::TaskGraphRunner* task_graph_runner,
       ResourceProvider* resource_provider,
       unsigned texture_target);
 
   // Overridden from RasterWorkerPool:
-  virtual void SetClient(RasterWorkerPoolClient* client) OVERRIDE;
+  virtual Rasterizer* AsRasterizer() OVERRIDE;
+
+  // Overridden from Rasterizer:
+  virtual void SetClient(RasterizerClient* client) OVERRIDE;
   virtual void Shutdown() OVERRIDE;
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
   virtual unsigned GetResourceTarget() const OVERRIDE;
   virtual ResourceFormat GetResourceFormat() const OVERRIDE;
   virtual void CheckForCompletedTasks() OVERRIDE;
 
-  // Overridden from internal::WorkerPoolTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::WorkerPoolTask* task,
-                                           const Resource* resource) OVERRIDE;
-  virtual void ReleaseCanvasForRaster(internal::WorkerPoolTask* task,
-                                      const Resource* resource) OVERRIDE;
+  // Overridden from internal::RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task) OVERRIDE;
+  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE;
 
  protected:
   ImageRasterWorkerPool(base::SequencedTaskRunner* task_runner,
@@ -50,7 +54,7 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   internal::TaskGraphRunner* task_graph_runner_;
   const internal::NamespaceToken namespace_token_;
-  RasterWorkerPoolClient* client_;
+  RasterizerClient* client_;
   ResourceProvider* resource_provider_;
   const unsigned texture_target_;
 
@@ -59,8 +63,8 @@ class CC_EXPORT ImageRasterWorkerPool : public RasterWorkerPool,
 
   base::WeakPtrFactory<ImageRasterWorkerPool> raster_finished_weak_ptr_factory_;
 
-  scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
-  scoped_refptr<internal::WorkerPoolTask>
+  scoped_refptr<internal::RasterizerTask> raster_finished_task_;
+  scoped_refptr<internal::RasterizerTask>
       raster_required_for_activation_finished_task_;
 
   // Task graph used when scheduling tasks and vector used to gather

cc/resources/managed_tile_state.h

@@ -8,7 +8,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/raster_mode.h"
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
@@ -102,7 +102,7 @@ class CC_EXPORT ManagedTileState {
     SkColor solid_color_;
     bool has_text_;
     scoped_ptr<ScopedResource> resource_;
-    scoped_refptr<internal::RasterWorkerPoolTask> raster_task_;
+    scoped_refptr<internal::RasterTask> raster_task_;
   };
 
   ManagedTileState();

cc/resources/pixel_buffer_raster_worker_pool.h

@@ -11,72 +11,71 @@
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 
 namespace cc {
 class ResourceProvider;
 
 class CC_EXPORT PixelBufferRasterWorkerPool
     : public RasterWorkerPool,
-      public internal::WorkerPoolTaskClient {
+      public Rasterizer,
+      public internal::RasterizerTaskClient {
  public:
   virtual ~PixelBufferRasterWorkerPool();
 
-  static scoped_ptr<PixelBufferRasterWorkerPool> Create(
+  static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
+      internal::TaskGraphRunner* task_graph_runner,
       ResourceProvider* resource_provider,
       size_t max_transfer_buffer_usage_bytes);
 
   // Overridden from RasterWorkerPool:
-  virtual void SetClient(RasterWorkerPoolClient* client) OVERRIDE;
+  virtual Rasterizer* AsRasterizer() OVERRIDE;
+
+  // Overridden from Rasterizer:
+  virtual void SetClient(RasterizerClient* client) OVERRIDE;
   virtual void Shutdown() OVERRIDE;
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE;
   virtual unsigned GetResourceTarget() const OVERRIDE;
   virtual ResourceFormat GetResourceFormat() const OVERRIDE;
   virtual void CheckForCompletedTasks() OVERRIDE;
 
-  // Overridden from internal::WorkerPoolTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::WorkerPoolTask* task,
-                                           const Resource* resource) OVERRIDE;
-  virtual void ReleaseCanvasForRaster(internal::WorkerPoolTask* task,
-                                      const Resource* resource) OVERRIDE;
-
- protected:
-  PixelBufferRasterWorkerPool(base::SequencedTaskRunner* task_runner,
-                              internal::TaskGraphRunner* task_graph_runner,
-                              ResourceProvider* resource_provider,
-                              size_t max_transfer_buffer_usage_bytes);
+  // Overridden from internal::RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task) OVERRIDE;
+  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE;
 
  private:
   struct RasterTaskState {
     class TaskComparator {
      public:
-      explicit TaskComparator(const internal::WorkerPoolTask* task)
-          : task_(task) {}
+      explicit TaskComparator(const internal::RasterTask* task) : task_(task) {}
 
       bool operator()(const RasterTaskState& state) const {
         return state.task == task_;
       }
 
      private:
-      const internal::WorkerPoolTask* task_;
+      const internal::RasterTask* task_;
     };
 
     typedef std::vector<RasterTaskState> Vector;
 
-    RasterTaskState(internal::WorkerPoolTask* task,
-                    bool required_for_activation)
+    RasterTaskState(internal::RasterTask* task, bool required_for_activation)
         : type(UNSCHEDULED),
           task(task),
-          resource(NULL),
           required_for_activation(required_for_activation) {}
 
     enum { UNSCHEDULED, SCHEDULED, UPLOADING, COMPLETED } type;
-    internal::WorkerPoolTask* task;
-    const Resource* resource;
+    internal::RasterTask* task;
     bool required_for_activation;
   };
 
-  typedef std::deque<scoped_refptr<internal::WorkerPoolTask> > TaskDeque;
+  typedef std::deque<scoped_refptr<internal::RasterTask> > RasterTaskDeque;
+
+  PixelBufferRasterWorkerPool(base::SequencedTaskRunner* task_runner,
+                              internal::TaskGraphRunner* task_graph_runner,
+                              ResourceProvider* resource_provider,
+                              size_t max_transfer_buffer_usage_bytes);
 
   void OnRasterFinished();
   void OnRasterRequiredForActivationFinished();
@@ -89,7 +88,7 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   unsigned PendingRasterTaskCount() const;
   bool HasPendingTasks() const;
   bool HasPendingTasksRequiredForActivation() const;
-  void CheckForCompletedWorkerPoolTasks();
+  void CheckForCompletedRasterizerTasks();
 
   const char* StateName() const;
   scoped_ptr<base::Value> StateAsValue() const;
@@ -98,16 +97,16 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   internal::TaskGraphRunner* task_graph_runner_;
   const internal::NamespaceToken namespace_token_;
-  RasterWorkerPoolClient* client_;
+  RasterizerClient* client_;
   ResourceProvider* resource_provider_;
 
   bool shutdown_;
 
   RasterTaskQueue raster_tasks_;
   RasterTaskState::Vector raster_task_states_;
-  TaskDeque raster_tasks_with_pending_upload_;
-  internal::WorkerPoolTask::Vector completed_raster_tasks_;
-  internal::WorkerPoolTask::Vector completed_image_decode_tasks_;
+  RasterTaskDeque raster_tasks_with_pending_upload_;
+  internal::RasterTask::Vector completed_raster_tasks_;
+  internal::RasterizerTask::Vector completed_image_decode_tasks_;
 
   size_t scheduled_raster_task_count_;
   size_t raster_tasks_required_for_activation_count_;
@@ -125,8 +124,8 @@ class CC_EXPORT PixelBufferRasterWorkerPool
   base::WeakPtrFactory<PixelBufferRasterWorkerPool>
       raster_finished_weak_ptr_factory_;
 
-  scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
-  scoped_refptr<internal::WorkerPoolTask>
+  scoped_refptr<internal::RasterizerTask> raster_finished_task_;
+  scoped_refptr<internal::RasterizerTask>
       raster_required_for_activation_finished_task_;
 
   // Task graph used when scheduling tasks and vector used to gather

cc/resources/raster_worker_pool.cc

@@ -85,9 +85,9 @@ const int kDefaultNumRasterThreads = 1;
 
 int g_num_raster_threads = 0;
 
-class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+class RasterFinishedTaskImpl : public internal::RasterizerTask {
  public:
-  explicit RasterFinishedWorkerPoolTaskImpl(
+  explicit RasterFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& on_raster_finished_callback)
       : task_runner_(task_runner),
@@ -95,23 +95,23 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread() OVERRIDE {
-    TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnWorkerThread");
+    TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnWorkerThread");
     RasterFinished();
   }
 
-  // Overridden from internal::WorkerPoolTask:
-  virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
+  // Overridden from internal::RasterizerTask:
+  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
       OVERRIDE {}
   virtual void RunOnOriginThread() OVERRIDE {
-    TRACE_EVENT0("cc", "RasterFinishedWorkerPoolTaskImpl::RunOnOriginThread");
+    TRACE_EVENT0("cc", "RasterFinishedTaskImpl::RunOnOriginThread");
     RasterFinished();
   }
-  virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
+  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
       OVERRIDE {}
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
-  virtual ~RasterFinishedWorkerPoolTaskImpl() {}
+  virtual ~RasterFinishedTaskImpl() {}
 
   void RasterFinished() {
     task_runner_->PostTask(FROM_HERE, on_raster_finished_callback_);
@@ -121,18 +121,17 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   const base::Closure on_raster_finished_callback_;
 
-  DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(RasterFinishedTaskImpl);
 };
 
-class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
-    : public RasterFinishedWorkerPoolTaskImpl {
+class RasterRequiredForActivationFinishedTaskImpl
+    : public RasterFinishedTaskImpl {
  public:
-  RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
+  RasterRequiredForActivationFinishedTaskImpl(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& on_raster_finished_callback,
       size_t tasks_required_for_activation_count)
-      : RasterFinishedWorkerPoolTaskImpl(task_runner,
-                                         on_raster_finished_callback),
+      : RasterFinishedTaskImpl(task_runner, on_raster_finished_callback),
         tasks_required_for_activation_count_(
             tasks_required_for_activation_count) {
     if (tasks_required_for_activation_count_) {
@@ -143,22 +142,20 @@ class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread() OVERRIDE {
-    TRACE_EVENT0("cc",
-                 "RasterRequiredForActivationFinishedWorkerPoolTaskImpl::"
-                 "RunOnWorkerThread");
+    TRACE_EVENT0(
+        "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnWorkerThread");
     RunRasterFinished();
   }
 
-  // Overridden from internal::WorkerPoolTask:
+  // Overridden from internal::RasterizerTask:
   virtual void RunOnOriginThread() OVERRIDE {
-    TRACE_EVENT0("cc",
-                 "RasterRequiredForActivationFinishedWorkerPoolTaskImpl::"
-                 "RunOnOriginThread");
+    TRACE_EVENT0(
+        "cc", "RasterRequiredForActivationFinishedTaskImpl::RunOnOriginThread");
     RunRasterFinished();
   }
 
  private:
-  virtual ~RasterRequiredForActivationFinishedWorkerPoolTaskImpl() {}
+  virtual ~RasterRequiredForActivationFinishedTaskImpl() {}
 
   void RunRasterFinished() {
     if (tasks_required_for_activation_count_) {
@@ -171,73 +168,11 @@ class RasterRequiredForActivationFinishedWorkerPoolTaskImpl
   base::TimeTicks activation_delay_end_time_;
   const size_t tasks_required_for_activation_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(
-      RasterRequiredForActivationFinishedWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(RasterRequiredForActivationFinishedTaskImpl);
 };
 
 }  // namespace
 
-namespace internal {
-
-WorkerPoolTask::WorkerPoolTask() : did_schedule_(false), did_complete_(false) {}
-
-WorkerPoolTask::~WorkerPoolTask() {
-  DCHECK(!did_schedule_);
-  DCHECK(!did_run_ || did_complete_);
-}
-
-void WorkerPoolTask::WillSchedule() { DCHECK(!did_schedule_); }
-
-void WorkerPoolTask::DidSchedule() {
-  did_schedule_ = true;
-  did_complete_ = false;
-}
-
-bool WorkerPoolTask::HasBeenScheduled() const { return did_schedule_; }
-
-void WorkerPoolTask::WillComplete() { DCHECK(!did_complete_); }
-
-void WorkerPoolTask::DidComplete() {
-  DCHECK(did_schedule_);
-  DCHECK(!did_complete_);
-  did_schedule_ = false;
-  did_complete_ = true;
-}
-
-bool WorkerPoolTask::HasCompleted() const { return did_complete_; }
-
-RasterWorkerPoolTask::RasterWorkerPoolTask(
-    const Resource* resource,
-    internal::WorkerPoolTask::Vector* dependencies)
-    : resource_(resource) {
-  dependencies_.swap(*dependencies);
-}
-
-RasterWorkerPoolTask::~RasterWorkerPoolTask() {}
-
-}  // namespace internal
-
-RasterTaskQueue::Item::Item(internal::RasterWorkerPoolTask* task,
-                            bool required_for_activation)
-    : task(task), required_for_activation(required_for_activation) {}
-
-RasterTaskQueue::Item::~Item() {}
-
-RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {}
-
-RasterTaskQueue::~RasterTaskQueue() {}
-
-void RasterTaskQueue::Swap(RasterTaskQueue* other) {
-  items.swap(other->items);
-  std::swap(required_for_activation_count,
-            other->required_for_activation_count);
-}
-
-void RasterTaskQueue::Reset() {
-  required_for_activation_count = 0u;
-  items.clear();
-}
-
 // This allows an external rasterize on-demand system to run raster tasks
 // with highest priority using the same task graph runner instance.
 unsigned RasterWorkerPool::kOnDemandRasterTaskPriority = 0u;
@@ -251,6 +186,10 @@ unsigned RasterWorkerPool::kRasterRequiredForActivationFinishedTaskPriority =
     1u;
 unsigned RasterWorkerPool::kRasterTaskPriorityBase = 3u;
 
+RasterWorkerPool::RasterWorkerPool() {}
+
+RasterWorkerPool::~RasterWorkerPool() {}
+
 // static
 void RasterWorkerPool::SetNumRasterThreads(int num_threads) {
   DCHECK_LT(0, num_threads);
@@ -278,39 +217,38 @@ size_t RasterWorkerPool::GetPictureCloneIndexForCurrentThread() {
 }
 
 // static
-scoped_refptr<internal::WorkerPoolTask>
+scoped_refptr<internal::RasterizerTask>
 RasterWorkerPool::CreateRasterFinishedTask(
     base::SequencedTaskRunner* task_runner,
     const base::Closure& on_raster_finished_callback) {
-  return make_scoped_refptr(new RasterFinishedWorkerPoolTaskImpl(
-      task_runner, on_raster_finished_callback));
+  return make_scoped_refptr(
+      new RasterFinishedTaskImpl(task_runner, on_raster_finished_callback));
 }
 
 // static
-scoped_refptr<internal::WorkerPoolTask>
+scoped_refptr<internal::RasterizerTask>
 RasterWorkerPool::CreateRasterRequiredForActivationFinishedTask(
     size_t tasks_required_for_activation_count,
     base::SequencedTaskRunner* task_runner,
     const base::Closure& on_raster_finished_callback) {
-  return make_scoped_refptr(
-      new RasterRequiredForActivationFinishedWorkerPoolTaskImpl(
-          task_runner,
-          on_raster_finished_callback,
-          tasks_required_for_activation_count));
+  return make_scoped_refptr(new RasterRequiredForActivationFinishedTaskImpl(
+      task_runner,
+      on_raster_finished_callback,
+      tasks_required_for_activation_count));
 }
 
 // static
 void RasterWorkerPool::ScheduleTasksOnOriginThread(
-    internal::WorkerPoolTaskClient* client,
+    internal::RasterizerTaskClient* client,
     internal::TaskGraph* graph) {
-  TRACE_EVENT0("cc", "RasterWorkerPool::ScheduleTasksOnOriginThread");
+  TRACE_EVENT0("cc", "Rasterizer::ScheduleTasksOnOriginThread");
 
   for (internal::TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end();
        ++it) {
     internal::TaskGraph::Node& node = *it;
-    internal::WorkerPoolTask* task =
-        static_cast<internal::WorkerPoolTask*>(node.task);
+    internal::RasterizerTask* task =
+        static_cast<internal::RasterizerTask*>(node.task);
 
     if (!task->HasBeenScheduled()) {
       task->WillSchedule();
@@ -322,7 +260,7 @@ void RasterWorkerPool::ScheduleTasksOnOriginThread(
 
 // static
 void RasterWorkerPool::InsertNodeForTask(internal::TaskGraph* graph,
-                                         internal::WorkerPoolTask* task,
+                                         internal::RasterizerTask* task,
                                          unsigned priority,
                                          size_t dependencies) {
   DCHECK(std::find_if(graph->nodes.begin(),
@@ -336,17 +274,17 @@ void RasterWorkerPool::InsertNodeForTask(internal::TaskGraph* graph,
 // static
 void RasterWorkerPool::InsertNodesForRasterTask(
     internal::TaskGraph* graph,
-    internal::WorkerPoolTask* raster_task,
-    const internal::WorkerPoolTask::Vector& decode_tasks,
+    internal::RasterTask* raster_task,
+    const internal::ImageDecodeTask::Vector& decode_tasks,
     unsigned priority) {
   size_t dependencies = 0u;
 
   // Insert image decode tasks.
-  for (internal::WorkerPoolTask::Vector::const_iterator it =
+  for (internal::ImageDecodeTask::Vector::const_iterator it =
            decode_tasks.begin();
        it != decode_tasks.end();
        ++it) {
-    internal::WorkerPoolTask* decode_task = it->get();
+    internal::ImageDecodeTask* decode_task = it->get();
 
     // Skip if already decoded.
     if (decode_task->HasCompleted())

cc/resources/raster_worker_pool.h

@@ -5,130 +5,14 @@
 #ifndef CC_RESOURCES_RASTER_WORKER_POOL_H_
 #define CC_RESOURCES_RASTER_WORKER_POOL_H_
 
-#include <vector>
-
-#include "base/callback.h"
-#include "cc/resources/resource_format.h"
-#include "cc/resources/task_graph_runner.h"
-
-class SkCanvas;
+#include "cc/resources/rasterizer.h"
 
 namespace base {
 class SequencedTaskRunner;
 }
 
 namespace cc {
-class Resource;
-
-namespace internal {
-class WorkerPoolTask;
-
-class CC_EXPORT WorkerPoolTaskClient {
- public:
-  virtual SkCanvas* AcquireCanvasForRaster(WorkerPoolTask* task,
-                                           const Resource* resource) = 0;
-  virtual void ReleaseCanvasForRaster(WorkerPoolTask* task,
-                                      const Resource* resource) = 0;
-
- protected:
-  virtual ~WorkerPoolTaskClient() {}
-};
-
-class CC_EXPORT WorkerPoolTask : public Task {
- public:
-  typedef std::vector<scoped_refptr<WorkerPoolTask> > Vector;
-
-  virtual void ScheduleOnOriginThread(WorkerPoolTaskClient* client) = 0;
-  virtual void RunOnOriginThread() = 0;
-  virtual void CompleteOnOriginThread(WorkerPoolTaskClient* client) = 0;
-  virtual void RunReplyOnOriginThread() = 0;
-
-  void WillSchedule();
-  void DidSchedule();
-  bool HasBeenScheduled() const;
-
-  void WillComplete();
-  void DidComplete();
-  bool HasCompleted() const;
-
- protected:
-  WorkerPoolTask();
-  virtual ~WorkerPoolTask();
-
-  bool did_schedule_;
-  bool did_complete_;
-};
-
-class CC_EXPORT RasterWorkerPoolTask : public WorkerPoolTask {
- public:
-  const Resource* resource() const { return resource_; }
-  const internal::WorkerPoolTask::Vector& dependencies() const {
-    return dependencies_;
-  }
-
- protected:
-  RasterWorkerPoolTask(const Resource* resource,
-                       internal::WorkerPoolTask::Vector* dependencies);
-  virtual ~RasterWorkerPoolTask();
-
- private:
-  const Resource* resource_;
-  WorkerPoolTask::Vector dependencies_;
-};
-
-}  // namespace internal
-
-class CC_EXPORT RasterWorkerPoolClient {
- public:
-  virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0;
-  virtual void DidFinishRunningTasks() = 0;
-  virtual void DidFinishRunningTasksRequiredForActivation() = 0;
 
- protected:
-  virtual ~RasterWorkerPoolClient() {}
-};
-
-struct CC_EXPORT RasterTaskQueue {
-  struct CC_EXPORT Item {
-    class TaskComparator {
-     public:
-      explicit TaskComparator(const internal::WorkerPoolTask* task)
-          : task_(task) {}
-
-      bool operator()(const Item& item) const { return item.task == task_; }
-
-     private:
-      const internal::WorkerPoolTask* task_;
-    };
-
-    typedef std::vector<Item> Vector;
-
-    Item(internal::RasterWorkerPoolTask* task, bool required_for_activation);
-    ~Item();
-
-    static bool IsRequiredForActivation(const Item& item) {
-      return item.required_for_activation;
-    }
-
-    internal::RasterWorkerPoolTask* task;
-    bool required_for_activation;
-  };
-
-  RasterTaskQueue();
-  ~RasterTaskQueue();
-
-  void Swap(RasterTaskQueue* other);
-  void Reset();
-
-  Item::Vector items;
-  size_t required_for_activation_count;
-};
-
-// This interface can be used to schedule and run raster tasks. The client will
-// be notified asynchronously when the set of tasks marked as "required for
-// activation" have finished running and when all scheduled tasks have finished
-// running. The client can call CheckForCompletedTasks() at any time to dispatch
-// pending completion callbacks for all tasks that have finished running.
 class CC_EXPORT RasterWorkerPool {
  public:
   static unsigned kOnDemandRasterTaskPriority;
@@ -137,6 +21,9 @@ class CC_EXPORT RasterWorkerPool {
   static unsigned kRasterRequiredForActivationFinishedTaskPriority;
   static unsigned kRasterTaskPriorityBase;
 
+  RasterWorkerPool();
+  virtual ~RasterWorkerPool();
+
   // Set the number of threads to use for the global TaskGraphRunner instance.
   // This can only be called once and must be called prior to
   // GetNumRasterThreads().
@@ -152,70 +39,44 @@ class CC_EXPORT RasterWorkerPool {
   // value between 0 and GetNumRasterThreads() - 1.
   static size_t GetPictureCloneIndexForCurrentThread();
 
-  // Utility function that can be used by implementations to create a "raster
-  // finished" task that posts |callback| to |task_runner| when run.
-  static scoped_refptr<internal::WorkerPoolTask> CreateRasterFinishedTask(
+  // Utility function that can be used to create a "raster finished" task that
+  // posts |callback| to |task_runner| when run.
+  static scoped_refptr<internal::RasterizerTask> CreateRasterFinishedTask(
       base::SequencedTaskRunner* task_runner,
       const base::Closure& callback);
 
-  // Utility function that can be used by implementations to create a "raster
-  // required for activation finished" task that posts |callback| to
-  // |task_runner| when run.
-  static scoped_refptr<internal::WorkerPoolTask>
+  // Utility function that can be used to create a "raster required for
+  // activation finished" task that posts |callback| to |task_runner| when run.
+  static scoped_refptr<internal::RasterizerTask>
       CreateRasterRequiredForActivationFinishedTask(
           size_t tasks_required_for_activation_count,
           base::SequencedTaskRunner* task_runner,
           const base::Closure& callback);
 
-  // Utility function that can be used by implementations to call
-  // ::ScheduleOnOriginThread() for each task in |graph|.
+  // Utility function that can be used to call ::ScheduleOnOriginThread() for
+  // each task in |graph|.
   static void ScheduleTasksOnOriginThread(
-      internal::WorkerPoolTaskClient* client,
+      internal::RasterizerTaskClient* client,
       internal::TaskGraph* graph);
 
-  // Utility function that can be used by implementations to build a task graph.
-  // Inserts a node that represents |task| in |graph|. See TaskGraph definition
-  // for valid |priority| values.
+  // Utility function that can be used to build a task graph. Inserts a node
+  // that represents |task| in |graph|. See TaskGraph definition for valid
+  // |priority| values.
   static void InsertNodeForTask(internal::TaskGraph* graph,
-                                internal::WorkerPoolTask* task,
+                                internal::RasterizerTask* task,
                                 unsigned priority,
                                 size_t dependencies);
 
-  // Utility function that can be used by implementations to build a task graph.
-  // Inserts nodes that represent |task| and all its image decode dependencies
-  // in |graph|.
+  // Utility function that can be used to build a task graph. Inserts nodes that
+  // represent |task| and all its image decode dependencies in |graph|.
   static void InsertNodesForRasterTask(
       internal::TaskGraph* graph,
-      internal::WorkerPoolTask* task,
-      const internal::WorkerPoolTask::Vector& decode_tasks,
+      internal::RasterTask* task,
+      const internal::ImageDecodeTask::Vector& decode_tasks,
       unsigned priority);
 
-  // Set the client instance to be notified when finished running tasks.
-  virtual void SetClient(RasterWorkerPoolClient* client) = 0;
-
-  // Tells the worker pool to shutdown after canceling all previously scheduled
-  // tasks. Reply callbacks are still guaranteed to run when
-  // CheckForCompletedTasks() is called.
-  virtual void Shutdown() = 0;
-
-  // Schedule running of raster tasks in |queue| and all dependencies.
-  // Previously scheduled tasks that are not in |queue| will be canceled unless
-  // already running. Once scheduled, reply callbacks are guaranteed to run for
-  // all tasks even if they later get canceled by another call to
-  // ScheduleTasks().
-  virtual void ScheduleTasks(RasterTaskQueue* queue) = 0;
-
-  // Check for completed tasks and dispatch reply callbacks.
-  virtual void CheckForCompletedTasks() = 0;
-
-  // Returns the target that needs to be used for raster task resources.
-  virtual unsigned GetResourceTarget() const = 0;
-
-  // Returns the format that needs to be used for raster task resources.
-  virtual ResourceFormat GetResourceFormat() const = 0;
-
- protected:
-  virtual ~RasterWorkerPool() {}
+  // Type-checking downcast routine.
+  virtual Rasterizer* AsRasterizer() = 0;
 };
 
 }  // namespace cc

cc/resources/raster_worker_pool_unittest.cc

@@ -13,6 +13,7 @@
 #include "cc/resources/picture_pile.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/test/fake_output_surface.h"
@@ -36,16 +37,16 @@ enum RasterWorkerPoolType {
   RASTER_WORKER_POOL_TYPE_DIRECT
 };
 
-class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
+class TestRasterTaskImpl : public internal::RasterTask {
  public:
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
                               RasterThread raster_thread)> Reply;
 
-  TestRasterWorkerPoolTaskImpl(const Resource* resource,
-                               const Reply& reply,
-                               internal::WorkerPoolTask::Vector* dependencies)
-      : internal::RasterWorkerPoolTask(resource, dependencies),
+  TestRasterTaskImpl(const Resource* resource,
+                     const Reply& reply,
+                     internal::ImageDecodeTask::Vector* dependencies)
+      : internal::RasterTask(resource, dependencies),
         reply_(reply),
         raster_thread_(RASTER_THREAD_NONE) {}
 
@@ -54,17 +55,17 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
     raster_thread_ = RASTER_THREAD_WORKER;
   }
 
-  // Overridden from internal::WorkerPoolTask:
-  virtual void ScheduleOnOriginThread(internal::WorkerPoolTaskClient* client)
+  // Overridden from internal::RasterizerTask:
+  virtual void ScheduleOnOriginThread(internal::RasterizerTaskClient* client)
       OVERRIDE {
-    client->AcquireCanvasForRaster(this, resource());
+    client->AcquireCanvasForRaster(this);
   }
   virtual void RunOnOriginThread() OVERRIDE {
     raster_thread_ = RASTER_THREAD_ORIGIN;
   }
-  virtual void CompleteOnOriginThread(internal::WorkerPoolTaskClient* client)
+  virtual void CompleteOnOriginThread(internal::RasterizerTaskClient* client)
       OVERRIDE {
-    client->ReleaseCanvasForRaster(this, resource());
+    client->ReleaseCanvasForRaster(this);
   }
   virtual void RunReplyOnOriginThread() OVERRIDE {
     reply_.Run(
@@ -72,47 +73,44 @@ class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
   }
 
  protected:
-  virtual ~TestRasterWorkerPoolTaskImpl() {}
+  virtual ~TestRasterTaskImpl() {}
 
  private:
   const Reply reply_;
   RasterThread raster_thread_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl);
 };
 
-class BlockingTestRasterWorkerPoolTaskImpl
-    : public TestRasterWorkerPoolTaskImpl {
+class BlockingTestRasterTaskImpl : public TestRasterTaskImpl {
  public:
-  BlockingTestRasterWorkerPoolTaskImpl(
-      const Resource* resource,
-      const Reply& reply,
-      base::Lock* lock,
-      internal::WorkerPoolTask::Vector* dependencies)
-      : TestRasterWorkerPoolTaskImpl(resource, reply, dependencies),
-        lock_(lock) {}
+  BlockingTestRasterTaskImpl(const Resource* resource,
+                             const Reply& reply,
+                             base::Lock* lock,
+                             internal::ImageDecodeTask::Vector* dependencies)
+      : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {}
 
   // Overridden from internal::Task:
   virtual void RunOnWorkerThread() OVERRIDE {
     base::AutoLock lock(*lock_);
-    TestRasterWorkerPoolTaskImpl::RunOnWorkerThread();
+    TestRasterTaskImpl::RunOnWorkerThread();
   }
 
-  // Overridden from internal::WorkerPoolTask:
+  // Overridden from internal::RasterizerTask:
   virtual void RunReplyOnOriginThread() OVERRIDE {}
 
  protected:
-  virtual ~BlockingTestRasterWorkerPoolTaskImpl() {}
+  virtual ~BlockingTestRasterTaskImpl() {}
 
  private:
   base::Lock* lock_;
 
-  DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterWorkerPoolTaskImpl);
+  DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl);
 };
 
 class RasterWorkerPoolTest
     : public testing::TestWithParam<RasterWorkerPoolType>,
-      public RasterWorkerPoolClient {
+      public RasterizerClient {
  public:
   struct RasterTaskResult {
     unsigned id;
@@ -120,8 +118,7 @@ class RasterWorkerPoolTest
     RasterThread raster_thread;
   };
 
-  typedef std::vector<scoped_refptr<internal::RasterWorkerPoolTask> >
-      RasterTaskVector;
+  typedef std::vector<scoped_refptr<internal::RasterTask> > RasterTaskVector;
 
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
@@ -135,49 +132,48 @@ class RasterWorkerPoolTest
         ResourceProvider::Create(
             output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1)
             .Pass();
-    pixel_buffer_raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
-        base::MessageLoopProxy::current().get(),
-        resource_provider_.get(),
-        std::numeric_limits<size_t>::max());
-    image_raster_worker_pool_ =
-        ImageRasterWorkerPool::Create(base::MessageLoopProxy::current().get(),
-                                      resource_provider_.get(),
-                                      GL_TEXTURE_2D);
-    direct_raster_worker_pool_ =
-        DirectRasterWorkerPool::Create(base::MessageLoopProxy::current().get(),
-                                       resource_provider_.get(),
-                                       context_provider_.get());
 
     switch (GetParam()) {
       case RASTER_WORKER_POOL_TYPE_PIXEL_BUFFER:
-        raster_worker_pool_ = pixel_buffer_raster_worker_pool_.get();
+        raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
+            base::MessageLoopProxy::current().get(),
+            RasterWorkerPool::GetTaskGraphRunner(),
+            resource_provider_.get(),
+            std::numeric_limits<size_t>::max());
         break;
       case RASTER_WORKER_POOL_TYPE_IMAGE:
-        raster_worker_pool_ = image_raster_worker_pool_.get();
+        raster_worker_pool_ = ImageRasterWorkerPool::Create(
+            base::MessageLoopProxy::current().get(),
+            RasterWorkerPool::GetTaskGraphRunner(),
+            resource_provider_.get(),
+            GL_TEXTURE_2D);
         break;
       case RASTER_WORKER_POOL_TYPE_DIRECT:
-        raster_worker_pool_ = direct_raster_worker_pool_.get();
+        raster_worker_pool_ = DirectRasterWorkerPool::Create(
+            base::MessageLoopProxy::current().get(),
+            resource_provider_.get(),
+            context_provider_.get());
         break;
     }
 
     DCHECK(raster_worker_pool_);
-    raster_worker_pool_->SetClient(this);
+    raster_worker_pool_->AsRasterizer()->SetClient(this);
   }
   virtual ~RasterWorkerPoolTest() { resource_provider_.reset(); }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
-    raster_worker_pool_->Shutdown();
-    raster_worker_pool_->CheckForCompletedTasks();
+    raster_worker_pool_->AsRasterizer()->Shutdown();
+    raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
   }
 
   // Overriden from RasterWorkerPoolClient:
-  virtual bool ShouldForceTasksRequiredForActivationToComplete()
-      const OVERRIDE {
+  virtual bool ShouldForceTasksRequiredForActivationToComplete() const
+      OVERRIDE {
     return false;
   }
   virtual void DidFinishRunningTasks() OVERRIDE {
-    raster_worker_pool_->CheckForCompletedTasks();
+    raster_worker_pool_->AsRasterizer()->CheckForCompletedTasks();
     base::MessageLoop::current()->Quit();
   }
   virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE {}
@@ -207,7 +203,7 @@ class RasterWorkerPoolTest
          ++it)
       queue.items.push_back(RasterTaskQueue::Item(*it, false));
 
-    raster_worker_pool_->ScheduleTasks(&queue);
+    raster_worker_pool_->AsRasterizer()->ScheduleTasks(&queue);
   }
 
   void AppendTask(unsigned id) {
@@ -218,8 +214,8 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    internal::WorkerPoolTask::Vector empty;
-    tasks_.push_back(new TestRasterWorkerPoolTaskImpl(
+    internal::ImageDecodeTask::Vector empty;
+    tasks_.push_back(new TestRasterTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
@@ -236,8 +232,8 @@ class RasterWorkerPoolTest
     resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
     const Resource* const_resource = resource.get();
 
-    internal::WorkerPoolTask::Vector empty;
-    tasks_.push_back(new BlockingTestRasterWorkerPoolTaskImpl(
+    internal::ImageDecodeTask::Vector empty;
+    tasks_.push_back(new BlockingTestRasterTaskImpl(
         const_resource,
         base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                    base::Unretained(this),
@@ -275,10 +271,7 @@ class RasterWorkerPoolTest
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
-  scoped_ptr<PixelBufferRasterWorkerPool> pixel_buffer_raster_worker_pool_;
-  scoped_ptr<ImageRasterWorkerPool> image_raster_worker_pool_;
-  scoped_ptr<DirectRasterWorkerPool> direct_raster_worker_pool_;
-  RasterWorkerPool* raster_worker_pool_;
+  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;

cc/resources/rasterizer.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/rasterizer.h"
+
+#include <algorithm>
+
+namespace cc {
+namespace internal {
+
+RasterizerTask::RasterizerTask() : did_schedule_(false), did_complete_(false) {}
+
+RasterizerTask::~RasterizerTask() {
+  DCHECK(!did_schedule_);
+  DCHECK(!did_run_ || did_complete_);
+}
+
+ImageDecodeTask* RasterizerTask::AsImageDecodeTask() { return NULL; }
+
+RasterTask* RasterizerTask::AsRasterTask() { return NULL; }
+
+void RasterizerTask::WillSchedule() { DCHECK(!did_schedule_); }
+
+void RasterizerTask::DidSchedule() {
+  did_schedule_ = true;
+  did_complete_ = false;
+}
+
+bool RasterizerTask::HasBeenScheduled() const { return did_schedule_; }
+
+void RasterizerTask::WillComplete() { DCHECK(!did_complete_); }
+
+void RasterizerTask::DidComplete() {
+  DCHECK(did_schedule_);
+  DCHECK(!did_complete_);
+  did_schedule_ = false;
+  did_complete_ = true;
+}
+
+bool RasterizerTask::HasCompleted() const { return did_complete_; }
+
+ImageDecodeTask::ImageDecodeTask() {}
+
+ImageDecodeTask::~ImageDecodeTask() {}
+
+ImageDecodeTask* ImageDecodeTask::AsImageDecodeTask() { return this; }
+
+RasterTask::RasterTask(const Resource* resource,
+                       internal::ImageDecodeTask::Vector* dependencies)
+    : resource_(resource) {
+  dependencies_.swap(*dependencies);
+}
+
+RasterTask::~RasterTask() {}
+
+RasterTask* RasterTask::AsRasterTask() { return this; }
+
+}  // namespace internal
+
+RasterTaskQueue::Item::Item(internal::RasterTask* task,
+                            bool required_for_activation)
+    : task(task), required_for_activation(required_for_activation) {}
+
+RasterTaskQueue::Item::~Item() {}
+
+RasterTaskQueue::RasterTaskQueue() : required_for_activation_count(0u) {}
+
+RasterTaskQueue::~RasterTaskQueue() {}
+
+void RasterTaskQueue::Swap(RasterTaskQueue* other) {
+  items.swap(other->items);
+  std::swap(required_for_activation_count,
+            other->required_for_activation_count);
+}
+
+void RasterTaskQueue::Reset() {
+  required_for_activation_count = 0u;
+  items.clear();
+}
+
+}  // namespace cc

cc/resources/rasterizer.h

+// 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.
+
+#ifndef CC_RESOURCES_RASTERIZER_H_
+#define CC_RESOURCES_RASTERIZER_H_
+
+#include <vector>
+
+#include "base/callback.h"
+#include "cc/resources/resource_format.h"
+#include "cc/resources/task_graph_runner.h"
+
+class SkCanvas;
+
+namespace cc {
+class Resource;
+
+namespace internal {
+class RasterTask;
+
+class CC_EXPORT RasterizerTaskClient {
+ public:
+  virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) = 0;
+  virtual void ReleaseCanvasForRaster(RasterTask* task) = 0;
+
+ protected:
+  virtual ~RasterizerTaskClient() {}
+};
+
+class ImageDecodeTask;
+
+class CC_EXPORT RasterizerTask : public Task {
+ public:
+  typedef std::vector<scoped_refptr<RasterizerTask> > Vector;
+
+  virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) = 0;
+  virtual void RunOnOriginThread() = 0;
+  virtual void CompleteOnOriginThread(RasterizerTaskClient* client) = 0;
+  virtual void RunReplyOnOriginThread() = 0;
+
+  // Type-checking downcast routines.
+  virtual ImageDecodeTask* AsImageDecodeTask();
+  virtual RasterTask* AsRasterTask();
+
+  void WillSchedule();
+  void DidSchedule();
+  bool HasBeenScheduled() const;
+
+  void WillComplete();
+  void DidComplete();
+  bool HasCompleted() const;
+
+ protected:
+  RasterizerTask();
+  virtual ~RasterizerTask();
+
+  bool did_schedule_;
+  bool did_complete_;
+};
+
+class CC_EXPORT ImageDecodeTask : public RasterizerTask {
+ public:
+  typedef std::vector<scoped_refptr<ImageDecodeTask> > Vector;
+
+  // Overridden from RasterizerTask:
+  virtual ImageDecodeTask* AsImageDecodeTask() OVERRIDE;
+
+ protected:
+  ImageDecodeTask();
+  virtual ~ImageDecodeTask();
+};
+
+class CC_EXPORT RasterTask : public RasterizerTask {
+ public:
+  typedef std::vector<scoped_refptr<RasterTask> > Vector;
+
+  // Overridden from RasterizerTask:
+  virtual RasterTask* AsRasterTask() OVERRIDE;
+
+  const Resource* resource() const { return resource_; }
+  const ImageDecodeTask::Vector& dependencies() const { return dependencies_; }
+
+ protected:
+  RasterTask(const Resource* resource, ImageDecodeTask::Vector* dependencies);
+  virtual ~RasterTask();
+
+ private:
+  const Resource* resource_;
+  ImageDecodeTask::Vector dependencies_;
+};
+
+}  // namespace internal
+
+class CC_EXPORT RasterizerClient {
+ public:
+  virtual bool ShouldForceTasksRequiredForActivationToComplete() const = 0;
+  virtual void DidFinishRunningTasks() = 0;
+  virtual void DidFinishRunningTasksRequiredForActivation() = 0;
+
+ protected:
+  virtual ~RasterizerClient() {}
+};
+
+struct CC_EXPORT RasterTaskQueue {
+  struct CC_EXPORT Item {
+    class TaskComparator {
+     public:
+      explicit TaskComparator(const internal::RasterTask* task) : task_(task) {}
+
+      bool operator()(const Item& item) const { return item.task == task_; }
+
+     private:
+      const internal::RasterTask* task_;
+    };
+
+    typedef std::vector<Item> Vector;
+
+    Item(internal::RasterTask* task, bool required_for_activation);
+    ~Item();
+
+    static bool IsRequiredForActivation(const Item& item) {
+      return item.required_for_activation;
+    }
+
+    internal::RasterTask* task;
+    bool required_for_activation;
+  };
+
+  RasterTaskQueue();
+  ~RasterTaskQueue();
+
+  void Swap(RasterTaskQueue* other);
+  void Reset();
+
+  Item::Vector items;
+  size_t required_for_activation_count;
+};
+
+// This interface can be used to schedule and run raster tasks. The client will
+// be notified asynchronously when the set of tasks marked as "required for
+// activation" have finished running and when all scheduled tasks have finished
+// running. The client can call CheckForCompletedTasks() at any time to dispatch
+// pending completion callbacks for all tasks that have finished running.
+class CC_EXPORT Rasterizer {
+ public:
+  // Set the client instance to be notified when finished running tasks.
+  virtual void SetClient(RasterizerClient* client) = 0;
+
+  // Tells the worker pool to shutdown after canceling all previously scheduled
+  // tasks. Reply callbacks are still guaranteed to run when
+  // CheckForCompletedTasks() is called.
+  virtual void Shutdown() = 0;
+
+  // Schedule running of raster tasks in |queue| and all dependencies.
+  // Previously scheduled tasks that are not in |queue| will be canceled unless
+  // already running. Once scheduled, reply callbacks are guaranteed to run for
+  // all tasks even if they later get canceled by another call to
+  // ScheduleTasks().
+  virtual void ScheduleTasks(RasterTaskQueue* queue) = 0;
+
+  // Check for completed tasks and dispatch reply callbacks.
+  virtual void CheckForCompletedTasks() = 0;
+
+  // Returns the target that needs to be used for raster task resources.
+  virtual unsigned GetResourceTarget() const = 0;
+
+  // Returns the format that needs to be used for raster task resources.
+  virtual ResourceFormat GetResourceFormat() const = 0;
+
+ protected:
+  virtual ~Rasterizer() {}
+};
+
+}  // namespace cc
+
+#endif  // CC_RESOURCES_RASTERIZER_H_

cc/resources/raster_worker_pool_delegate.cc → cc/resources/rasterizer_delegate.cc

@@ -2,73 +2,83 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "cc/resources/raster_worker_pool_delegate.h"
+#include "cc/resources/rasterizer_delegate.h"
+
+#include "base/debug/trace_event.h"
 
 namespace cc {
 
-RasterWorkerPoolDelegate::RasterWorkerPoolDelegate(
-    RasterWorkerPoolClient* client,
-    RasterWorkerPool** raster_worker_pools,
-    size_t num_raster_worker_pools)
+RasterizerDelegate::RasterizerDelegate(RasterizerClient* client,
+                                       Rasterizer** rasterizers,
+                                       size_t num_rasterizers)
     : client_(client),
-      raster_worker_pools_(raster_worker_pools,
-                           raster_worker_pools + num_raster_worker_pools),
+      rasterizers_(rasterizers, rasterizers + num_rasterizers),
       did_finish_running_tasks_pending_count_(0u),
       did_finish_running_tasks_required_for_activation_pending_count_(0u) {
   DCHECK(client_);
-  for (RasterWorkerPoolVector::iterator it = raster_worker_pools_.begin();
-       it != raster_worker_pools_.end();
+  for (RasterizerVector::iterator it = rasterizers_.begin();
+       it != rasterizers_.end();
        ++it)
     (*it)->SetClient(this);
 }
 
-RasterWorkerPoolDelegate::~RasterWorkerPoolDelegate() {}
+RasterizerDelegate::~RasterizerDelegate() {}
 
 // static
-scoped_ptr<RasterWorkerPoolDelegate> RasterWorkerPoolDelegate::Create(
-    RasterWorkerPoolClient* client,
-    RasterWorkerPool** raster_worker_pools,
-    size_t num_raster_worker_pools) {
-  return make_scoped_ptr(new RasterWorkerPoolDelegate(
-      client, raster_worker_pools, num_raster_worker_pools));
+scoped_ptr<RasterizerDelegate> RasterizerDelegate::Create(
+    RasterizerClient* client,
+    Rasterizer** rasterizers,
+    size_t num_rasterizers) {
+  return make_scoped_ptr(
+      new RasterizerDelegate(client, rasterizers, num_rasterizers));
 }
 
-void RasterWorkerPoolDelegate::Shutdown() {
-  for (RasterWorkerPoolVector::iterator it = raster_worker_pools_.begin();
-       it != raster_worker_pools_.end();
+void RasterizerDelegate::Shutdown() {
+  for (RasterizerVector::iterator it = rasterizers_.begin();
+       it != rasterizers_.end();
        ++it)
     (*it)->Shutdown();
 }
 
-void RasterWorkerPoolDelegate::ScheduleTasks(RasterTaskQueue* raster_queue) {
-  for (size_t i = 0; i < raster_worker_pools_.size(); ++i)
-    raster_worker_pools_[i]->ScheduleTasks(&raster_queue[i]);
+void RasterizerDelegate::ScheduleTasks(RasterTaskQueue* queue) {
+  for (size_t i = 0; i < rasterizers_.size(); ++i)
+    rasterizers_[i]->ScheduleTasks(&queue[i]);
 
-  did_finish_running_tasks_pending_count_ = raster_worker_pools_.size();
+  did_finish_running_tasks_pending_count_ = rasterizers_.size();
   did_finish_running_tasks_required_for_activation_pending_count_ =
-      raster_worker_pools_.size();
+      rasterizers_.size();
 }
 
-void RasterWorkerPoolDelegate::CheckForCompletedTasks() {
-  for (RasterWorkerPoolVector::iterator it = raster_worker_pools_.begin();
-       it != raster_worker_pools_.end();
+void RasterizerDelegate::CheckForCompletedTasks() {
+  for (RasterizerVector::iterator it = rasterizers_.begin();
+       it != rasterizers_.end();
        ++it)
     (*it)->CheckForCompletedTasks();
 }
 
-bool RasterWorkerPoolDelegate::ShouldForceTasksRequiredForActivationToComplete()
+bool RasterizerDelegate::ShouldForceTasksRequiredForActivationToComplete()
     const {
   return client_->ShouldForceTasksRequiredForActivationToComplete();
 }
 
-void RasterWorkerPoolDelegate::DidFinishRunningTasks() {
+void RasterizerDelegate::DidFinishRunningTasks() {
+  TRACE_EVENT1("cc",
+               "RasterizerDelegate::DidFinishRunningTasks",
+               "pending_count",
+               did_finish_running_tasks_pending_count_);
+
   DCHECK_LT(0u, did_finish_running_tasks_pending_count_);
   if (--did_finish_running_tasks_pending_count_)
     return;
   client_->DidFinishRunningTasks();
 }
 
-void RasterWorkerPoolDelegate::DidFinishRunningTasksRequiredForActivation() {
+void RasterizerDelegate::DidFinishRunningTasksRequiredForActivation() {
+  TRACE_EVENT1("cc",
+               "RasterizerDelegate::DidFinishRunningTasksRequiredForActivation",
+               "pending_count",
+               did_finish_running_tasks_required_for_activation_pending_count_);
+
   DCHECK_LT(0u,
             did_finish_running_tasks_required_for_activation_pending_count_);
   if (--did_finish_running_tasks_required_for_activation_pending_count_)

cc/resources/raster_worker_pool_delegate.h → cc/resources/rasterizer_delegate.h

@@ -2,46 +2,45 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CC_RESOURCES_RASTER_WORKER_POOL_DELEGATE_H_
-#define CC_RESOURCES_RASTER_WORKER_POOL_DELEGATE_H_
+#ifndef CC_RESOURCES_RASTERIZER_DELEGATE_H_
+#define CC_RESOURCES_RASTERIZER_DELEGATE_H_
 
 #include <vector>
 
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 
 namespace cc {
 
-class RasterWorkerPoolDelegate : public RasterWorkerPoolClient {
+class RasterizerDelegate : public RasterizerClient {
  public:
-  virtual ~RasterWorkerPoolDelegate();
+  virtual ~RasterizerDelegate();
 
-  static scoped_ptr<RasterWorkerPoolDelegate> Create(
-      RasterWorkerPoolClient* client,
-      RasterWorkerPool** raster_worker_pools,
-      size_t num_raster_worker_pools);
+  static scoped_ptr<RasterizerDelegate> Create(RasterizerClient* client,
+                                               Rasterizer** rasterizers,
+                                               size_t num_rasterizers);
 
-  void SetClient(RasterWorkerPoolClient* client);
+  void SetClient(RasterizerClient* client);
   void Shutdown();
-  void ScheduleTasks(RasterTaskQueue* raster_queue);
+  void ScheduleTasks(RasterTaskQueue* queue);
   void CheckForCompletedTasks();
 
-  // Overriden from RasterWorkerPoolClient:
+  // Overriden from RasterizerClient:
   virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE;
   virtual void DidFinishRunningTasks() OVERRIDE;
   virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
 
  private:
-  RasterWorkerPoolDelegate(RasterWorkerPoolClient* client,
-                           RasterWorkerPool** raster_worker_pools,
-                           size_t num_raster_worker_pools);
+  RasterizerDelegate(RasterizerClient* client,
+                     Rasterizer** rasterizers,
+                     size_t num_rasterizers);
 
-  RasterWorkerPoolClient* client_;
-  typedef std::vector<RasterWorkerPool*> RasterWorkerPoolVector;
-  RasterWorkerPoolVector raster_worker_pools_;
+  RasterizerClient* client_;
+  typedef std::vector<Rasterizer*> RasterizerVector;
+  RasterizerVector rasterizers_;
   size_t did_finish_running_tasks_pending_count_;
   size_t did_finish_running_tasks_required_for_activation_pending_count_;
 };
 
 }  // namespace cc
 
-#endif  // CC_RESOURCES_RASTER_WORKER_POOL_DELEGATE_H_
+#endif  // CC_RESOURCES_RASTERIZER_DELEGATE_H_

cc/resources/tile_manager.h

@@ -20,12 +20,12 @@
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/prioritized_tile_set.h"
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 
 namespace cc {
-class RasterWorkerPoolDelegate;
+class RasterizerDelegate;
 class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
@@ -49,7 +49,7 @@ scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
 // should no longer have any memory assigned to them. Tile objects are "owned"
 // by layers; they automatically register with the manager when they are
 // created, and unregister from the manager when they are deleted.
-class CC_EXPORT TileManager : public RasterWorkerPoolClient,
+class CC_EXPORT TileManager : public RasterizerClient,
                               public RefCountedManager<Tile> {
  public:
   struct CC_EXPORT PairedPictureLayer {
@@ -109,8 +109,8 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
   static scoped_ptr<TileManager> Create(
       TileManagerClient* client,
       ResourceProvider* resource_provider,
-      RasterWorkerPool* raster_worker_pool,
-      RasterWorkerPool* gpu_raster_worker_pool,
+      Rasterizer* rasterizer,
+      Rasterizer* gpu_rasterizer,
       size_t max_raster_usage_bytes,
       bool use_rasterize_on_demand,
       RenderingStatsInstrumentation* rendering_stats_instrumentation);
@@ -178,8 +178,8 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
  protected:
   TileManager(TileManagerClient* client,
               ResourceProvider* resource_provider,
-              RasterWorkerPool* raster_worker_pool,
-              RasterWorkerPool* gpu_raster_worker_pool,
+              Rasterizer* rasterizer,
+              Rasterizer* gpu_rasterizer,
               size_t max_raster_usage_bytes,
               bool use_rasterize_on_demand,
               RenderingStatsInstrumentation* rendering_stats_instrumentation);
@@ -193,7 +193,7 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
   // Overriden from RefCountedManager<Tile>:
   virtual void Release(Tile* tile) OVERRIDE;
 
-  // Overriden from RasterWorkerPoolClient:
+  // Overriden from RasterizerClient:
   virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE;
   virtual void DidFinishRunningTasks() OVERRIDE;
   virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
@@ -210,10 +210,10 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
   void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
 
  private:
-  enum RasterWorkerPoolType {
-    RASTER_WORKER_POOL_TYPE_DEFAULT,
-    RASTER_WORKER_POOL_TYPE_GPU,
-    NUM_RASTER_WORKER_POOL_TYPES
+  enum RasterizerType {
+    RASTERIZER_TYPE_DEFAULT,
+    RASTERIZER_TYPE_GPU,
+    NUM_RASTERIZER_TYPES
   };
 
   void OnImageDecodeTaskCompleted(int layer_id,
@@ -232,16 +232,16 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
-  scoped_refptr<internal::WorkerPoolTask> CreateImageDecodeTask(
+  scoped_refptr<internal::ImageDecodeTask> CreateImageDecodeTask(
       Tile* tile,
       SkPixelRef* pixel_ref);
-  scoped_refptr<internal::RasterWorkerPoolTask> CreateRasterTask(Tile* tile);
+  scoped_refptr<internal::RasterTask> CreateRasterTask(Tile* tile);
   scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
   void UpdatePrioritizedTileSetIfNeeded();
 
   TileManagerClient* client_;
   scoped_ptr<ResourcePool> resource_pool_;
-  scoped_ptr<RasterWorkerPoolDelegate> raster_worker_pool_delegate_;
+  scoped_ptr<RasterizerDelegate> rasterizer_delegate_;
   GlobalStateThatImpactsTilePriority global_state_;
 
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
@@ -268,7 +268,7 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
   bool did_initialize_visible_tile_;
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
 
-  typedef base::hash_map<uint32_t, scoped_refptr<internal::WorkerPoolTask> >
+  typedef base::hash_map<uint32_t, scoped_refptr<internal::ImageDecodeTask> >
       PixelRefTaskMap;
   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
   LayerPixelRefTaskMap image_decode_tasks_;
@@ -285,9 +285,9 @@ class CC_EXPORT TileManager : public RasterWorkerPoolClient,
   ResourceFormat resource_format_;
 
   // Queues used when scheduling raster tasks.
-  RasterTaskQueue raster_queue_[NUM_RASTER_WORKER_POOL_TYPES];
+  RasterTaskQueue raster_queue_[NUM_RASTERIZER_TYPES];
 
-  std::vector<scoped_refptr<internal::Task> > orphan_raster_tasks_;
+  std::vector<scoped_refptr<internal::RasterTask> > orphan_raster_tasks_;
 
   std::vector<PictureLayerImpl*> layers_;
 

cc/test/fake_tile_manager.cc

@@ -8,24 +8,24 @@
 #include <limits>
 
 #include "base/lazy_instance.h"
-#include "cc/resources/raster_worker_pool.h"
+#include "cc/resources/rasterizer.h"
 
 namespace cc {
 
 namespace {
 
-class FakeRasterWorkerPool : public RasterWorkerPool,
-                             public internal::WorkerPoolTaskClient {
+class FakeRasterizerImpl : public Rasterizer,
+                           public internal::RasterizerTaskClient {
  public:
-  // Overridden from RasterWorkerPool:
-  virtual void SetClient(RasterWorkerPoolClient* client) OVERRIDE {}
+  // Overridden from Rasterizer:
+  virtual void SetClient(RasterizerClient* client) OVERRIDE {}
   virtual void Shutdown() OVERRIDE {}
   virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE {
     for (RasterTaskQueue::Item::Vector::const_iterator it =
              queue->items.begin();
          it != queue->items.end();
          ++it) {
-      internal::RasterWorkerPoolTask* task = it->task;
+      internal::RasterTask* task = it->task;
 
       task->WillSchedule();
       task->ScheduleOnOriginThread(this);
@@ -35,11 +35,10 @@ class FakeRasterWorkerPool : public RasterWorkerPool,
     }
   }
   virtual void CheckForCompletedTasks() OVERRIDE {
-    for (internal::WorkerPoolTask::Vector::iterator it =
-             completed_tasks_.begin();
+    for (internal::RasterTask::Vector::iterator it = completed_tasks_.begin();
          it != completed_tasks_.end();
          ++it) {
-      internal::WorkerPoolTask* task = it->get();
+      internal::RasterTask* task = it->get();
 
       task->WillComplete();
       task->CompleteOnOriginThread(this);
@@ -56,18 +55,17 @@ class FakeRasterWorkerPool : public RasterWorkerPool,
     return RGBA_8888;
   }
 
-  // Overridden from internal::WorkerPoolTaskClient:
-  virtual SkCanvas* AcquireCanvasForRaster(internal::WorkerPoolTask* task,
-                                           const Resource* resource) OVERRIDE {
+  // Overridden from internal::RasterizerTaskClient:
+  virtual SkCanvas* AcquireCanvasForRaster(internal::RasterTask* task)
+      OVERRIDE {
     return NULL;
   }
-  virtual void ReleaseCanvasForRaster(internal::WorkerPoolTask* task,
-                                      const Resource* resource) OVERRIDE {}
+  virtual void ReleaseCanvasForRaster(internal::RasterTask* task) OVERRIDE {}
 
  private:
-  internal::WorkerPoolTask::Vector completed_tasks_;
+  internal::RasterTask::Vector completed_tasks_;
 };
-base::LazyInstance<FakeRasterWorkerPool> g_fake_raster_worker_pool =
+base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
@@ -75,8 +73,8 @@ base::LazyInstance<FakeRasterWorkerPool> g_fake_raster_worker_pool =
 FakeTileManager::FakeTileManager(TileManagerClient* client)
     : TileManager(client,
                   NULL,
-                  g_fake_raster_worker_pool.Pointer(),
-                  g_fake_raster_worker_pool.Pointer(),
+                  g_fake_rasterizer.Pointer(),
+                  g_fake_rasterizer.Pointer(),
                   std::numeric_limits<unsigned>::max(),
                   true,
                   NULL) {}
@@ -85,8 +83,8 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
                                  ResourceProvider* resource_provider)
     : TileManager(client,
                   resource_provider,
-                  g_fake_raster_worker_pool.Pointer(),
-                  g_fake_raster_worker_pool.Pointer(),
+                  g_fake_rasterizer.Pointer(),
+                  g_fake_rasterizer.Pointer(),
                   std::numeric_limits<unsigned>::max(),
                   true,
                   NULL) {}
@@ -96,8 +94,8 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
                                  bool allow_on_demand_raster)
     : TileManager(client,
                   resource_provider,
-                  g_fake_raster_worker_pool.Pointer(),
-                  g_fake_raster_worker_pool.Pointer(),
+                  g_fake_rasterizer.Pointer(),
+                  g_fake_rasterizer.Pointer(),
                   std::numeric_limits<unsigned>::max(),
                   allow_on_demand_raster,
                   NULL) {}
@@ -107,8 +105,8 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
                                  size_t raster_task_limit_bytes)
     : TileManager(client,
                   resource_provider,
-                  g_fake_raster_worker_pool.Pointer(),
-                  g_fake_raster_worker_pool.Pointer(),
+                  g_fake_rasterizer.Pointer(),
+                  g_fake_rasterizer.Pointer(),
                   raster_task_limit_bytes,
                   true,
                   NULL) {}

cc/trees/layer_tree_host_impl.cc

@@ -49,6 +49,7 @@
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/prioritized_resource_manager.h"
+#include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
@@ -306,8 +307,7 @@ LayerTreeHostImpl::~LayerTreeHostImpl() {
   pending_tree_.reset();
   active_tree_.reset();
   tile_manager_.reset();
-  image_raster_worker_pool_.reset();
-  pixel_buffer_raster_worker_pool_.reset();
+  raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
 }
 
@@ -1796,27 +1796,26 @@ void LayerTreeHostImpl::CreateAndSetTileManager(
   DCHECK(resource_provider);
   DCHECK(proxy_->ImplThreadTaskRunner());
 
-  RasterWorkerPool* default_raster_worker_pool = NULL;
   if (using_map_image) {
-    image_raster_worker_pool_ = ImageRasterWorkerPool::Create(
+    raster_worker_pool_ = ImageRasterWorkerPool::Create(
         proxy_->ImplThreadTaskRunner(),
+        RasterWorkerPool::GetTaskGraphRunner(),
         resource_provider,
         GetMapImageTextureTarget(context_provider));
-    default_raster_worker_pool = image_raster_worker_pool_.get();
   } else {
-    pixel_buffer_raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
+    raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
         proxy_->ImplThreadTaskRunner(),
+        RasterWorkerPool::GetTaskGraphRunner(),
         resource_provider,
         GetMaxTransferBufferUsageBytes(context_provider));
-    default_raster_worker_pool = pixel_buffer_raster_worker_pool_.get();
   }
   direct_raster_worker_pool_ = DirectRasterWorkerPool::Create(
       proxy_->ImplThreadTaskRunner(), resource_provider, context_provider);
   tile_manager_ =
       TileManager::Create(this,
                           resource_provider,
-                          default_raster_worker_pool,
-                          direct_raster_worker_pool_.get(),
+                          raster_worker_pool_->AsRasterizer(),
+                          direct_raster_worker_pool_->AsRasterizer(),
                           GetMaxRasterTasksUsageBytes(context_provider),
                           allow_rasterize_on_demand,
                           rendering_stats_instrumentation_);
@@ -1843,8 +1842,7 @@ bool LayerTreeHostImpl::InitializeRenderer(
   // Note: order is important here.
   renderer_.reset();
   tile_manager_.reset();
-  image_raster_worker_pool_.reset();
-  pixel_buffer_raster_worker_pool_.reset();
+  raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
   resource_provider_.reset();
   output_surface_.reset();
@@ -1971,8 +1969,7 @@ void LayerTreeHostImpl::ReleaseGL() {
   ReleaseTreeResources();
   renderer_.reset();
   tile_manager_.reset();
-  image_raster_worker_pool_.reset();
-  pixel_buffer_raster_worker_pool_.reset();
+  raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
   resource_provider_->InitializeSoftware();
 

cc/trees/layer_tree_host_impl.h

@@ -40,16 +40,14 @@ namespace cc {
 class CompletionEvent;
 class CompositorFrameMetadata;
 class DebugRectHistory;
-class DirectRasterWorkerPool;
 class FrameRateCounter;
-class ImageRasterWorkerPool;
 class LayerImpl;
 class LayerTreeHostImplTimeSourceAdapter;
 class LayerTreeImpl;
 class MemoryHistory;
 class PageScaleAnimation;
 class PaintTimeCounter;
-class PixelBufferRasterWorkerPool;
+class RasterWorkerPool;
 class RenderPassDrawQuad;
 class RenderingStatsInstrumentation;
 class ScrollbarLayerImplBase;
@@ -540,9 +538,8 @@ class CC_EXPORT LayerTreeHostImpl
   // free rendering - see OutputSurface::ForcedDrawToSoftwareDevice().
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<TileManager> tile_manager_;
-  scoped_ptr<ImageRasterWorkerPool> image_raster_worker_pool_;
-  scoped_ptr<PixelBufferRasterWorkerPool> pixel_buffer_raster_worker_pool_;
-  scoped_ptr<DirectRasterWorkerPool> direct_raster_worker_pool_;
+  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
+  scoped_ptr<RasterWorkerPool> direct_raster_worker_pool_;
   scoped_ptr<Renderer> renderer_;
 
   GlobalStateThatImpactsTilePriority global_tile_state_;