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"
 #include "base/memory/ptr_util.h"
 #include "base/task_scheduler/delayed_task_manager.h"
-#include "base/task_scheduler/scheduler_single_thread_task_runner_manager.h"
 #include "base/task_scheduler/scheduler_worker_pool_params.h"
 #include "base/task_scheduler/sequence_sort_key.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
@@ skipping 68 matching lines @@
   return GetWorkerPoolForTraits(traits)->CreateSequencedTaskRunnerWithTraits(
       traits);
 }
 
 scoped_refptr<SingleThreadTaskRunner>
 TaskSchedulerImpl::CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits) {
   const auto& environment_params =
       kEnvironmentParams[GetEnvironmentIndexForTraits(traits)];
   return single_thread_task_runner_manager_
-      ->CreateSingleThreadTaskRunnerWithTraits(
+      .CreateSingleThreadTaskRunnerWithTraits(
           name_ + environment_params.name_suffix,
           environment_params.priority_hint, traits);
 }
 
 #if defined(OS_WIN)
 scoped_refptr<SingleThreadTaskRunner>
 TaskSchedulerImpl::CreateCOMSTATaskRunnerWithTraits(const TaskTraits& traits) {
   const auto& environment_params =
       kEnvironmentParams[GetEnvironmentIndexForTraits(traits)];
-  return single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+  return single_thread_task_runner_manager_.CreateCOMSTATaskRunnerWithTraits(
       environment_params.name_suffix, environment_params.priority_hint, traits);
 }
 #endif  // defined(OS_WIN)
 
 std::vector<const HistogramBase*> TaskSchedulerImpl::GetHistograms() const {
   std::vector<const HistogramBase*> histograms;
   for (const auto& worker_pool : worker_pools_)
     worker_pool->GetHistograms(&histograms);
 
   return histograms;
@@ skipping 10 matching lines @@
 }
 
 void TaskSchedulerImpl::FlushForTesting() {
   task_tracker_.Flush();
 }
 
 void TaskSchedulerImpl::JoinForTesting() {
 #if DCHECK_IS_ON()
   DCHECK(!join_for_testing_returned_.IsSet());
 #endif
-  single_thread_task_runner_manager_->JoinForTesting();
+  single_thread_task_runner_manager_.JoinForTesting();
   for (const auto& worker_pool : worker_pools_)
     worker_pool->DisallowWorkerDetachmentForTesting();
   for (const auto& worker_pool : worker_pools_)
     worker_pool->JoinForTesting();
   service_thread_.Stop();
 #if DCHECK_IS_ON()
   join_for_testing_returned_.Set();
 #endif
 }
 
 TaskSchedulerImpl::TaskSchedulerImpl(const std::string& name)
-    : name_(name), service_thread_("TaskSchedulerServiceThread") {}
+    : name_(name),
+      service_thread_("TaskSchedulerServiceThread"),
+      single_thread_task_runner_manager_(&task_tracker_,
+                                         &delayed_task_manager_) {}
 
 void TaskSchedulerImpl::Initialize(
     const TaskScheduler::InitParams& init_params) {
   // Start the service thread. On platforms that support it (POSIX except NaCL
   // SFI), the service thread runs a MessageLoopForIO which is used to support
   // FileDescriptorWatcher in the scope in which tasks run.
   Thread::Options service_thread_options;
   service_thread_options.message_loop_type =
 #if defined(OS_POSIX) && !defined(OS_NACL_SFI)
       MessageLoop::TYPE_IO;
 #else
       MessageLoop::TYPE_DEFAULT;
 #endif
   service_thread_options.timer_slack = TIMER_SLACK_MAXIMUM;
   CHECK(service_thread_.StartWithOptions(service_thread_options));
 
 #if defined(OS_POSIX) && !defined(OS_NACL_SFI)
   // Needs to happen after starting the service thread to get its
   // message_loop().
   task_tracker_.set_watch_file_descriptor_message_loop(
       static_cast<MessageLoopForIO*>(service_thread_.message_loop()));
 #endif
 
   // Needs to happen after starting the service thread to get its task_runner().
-  delayed_task_manager_ =
-      base::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());
-  single_thread_task_runner_manager_->Start();
+  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[] = {
       &init_params.background_worker_pool_params,
@@ skipping 12 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_,
-        delayed_task_manager_.get());
+        re_enqueue_sequence_callback, &task_tracker_, &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