cc: Switch to vector based TaskGraph implementation.

cc/resources/raster_worker_pool_perftest.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/raster_worker_pool.h"
 
 #include "base/time/time.h"
 #include "cc/test/lap_timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
@@ skipping 61 matching lines @@
   virtual void OnRasterTasksFinished() OVERRIDE { NOTREACHED(); }
   virtual void OnRasterTasksRequiredForActivationFinished() OVERRIDE {
     NOTREACHED();
   }
 
   void SetRasterTasks(RasterTask::Queue* queue) {
     RasterWorkerPool::SetRasterTasks(queue);
   }
 
   void BuildTaskGraph() {
-    unsigned priority = 0;
-    TaskGraph graph;
+    unsigned priority = 2u;
+    internal::TaskGraph graph;
 
     scoped_refptr<internal::WorkerPoolTask>
         raster_required_for_activation_finished_task(
             CreateRasterRequiredForActivationFinishedTask(
                 raster_tasks_required_for_activation().size()));
-    internal::GraphNode* raster_required_for_activation_finished_node =
-        CreateGraphNodeForTask(
-            raster_required_for_activation_finished_task.get(),
-            priority++,
-            &graph);
-
     scoped_refptr<internal::WorkerPoolTask> raster_finished_task(
         CreateRasterFinishedTask());
-    internal::GraphNode* raster_finished_node =
-        CreateGraphNodeForTask(raster_finished_task.get(), priority++, &graph);
+
+    size_t raster_required_for_activation_finished_dependencies = 0u;
+    size_t raster_finished_dependencies = 0u;
 
     for (RasterTaskVector::const_iterator it = raster_tasks().begin();
          it != raster_tasks().end();
          ++it) {
       internal::RasterWorkerPoolTask* task = it->get();
 
-      internal::GraphNode* node = CreateGraphNodeForRasterTask(
-          task, task->dependencies(), priority++, &graph);
-
       if (IsRasterTaskRequiredForActivation(task)) {
-        raster_required_for_activation_finished_node->add_dependency();
-        node->add_dependent(raster_required_for_activation_finished_node);
+        raster_required_for_activation_finished_dependencies++;
+        graph.edges.push_back(internal::TaskGraph::Edge(
+            task, raster_required_for_activation_finished_task.get()));
       }
 
-      raster_finished_node->add_dependency();
-      node->add_dependent(raster_finished_node);
+      InsertNodeForRasterTask(&graph, task, task->dependencies(), priority++);
+
+      raster_finished_dependencies++;
+      graph.edges.push_back(
+          internal::TaskGraph::Edge(task, raster_finished_task.get()));
     }
+
+    InsertNodeForTask(&graph,
+                      raster_required_for_activation_finished_task.get(),
+                      0u,
+                      raster_required_for_activation_finished_dependencies);
+    InsertNodeForTask(
+        &graph, raster_finished_task.get(), 1u, raster_finished_dependencies);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PerfRasterWorkerPool);
 };
 
 class RasterWorkerPoolPerfTest : public testing::Test {
  public:
   RasterWorkerPoolPerfTest()
       : timer_(kWarmupRuns,
@@ skipping 85 matching lines @@
   RunBuildTaskGraphTest("10_4", 10, 4);
   RunBuildTaskGraphTest("100_4", 100, 4);
   RunBuildTaskGraphTest("1000_4", 1000, 4);
   RunBuildTaskGraphTest("10_16", 10, 16);
   RunBuildTaskGraphTest("100_16", 100, 16);
   RunBuildTaskGraphTest("1000_16", 1000, 16);
 }
 
 }  // namespace
 }  // namespace cc