Introduce TaskRunner::RunsTasksInCurrentSequence()

base/test/scoped_task_scheduler.cc

 // Copyright 2016 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/test/scoped_task_scheduler.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 60 matching lines @@
   // Posts |task| to this TaskScheduler with |sequence_token|. Returns true on
   // success.
   bool PostTask(std::unique_ptr<internal::Task> task,
                 const SequenceToken& sequence_token);
 
   // Runs |task| with |sequence_token| using this TaskScheduler's TaskTracker.
   void RunTask(std::unique_ptr<internal::Task> task,
                const SequenceToken& sequence_token);
 
   // Returns true if this TaskScheduler runs its tasks on the current thread.
-  bool RunsTasksOnCurrentThread() const;
+  bool RunsTasksInCurrentSequence() const;
 
  private:
   // Returns the TaskRunner to which this TaskScheduler forwards tasks. It may
   // be |message_loop_->task_runner()| or a reference to it saved on entry to
   // RunTask().
   scoped_refptr<SingleThreadTaskRunner> MessageLoopTaskRunner() const {
     if (saved_task_runner_)
       return saved_task_runner_;
     DCHECK(message_loop_->task_runner());
     return message_loop_->task_runner();
@@ skipping 40 matching lines @@
                               ExecutionMode execution_mode,
                               TaskTraits traits);
 
   // SingleThreadTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        OnceClosure closure,
                        TimeDelta delay) override;
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
                                   OnceClosure closure,
                                   TimeDelta delay) override;
-  bool RunsTasksOnCurrentThread() const override;
+  bool RunsTasksInCurrentSequence() const override;
 
  private:
   ~TestTaskSchedulerTaskRunner() override;
 
   TestTaskScheduler* const task_scheduler_;
   const ExecutionMode execution_mode_;
   const SequenceToken sequence_token_;
   const TaskTraits traits_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTaskSchedulerTaskRunner);
@@ skipping 104 matching lines @@
                                              : SequenceToken::Create());
 
   // Make sure that any task runner that was registered was also cleaned up.
   DCHECK(!MessageLoop::current()->task_runner());
 
   // Restore the MessageLoop TaskRunner.
   MessageLoop::current()->SetTaskRunner(saved_task_runner_);
   saved_task_runner_ = nullptr;
 }
 
-bool TestTaskScheduler::RunsTasksOnCurrentThread() const {
-  return MessageLoopTaskRunner()->RunsTasksOnCurrentThread();
+bool TestTaskScheduler::RunsTasksInCurrentSequence() const {
+  return MessageLoopTaskRunner()->RunsTasksInCurrentSequence();
 }
 
 TestTaskSchedulerTaskRunner::TestTaskSchedulerTaskRunner(
     TestTaskScheduler* task_scheduler,
     ExecutionMode execution_mode,
     TaskTraits traits)
     : task_scheduler_(task_scheduler),
       execution_mode_(execution_mode),
       sequence_token_(execution_mode == ExecutionMode::PARALLEL
                           ? SequenceToken()
@@ skipping 14 matching lines @@
 }
 
 bool TestTaskSchedulerTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
     OnceClosure closure,
     TimeDelta delay) {
   // Tasks are never nested within the task scheduler.
   return PostDelayedTask(from_here, std::move(closure), delay);
 }
 
-bool TestTaskSchedulerTaskRunner::RunsTasksOnCurrentThread() const {
+bool TestTaskSchedulerTaskRunner::RunsTasksInCurrentSequence() const {
   if (execution_mode_ == ExecutionMode::PARALLEL)
-    return task_scheduler_->RunsTasksOnCurrentThread();
+    return task_scheduler_->RunsTasksInCurrentSequence();
   return sequence_token_ == SequenceToken::GetForCurrentThread();
 }
 
 TestTaskSchedulerTaskRunner::~TestTaskSchedulerTaskRunner() = default;
 
 }  // namespace
 
 ScopedTaskScheduler::ScopedTaskScheduler() : ScopedTaskScheduler(nullptr) {}
 
 ScopedTaskScheduler::ScopedTaskScheduler(MessageLoop* message_loop) {
   DCHECK(!TaskScheduler::GetInstance());
   TaskScheduler::SetInstance(MakeUnique<TestTaskScheduler>(message_loop));
   task_scheduler_ = TaskScheduler::GetInstance();
 }
 
 ScopedTaskScheduler::~ScopedTaskScheduler() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(task_scheduler_, TaskScheduler::GetInstance());
 
   // Per contract, call JoinForTesting() before deleting the TaskScheduler.
   TaskScheduler::GetInstance()->JoinForTesting();
 
   TaskScheduler::SetInstance(nullptr);
 }
 
 }  // namespace test
 }  // namespace base