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

cc/resources/raster_worker_pool.cc

Index: cc/resources/raster_worker_pool.cc
diff --git a/cc/resources/raster_worker_pool.cc b/cc/resources/raster_worker_pool.cc
index 5f356e5b2122a304eb8eda800af5fd09e0914d3d..971612fcf162e1da2aad632caf1665939a270264 100644
--- a/cc/resources/raster_worker_pool.cc
+++ b/cc/resources/raster_worker_pool.cc
@@ -224,8 +224,6 @@ class RasterFinishedWorkerPoolTaskImpl : public internal::WorkerPoolTask {
   DISALLOW_COPY_AND_ASSIGN(RasterFinishedWorkerPoolTaskImpl);
 };
 
-void Noop() {}
-
 const char* kWorkerThreadNamePrefix = "CompositorRaster";
 
 }  // namespace
@@ -335,7 +333,11 @@ RasterWorkerPool::RasterTask::~RasterTask() {
 
 RasterWorkerPool::RasterTaskGraph::RasterTaskGraph()
     : raster_finished_node_(new GraphNode),
-      next_priority_(1u) {
+      raster_required_for_activation_finished_node_(new GraphNode),
+      next_priority_(2u) {  // priority 0-1 is reserved for OnRasterFinished.
+  raster_finished_node_->add_dependency();
+  raster_required_for_activation_finished_node_->add_dependent(
+      raster_finished_node_.get());
 }
 
 RasterWorkerPool::RasterTaskGraph::~RasterTaskGraph() {
@@ -343,7 +345,8 @@ RasterWorkerPool::RasterTaskGraph::~RasterTaskGraph() {
 
 void RasterWorkerPool::RasterTaskGraph::InsertRasterTask(
     internal::WorkerPoolTask* raster_task,
-    const TaskVector& decode_tasks) {
+    const TaskVector& decode_tasks,
+    bool required_for_activation) {
   DCHECK(!raster_task->HasCompleted());
   DCHECK(graph_.find(raster_task) == graph_.end());
 
@@ -377,8 +380,14 @@ void RasterWorkerPool::RasterTaskGraph::InsertRasterTask(
     graph_.set(decode_task, decode_node.Pass());
   }
 
-  raster_finished_node_->add_dependency();
-  raster_node->add_dependent(raster_finished_node_.get());
+  if (required_for_activation) {
+    raster_required_for_activation_finished_node_->add_dependency();
+    raster_node->add_dependent(
+        raster_required_for_activation_finished_node_.get());
+  } else {
+    raster_finished_node_->add_dependency();
+    raster_node->add_dependent(raster_finished_node_.get());
+  }
 
   graph_.set(raster_task, raster_node.Pass());
 }
@@ -436,12 +445,12 @@ void RasterWorkerPool::SetClient(RasterWorkerPoolClient* client) {
 }
 
 void RasterWorkerPool::Shutdown() {
+  // Cancel any pending OnRasterFinished callbacks.
+  weak_ptr_factory_.InvalidateWeakPtrs();
+  raster_tasks_.clear();
   TaskGraph empty;
   SetTaskGraph(&empty);
   WorkerPool::Shutdown();
-  raster_tasks_.clear();
-  // Cancel any pending OnRasterFinished callback.
-  weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void RasterWorkerPool::SetRasterTasks(RasterTask::Queue* queue) {
@@ -453,15 +462,11 @@ void RasterWorkerPool::SetRasterTasks(RasterTask::Queue* queue) {
 void RasterWorkerPool::SetRasterTaskGraph(RasterTaskGraph* graph) {
   scoped_ptr<GraphNode> raster_finished_node(
       graph->raster_finished_node_.Pass());
+  scoped_ptr<GraphNode> raster_required_for_activation_finished_node(
+      graph->raster_required_for_activation_finished_node_.Pass());
   TaskGraph new_graph;
   new_graph.swap(graph->graph_);
 
-  if (new_graph.empty()) {
-    SetTaskGraph(&new_graph);
-    raster_finished_task_ = NULL;
-    return;
-  }
-
   ++schedule_raster_tasks_count_;
 
   scoped_refptr<internal::WorkerPoolTask> new_raster_finished_task(
@@ -471,10 +476,28 @@ void RasterWorkerPool::SetRasterTaskGraph(RasterTaskGraph* graph) {
                      weak_ptr_factory_.GetWeakPtr(),
                      schedule_raster_tasks_count_)));
   raster_finished_node->set_task(new_raster_finished_task.get());
-  // Insert "raster finished" task before switching to new graph.
+  raster_finished_node->set_priority(0u);
   new_graph.set(new_raster_finished_task.get(), raster_finished_node.Pass());
+
+  scoped_refptr<internal::WorkerPoolTask>
+      new_raster_required_for_activation_finished_task(

[vmpstr, 2013/06/24 16:34:03]

Should this one be marked as a dependency of the raster_finished_node?

[reveman, 2013/06/24 19:05:17]

That's currently done in RasterTaskGraph ctor.

+          new RasterFinishedWorkerPoolTaskImpl(
+              base::MessageLoopProxy::current(),
+              base::Bind(
+                  &RasterWorkerPool::OnRasterRequiredForActivationFinished,
+                  weak_ptr_factory_.GetWeakPtr(),
+                  schedule_raster_tasks_count_)));
+  raster_required_for_activation_finished_node->set_task(
+      new_raster_required_for_activation_finished_task.get());
+  raster_required_for_activation_finished_node->set_priority(1u);

[vmpstr, 2013/06/24 16:34:03]

As a follow-up, we might want to do something like set_task_with_priority, since
any time we call set_task, we immediately call set_priority.

[reveman, 2013/06/24 19:05:17]

Sounds good. This will likely be done as part of the switch to using a vector
which I think will require similar changes.

+  new_graph.set(new_raster_required_for_activation_finished_task.get(),
+                raster_required_for_activation_finished_node.Pass());
+
   SetTaskGraph(&new_graph);
+
   raster_finished_task_.swap(new_raster_finished_task);
+  raster_required_for_activation_finished_task_.swap(
+      new_raster_required_for_activation_finished_task);
 }
 
 bool RasterWorkerPool::IsRasterTaskRequiredForActivation(
@@ -484,14 +507,26 @@ bool RasterWorkerPool::IsRasterTaskRequiredForActivation(
       raster_tasks_required_for_activation_.end();
 }
 
-void RasterWorkerPool::OnRasterFinished(int64 schedule_raster_tasks_count) {
+void RasterWorkerPool::OnRasterFinished(
+    int64 schedule_raster_tasks_count) {
   TRACE_EVENT1("cc", "RasterWorkerPool::OnRasterFinished",
                "schedule_raster_tasks_count", schedule_raster_tasks_count);
   DCHECK_GE(schedule_raster_tasks_count_, schedule_raster_tasks_count);
-  // Call OnRasterTasksFinished() when we've finished running all raster
-  // tasks needed since last time SetRasterTaskGraph() was called.
+  // Call OnRasterTasksFinished() if this callback is
+  // associated with the last call to SetRasterTaskGraph().
   if (schedule_raster_tasks_count_ == schedule_raster_tasks_count)
     OnRasterTasksFinished();
 }
 
+void RasterWorkerPool::OnRasterRequiredForActivationFinished(
+    int64 schedule_raster_tasks_count) {
+  TRACE_EVENT1("cc", "RasterWorkerPool::OnRasterRequiredForActivationFinished",
+               "schedule_raster_tasks_count", schedule_raster_tasks_count);
+  DCHECK_GE(schedule_raster_tasks_count_, schedule_raster_tasks_count);
+  // Call OnRasterTasksRequiredForActivationFinished() if this callback is
+  // associated with the last call to SetRasterTaskGraph().
+  if (schedule_raster_tasks_count_ == schedule_raster_tasks_count)
+    OnRasterTasksRequiredForActivationFinished();
+}
+
 }  // namespace cc