Introduce TaskRunner::RunsTasksInCurrentSequence()

content/renderer/categorized_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/categorized_worker_pool.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 39 matching lines @@
       cc::TaskGraphRunner* task_graph_runner)
       : task_graph_runner_(task_graph_runner),
         namespace_token_(task_graph_runner->GenerateNamespaceToken()) {}
 
   // Overridden from base::TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        base::OnceClosure task,
                        base::TimeDelta delay) override {
     return PostNonNestableDelayedTask(from_here, std::move(task), delay);
   }
-  bool RunsTasksOnCurrentThread() const override { return true; }
+  bool RunsTasksInCurrentSequence() const override { return true; }
 
   // Overridden from base::SequencedTaskRunner:
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   base::OnceClosure task,
                                   base::TimeDelta delay) override {
     DCHECK(task);
     base::AutoLock lock(lock_);
 
     // Remove completed tasks.
     DCHECK(completed_tasks_.empty());
@@ skipping 140 matching lines @@
     graph_.nodes.push_back(
         cc::TaskGraph::Node(graph_task.get(), cc::TASK_CATEGORY_FOREGROUND,
                             0u /* priority */, 0u /* dependencies */));
   }
 
   ScheduleTasksWithLockAcquired(namespace_token_, &graph_);
   completed_tasks_.clear();
   return true;
 }
 
-bool CategorizedWorkerPool::RunsTasksOnCurrentThread() const {
+bool CategorizedWorkerPool::RunsTasksInCurrentSequence() const {
   return true;
 }
 
 void CategorizedWorkerPool::Run(
     const std::vector<cc::TaskCategory>& categories,
     base::ConditionVariable* has_ready_to_run_tasks_cv) {
   base::AutoLock lock(lock_);
 
   while (true) {
     if (!RunTaskWithLockAcquired(categories)) {
@@ skipping 187 matching lines @@
     : closure_(std::move(closure)) {}
 
 // Overridden from cc::Task:
 void CategorizedWorkerPool::ClosureTask::RunOnWorkerThread() {
   std::move(closure_).Run();
 }
 
 CategorizedWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content