Allow ScopedTaskScheduler to be created before a class that overrides MessageLoop::current()'s task…

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 59 matching lines @@
   bool RunsTasksOnCurrentThread() const;
 
  private:
   // |message_loop_owned_| will be non-null if this TestTaskScheduler owns the
   // MessageLoop (wasn't provided an external one at construction).
   // |message_loop_| will always be set and is used by this TestTaskScheduler to
   // run tasks.
   std::unique_ptr<MessageLoop> message_loop_owned_;
   MessageLoop* message_loop_;
 
-  // The SingleThreadTaskRunner associated with |message_loop_|.
-  const scoped_refptr<SingleThreadTaskRunner> message_loop_task_runner_ =
-      message_loop_->task_runner();
-
   // Handles shutdown behaviors and sets up the environment to run a task.
   internal::TaskTracker task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTaskScheduler);
 };
 
 class TestTaskSchedulerTaskRunner : public SingleThreadTaskRunner {
  public:
   TestTaskSchedulerTaskRunner(TestTaskScheduler* task_scheduler,
                               ExecutionMode execution_mode,
@@ skipping 85 matching lines @@
 void TestTaskScheduler::JoinForTesting() {
   // TestTaskScheduler doesn't create threads so this does nothing.
 }
 
 bool TestTaskScheduler::PostTask(std::unique_ptr<internal::Task> task,
                                  const SequenceToken& sequence_token) {
   DCHECK(task);
   if (!task_tracker_.WillPostTask(task.get()))
     return false;
   internal::Task* const task_ptr = task.get();
-  return message_loop_task_runner_->PostDelayedTask(
+  return message_loop_->task_runner()->PostDelayedTask(
       task_ptr->posted_from, Bind(&TestTaskScheduler::RunTask, Unretained(this),
                                   Passed(&task), sequence_token),
       task_ptr->delay);
 }
 
 void TestTaskScheduler::RunTask(std::unique_ptr<internal::Task> task,
                                 const SequenceToken& sequence_token) {
   // Clear the MessageLoop TaskRunner to allow TaskTracker to register its own
   // Thread/SequencedTaskRunnerHandle as appropriate.
+  scoped_refptr<SingleThreadTaskRunner> saved_task_runner =
+      MessageLoop::current()->task_runner();
   MessageLoop::current()->ClearTaskRunnerForTesting();
 
   // Run the task.
   task_tracker_.RunTask(std::move(task), sequence_token.IsValid()
                                              ? sequence_token
                                              : SequenceToken::Create());
 
   // Restore the MessageLoop TaskRunner.
-  MessageLoop::current()->SetTaskRunner(message_loop_task_runner_);
+  MessageLoop::current()->SetTaskRunner(saved_task_runner);
 }
 
 bool TestTaskScheduler::RunsTasksOnCurrentThread() const {
-  return message_loop_task_runner_->RunsTasksOnCurrentThread();
+  return message_loop_->task_runner()->RunsTasksOnCurrentThread();
 }
 
 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 43 matching lines @@
   DCHECK_EQ(task_scheduler_, TaskScheduler::GetInstance());
 
   // Per contract, call JoinForTesting() before deleting the TaskScheduler.
   TaskScheduler::GetInstance()->JoinForTesting();
 
   TaskScheduler::SetInstance(nullptr);
 }
 
 }  // namespace test
 }  // namespace base