cc: Switch to vector based TaskGraph implementation.

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 16 matching lines @@
   TRACE_EVENT0("cc", "ImageRasterWorkerPool::ScheduleTasks");
 
   RasterWorkerPool::SetRasterTasks(queue);
 
   if (!raster_tasks_pending_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ScheduledTasks", this);
 
   raster_tasks_pending_ = true;
   raster_tasks_required_for_activation_pending_ = true;
 
-  unsigned priority = 0u;
-  TaskGraph graph;
+  unsigned priority = kRasterTaskPriorityBase;
+  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_dependency_count = 0u;
+  size_t raster_finished_dependency_count = 0u;
 
   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());
 
     if (task->use_gpu_rasterization()) {
       gpu_raster_tasks.push_back(task);
       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_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()));
   }
 
+  InsertNodeForTask(&graph,
+                    new_raster_required_for_activation_finished_task.get(),
+                    kRasterRequiredForActivationFinishedTaskPriority,
+                    raster_required_for_activation_finished_dependency_count);
+  InsertNodeForTask(&graph,
+                    new_raster_finished_task.get(),
+                    kRasterFinishedTaskPriority,
+                    raster_finished_dependency_count);
+
   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",
@@ skipping 75 matching lines @@
 
 scoped_ptr<base::Value> ImageRasterWorkerPool::StateAsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
 
   state->SetBoolean("tasks_required_for_activation_pending",
                     raster_tasks_required_for_activation_pending_);
   state->Set("scheduled_state", ScheduledStateAsValue().release());
   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