Fix lack of lock in MTTR::TakePendingTasks() and add a few more safety checks.

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"
@@ skipping 179 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return MakeUnique<MockClock>(this);
 }
 
 std::unique_ptr<TickClock> TestMockTimeTaskRunner::GetMockTickClock() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return MakeUnique<MockTickClock>(this);
 }
 
 std::deque<TestPendingTask> TestMockTimeTaskRunner::TakePendingTasks() {
+  AutoLock scoped_lock(tasks_lock_);
   std::deque<TestPendingTask> tasks;
   while (!tasks_.empty()) {
     // It's safe to remove const and consume |task| here, since |task| is not
     // used for ordering the item.
     tasks.push_back(
         std::move(const_cast<TestOrderedPendingTask&>(tasks_.top())));
     tasks_.pop();
   }
   return tasks;
 }
@@ skipping 49 matching lines @@
 
 void TestMockTimeTaskRunner::OnAfterTimePassed() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::OnAfterTaskRun() {
   // Empty default implementation.
 }
 
 void TestMockTimeTaskRunner::ProcessAllTasksNoLaterThan(TimeDelta max_delta) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   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());
     std::move(task_info.task).Run();
     OnAfterTaskRun();
   }
 }
 
 void TestMockTimeTaskRunner::ForwardClocksUntilTickTime(TimeTicks later_ticks) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (later_ticks <= now_ticks_)
     return;
 
   now_ += later_ticks - now_ticks_;
   now_ticks_ = later_ticks;
   OnAfterTimePassed();
 }
 
 bool TestMockTimeTaskRunner::DequeueNextTask(const TimeTicks& reference,
                                              const TimeDelta& max_delta,
                                              TestPendingTask* next_task) {
   AutoLock scoped_lock(tasks_lock_);
   if (!tasks_.empty() &&
       (tasks_.top().GetTimeToRun() - reference) <= max_delta) {
     // 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