Add preliminary support for hw-accelerated tile rasterization.

cc/resources/pixel_buffer_raster_worker_pool.cc

Index: cc/resources/pixel_buffer_raster_worker_pool.cc
diff --git a/cc/resources/pixel_buffer_raster_worker_pool.cc b/cc/resources/pixel_buffer_raster_worker_pool.cc
index 011e5147e066e4c3e294aceb14ae22bc0b931f31..540bdc94c74683e6bb1604ce9893b9f7c1a315a7 100644
--- a/cc/resources/pixel_buffer_raster_worker_pool.cc
+++ b/cc/resources/pixel_buffer_raster_worker_pool.cc
@@ -91,9 +91,10 @@ bool WasCanceled(const internal::RasterWorkerPoolTask* task) {
 
 PixelBufferRasterWorkerPool::PixelBufferRasterWorkerPool(
     ResourceProvider* resource_provider,
+    ContextProvider* context_provider,
     size_t num_threads,
     size_t max_transfer_buffer_usage_bytes)
-    : RasterWorkerPool(resource_provider, num_threads),
+    : RasterWorkerPool(resource_provider, context_provider, num_threads),
       shutdown_(false),
       scheduled_raster_task_count_(0),
       bytes_pending_upload_(0),
@@ -149,6 +150,7 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
 
   // Build new pixel buffer task set.
   TaskMap new_pixel_buffer_tasks;
+  RasterTaskVector gpu_rasterization_tasks;
   for (RasterTaskVector::const_iterator it = raster_tasks().begin();
        it != raster_tasks().end(); ++it) {
     internal::RasterWorkerPoolTask* task = it->get();
@@ -156,6 +158,11 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
     DCHECK(!task->HasCompleted());
     DCHECK(!task->WasCanceled());
 
+    if (task->use_gpu_rasterization()) {
+      gpu_rasterization_tasks.push_back(task);
+      continue;
+    }
+
     new_pixel_buffer_tasks[task] = pixel_buffer_tasks_[task];
     pixel_buffer_tasks_.erase(task);
 
@@ -212,6 +219,17 @@ void PixelBufferRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   check_for_completed_raster_tasks_pending_ = false;
   ScheduleCheckForCompletedRasterTasks();
 
+  // Run raster tasks that use GPU on impl thread.
+  RasterWorkerPool::RunGpuRasterizationTasks(gpu_rasterization_tasks);
+  for (RasterTaskVector::iterator it = gpu_rasterization_tasks.begin();
+      it != gpu_rasterization_tasks.end(); ++it) {
+    internal::RasterWorkerPoolTask* task = it->get();
+    task->DidRun(false);

[vmpstr, 2013/12/17 22:52:45]

In ImageRasterWorkerPool, similar block does a OnRasterTaskCompleted (which is
also changed to do special logic for gpu rasterization tasks). In here, you call
task->DidRun/WillComplete/etc directly. I think we should add some consistency
between the two methods.

I would vote for calling OnRasterTaskCompleted in both cases and handling gpu
rasterization tasks specially (this would allow us to still have the trace event
that is triggered from there)

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

Should this be done by RasterWorkerPool::RunGpuRasterizationTasks?

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

Yes. It can be. I was just following the pattern used by other tasks.

+    task->WillComplete();
+    task->CompleteOnOriginThread();
+    task->DidComplete();

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

I think these 3 lines need to be moved to ::CheckForCompletedTasks().

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

Are you suggesting implementing RasterWorkerPool::CheckForCompletedTasks, which
will iterate through the gpu-raster tasks and call these 3 functions?

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

You already have an impl of this function below:
PixelBufferRasterWorkerPool::CheckForCompletedTasks()
just do it from there instead.

And for ImageRasterWorkerPool you'll need to add:
ImageRasterWorkerPool::CheckForCompletedTasks() as it was not needed before
(WorkerPool::CheckForCompletedTasks() was already doing the right thing there
before).

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

I added an implementation of RWP::CheckForCompletedTasks instead.

+  }
+
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc", "ScheduledTasks", this, StateName(),
       "state", TracedValue::FromValue(StateAsValue().release()));