Add preliminary support for hw-accelerated tile rasterization.

cc/resources/image_raster_worker_pool.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/image_raster_worker_pool.h"
 
 #include "base/debug/trace_event.h"
 #include "base/values.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/resource.h"
@@ skipping 40 matching lines @@
   int stride_;
   const Reply reply_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageWorkerPoolTaskImpl);
 };
 
 }  // namespace
 
 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) {
 }
 
 ImageRasterWorkerPool::~ImageRasterWorkerPool() {
   DCHECK_EQ(0u, image_tasks_.size());
 }
 
 void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
@@ skipping 19 matching lines @@
           priority++,
           &graph);
 
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
       CreateRasterFinishedTask());
   internal::GraphNode* raster_finished_node =
       CreateGraphNodeForTask(new_raster_finished_task.get(),
                              priority++,
                              &graph);
 
+  RasterTaskVector gpu_raster_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_raster_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();
       CreateGraphNodeForImageTask(
           image_task,
           task->dependencies(),
           priority++,
           IsRasterTaskRequiredForActivation(task),
           raster_required_for_activation_finished_node,
           raster_finished_node,
@@ skipping 26 matching lines @@
         raster_finished_node,
         &graph);
   }
 
   SetTaskGraph(&graph);
 
   set_raster_finished_task(new_raster_finished_task);
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 
+  RunGpuRasterTasks(gpu_raster_tasks);
+
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc", "ScheduledTasks", this, "rasterizing",
       "state", TracedValue::FromValue(StateAsValue().release()));
 }
 
 GLenum ImageRasterWorkerPool::GetResourceTarget() const {
   return texture_target_;
 }
 
 ResourceFormat ImageRasterWorkerPool::GetResourceFormat() const {
@@ skipping 15 matching lines @@
       "state", TracedValue::FromValue(StateAsValue().release()));
   client()->DidFinishRunningTasksRequiredForActivation();
 }
 
 void ImageRasterWorkerPool::OnRasterTaskCompleted(
     scoped_refptr<internal::RasterWorkerPoolTask> task,
     bool was_canceled) {
   TRACE_EVENT1("cc", "ImageRasterWorkerPool::OnRasterTaskCompleted",
                "was_canceled", was_canceled);
 
+  DCHECK(!task->use_gpu_rasterization());
   DCHECK(image_tasks_.find(task.get()) != image_tasks_.end());
 
   // Balanced with MapImage() call in ScheduleTasks().
   resource_provider()->UnmapImage(task->resource()->id());
 
   task->DidRun(was_canceled);
   task->WillComplete();
   task->CompleteOnOriginThread();
   task->DidComplete();
 
@@ skipping 26 matching lines @@
   if (is_required_for_activation) {
     raster_required_for_activation_finished_node->add_dependency();
     image_node->add_dependent(raster_required_for_activation_finished_node);
   }
 
   raster_finished_node->add_dependency();
   image_node->add_dependent(raster_finished_node);
 }
 
 }  // namespace cc