Test dynamic priorities

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 43 matching lines @@
 
 TaskGraphWorkQueue::TaskGraphWorkQueue() : next_namespace_id_(1) {}
 TaskGraphWorkQueue::~TaskGraphWorkQueue() {}
 
 NamespaceToken TaskGraphWorkQueue::GetNamespaceToken() {
   NamespaceToken token(next_namespace_id_++);
   DCHECK(namespaces_.find(token) == namespaces_.end());
   return token;
 }
 
+void AdjustRunnerPriority(Task* task, uint16_t old_cat, uint16_t new_cat) {
+  // Remove or put DCHECK.
+  if (old_cat == new_cat)
+    return;
+
+  // Put DCHECK.
+  if (!task->IsRasterTask())
+    return;
+
+  base::TestSimpleThread* runner = task->GetRunner();
+
+  // Currently take care of only speeding up background threads.
+  if (new_cat == TASK_CATEGORY_NONCONCURRENT_FOREGROUND ||
+      new_cat == TASK_CATEGORY_FOREGROUND) {
+    if (runner->Speedup()) {
+      // LOG(ERROR) << "\nPRAS:: [" << std::hex << runner << "]  "
+      //            << runner->GetPrioritySetForDebugging()
+      //            << ".  Runner speeded up ^^^^^^^^^";
+    }
+  }
+}
+
 void TaskGraphWorkQueue::ScheduleTasks(NamespaceToken token, TaskGraph* graph) {
   TaskNamespace& task_namespace = namespaces_[token];
 
   // First adjust number of dependencies to reflect completed tasks.
   for (const scoped_refptr<Task>& task : task_namespace.completed_tasks) {
     for (DependentIterator node_it(graph, task.get()); node_it; ++node_it) {
       TaskGraph::Node& node = *node_it;
       DCHECK_LT(0u, node.dependencies);
       node.dependencies--;
     }
@@ skipping 19 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.
-    if (std::any_of(task_namespace.running_tasks.begin(),
-                    task_namespace.running_tasks.end(),
-                    [&node](const CategorizedTask& task) {
-                      return task.second == node.task;
-                    }))
+    if (std::any_of(
+            task_namespace.running_tasks.begin(),
+            task_namespace.running_tasks.end(),
+            [&node](const CategorizedTask& task) {
+              if ((task.second == node.task) && task.first != node.category) {
+                AdjustRunnerPriority(task.second.get(), (uint16_t)task.first,
+                                     (uint16_t)node.category);
+              }
+              return task.second == node.task;
+            }))
       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;
@@ skipping 183 matching lines @@
 
   for (const TaskGraph::Node& node : graph->nodes) {
     if (dependents[node.task] != node.dependencies)
       return true;
   }
 
   return false;
 }
 
 }  // namespace cc