Add preliminary support for hw-accelerated tile rasterization.

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 fac2fd845ce81db11136a986f0437db89f6e8867..001ab4e00dba00d66e0b79105a58a2c957ec2dc4 100644
--- a/cc/resources/raster_worker_pool.h
+++ b/cc/resources/raster_worker_pool.h
@@ -36,6 +36,8 @@ class CC_EXPORT RasterWorkerPoolTask
                                  void* buffer,
                                  gfx::Size size,
                                  int stride) = 0;
+  virtual void RunOnOriginThread(ResourceProvider* resource_provider,
+                                 ContextProvider* context_provider) = 0;
   virtual void CompleteOnOriginThread() = 0;
 
   void DidRun(bool was_canceled);
@@ -47,11 +49,14 @@ class CC_EXPORT RasterWorkerPoolTask
 
   const Resource* resource() const { return resource_; }
   const TaskVector& dependencies() const { return dependencies_; }
+  bool use_gpu_rasterization() const { return use_gpu_rasterization_; }
 
  protected:
   friend class base::RefCounted<RasterWorkerPoolTask>;
 
-  RasterWorkerPoolTask(const Resource* resource, TaskVector* dependencies);
+  RasterWorkerPoolTask(const Resource* resource,
+                       TaskVector* dependencies,
+                       bool use_gpu_rasterization);
   virtual ~RasterWorkerPoolTask();
 
  private:
@@ -60,6 +65,7 @@ class CC_EXPORT RasterWorkerPoolTask
   bool was_canceled_;
   const Resource* resource_;
   TaskVector dependencies_;
+  bool use_gpu_rasterization_;
 };
 
 }  // namespace internal
@@ -199,6 +205,7 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
       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);
@@ -218,7 +225,9 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   typedef base::hash_map<TaskMapKey,
                          scoped_refptr<internal::WorkerPoolTask> > TaskMap;
 
-  RasterWorkerPool(ResourceProvider* resource_provider, size_t num_threads);
+  RasterWorkerPool(ResourceProvider* resource_provider,
+                   ContextProvider* context_provider,
+                   size_t num_threads);
 
   virtual void OnRasterTasksFinished() = 0;
   virtual void OnRasterTasksRequiredForActivationFinished() = 0;
@@ -226,9 +235,11 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   void SetRasterTasks(RasterTask::Queue* queue);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
+  void RunGpuRasterizationTasks(RasterTaskVector& tasks);

[reveman, 2013/12/17 23:03:16]

can this be "const RasterTaskVector&"? otherwise "RasterTaskVector*" is probably
better.

[alokp, 2013/12/18 22:49:22]

Done.

 
   RasterWorkerPoolClient* client() const { return client_; }
   ResourceProvider* resource_provider() const { return resource_provider_; }
+  ContextProvider* context_provider() const { return context_provider_; }
   const RasterTaskVector& raster_tasks() const { return raster_tasks_; }
   const RasterTaskSet& raster_tasks_required_for_activation() const {
     return raster_tasks_required_for_activation_;
@@ -268,6 +279,7 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
 
   RasterWorkerPoolClient* client_;
   ResourceProvider* resource_provider_;
+  ContextProvider* context_provider_;
   RasterTask::Queue::TaskVector raster_tasks_;
   RasterTask::Queue::TaskSet raster_tasks_required_for_activation_;