Separate the create and start phases in TaskSchedulerImpl.

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 20 matching lines @@
 #include "base/win/scoped_com_initializer.h"
 #endif  // defined(OS_WIN)
 
 namespace base {
 namespace test {
 
 namespace {
 
 enum class ExecutionMode { PARALLEL, SEQUENCED, SINGLE_THREADED };
 
+// ScopedTaskScheduler intentionally breaks the TaskScheduler contract of not
+// running tasks before Start(). This avoid having to call Start() with dummy
+// parameters.
 class TestTaskScheduler : public TaskScheduler {
  public:
   // |external_message_loop| is an externally provided MessageLoop on which to
   // run tasks. A MessageLoop will be created by TestTaskScheduler if
   // |external_message_loop| is nullptr.
   explicit TestTaskScheduler(MessageLoop* external_message_loop);
   ~TestTaskScheduler() override;
 
   // TaskScheduler:
+  void Start(const TaskScheduler::InitParams& init_params) override;
   void PostDelayedTaskWithTraits(const tracked_objects::Location& from_here,
                                  const TaskTraits& traits,
                                  OnceClosure task,
                                  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;
@@ skipping 97 matching lines @@
                                                 : MakeUnique<MessageLoop>()),
       message_loop_(message_loop_owned_ ? message_loop_owned_.get()
                                         : external_message_loop) {}
 
 TestTaskScheduler::~TestTaskScheduler() {
   // Shutdown if it hasn't already been done explicitly.
   if (!task_tracker_.HasShutdownStarted())
     Shutdown();
 }
 
+void TestTaskScheduler::Start(const TaskScheduler::InitParams&) {
+  NOTREACHED();
+}
+
 void TestTaskScheduler::PostDelayedTaskWithTraits(
     const tracked_objects::Location& from_here,
     const TaskTraits& traits,
     OnceClosure task,
     TimeDelta delay) {
   CreateTaskRunnerWithTraits(traits)->PostDelayedTask(from_here,
                                                       std::move(task), delay);
 }
 
 scoped_refptr<TaskRunner> TestTaskScheduler::CreateTaskRunnerWithTraits(
@@ skipping 146 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