Revert 209912 "cc: Add raster finished signals to RasterWorkerPool."

Caused failure in LayerTreeHostTestDeferredInitialize.RunMultiThread_DelegatingRenderer_MainThreadPain on Linux
http://build.chromium.org/p/chromium.linux/builders/Linux%20Tests%20%28dbg%29%282%29%2832%29/builds/3728

> cc: Add raster finished signals to RasterWorkerPool.
>     
> This adds to important signals to the RasterWorkerPoolClient
> interface. Each signal is generated as a result of calling
> ScheduleTasks() and the signals always reflect the state of the
> last call to ScheduleTasks().
>     
> BUG=253508,254135,252787
> TEST=cc_unittests --gtest_filter=TileManagerTest.*
> 
> Review URL: https://chromiumcodereview.appspot.com/17351017

TBR=reveman@chromium.org

Review URL: https://codereview.chromium.org/18630002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@209936 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 46 insertions, 31 deletions

diff --git a/cc/resources/worker_pool_perftest.cc b/cc/resources/worker_pool_perftest.cc
index aee1f24..d708cf5 100644
--- a/cc/resources/worker_pool_perftest.cc
+++ b/cc/resources/worker_pool_perftest.cc
@@ -69,31 +69,41 @@ class PerfWorkerPool : public WorkerPool {
                      unsigned max_depth,
                      unsigned num_children_per_node) {
     TaskVector tasks;
+    unsigned priority = 0u;
     TaskGraph graph;
 
-    scoped_ptr<internal::GraphNode> root_node;
-    if (root_task)
-      root_node = make_scoped_ptr(new internal::GraphNode(root_task, 0u));
+    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> leaf_node;
-    if (leaf_task)
-      leaf_node = make_scoped_ptr(new internal::GraphNode(leaf_task, 0u));
+    scoped_ptr<GraphNode> leaf_node;
+    if (leaf_task) {
+      leaf_node = make_scoped_ptr(new GraphNode);
+      leaf_node->set_task(leaf_task);
+    }
 
     if (max_depth) {
-      BuildTaskGraph(&tasks,
-                     &graph,
-                     root_node.get(),
-                     leaf_node.get(),
-                     0,
-                     max_depth,
-                     num_children_per_node);
+      priority = BuildTaskGraph(&tasks,
+                                &graph,
+                                root_node.get(),
+                                leaf_node.get(),
+                                priority,
+                                0,
+                                max_depth,
+                                num_children_per_node);
     }
 
-    if (leaf_node)
+    if (leaf_node) {
+      leaf_node->set_priority(priority++);
       graph.set(leaf_task, leaf_node.Pass());
+    }
 
-    if (root_node)
+    if (root_node) {
+      root_node->set_priority(priority++);
       graph.set(root_task, root_node.Pass());
+    }
 
     SetTaskGraph(&graph);
 
@@ -103,26 +113,28 @@ class PerfWorkerPool : public WorkerPool {
  private:
   typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
 
-  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) {
+  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) {
     scoped_refptr<PerfWorkerPoolTaskImpl> task(new PerfWorkerPoolTaskImpl);
-    scoped_ptr<internal::GraphNode> node(
-        new internal::GraphNode(task.get(), 0u));
+    scoped_ptr<GraphNode> node(new GraphNode);
+    node->set_task(task.get());
 
     if (current_depth < max_depth) {
       for (unsigned i = 0; i < num_children_per_node; ++i) {
-        BuildTaskGraph(tasks,
-                       graph,
-                       node.get(),
-                       leaf_node,
-                       current_depth + 1,
-                       max_depth,
-                       num_children_per_node);
+        priority = BuildTaskGraph(tasks,
+                                  graph,
+                                  node.get(),
+                                  leaf_node,
+                                  priority,
+                                  current_depth + 1,
+                                  max_depth,
+                                  num_children_per_node);
       }
     } else if (leaf_node) {
       leaf_node->add_dependent(node.get());
@@ -133,8 +145,11 @@ class PerfWorkerPool : public WorkerPool {
       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_;