TaskGraphRunner Group support

content/renderer/raster_worker_pool.cc

 // Copyright 2015 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 "content/renderer/raster_worker_pool.h"
 
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/raster/task_category.h"
 
 namespace content {
 
 // A sequenced task runner which posts tasks to a RasterWorkerPool.
 class RasterWorkerPool::RasterWorkerPoolSequencedTaskRunner
     : public base::SequencedTaskRunner {
  public:
   explicit RasterWorkerPoolSequencedTaskRunner(
       cc::TaskGraphRunner* task_graph_runner)
       : task_graph_runner_(task_graph_runner),
@@ skipping 20 matching lines @@
 
     tasks_.erase(tasks_.begin(), tasks_.begin() + completed_tasks_.size());
 
     tasks_.push_back(make_scoped_refptr(new ClosureTask(task)));
     graph_.Reset();
     for (const auto& graph_task : tasks_) {
       int dependencies = 0;
       if (!graph_.nodes.empty())
         dependencies = 1;
 
-      cc::TaskGraph::Node node(graph_task.get(), 0, dependencies);
+      cc::TaskGraph::Node node(graph_task.get(),
+                               cc::TASK_CATEGORY_HIGH_PRIORITY,
+                               0u /* priority */, dependencies);
       if (dependencies) {
         graph_.edges.push_back(
             cc::TaskGraph::Edge(graph_.nodes.back().task, node.task));
       }
       graph_.nodes.push_back(node);
     }
     task_graph_runner_->ScheduleTasks(namespace_token_, &graph_);
     completed_tasks_.clear();
     return true;
   }
@@ skipping 80 matching lines @@
       tasks_.begin(), tasks_.end(), [this](const scoped_refptr<cc::Task>& e) {
         return std::find(this->completed_tasks_.begin(),
                          this->completed_tasks_.end(),
                          e) != this->completed_tasks_.end();
       });
   tasks_.erase(end, tasks_.end());
 
   tasks_.push_back(make_scoped_refptr(new ClosureTask(task)));
   graph_.Reset();
   for (const auto& graph_task : tasks_)
-    graph_.nodes.push_back(cc::TaskGraph::Node(graph_task.get(), 0, 0));
+    graph_.nodes.push_back(
+        cc::TaskGraph::Node(graph_task.get(), cc::TASK_CATEGORY_HIGH_PRIORITY,
+                            0u /* priority */, 0u /* dependencies */));
 
   ScheduleTasksWithLockAcquired(namespace_token_, &graph_);
   completed_tasks_.clear();
   return true;
 }
 
 bool RasterWorkerPool::RunsTasksOnCurrentThread() const {
   return true;
 }
 
@@ skipping 94 matching lines @@
     cc::Task::Vector* completed_tasks) {
   DCHECK(token.IsValid());
   work_queue_.CollectCompletedTasks(token, completed_tasks);
 }
 
 void RasterWorkerPool::RunTaskWithLockAcquired() {
   TRACE_EVENT0("toplevel", "TaskGraphRunner::RunTask");
 
   lock_.AssertAcquired();
 
-  auto prioritized_task = work_queue_.GetNextTaskToRun();
+  // Find the first category with any tasks to run. Categories used by this task
+  // graph runner are ordered by priority.
+  // TODO(ericrk): Add more category/thread logic.
+  uint16_t category;
+  for (category = 0u; category < cc::kNumTaskCategories; ++category) {
+    if (work_queue_.HasReadyToRunTasksForCategory(category))
+      break;
+  }
+  DCHECK(category < cc::kNumTaskCategories);
+
+  auto prioritized_task = work_queue_.GetNextTaskToRun(category);
   cc::Task* task = prioritized_task.task;
 
   // There may be more work available, so wake up another worker thread.
   if (work_queue_.HasReadyToRunTasks())
     has_ready_to_run_tasks_cv_.Signal();
 
   // Call WillRun() before releasing |lock_| and running task.
   task->WillRun();
 
   {
@@ skipping 18 matching lines @@
 
 // Overridden from cc::Task:
 void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 RasterWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content