Reland - Refactor signaling in RWP

cc/raster/task_graph_work_queue.h

 // Copyright 2014 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.
 
 #ifndef CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_
 #define CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_
 
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 10 matching lines @@
 // responsible for all necessary locking.
 //
 // Tasks in the queue are divided into categories. Tasks from a single graph may
 // be put into different categories, each of which is prioritized independently
 // from the others. It is up to the implementation of TaskGraphRunner to
 // define the meaning of the categories and handle them appropriately.
 class CC_EXPORT TaskGraphWorkQueue {
  public:
   struct TaskNamespace;
 
-  struct PrioritizedTask {
+  struct CC_EXPORT PrioritizedTask {
     typedef std::vector<PrioritizedTask> Vector;
 
     PrioritizedTask(Task* task,
                     TaskNamespace* task_namespace,
                     uint16_t category,
-                    uint16_t priority)
-        : task(task),
-          task_namespace(task_namespace),
-          category(category),
-          priority(priority) {}
+                    uint16_t priority);
+    ~PrioritizedTask();
 
-    Task* task;
+    scoped_refptr<Task> task;

[reveman, 2016/02/24 18:53:00]

hm, not sure about this. I'm worried this will make ScheduleTasks much more
expensive as increments/decrements of these thread-safe ref-counted tasks is
very expensive compared to everything else done at ScheduleTasks time. Can we
avoid this change?

[ericrk, 2016/02/24 19:30:43]

Introduced a new type, CategorizedTask, which refcounts (as Task::Vector did),
but is only used for running_tasks. This avoids unnecessary refcounting but adds
a new type.

     TaskNamespace* task_namespace;
     uint16_t category;
     uint16_t priority;
   };
 
   // Helper classes and static methods used by dependent classes.
   struct TaskNamespace {
     typedef std::vector<TaskNamespace*> Vector;
 
     TaskNamespace();
     ~TaskNamespace();
 
     // Current task graph.
     TaskGraph graph;
 
     // Map from category to a vector of tasks that are ready to run for that
     // category.
     std::map<uint16_t, PrioritizedTask::Vector> ready_to_run_tasks;
 
     // Completed tasks not yet collected by origin thread.
     Task::Vector completed_tasks;
 
     // This set contains all currently running tasks.
-    Task::Vector running_tasks;
+    PrioritizedTask::Vector running_tasks;
   };
 
   TaskGraphWorkQueue();
   virtual ~TaskGraphWorkQueue();
 
   // Gets a NamespaceToken which is guaranteed to be unique within this
   // TaskGraphWorkQueue.
   NamespaceToken GetNamespaceToken();
 
   // Updates a TaskNamespace with a new TaskGraph to run. This cancels any
@@ skipping 60 matching lines @@
                [](const TaskNamespaceMap::value_type& entry) {
                  return !HasFinishedRunningTasksInNamespace(&entry.second);
                }) == namespaces_.end();
   }
 
   const std::map<uint16_t, TaskNamespace::Vector>& ready_to_run_namespaces()
       const {
     return ready_to_run_namespaces_;
   }
 
+  size_t NumRunningTasksForCategory(uint16_t category) const {
+    size_t count = 0;
+    for (const auto& task_namespace_entry : namespaces_) {
+      for (const auto& prioritized_task :
+           task_namespace_entry.second.running_tasks) {
+        if (prioritized_task.category == category) {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+
   // Helper function which ensures that graph dependencies were correctly
   // configured.
   static bool DependencyMismatch(const TaskGraph* graph);
 
  private:
   // Helper class used to provide NamespaceToken comparison to TaskNamespaceMap.
   class CompareToken {
    public:
     bool operator()(const NamespaceToken& lhs,
                     const NamespaceToken& rhs) const {
       return lhs.id_ < rhs.id_;
     }
   };
 
   using TaskNamespaceMap =
       std::map<NamespaceToken, TaskNamespace, CompareToken>;
 
   TaskNamespaceMap namespaces_;
 
   // Map from category to a vector of ready to run namespaces for that category.
   std::map<uint16_t, TaskNamespace::Vector> ready_to_run_namespaces_;
 
   // Provides a unique id to each NamespaceToken.
   int next_namespace_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_