cc: Move GPU raster to DirectRasterWorkerPool.

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 d4ba08cc5bacc25ec9a06f55bdd749ed1882916a..55283660035badf1a5737ee2dfd10b04ad64fbb4 100644
--- a/cc/resources/image_raster_worker_pool.cc
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -15,30 +15,33 @@ namespace cc {
 // static
 scoped_ptr<RasterWorkerPool> ImageRasterWorkerPool::Create(
     ResourceProvider* resource_provider,
-    ContextProvider* context_provider,
     unsigned texture_target) {
   return make_scoped_ptr<RasterWorkerPool>(
       new ImageRasterWorkerPool(GetTaskGraphRunner(),
                                 resource_provider,
-                                context_provider,
                                 texture_target));
 }
 
 ImageRasterWorkerPool::ImageRasterWorkerPool(
     internal::TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
-    ContextProvider* context_provider,
     unsigned texture_target)
-    : RasterWorkerPool(task_graph_runner, resource_provider, context_provider),
+    : RasterWorkerPool(task_graph_runner, resource_provider),
       texture_target_(texture_target),
       raster_tasks_pending_(false),
       raster_tasks_required_for_activation_pending_(false) {}
 
 ImageRasterWorkerPool::~ImageRasterWorkerPool() {}
 
-void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
+void ImageRasterWorkerPool::ScheduleTasks(RasterTaskQueue* queue) {
   TRACE_EVENT0("cc", "ImageRasterWorkerPool::ScheduleTasks");
 
+  DCHECK_EQ(queue->required_for_activation_count,
+            static_cast<size_t>(
+                std::count_if(queue->tasks.begin(),
+                              queue->tasks.end(),
+                              RasterTaskQueue::Task::IsRequiredForActivation)));
+
   if (!raster_tasks_pending_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
 
@@ -52,32 +55,21 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   scoped_refptr<internal::WorkerPoolTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
-              queue->required_for_activation_count()));
+              queue->required_for_activation_count));
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
       CreateRasterFinishedTask());
 
-  size_t raster_required_for_activation_finished_dependency_count = 0u;

[alokp, 2014/02/14 18:50:59]

Are these changes necessary in this patch?

[reveman, 2014/02/14 23:30:52]

No but I think they should be included as the only reason we needed these
variables before was because some tasks could be gpu raster tasks. I think they
should be removed in this patch now that they are no longer needed.

-  size_t raster_finished_dependency_count = 0u;
-
-  RasterTaskVector gpu_raster_tasks;
   for (RasterTaskQueueIterator it(queue); it; ++it) {
     internal::RasterWorkerPoolTask* task = *it;
     DCHECK(!task->HasCompleted());
 
-    if (task->use_gpu_rasterization()) {
-      gpu_raster_tasks.push_back(task);
-      continue;
-    }
-
     if (it.required_for_activation()) {
-      ++raster_required_for_activation_finished_dependency_count;
       graph_.edges.push_back(internal::TaskGraph::Edge(
           task, new_raster_required_for_activation_finished_task.get()));
     }
 
     InsertNodeForRasterTask(&graph_, task, task->dependencies(), priority++);
 
-    ++raster_finished_dependency_count;
     graph_.edges.push_back(
         internal::TaskGraph::Edge(task, new_raster_finished_task.get()));
   }
@@ -85,11 +77,11 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   InsertNodeForTask(&graph_,
                     new_raster_required_for_activation_finished_task.get(),
                     kRasterRequiredForActivationFinishedTaskPriority,
-                    raster_required_for_activation_finished_dependency_count);
+                    queue->required_for_activation_count);
   InsertNodeForTask(&graph_,
                     new_raster_finished_task.get(),
                     kRasterFinishedTaskPriority,
-                    raster_finished_dependency_count);
+                    queue->tasks.size());
 
   raster_tasks_.Swap(queue);
 
@@ -99,9 +91,6 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   set_raster_required_for_activation_finished_task(
       new_raster_required_for_activation_finished_task);
 
-  if (!gpu_raster_tasks.empty())
-    RunGpuRasterTasks(gpu_raster_tasks);
-
   TRACE_EVENT_ASYNC_STEP_INTO1(
       "cc",
       "ScheduledTasks",
@@ -136,31 +125,19 @@ void ImageRasterWorkerPool::CheckForCompletedTasks() {
     task->RunReplyOnOriginThread();
   }
   completed_tasks_.clear();
-
-  CheckForCompletedGpuRasterTasks();
 }
 
 SkCanvas* ImageRasterWorkerPool::AcquireCanvasForRaster(
     internal::RasterWorkerPoolTask* task) {
-  if (task->use_gpu_rasterization())
-    return resource_provider()->MapDirectRasterBuffer(task->resource()->id());
-
   return resource_provider()->MapImageRasterBuffer(task->resource()->id());
 }
 
 void ImageRasterWorkerPool::OnRasterCompleted(
     internal::RasterWorkerPoolTask* task,
     const PicturePileImpl::Analysis& analysis) {
-  if (task->use_gpu_rasterization()) {
-    resource_provider()->UnmapDirectRasterBuffer(task->resource()->id());
-    return;
-  }
   resource_provider()->UnmapImageRasterBuffer(task->resource()->id());
 }
 
-void ImageRasterWorkerPool::OnImageDecodeCompleted(
-    internal::WorkerPoolTask* task) {}
-
 void ImageRasterWorkerPool::OnRasterTasksFinished() {
   DCHECK(raster_tasks_pending_);
   raster_tasks_pending_ = false;