Separate the create and start phases in DelayedTaskManager.

base/task_scheduler/task_scheduler_impl.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/task_scheduler/task_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 168 matching lines @@
   // Instantiate TaskTracker. Needs to happen after starting the service thread
   // to get its message_loop().
   task_tracker_ =
 #if defined(OS_POSIX) && !defined(OS_NACL_SFI)
       base::MakeUnique<TaskTrackerPosix>(
           static_cast<MessageLoopForIO*>(service_thread_.message_loop()));
 #else
       base::MakeUnique<TaskTracker>();
 #endif
 
-  // Instantiate DelayedTaskManager. Needs to happen after starting the service
-  // thread to get its task_runner().
-  delayed_task_manager_ =
-      base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
+  // Start DelayedTaskManager. Needs to happen after starting the service thread
+  // to get its task_runner().
+  delayed_task_manager_.Start(service_thread_.task_runner());
 
   single_thread_task_runner_manager_ =
       MakeUnique<SchedulerSingleThreadTaskRunnerManager>(
-          task_tracker_.get(), delayed_task_manager_.get());
+          task_tracker_.get(), &delayed_task_manager_);
   single_thread_task_runner_manager_->Start();
 
   // Callback invoked by workers to re-enqueue a sequence in the appropriate
   // PriorityQueue.
   const SchedulerWorkerPoolImpl::ReEnqueueSequenceCallback
       re_enqueue_sequence_callback =
           Bind(&TaskSchedulerImpl::ReEnqueueSequenceCallback, Unretained(this));
 
   // Order must match the EnvironmentType enum.
   const SchedulerWorkerPoolParams* worker_pool_params[] = {
@@ skipping 14 matching lines @@
   // Start worker pools.
   for (int environment_type = 0; environment_type < ENVIRONMENT_COUNT;
        ++environment_type) {
     // Passing pointers to objects owned by |this| to the constructor of
     // SchedulerWorkerPoolImpl is safe because a TaskSchedulerImpl can't be
     // deleted before all its worker pools have been joined.
     worker_pools_[environment_type] = MakeUnique<SchedulerWorkerPoolImpl>(
         name_ + kEnvironmentParams[environment_type].name_suffix,
         kEnvironmentParams[environment_type].priority_hint,
         re_enqueue_sequence_callback, task_tracker_.get(),
-        delayed_task_manager_.get());
+        &delayed_task_manager_);
     worker_pools_[environment_type]->Start(
         *worker_pool_params[environment_type]);
   }
 }
 
 SchedulerWorkerPoolImpl* TaskSchedulerImpl::GetWorkerPoolForTraits(
     const TaskTraits& traits) const {
   return worker_pools_[GetEnvironmentIndexForTraits(traits)].get();
 }
 
 void TaskSchedulerImpl::ReEnqueueSequenceCallback(
     scoped_refptr<Sequence> sequence) {
   DCHECK(sequence);
 
   const SequenceSortKey sort_key = sequence->GetSortKey();
 
   // The next task in |sequence| should run in a worker pool suited for its
   // traits, except for the priority which is adjusted to the highest priority
   // in |sequence|.
   const TaskTraits traits =
       sequence->PeekTaskTraits().WithPriority(sort_key.priority());
 
   GetWorkerPoolForTraits(traits)->ReEnqueueSequence(std::move(sequence),
                                                     sort_key);
 }
 
 }  // namespace internal
 }  // namespace base