Add preliminary support for hw-accelerated tile rasterization.

cc/resources/image_raster_worker_pool.cc

Index: cc/resources/image_raster_worker_pool.cc
diff --git a/cc/resources/image_raster_worker_pool.cc b/cc/resources/image_raster_worker_pool.cc
index 90572ab417dedc02c00d3d082ce2ca94643e3449..e980e9c5bba9a1fd9944acb408befeb28a4ac6be 100644
--- a/cc/resources/image_raster_worker_pool.cc
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -58,9 +58,10 @@ class ImageWorkerPoolTaskImpl : public internal::WorkerPoolTask {
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     size_t num_threads,
     GLenum texture_target)
-    : RasterWorkerPool(resource_provider, num_threads),
+    : RasterWorkerPool(resource_provider, context_provider, num_threads),
       texture_target_(texture_target),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false) {
@@ -100,12 +101,19 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
                              priority++,
                              &graph);
 
+  RasterTaskVector gpu_rasterization_tasks;
+
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
     DCHECK(!task->HasCompleted());
     DCHECK(!task->WasCanceled());
 
+    if (task->use_gpu_rasterization()) {
+      gpu_rasterization_tasks.push_back(task);
+      continue;
+    }
+
     TaskMap::iterator image_it = image_tasks_.find(task);
     if (image_it != image_tasks_.end()) {
       internal::WorkerPoolTask* image_task = image_it->second.get();
@@ -152,6 +160,13 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 
+   // Run raster tasks that use GPU on impl thread.
+  RasterWorkerPool::RunGpuRasterizationTasks(gpu_rasterization_tasks);

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

RasterWorkerPool:: suffix unnecessary. Move comment to header.

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

Done.

+  for (RasterTaskVector::iterator it = gpu_rasterization_tasks.begin();
+      it != gpu_rasterization_tasks.end(); ++it) {
+    OnRasterTaskCompleted(*it, false);
+  }

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

You'll have to implement CheckForCompletedTasks and run these callbacks at that
time.

[alokp, 2013/12/17 23:26:08]

I am confused. Do you mean implement RasterWorkerPool::CheckForCompletedTasks?
Where is it called in ImageRasterWorkerPool? How would
Image/PixelBufferRasterWorkerPool be notified of completed raster tasks without
a callback? The callback is only registered for tasks in the task-graph.

[reveman, 2013/12/18 00:09:51]

As discussed offline. TileManager calls RasterWorkerPool::CheckForCompletedTasks
and expects callbacks to only run at that time.

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

Done.

+
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc", "ScheduledTasks", this, "rasterizing",
       "state", TracedValue::FromValue(StateAsValue().release()));
@@ -187,17 +202,20 @@ void ImageRasterWorkerPool::OnRasterTaskCompleted(
   TRACE_EVENT1("cc", "ImageRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
-  DCHECK(image_tasks_.find(task.get()) != image_tasks_.end());
-
-  // Balanced with MapImage() call in ScheduleTasks().
-  resource_provider()->UnmapImage(task->resource()->id());
+  if (task->use_gpu_rasterization()) {

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

Hm, as you're not running gpu raster in the thread pool can't this just be
DCHECK(!task->use_gpu_rasterization())?

[alokp, 2013/12/17 23:26:08]

Sorry. I am confused. Are you suggesting not calling
ImageRasterWorkerPool::OnRasterTaskCompleted for gpu-raster tasks?

[reveman, 2013/12/18 00:09:51]

I missed that you were calling this function directly from
ImageRasterWorkerPool::ScheduleTasks. I don't think you should do this as it's
meant for tasks that run on worker threads. You can instead handle completion of
gpu tasks separately in a similar way to how you're already doing this for
PBRWP.

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

Done.

+    // GPU rasterization tasks are not wrapped into image tasks.
+    DCHECK(image_tasks_.find(task.get()) == image_tasks_.end());
+  } else {
+    DCHECK(image_tasks_.find(task.get()) != image_tasks_.end());
+    // Balanced with MapImage() call in ScheduleTasks().
+    resource_provider()->UnmapImage(task->resource()->id());
+    image_tasks_.erase(task.get());
+  }
 
   task->DidRun(was_canceled);
   task->WillComplete();
   task->CompleteOnOriginThread();
   task->DidComplete();
-
-  image_tasks_.erase(task.get());
 }
 
 scoped_ptr<base::Value> ImageRasterWorkerPool::StateAsValue() const {