content: Implement dynamic priorities for raster threads.

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>
 #include <map>
 #include <vector>
 
 #include "cc/base/cc_export.h"
 #include "cc/raster/task_graph_runner.h"
 
 namespace cc {
 
+class CC_EXPORT TaskGraphWorkQueueClient {
+  virtual void AdjustWorkerPriorityForTask(Task* task,
+                                           uint16_t old_category,
+                                           uint16_t new_category) = 0;
+};
+
 // Implements a queue of incoming TaskGraph work. Designed for use by
 // implementations of TaskGraphRunner. Not thread safe, so the caller is
 // responsible for all necessary locking.
 //
 // Tasks in the queue are divided into categories. Tasks from a single graph may
 // be put into different categories, each of which is prioritized independently
 // from the others. It is up to the implementation of TaskGraphRunner to
 // define the meaning of the categories and handle them appropriately.
 class CC_EXPORT TaskGraphWorkQueue {
  public:
@@ skipping 34 matching lines @@
     // category.
     std::map<uint16_t, PrioritizedTask::Vector> ready_to_run_tasks;
 
     // Completed tasks not yet collected by origin thread.
     Task::Vector completed_tasks;
 
     // This set contains all currently running tasks.
     std::vector<CategorizedTask> running_tasks;
   };
 
-  TaskGraphWorkQueue();
+  explicit TaskGraphWorkQueue(TaskGraphWorkQueueClient* client);
   virtual ~TaskGraphWorkQueue();
 
   // Gets a NamespaceToken which is guaranteed to be unique within this
   // TaskGraphWorkQueue.
   NamespaceToken GetNamespaceToken();
 
   // Updates a TaskNamespace with a new TaskGraph to run. This cancels any
   // previous tasks in the graph being replaced.
   void ScheduleTasks(NamespaceToken token, TaskGraph* graph);
 
@@ skipping 84 matching lines @@
  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_;
     }
   };
 
+  TaskGraphWorkQueueClient* client_;
+
   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_;
 
   // Provides a unique id to each NamespaceToken.
   int next_namespace_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RASTER_TASK_GRAPH_WORK_QUEUE_H_