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

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"
 
 #include <algorithm>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
 }
 
 bool WorkerPoolTask::HasFinishedRunning() const {
   return did_run_;
 }
 
 bool WorkerPoolTask::HasCompleted() const {
   return did_complete_;
 }
 
+GraphNode::GraphNode(internal::WorkerPoolTask* task, unsigned priority)
+    : task_(task),
+      priority_(priority),
+      num_dependencies_(0) {
+}
+
+GraphNode::~GraphNode() {
+}
+
 }  // namespace internal
 
 // Internal to the worker pool. Any data or logic that needs to be
 // shared between threads lives in this class. All members are guarded
 // by |lock_|.
 class WorkerPool::Inner : public base::DelegateSimpleThread::Delegate {
  public:
   Inner(size_t num_threads, const std::string& thread_name_prefix);
   virtual ~Inner();
 
   void Shutdown();
 
   // Schedule running of tasks in |graph|. Tasks previously scheduled but
   // no longer needed will be canceled unless already running. Canceled
   // tasks are moved to |completed_tasks_| without being run. The result
   // is that once scheduled, a task is guaranteed to end up in the
   // |completed_tasks_| queue even if they later get canceled by another
   // call to SetTaskGraph().
   void SetTaskGraph(TaskGraph* graph);
 
   // Collect all completed tasks in |completed_tasks|.
   void CollectCompletedTasks(TaskVector* completed_tasks);
 
  private:
   class PriorityComparator {
    public:
-    bool operator()(const GraphNode* a,
-                    const GraphNode* b) {
+    bool operator()(const internal::GraphNode* a,
+                    const internal::GraphNode* b) {
       // In this system, numerically lower priority is run first.
       if (a->priority() != b->priority())
         return a->priority() > b->priority();
 
       // Run task with most dependents first when priority is the same.
       return a->dependents().size() < b->dependents().size();
     }
   };
 
   // Overridden from base::DelegateSimpleThread:
@@ skipping 13 matching lines @@
   unsigned next_thread_index_;
 
   // Set during shutdown. Tells workers to exit when no more tasks
   // are pending.
   bool shutdown_;
 
   // This set contains all pending tasks.
   GraphNodeMap pending_tasks_;
 
   // Ordered set of tasks that are ready to run.
-  typedef std::priority_queue<GraphNode*,
-                              std::vector<GraphNode*>,
+  typedef std::priority_queue<internal::GraphNode*,
+                              std::vector<internal::GraphNode*>,
                               PriorityComparator> TaskQueue;
   TaskQueue ready_to_run_tasks_;
 
   // This set contains all currently running tasks.
   GraphNodeMap running_tasks_;
 
   // Completed tasks not yet collected by origin thread.
   TaskVector completed_tasks_;
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
@@ skipping 69 matching lines @@
 
   {
     base::AutoLock lock(lock_);
 
     // First remove all completed tasks from |new_pending_tasks| and
     // adjust number of dependencies.
     for (TaskVector::iterator it = completed_tasks_.begin();
          it != completed_tasks_.end(); ++it) {
       internal::WorkerPoolTask* task = it->get();
 
-      scoped_ptr<GraphNode> node = new_pending_tasks.take_and_erase(task);
+      scoped_ptr<internal::GraphNode> node = new_pending_tasks.take_and_erase(
+          task);
       if (node) {
-        for (GraphNode::Vector::const_iterator it = node->dependents().begin();
+        for (internal::GraphNode::Vector::const_iterator it =
+                 node->dependents().begin();
              it != node->dependents().end(); ++it) {
-          GraphNode* dependent_node = *it;
+          internal::GraphNode* dependent_node = *it;
           dependent_node->remove_dependency();
         }
       }
     }
 
     // Build new running task set.
     for (GraphNodeMap::iterator it = running_tasks_.begin();
          it != running_tasks_.end(); ++it) {
       internal::WorkerPoolTask* task = it->first;
       // Transfer scheduled task value from |new_pending_tasks| to
       // |new_running_tasks| if currently running. Value must be set to
       // 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;
+      internal::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();
 
       if (!node->num_dependencies())
         new_ready_to_run_tasks.push(node);
@@ skipping 72 matching lines @@
       base::AutoUnlock unlock(lock_);
 
       task->RunOnWorkerThread(thread_index);
     }
 
     // This will mark task as finished running.
     task->DidRun();
 
     // Now iterate over all dependents to remove dependency and check
     // if they are ready to run.
-    scoped_ptr<GraphNode> node = running_tasks_.take_and_erase(task.get());
+    scoped_ptr<internal::GraphNode> node = running_tasks_.take_and_erase(
+        task.get());
     if (node) {
-      for (GraphNode::Vector::const_iterator it = node->dependents().begin();
+      for (internal::GraphNode::Vector::const_iterator it =
+               node->dependents().begin();
            it != node->dependents().end(); ++it) {
-        GraphNode* dependent_node = *it;
+        internal::GraphNode* dependent_node = *it;
 
         dependent_node->remove_dependency();
         // Task is ready if it has no dependencies. Add it to
         // |ready_to_run_tasks_|.
         if (!dependent_node->num_dependencies())
           ready_to_run_tasks_.push(dependent_node);
       }
     }
 
     // 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()
-    : 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),
       inner_(make_scoped_ptr(new Inner(num_threads, thread_name_prefix))) {
 }
 
 WorkerPool::~WorkerPool() {
 }
 
 void WorkerPool::Shutdown() {
@@ skipping 37 matching lines @@
 void WorkerPool::SetTaskGraph(TaskGraph* graph) {
   TRACE_EVENT1("cc", "WorkerPool::SetTaskGraph",
                "num_tasks", graph->size());
 
   DCHECK(!in_dispatch_completion_callbacks_);
 
   inner_->SetTaskGraph(graph);
 }
 
 }  // namespace cc