cc: Switch to vector based TaskGraph implementation.

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 845ed1257e6abedb4f8449afef25035bbf426210..fc3de9306be43f7e0b7bd7e4e052270dbf879553 100644
--- a/cc/resources/image_raster_worker_pool.cc
+++ b/cc/resources/image_raster_worker_pool.cc
@@ -34,23 +34,18 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
   raster_tasks_pending_ = true;
   raster_tasks_required_for_activation_pending_ = true;
 
-  unsigned priority = 0u;
-  TaskGraph graph;
+  unsigned priority = 2u;  // 0-1 reserved for RasterFinished tasks.

[enne (OOO), 2014/02/06 18:49:14]

Can you use an enum for these values?

[reveman, 2014/02/06 20:51:52]

I don't think an enum is appropriate as there's not a limited set of priorities
but I added some constants to the RasterWorkerPool class that I think makes this
cleaner. PTAL.

+  internal::TaskGraph graph;
 
   scoped_refptr<internal::WorkerPoolTask>
       new_raster_required_for_activation_finished_task(
           CreateRasterRequiredForActivationFinishedTask(
               raster_tasks_required_for_activation().size()));
-  internal::GraphNode* raster_required_for_activation_finished_node =
-      CreateGraphNodeForTask(
-          new_raster_required_for_activation_finished_task.get(),
-          priority++,
-          &graph);
-
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
       CreateRasterFinishedTask());
-  internal::GraphNode* raster_finished_node = CreateGraphNodeForTask(
-      new_raster_finished_task.get(), priority++, &graph);
+
+  size_t raster_required_for_activation_finished_dependencies = 0u;

[vmpstr, 2014/02/06 19:44:37]

nit: It would be awesome if the word "count" appeared in the variable name
somehow. However, if that makes it too long for practical uses, this is fine as
well. I don't really have any ideas short of abbreviating required for
activation as rfa, but I don't really like that idea.

[reveman, 2014/02/06 20:51:52]

Done.

+  size_t raster_finished_dependencies = 0u;
 
   RasterTaskVector gpu_raster_tasks;
 
@@ -65,16 +60,28 @@ void ImageRasterWorkerPool::ScheduleTasks(RasterTask::Queue* queue) {
       continue;
     }
 
-    CreateGraphNodeForImageRasterTask(
-        task,
-        task->dependencies(),
-        priority++,
-        IsRasterTaskRequiredForActivation(task),
-        raster_required_for_activation_finished_node,
-        raster_finished_node,
-        &graph);
+    if (IsRasterTaskRequiredForActivation(task)) {
+      raster_required_for_activation_finished_dependencies++;

[vmpstr, 2014/02/06 19:44:37]

nit: ++raster...

[reveman, 2014/02/06 20:51:52]

Done.

+      graph.edges.push_back(internal::TaskGraph::Edge(
+          task, new_raster_required_for_activation_finished_task.get()));
+    }
+
+    InsertNodeForRasterTask(&graph, task, task->dependencies(), priority++);
+
+    raster_finished_dependencies++;

[vmpstr, 2014/02/06 19:44:37]

nit: ++raster...

[reveman, 2014/02/06 20:51:52]

Done.

+    graph.edges.push_back(
+        internal::TaskGraph::Edge(task, new_raster_finished_task.get()));
   }
 
+  InsertNodeForTask(&graph,
+                    new_raster_required_for_activation_finished_task.get(),
+                    0u,  // Priority 0
+                    raster_required_for_activation_finished_dependencies);
+  InsertNodeForTask(&graph,
+                    new_raster_finished_task.get(),
+                    1u,  // Priority 1
+                    raster_finished_dependencies);
+
   SetTaskGraph(&graph);
 
   set_raster_finished_task(new_raster_finished_task);
@@ -170,25 +177,4 @@ scoped_ptr<base::Value> ImageRasterWorkerPool::StateAsValue() const {
   return state.PassAs<base::Value>();
 }
 
-// static
-void ImageRasterWorkerPool::CreateGraphNodeForImageRasterTask(
-    internal::WorkerPoolTask* image_task,
-    const internal::Task::Vector& decode_tasks,
-    unsigned priority,
-    bool is_required_for_activation,
-    internal::GraphNode* raster_required_for_activation_finished_node,
-    internal::GraphNode* raster_finished_node,
-    TaskGraph* graph) {
-  internal::GraphNode* image_node =
-      CreateGraphNodeForRasterTask(image_task, decode_tasks, priority, graph);
-
-  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