cc: Move GPU raster to DirectRasterWorkerPool.

cc/resources/raster_worker_pool.h

Index: cc/resources/raster_worker_pool.h
diff --git a/cc/resources/raster_worker_pool.h b/cc/resources/raster_worker_pool.h
index 389ac4178e47cce50d66d9c53789e290e023419d..b2ea581d7ba7d9c5d3eaeac92cdf877ad758b595 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -41,7 +41,10 @@ class CC_EXPORT 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;
 
@@ -63,23 +66,19 @@ class CC_EXPORT WorkerPoolTask : public Task {
 
 class CC_EXPORT RasterWorkerPoolTask : public WorkerPoolTask {

[reveman, 2014/02/14 16:11:53]

should now be relatively easy to remove this class as a follow up.

  public:
-  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
-                                 ContextProvider* context_provider) = 0;
-
   const Resource* resource() const { return resource_; }
-  const internal::Task::Vector& dependencies() const { return dependencies_; }
-  bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
+  const internal::WorkerPoolTask::Vector& dependencies() const {
+    return dependencies_;
+  }
 
  protected:
   RasterWorkerPoolTask(const Resource* resource,
-                       internal::Task::Vector* dependencies,
-                       bool use_gpu_rasterization);
+                       internal::WorkerPoolTask::Vector* dependencies);
   virtual ~RasterWorkerPoolTask();
 
  private:
   const Resource* resource_;
-  Task::Vector dependencies_;
-  bool use_gpu_rasterization_;
+  WorkerPoolTask::Vector dependencies_;
 };
 
 }  // namespace internal
@@ -94,101 +93,37 @@ class CC_EXPORT RasterWorkerPoolClient {
   virtual ~RasterWorkerPoolClient() {}
 };
 
-// A worker thread pool that runs raster tasks.
-class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
- public:
-  class CC_EXPORT Task {
-   public:
-    typedef base::Callback<void(bool was_canceled)> Reply;
-
-    class CC_EXPORT Set {
-     public:
-      Set();
-      ~Set();
-
-      void Insert(const Task& task);
-
-     private:
-      friend class RasterWorkerPool;
+struct CC_EXPORT RasterTaskQueue {
+  struct CC_EXPORT Task {
+    typedef std::vector<Task> Vector;
 
-      internal::Task::Vector tasks_;
-    };
-
-    Task();
+    Task(internal::RasterWorkerPoolTask* task, bool required_for_activation);
     ~Task();
 
-    // Returns true if Task is null (doesn't refer to anything).
-    bool is_null() const { return !internal_.get(); }
-
-    // Returns the Task into an uninitialized state.
-    void Reset();
-
-   protected:
-    friend class RasterWorkerPool;
-
-    explicit Task(internal::WorkerPoolTask* internal);
+    static bool IsRequiredForActivation(const Task& task) {
+      return task.required_for_activation;
+    }
 
-    scoped_refptr<internal::WorkerPoolTask> internal_;
+    scoped_refptr<internal::RasterWorkerPoolTask> task;
+    bool required_for_activation;
   };
 
-  class CC_EXPORT RasterTask {
-   public:
-    typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
-                                bool was_canceled)> Reply;
-
-    class CC_EXPORT Queue {
-     public:
-      Queue();
-      ~Queue();
-
-      void Reset();
-      void Append(const RasterTask& task, bool required_for_activation);
-      void Swap(Queue* other);
-
-      size_t count() const { return tasks_.size(); }
-      size_t required_for_activation_count() const {
-        return required_for_activation_count_;
-      }
+  RasterTaskQueue();
+  ~RasterTaskQueue();
 
-     private:
-      friend class RasterWorkerPool;
+  void Swap(RasterTaskQueue* other);
+  void Reset();
 
-      struct QueuedTask {
-        typedef std::vector<QueuedTask> Vector;
-
-        QueuedTask(internal::RasterWorkerPoolTask* task,
-                   bool required_for_activation);
-        ~QueuedTask();
-
-        scoped_refptr<internal::RasterWorkerPoolTask> task;
-        bool required_for_activation;
-      };
-
-      QueuedTask::Vector tasks_;
-      size_t required_for_activation_count_;
-    };
-
-    RasterTask();
-    ~RasterTask();
-
-    // Returns true if Task is null (doesn't refer to anything).
-    bool is_null() const { return !internal_.get(); }
-
-    // Returns the Task into an uninitialized state.
-    void Reset();
-
-   protected:
-    friend class RasterWorkerPool;
-
-    explicit RasterTask(internal::RasterWorkerPoolTask* internal);
-
-    scoped_refptr<internal::RasterWorkerPoolTask> internal_;
-  };
+  Task::Vector tasks;
+  size_t required_for_activation_count;
+};
 
+// A worker thread pool that runs raster tasks.
+class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
+ public:
   virtual ~RasterWorkerPool();
 
   static void SetNumRasterThreads(int num_threads);
-
   static int GetNumRasterThreads();
 
   static internal::TaskGraphRunner* GetTaskGraphRunner();
@@ -199,7 +134,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
   static unsigned kRasterTaskPriorityBase;
 
   // TODO(vmpstr): Figure out an elegant way to not pass this many parameters.
