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..bf8e33e18f8ac62453afa97ba3f06f73824ad361 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
@@ -175,6 +181,10 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   // scheduled tasks. Reply callbacks are still guaranteed to run.

[reveman, 2013/12/19 01:36:47]

Do you mind replacing this comment with "// Overridden from WorkerPool:" while
here? As any documentation needed for this function should be on the WorkerPool
interface, not here.

[alokp, 2013/12/19 06:25:42]

Done.

   virtual void Shutdown() OVERRIDE;
 
+  // Force a check for completed tasks.
+  // Runs reply callbacks for completed tasks.
+  virtual void CheckForCompletedTasks() OVERRIDE;

[reveman, 2013/12/19 01:36:47]

Hm, this will still result in raster task completion callbacks taking place
outside the scope of the CheckForCompletedTasks() call made by the tile manager
as PBRWP will call this periodically to kick off more uploads. Maybe have IRWP
implement this instead and add a protected RWP::CheckForCompletedGpuRasterTasks
function that PBRWP and IRWP can call.

[alokp, 2013/12/19 06:25:42]

Hm. It does not sound like the right thing to do. Could PBRWP use a different
function to periodically collect completed tasks instead? I can look into it as
a separate patch.

[reveman, 2013/12/19 17:52:03]

This doesn't have to be overridden by RWP implementations if RWP is implementing
a "Check" function. How about we rename this to CheckForCompletedRasterTasks.
And WorkerPool::CheckForCompletedTasks becomes a protected non-virtual method
that PBRWP can call as much as it likes without having to worry about triggering
completion of gpu raster tasks?

[alokp, 2013/12/19 21:37:51]

Good Idea! With this change we are moving away from inheritance to composition.
Is there any reason for RWP to inherit from WP? It could easily have WP as a
data member and IMO it would be cleaner.

[reveman, 2013/12/19 22:05:26]

Yes, I think we'll do that but I like to first land all changes needed to share
the thread pool across LTHIs (https://codereview.chromium.org/73923003). That
will likely result in the base WorkerPool class being removed completely and the
RasterWorkerPool having a TaskGraphRunner as data member.

+
   // Schedule running of raster tasks in |queue| and all dependencies.
   // Previously scheduled tasks that are no longer needed to run
   // raster tasks in |queue| will be canceled unless already running.
@@ -199,6 +209,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 +229,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 +239,12 @@ class CC_EXPORT RasterWorkerPool : public WorkerPool {
   void SetRasterTasks(RasterTask::Queue* queue);
   bool IsRasterTaskRequiredForActivation(
       internal::RasterWorkerPoolTask* task) const;
+  // Run raster tasks that use GPU on impl thread.

[reveman, 2013/12/19 01:36:47]

nit: s/impl/current/

[alokp, 2013/12/19 06:25:42]

Done.

+  void RunGpuRasterTasks(RasterTaskVector* tasks);
 
   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,8 +284,10 @@ 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_;
+  RasterTaskVector gpu_raster_tasks_;
 
   scoped_refptr<internal::WorkerPoolTask> raster_finished_task_;
   scoped_refptr<internal::WorkerPoolTask>