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 34 matching lines @@
 };
 }  // namespace
 
 TaskGraphWorkQueue::TaskNamespace::TaskNamespace() {}
 
 TaskGraphWorkQueue::TaskNamespace::TaskNamespace(const TaskNamespace& other) =
     default;
 
 TaskGraphWorkQueue::TaskNamespace::~TaskNamespace() {}
 
-TaskGraphWorkQueue::TaskGraphWorkQueue() : next_namespace_id_(1) {}
+TaskGraphWorkQueue::TaskGraphWorkQueue(TaskGraphWorkQueueClient* client)
+    : client_(client), next_namespace_id_(1) {}
 TaskGraphWorkQueue::~TaskGraphWorkQueue() {}
 
 NamespaceToken TaskGraphWorkQueue::GetNamespaceToken() {
   NamespaceToken token(next_namespace_id_++);
   DCHECK(namespaces_.find(token) == namespaces_.end());
   return token;
 }
 
 void TaskGraphWorkQueue::ScheduleTasks(NamespaceToken token, TaskGraph* graph) {
   TaskNamespace& task_namespace = namespaces_[token];
@@ skipping 30 matching lines @@
       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) &&
+                          task.first != node.category) {
+                        // Fix lambda error.
+                        // client_->AdjustWorkerPriorityForTask(
+                        //    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.
@@ skipping 185 matching lines @@
 
   for (const TaskGraph::Node& node : graph->nodes) {
     if (dependents[node.task] != node.dependencies)
       return true;
   }
 
   return false;
 }
 
 }  // namespace cc