Separate the create and start phases in DelayedTaskManager.

base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc

 // Copyright 2017 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/task_scheduler/scheduler_single_thread_task_runner_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/lock.h"
@@ skipping 21 matching lines @@
 
 namespace {
 
 class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test {
  public:
   TaskSchedulerSingleThreadTaskRunnerManagerTest()
       : service_thread_("TaskSchedulerServiceThread") {}
 
   void SetUp() override {
     service_thread_.Start();
-    delayed_task_manager_ =
-        MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
+    delayed_task_manager_.Start(service_thread_.task_runner());
     single_thread_task_runner_manager_ =
         MakeUnique<SchedulerSingleThreadTaskRunnerManager>(
-            &task_tracker_, delayed_task_manager_.get());
+            &task_tracker_, &delayed_task_manager_);
     StartSingleThreadTaskRunnerManagerFromSetUp();
   }
 
   void TearDown() override {
     TearDownSingleThreadTaskRunnerManager();
-    delayed_task_manager_.reset();
     service_thread_.Stop();
   }
 
  protected:
   virtual void StartSingleThreadTaskRunnerManagerFromSetUp() {
     single_thread_task_runner_manager_->Start();
   }
 
   virtual void TearDownSingleThreadTaskRunnerManager() {
     single_thread_task_runner_manager_->JoinForTesting();
     single_thread_task_runner_manager_.reset();
   }
 
   std::unique_ptr<SchedulerSingleThreadTaskRunnerManager>
       single_thread_task_runner_manager_;
   TaskTracker task_tracker_;
 
  private:
   Thread service_thread_;
-  std::unique_ptr<DelayedTaskManager> delayed_task_manager_;
+  DelayedTaskManager delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTest);
 };
 
 void CaptureThreadRef(PlatformThreadRef* thread_ref) {
   ASSERT_TRUE(thread_ref);
   *thread_ref = PlatformThread::CurrentRef();
 }
 
 void CaptureThreadPriority(ThreadPriority* thread_priority) {
@@ skipping 399 matching lines @@
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   manager_started.Set();
   single_thread_task_runner_manager_->Start();
 
   // This should not hang if the task is scheduled after Start().
   task_running.Wait();
 }
 
 }  // namespace internal
 }  // namespace base