cc: Move task graph construction to RasterWorkerPool classes.

cc/resources/worker_pool.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"
 
 #if defined(OS_ANDROID)
 // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
 #include <sys/resource.h>
 #endif
@@ skipping 11 matching lines @@
 namespace cc {
 
 namespace internal {
 
 WorkerPoolTask::WorkerPoolTask()
     : did_schedule_(false),
       did_run_(false),
       did_complete_(false) {
 }
 
-WorkerPoolTask::WorkerPoolTask(TaskVector* dependencies)
-    : did_schedule_(false),
-      did_run_(false),
-      did_complete_(false) {
-  dependencies_.swap(*dependencies);
-}
-
 WorkerPoolTask::~WorkerPoolTask() {
   DCHECK_EQ(did_schedule_, did_complete_);
   DCHECK(!did_run_ || did_schedule_);
   DCHECK(!did_run_ || did_complete_);
 }
 
 void WorkerPoolTask::DidSchedule() {
   DCHECK(!did_complete_);
   did_schedule_ = true;
 }
@@ skipping 186 matching lines @@
       // NULL if |new_pending_tasks| doesn't contain task. This does
       // the right in both cases.
       new_running_tasks.set(task, new_pending_tasks.take_and_erase(task));
     }
 
     // Build new "ready to run" tasks queue.
     // TODO(reveman): Create this queue when building the task graph instead.
     for (GraphNodeMap::iterator it = new_pending_tasks.begin();
          it != new_pending_tasks.end(); ++it) {
       internal::WorkerPoolTask* task = it->first;
+      DCHECK(task);
       GraphNode* node = it->second;
 
       // Completed tasks should not exist in |new_pending_tasks|.
       DCHECK(!task->HasFinishedRunning());
 
       // Call DidSchedule() to indicate that this task has been scheduled.
       // Note: This is only for debugging purposes.
       task->DidSchedule();
 
       DCHECK_EQ(0u, new_ready_to_run_tasks.count(node->priority()));
@@ skipping 97 matching lines @@
 
     // Finally add task to |completed_tasks_|.
     completed_tasks_.push_back(task);
   }
 
   // We noticed we should exit. Wake up the next worker so it knows it should
   // exit as well (because the Shutdown() code only signals once).
   has_ready_to_run_tasks_cv_.Signal();
 }
 
-WorkerPool::GraphNode::GraphNode(internal::WorkerPoolTask* task)
-    : task_(task),
+WorkerPool::GraphNode::GraphNode()
+    : task_(NULL),
       priority_(0),
       num_dependencies_(0) {
 }
 
 WorkerPool::GraphNode::~GraphNode() {
 }
 
 WorkerPool::WorkerPool(size_t num_threads,
                        const std::string& thread_name_prefix)
     : in_dispatch_completion_callbacks_(false),
@@ skipping 33 matching lines @@
     task->DidComplete();
     task->DispatchCompletionCallback();
 
     completed_tasks->pop_front();
   }
 
   in_dispatch_completion_callbacks_ = false;
 }
 
 void WorkerPool::SetTaskGraph(TaskGraph* graph) {
-  TRACE_EVENT0("cc", "WorkerPool::SetTaskGraph");
+  TRACE_EVENT1("cc", "WorkerPool::SetTaskGraph",
+               "num_tasks", graph->size());
 
   DCHECK(!in_dispatch_completion_callbacks_);
 
   inner_->SetTaskGraph(graph);
 }
 
-// static
-unsigned WorkerPool::BuildTaskGraphRecursive(
-    internal::WorkerPoolTask* task,
-    GraphNode* dependent,
-    unsigned priority,
-    TaskGraph* graph) {
-  GraphNodeMap::iterator it = graph->find(task);
-  if (it != graph->end()) {
-    GraphNode* node = it->second;
-    node->add_dependent(dependent);
-    return priority;
-  }
-
-  scoped_ptr<GraphNode> node(new GraphNode(task));
-
-  typedef internal::WorkerPoolTask::TaskVector TaskVector;
-  for (TaskVector::iterator dependency_it = task->dependencies().begin();
-       dependency_it != task->dependencies().end(); ++dependency_it) {
-    internal::WorkerPoolTask* dependency = dependency_it->get();
-    // Skip sub-tree if task has already completed.
-    if (dependency->HasCompleted())
-      continue;
-
-    node->add_dependency();
-
-    priority = BuildTaskGraphRecursive(dependency,
-                                       node.get(),
-                                       priority,
-                                       graph);
-  }
-
-  node->set_priority(priority);
-  if (dependent)
-    node->add_dependent(dependent);
-
-  graph->set(task, node.Pass());
-
-  return priority + 1;
-}
-
-// static
-void WorkerPool::BuildTaskGraph(
-    internal::WorkerPoolTask* root, TaskGraph* graph) {
-  const unsigned kBasePriority = 0u;
-  if (root && !root->HasCompleted())
-    BuildTaskGraphRecursive(root, NULL, kBasePriority, graph);
-}
-
 }  // namespace cc