Re-land: cc: Add raster finished signals to RasterWorkerPool.

cc/resources/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/worker_pool.h"
 
 #include "base/time/time.h"
 #include "cc/base/completion_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 51 matching lines @@
 
   static scoped_ptr<PerfWorkerPool> Create() {
     return make_scoped_ptr(new PerfWorkerPool);
   }
 
   void ScheduleTasks(internal::WorkerPoolTask* root_task,
                      internal::WorkerPoolTask* leaf_task,
                      unsigned max_depth,
                      unsigned num_children_per_node) {
     TaskVector tasks;
-    unsigned priority = 0u;
     TaskGraph graph;
 
-    scoped_ptr<GraphNode> root_node;
-    if (root_task) {
-      root_node = make_scoped_ptr(new GraphNode);
-      root_node->set_task(root_task);
+    scoped_ptr<internal::GraphNode> root_node;
+    if (root_task)
+      root_node = make_scoped_ptr(new internal::GraphNode(root_task, 0u));
+
+    scoped_ptr<internal::GraphNode> leaf_node;
+    if (leaf_task)
+      leaf_node = make_scoped_ptr(new internal::GraphNode(leaf_task, 0u));
+
+    if (max_depth) {
+      BuildTaskGraph(&tasks,
+                     &graph,
+                     root_node.get(),
+                     leaf_node.get(),
+                     0,
+                     max_depth,
+                     num_children_per_node);
     }
 
-    scoped_ptr<GraphNode> leaf_node;
-    if (leaf_task) {
-      leaf_node = make_scoped_ptr(new GraphNode);
-      leaf_node->set_task(leaf_task);
-    }
+    if (leaf_node)
+      graph.set(leaf_task, leaf_node.Pass());
 
-    if (max_depth) {
-      priority = BuildTaskGraph(&tasks,
-                                &graph,
-                                root_node.get(),
-                                leaf_node.get(),
-                                priority,
-                                0,
-                                max_depth,
-                                num_children_per_node);
-    }
-
-    if (leaf_node) {
-      leaf_node->set_priority(priority++);
-      graph.set(leaf_task, leaf_node.Pass());
-    }
-
-    if (root_node) {
-      root_node->set_priority(priority++);
+    if (root_node)
       graph.set(root_task, root_node.Pass());
-    }
 
     SetTaskGraph(&graph);
 
     tasks_.swap(tasks);
   }
 
  private:
   typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
 
-  unsigned BuildTaskGraph(TaskVector* tasks,
-                          TaskGraph* graph,
-                          GraphNode* dependent_node,
-                          GraphNode* leaf_node,
-                          unsigned priority,
-                          unsigned current_depth,
-                          unsigned max_depth,
-                          unsigned num_children_per_node) {
+  void BuildTaskGraph(TaskVector* tasks,
+                      TaskGraph* graph,
+                      internal::GraphNode* dependent_node,
+                      internal::GraphNode* leaf_node,
+                      unsigned current_depth,
+                      unsigned max_depth,
+                      unsigned num_children_per_node) {
     scoped_refptr<PerfWorkerPoolTaskImpl> task(new PerfWorkerPoolTaskImpl);
-    scoped_ptr<GraphNode> node(new GraphNode);
-    node->set_task(task.get());
+    scoped_ptr<internal::GraphNode> node(
+        new internal::GraphNode(task.get(), 0u));
 
     if (current_depth < max_depth) {
       for (unsigned i = 0; i < num_children_per_node; ++i) {
-        priority = BuildTaskGraph(tasks,
-                                  graph,
-                                  node.get(),
-                                  leaf_node,
-                                  priority,
-                                  current_depth + 1,
-                                  max_depth,
-                                  num_children_per_node);
+        BuildTaskGraph(tasks,
+                       graph,
+                       node.get(),
+                       leaf_node,
+                       current_depth + 1,
+                       max_depth,
+                       num_children_per_node);
       }
     } else if (leaf_node) {
       leaf_node->add_dependent(node.get());
       node->add_dependency();
     }
 
     if (dependent_node) {
       node->add_dependent(dependent_node);
       dependent_node->add_dependency();
     }
-    node->set_priority(priority);
     graph->set(task.get(), node.Pass());
     tasks->push_back(task.get());
-
-    return priority + 1;
   }
 
   TaskVector tasks_;
 
   DISALLOW_COPY_AND_ASSIGN(PerfWorkerPool);
 };
 
 class WorkerPoolPerfTest : public testing::Test {
  public:
   WorkerPoolPerfTest() : num_runs_(0) {}
@@ skipping 94 matching lines @@
   RunExecuteTasksTest("execute_tasks_2_10", 2, 10);
   RunExecuteTasksTest("execute_tasks_5_5", 5, 5);
   RunExecuteTasksTest("execute_tasks_10_2", 10, 2);
   RunExecuteTasksTest("execute_tasks_1000_1", 1000, 1);
   RunExecuteTasksTest("execute_tasks_10_1", 10, 1);
 }
 
 }  // namespace
 
 }  // namespace cc