-  static RasterTask CreateRasterTask(
+  static scoped_refptr<internal::RasterWorkerPoolTask> CreateRasterTask(

[reveman, 2014/02/14 16:11:53]

Fyi, I'll remove this in follow up patch that makes TileVersion a
WorkerPoolTask.

[vmpstr, 2014/02/14 17:16:51]

That would be awesome.

       const Resource* resource,
       PicturePileImpl* picture_pile,
       const gfx::Rect& content_rect,
@@ -209,16 +144,16 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
       int layer_id,
       const void* tile_id,
       int source_frame_number,
-      bool use_gpu_rasterization,
       RenderingStatsInstrumentation* rendering_stats,
-      const RasterTask::Reply& reply,
-      Task::Set* dependencies);
+      const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
+      internal::WorkerPoolTask::Vector* dependencies,
+      ContextProvider* context_provider);
 
-  static Task CreateImageDecodeTask(
+  static scoped_refptr<internal::WorkerPoolTask> CreateImageDecodeTask(
       SkPixelRef* pixel_ref,
       int layer_id,
       RenderingStatsInstrumentation* rendering_stats,
-      const Task::Reply& reply);
+      const base::Callback<void(bool was_canceled)>& reply);
 
   void SetClient(RasterWorkerPoolClient* client);
 
@@ -231,7 +166,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
   // raster tasks 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(RasterTask::Queue* queue) = 0;
+  virtual void ScheduleTasks(RasterTaskQueue* queue) = 0;
 
   // Force a check for completed tasks.
   virtual void CheckForCompletedTasks() = 0;
@@ -245,8 +180,8 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
  protected:
   class RasterTaskQueueIterator {
    public:
-    explicit RasterTaskQueueIterator(const RasterTask::Queue* queue)
-        : tasks_(&queue->tasks_), current_index_(0u) {}
+    explicit RasterTaskQueueIterator(const RasterTaskQueue* queue)
+        : tasks_(&queue->tasks), current_index_(0u) {}
     ~RasterTaskQueueIterator() {}
 
     bool required_for_activation() const {
@@ -273,7 +208,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
     operator bool() const { return current_index_ < tasks_->size(); }
 
    private:
-    const RasterTask::Queue::QueuedTask::Vector* tasks_;
+    const RasterTaskQueue::Task::Vector* tasks_;
     size_t current_index_;
   };
   typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
@@ -282,8 +217,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
       RasterTaskVector;
 
   RasterWorkerPool(internal::TaskGraphRunner* task_graph_runner,
-                   ResourceProvider* resource_provider,
-                   ContextProvider* context_provider);
+                   ResourceProvider* resource_provider);
 
   virtual void OnRasterTasksFinished() = 0;
   virtual void OnRasterTasksRequiredForActivationFinished() = 0;
@@ -291,30 +225,32 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
   void SetTaskGraph(internal::TaskGraph* graph);
   void CollectCompletedWorkerPoolTasks(internal::Task::Vector* completed_tasks);
 
-  // Run raster tasks that use GPU on current thread.
-  void RunGpuRasterTasks(const RasterTaskVector& tasks);
-  void CheckForCompletedGpuRasterTasks();
-
   RasterWorkerPoolClient* client() const { return client_; }
   ResourceProvider* resource_provider() const { return resource_provider_; }
-  ContextProvider* context_provider() const { return context_provider_; }
 
   void set_raster_finished_task(
       internal::WorkerPoolTask* raster_finished_task) {
     raster_finished_task_ = raster_finished_task;
   }
+  internal::WorkerPoolTask* raster_finished_task() const {
+    return raster_finished_task_.get();
+  }
   void set_raster_required_for_activation_finished_task(
       internal::WorkerPoolTask* raster_required_for_activation_finished_task) {
     raster_required_for_activation_finished_task_ =
         raster_required_for_activation_finished_task;
   }
+  internal::WorkerPoolTask* raster_required_for_activation_finished_task()
+      const {
+    return raster_required_for_activation_finished_task_.get();
+  }
 
   scoped_refptr<internal::WorkerPoolTask> CreateRasterFinishedTask();
   scoped_refptr<internal::WorkerPoolTask>
       CreateRasterRequiredForActivationFinishedTask(
           size_t tasks_required_for_activation_count);
 
-  scoped_ptr<base::Value> ScheduledStateAsValue() const;
+  void RunTaskOnOriginThread(internal::WorkerPoolTask* task);
 
   static void InsertNodeForTask(internal::TaskGraph* graph,
                                 internal::WorkerPoolTask* task,
@@ -324,7 +260,7 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
   static void InsertNodeForRasterTask(
       internal::TaskGraph* graph,
       internal::WorkerPoolTask* task,
-      const internal::Task::Vector& decode_tasks,
+      const internal::WorkerPoolTask::Vector& decode_tasks,
       unsigned priority);
 
  private:
@@ -336,8 +272,6 @@ class CC_EXPORT RasterWorkerPool : public internal::WorkerPoolTaskClient {
   internal::NamespaceToken namespace_token_;
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
-  ContextProvider* context_provider_;
-  TaskDeque completed_gpu_raster_tasks_;
 
   scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
   scoped_refptr<internal::WorkerPoolTask>