Introduce ThreadTaskRunnerHandle::OverrideForTesting and TestMockTimeTaskRunner::ScopedContext.

base/test/test_mock_time_task_runner.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 "base/test/test_mock_time_task_runner.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/clock.h"
 #include "base/time/tick_clock.h"
 
 namespace base {
 
 namespace {
 
 // MockTickClock --------------------------------------------------------------
 
 // TickClock that always returns the then-current mock time ticks of
@@ skipping 92 matching lines @@
 
 TestMockTimeTaskRunner::TestOrderedPendingTask::~TestOrderedPendingTask() {
 }
 
 TestMockTimeTaskRunner::TestOrderedPendingTask&
 TestMockTimeTaskRunner::TestOrderedPendingTask::operator=(
     TestOrderedPendingTask&&) = default;
 
 // TestMockTimeTaskRunner -----------------------------------------------------
 
+// TODO(gab): This should also set the SequenceToken for the current thread.
+// Ref. TestMockTimeTaskRunner::RunsTasksOnCurrentThread().
+TestMockTimeTaskRunner::ScopedContext::ScopedContext(
+    scoped_refptr<TestMockTimeTaskRunner> scope)
+    : on_destroy_(ThreadTaskRunnerHandle::OverrideForTesting(scope)) {
+  scope->RunUntilIdle();
+}
+
+TestMockTimeTaskRunner::ScopedContext::~ScopedContext() = default;
+
 bool TestMockTimeTaskRunner::TemporalOrder::operator()(
     const TestOrderedPendingTask& first_task,
     const TestOrderedPendingTask& second_task) const {
   if (first_task.GetTimeToRun() == second_task.GetTimeToRun())
     return first_task.ordinal > second_task.ordinal;
   return first_task.GetTimeToRun() > second_task.GetTimeToRun();
 }
 
 TestMockTimeTaskRunner::TestMockTimeTaskRunner()
     : now_(Time::UnixEpoch()), next_task_ordinal_(0) {
@@ skipping 73 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return tasks_.size();
 }
 
 TimeDelta TestMockTimeTaskRunner::NextPendingTaskDelay() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return tasks_.empty() ? TimeDelta::Max()
                         : tasks_.top().GetTimeToRun() - now_ticks_;
 }
 
+// TODO(gab): Combine |thread_checker_| with a SequenceToken to differentiate
+// between tasks running in the scope of this TestMockTimeTaskRunner and other
+// task runners sharing this thread. http://crbug.com/631186
 bool TestMockTimeTaskRunner::RunsTasksOnCurrentThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 bool TestMockTimeTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
   AutoLock scoped_lock(tasks_lock_);
   tasks_.push(TestOrderedPendingTask(from_here, task, now_ticks_, delay,
@@ skipping 20 matching lines @@
 void TestMockTimeTaskRunner::OnAfterTimePassed() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::OnAfterTaskRun() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::ProcessAllTasksNoLaterThan(TimeDelta max_delta) {
   DCHECK_GE(max_delta, TimeDelta());
+
+  // Multiple test task runners can share the same thread for determinism in
+  // unit tests. Make sure this TestMockTimeTaskRunner's tasks run in its scope.
+  ScopedClosureRunner undo_override;
+  if (!ThreadTaskRunnerHandle::IsSet() ||
+      ThreadTaskRunnerHandle::Get() != this) {
+    undo_override = ThreadTaskRunnerHandle::OverrideForTesting(this);
+  }
+
   const TimeTicks original_now_ticks = now_ticks_;
   while (!IsElapsingStopped()) {
     OnBeforeSelectingTask();
     TestPendingTask task_info;
     if (!DequeueNextTask(original_now_ticks, max_delta, &task_info))
       break;
     // If tasks were posted with a negative delay, task_info.GetTimeToRun() will
     // be less than |now_ticks_|. ForwardClocksUntilTickTime() takes care of not
     // moving the clock backwards in this case.
     ForwardClocksUntilTickTime(task_info.GetTimeToRun());
@@ skipping 20 matching lines @@
     // It's safe to remove const and consume |task| here, since |task| is not
     // used for ordering the item.
     *next_task = std::move(const_cast<TestOrderedPendingTask&>(tasks_.top()));
     tasks_.pop();
     return true;
   }
   return false;
 }
 
 }  // namespace base