Revert of Refactor signaling in RWP

cc/raster/task_graph_work_queue.cc

 // 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.
 
 #include "cc/raster/task_graph_work_queue.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 79 matching lines @@
 
     // Task is not ready to run if dependencies are not yet satisfied.
     if (node.dependencies)
       continue;
 
     // Skip if already finished running task.
     if (node.task->HasFinishedRunning())
       continue;
 
     // Skip if already running.
-    const auto& running_tasks_for_category =
-        task_namespace.running_tasks.find(node.category);
-    if (running_tasks_for_category != task_namespace.running_tasks.cend() &&
-        std::find(running_tasks_for_category->second.cbegin(),
-                  running_tasks_for_category->second.cend(),
-                  node.task) != running_tasks_for_category->second.cend())
+    if (std::find(task_namespace.running_tasks.begin(),
+                  task_namespace.running_tasks.end(),
+                  node.task) != task_namespace.running_tasks.end())
       continue;
 
     task_namespace.ready_to_run_tasks[node.category].push_back(PrioritizedTask(
         node.task, &task_namespace, node.category, node.priority));
   }
 
   // Rearrange the elements in each vector within |ready_to_run_tasks| in such a
   // way that they form a heap.
   for (auto& it : task_namespace.ready_to_run_tasks) {
     auto& ready_to_run_tasks = it.second;
     std::make_heap(ready_to_run_tasks.begin(), ready_to_run_tasks.end(),
                    CompareTaskPriority);
   }
 
   // Swap task graph.
   task_namespace.graph.Swap(graph);
 
   // Determine what tasks in old graph need to be canceled.
   for (TaskGraph::Node::Vector::iterator it = graph->nodes.begin();
        it != graph->nodes.end(); ++it) {
     TaskGraph::Node& node = *it;
 
     // Skip if already finished running task.
     if (node.task->HasFinishedRunning())
       continue;
 
     // Skip if already running.
-    const auto& running_tasks_for_category =
-        task_namespace.running_tasks.find(node.category);
-    if (running_tasks_for_category != task_namespace.running_tasks.cend() &&
-        std::find(running_tasks_for_category->second.cbegin(),
-                  running_tasks_for_category->second.cend(),
-                  node.task) != running_tasks_for_category->second.cend())
+    if (std::find(task_namespace.running_tasks.begin(),
+                  task_namespace.running_tasks.end(),
+                  node.task) != task_namespace.running_tasks.end())
       continue;
 
     DCHECK(std::find(task_namespace.completed_tasks.begin(),
                      task_namespace.completed_tasks.end(),
                      node.task) == task_namespace.completed_tasks.end());
     task_namespace.completed_tasks.push_back(node.task);
   }
 
   // Build new "ready to run" task namespaces queue.
   for (auto& ready_to_run_namespaces_it : ready_to_run_namespaces_) {
@@ skipping 45 matching lines @@
   // Add task namespace back to |ready_to_run_namespaces| if not empty after
   // taking top priority task.
   if (!ready_to_run_tasks.empty()) {
     ready_to_run_namespaces.push_back(task_namespace);
     std::push_heap(ready_to_run_namespaces.begin(),
                    ready_to_run_namespaces.end(),
                    CompareTaskNamespacePriority(category));
   }
 
   // Add task to |running_tasks|.
-  task_namespace->running_tasks[category].push_back(task.task);
+  task_namespace->running_tasks.push_back(task.task);
 
   return task;
 }
 
 void TaskGraphWorkQueue::CompleteTask(const PrioritizedTask& completed_task) {
   TaskNamespace* task_namespace = completed_task.task_namespace;
   scoped_refptr<Task> task(completed_task.task);
-  uint16_t category = completed_task.category;
 
   // Remove task from |running_tasks|.
-  auto& running_tasks_for_category = task_namespace->running_tasks[category];
-  auto it = std::find(running_tasks_for_category.begin(),
-                      running_tasks_for_category.end(), task);
-  DCHECK(it != running_tasks_for_category.end());
-  std::swap(*it, running_tasks_for_category.back());
-  running_tasks_for_category.pop_back();
+  auto it = std::find(task_namespace->running_tasks.begin(),
+                      task_namespace->running_tasks.end(), task);
+  DCHECK(it != task_namespace->running_tasks.end());
+  std::swap(*it, task_namespace->running_tasks.back());
+  task_namespace->running_tasks.pop_back();
 
   // Now iterate over all dependents to decrement dependencies and check if they
   // are ready to run.
   bool ready_to_run_namespaces_has_heap_properties = true;
   for (DependentIterator it(&task_namespace->graph, task.get()); it; ++it) {
     TaskGraph::Node& dependent_node = *it;
 
     DCHECK_LT(0u, dependent_node.dependencies);
     dependent_node.dependencies--;
     // Task is ready if it has no dependencies. Add it to |ready_to_run_tasks_|.
@@ skipping 47 matching lines @@
 
   TaskNamespace& task_namespace = it->second;
 
   DCHECK_EQ(0u, completed_tasks->size());
   completed_tasks->swap(task_namespace.completed_tasks);
   if (!HasFinishedRunningTasksInNamespace(&task_namespace))
     return;
 
   // Remove namespace if finished running tasks.
   DCHECK_EQ(0u, task_namespace.completed_tasks.size());
-  DCHECK(HasFinishedRunningTasksInNamespace(&task_namespace));
+  DCHECK(!HasReadyToRunTasksInNamespace(&task_namespace));
+  DCHECK_EQ(0u, task_namespace.running_tasks.size());
   namespaces_.erase(it);
 }
 
 bool TaskGraphWorkQueue::DependencyMismatch(const TaskGraph* graph) {
   // Value storage will be 0-initialized.
   std::unordered_map<const Task*, size_t> dependents;
   for (const TaskGraph::Edge& edge : graph->edges)
     dependents[edge.dependent]++;
 
   for (const TaskGraph::Node& node : graph->nodes) {
     if (dependents[node.task] != node.dependencies)
       return true;
   }
 
   return false;
 }
 
 }  // namespace cc