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

cc/resources/worker_pool_unittest.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 <vector>
 
 #include "cc/base/completion_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 35 matching lines @@
   virtual ~FakeWorkerPool() {}
 
   static scoped_ptr<FakeWorkerPool> Create() {
     return make_scoped_ptr(new FakeWorkerPool);
   }
 
   void ScheduleTasks(const base::Closure& callback,
                      const base::Closure& reply,
                      const base::Closure& dependency,
                      int count) {
-    unsigned priority = 0u;
     TaskGraph graph;
 
     scoped_refptr<FakeWorkerPoolTaskImpl> completion_task(
         new FakeWorkerPoolTaskImpl(
             base::Bind(&FakeWorkerPool::OnTasksCompleted,
                        base::Unretained(this)),
             base::Closure()));
-    scoped_ptr<GraphNode> completion_node(new GraphNode);
-    completion_node->set_task(completion_task.get());
+    scoped_ptr<internal::GraphNode> completion_node(
+        new internal::GraphNode(completion_task.get(), 0u));
 
     scoped_refptr<FakeWorkerPoolTaskImpl> dependency_task(
         new FakeWorkerPoolTaskImpl(dependency, base::Closure()));
-    scoped_ptr<GraphNode> dependency_node(new GraphNode);
-    dependency_node->set_task(dependency_task.get());
+    scoped_ptr<internal::GraphNode> dependency_node(
+        new internal::GraphNode(dependency_task.get(), 0u));
 
     TaskVector tasks;
     for (int i = 0; i < count; ++i) {
       scoped_refptr<FakeWorkerPoolTaskImpl> task(
           new FakeWorkerPoolTaskImpl(callback, reply));
-      scoped_ptr<GraphNode> node(new GraphNode);
-      node->set_task(task.get());
+      scoped_ptr<internal::GraphNode> node(
+          new internal::GraphNode(task.get(), 0u));
       node->add_dependent(completion_node.get());
       completion_node->add_dependency();
       dependency_node->add_dependent(node.get());
       node->add_dependency();
-      node->set_priority(priority++);
       graph.set(task.get(), node.Pass());
       tasks.push_back(task.get());
     }
 
-    completion_node->set_priority(priority++);
     graph.set(completion_task.get(), completion_node.Pass());
-    dependency_node->set_priority(priority++);
     graph.set(dependency_task.get(), dependency_node.Pass());
 
     scheduled_tasks_completion_.reset(new CompletionEvent);
 
     SetTaskGraph(&graph);
 
     tasks_.swap(tasks);
     completion_task_.swap(completion_task);
     dependency_task_.swap(dependency_task);
   }
@@ skipping 122 matching lines @@
   EXPECT_EQ(1u, run_task_ids()[3]);
   EXPECT_EQ(1u, run_task_ids()[4]);
   ASSERT_EQ(3u, on_task_completed_ids().size());
   EXPECT_EQ(1u, on_task_completed_ids()[1]);
   EXPECT_EQ(1u, on_task_completed_ids()[2]);
 }
 
 }  // namespace
 
 }  // namespace cc