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 127 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_;
   }
 
+  uint32_t NumRunningTasks() const {

[reveman, 2016/02/08 19:10:21]

Do we need both of these functions or is the one below sufficient?

[ericrk, 2016/02/10 18:44:49]

Not really - we can drop this one for now.

+    uint32_t count = 0;
+    for (const auto& running_task_count_entry : running_task_count_) {
+      count += running_task_count_entry.second;
+    }
+    return count;
+  }
+
+  uint32_t NumRunningTasksForCategory(uint16_t category) const {
+    auto found = running_task_count_.find(category);
+    if (found != running_task_count_.end()) {
+      return found->second;
+    }
+    return 0;
+  }
+
   // 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_;
 
+  // Helper variable tracking the number of running tasks in each category. We
+  // could calculate this from data in namespaces_, but it would be less
+  // efficient.
+  std::map<uint16_t, uint32_t> running_task_count_;

[reveman, 2016/02/08 19:10:21]

I'd prefer if we minimized state and looped over all namespaces to compute this.
We only have one namespace in the most common case. It also seems consistent
with TaskNamespace::ready_to_run_tasks to also have ::running_tasks be a map.
Wdyt?

[ericrk, 2016/02/10 18:44:49]

Sure, went back and forth on this - can make this change.

+
   // Provides a unique id to each NamespaceToken.
   int next_namespace_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_