content: Implement dynamic priorities for raster threads.

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 59 matching lines @@
       TaskGraph::Node& node = *node_it;
       DCHECK_LT(0u, node.dependencies);
       node.dependencies--;
     }
   }
 
   // Build new "ready to run" queue and remove nodes from old graph.
   for (auto& ready_to_run_tasks_it : task_namespace.ready_to_run_tasks) {
     ready_to_run_tasks_it.second.clear();
   }
+
+  for (const CategorizedTask& task : task_namespace.running_tasks) {
+    task.second->cancelled = true;
+  }
+
   for (const TaskGraph::Node& node : graph->nodes) {
     // Remove any old nodes that are associated with this task. The result is
     // that the old graph is left with all nodes not present in this graph,
     // which we use below to determine what tasks need to be canceled.
     TaskGraph::Node::Vector::iterator old_it = std::find_if(
         task_namespace.graph.nodes.begin(), task_namespace.graph.nodes.end(),
         [node](const TaskGraph::Node& other) {
           return node.task == other.task;
         });
     if (old_it != task_namespace.graph.nodes.end()) {
       std::swap(*old_it, task_namespace.graph.nodes.back());
       task_namespace.graph.nodes.pop_back();
     }
 
     // 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.
     if (std::any_of(task_namespace.running_tasks.begin(),
                     task_namespace.running_tasks.end(),
                     [&node](const CategorizedTask& task) {
+                      if (task.second == node.task) {
+                        if (task.first > node.category) {
+                          TRACE_EVENT2("cc, pras", "Task::Rescheduled::Speedup",
+                                       "Old Category", task.first,
+                                       "New Category", node.category);
+                        } else if (task.first < node.category) {
+                          TRACE_EVENT2("cc, pras",
+                                       "Task::Rescheduled::Slowdown",
+                                       "Old Category", task.first,
+                                       "New Category", node.category);
+                        } else {
+                          TRACE_EVENT2("cc, pras", "Task::Rescheduled::Same",
+                                       "Old Category", task.first,
+                                       "New Category", node.category);
+                        }
+
+                        task.second->cancelled = false;
+                      }
+
                       return task.second == node.task;
                     }))
       continue;
 
+    {
+      TRACE_EVENT1("cc, pras", "Task::Scheduled::New", "New Category",
+                   node.category);
+    }
+
     task_namespace.ready_to_run_tasks[node.category].push_back(PrioritizedTask(
         node.task, &task_namespace, node.category, node.priority));
   }
 
+  for (const CategorizedTask& task : task_namespace.running_tasks) {
+    if (task.second->cancelled) {
+      TRACE_EVENT1("cc, pras", "Task::Rescheduled::Cancelled", "Old Category",
+                   task.first);
+    }
+  }
+
   // 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);
@@ skipping 177 matching lines @@
 
   for (const TaskGraph::Node& node : graph->nodes) {
     if (dependents[node.task] != node.dependencies)
       return true;
   }
 
   return false;
 }
 
 }  // namespace cc