Add TaskScheduler::JoinForTesting().

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 35 matching lines @@
                                  TimeDelta delay) override;
   scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   std::vector<const HistogramBase*> GetHistograms() const override;
   void Shutdown() override;
   void FlushForTesting() override;
+  void JoinForTesting() override;
 
   // 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);
 
@@ skipping 95 matching lines @@
   task_tracker_.SetHasShutdownStartedForTesting();
 
   // Run pending BLOCK_SHUTDOWN tasks.
   RunLoop().RunUntilIdle();
 }
 
 void TestTaskScheduler::FlushForTesting() {
   NOTREACHED();
 }
 
+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(
       task_ptr->posted_from, Bind(&TestTaskScheduler::RunTask, Unretained(this),
                                   Passed(&task), sequence_token),
       task_ptr->delay);
@@ skipping 64 matching lines @@
 ScopedTaskScheduler::ScopedTaskScheduler(MessageLoop* external_message_loop) {
   DCHECK(!TaskScheduler::GetInstance());
   TaskScheduler::SetInstance(
       MakeUnique<TestTaskScheduler>(external_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