Introduce TaskRunner::RunsTasksInCurrentSequence()

base/task_scheduler/scheduler_single_thread_task_runner_manager.cc

 // Copyright 2017 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 "base/task_scheduler/scheduler_single_thread_task_runner_manager.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 77 matching lines @@
     DCHECK_EQ(sequence, sequence_);
     has_work_ = true;
   }
 
   TimeDelta GetSleepTimeout() override { return TimeDelta::Max(); }
 
   bool CanDetach(SchedulerWorker* worker) override { return false; }
 
   void OnDetach() override { NOTREACHED(); }
 
-  bool RunsTasksOnCurrentThread() {
+  bool RunsTasksInCurrentSequence() {
     // We check the thread ref instead of the sequence for the benefit of COM
     // callbacks which may execute without a sequence context.
     return thread_ref_checker_.IsCurrentThreadSameAsSetThread();
   }
 
   void OnMainExit() override {
     // Move |sequence_| to |local_sequence| so that if we have the last
     // reference to the sequence we don't destroy it (and its tasks) within
     // |sequence_lock_|.
     scoped_refptr<Sequence> local_sequence;
@@ skipping 162 matching lines @@
     return true;
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   OnceClosure closure,
                                   TimeDelta delay) override {
     // Tasks are never nested within the task scheduler.
     return PostDelayedTask(from_here, std::move(closure), delay);
   }
 
-  bool RunsTasksOnCurrentThread() const override {
-    return GetDelegate()->RunsTasksOnCurrentThread();
+  bool RunsTasksInCurrentSequence() const override {
+    return GetDelegate()->RunsTasksInCurrentSequence();
   }
 
  private:
   ~SchedulerSingleThreadTaskRunner() override {
     outer_->UnregisterSchedulerWorker(worker_);
   }
 
   void PostTaskNow(std::unique_ptr<Task> task) {
     scoped_refptr<Sequence> sequence = GetDelegate()->sequence();
     // If |sequence| is null, then the thread is effectively gone (either
@@ skipping 169 matching lines @@
                      });
     DCHECK(worker_iter != workers_.end());
     worker_to_destroy = std::move(*worker_iter);
     workers_.erase(worker_iter);
   }
   worker_to_destroy->Cleanup();
 }
 
 }  // namespace internal
 }  // namespace base