Separate the create and start phases in SchedulerSingleThreadTaskRunnerManager.

base/task_scheduler/scheduler_single_thread_task_runner_manager.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 <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 322 matching lines @@
     ~SchedulerSingleThreadTaskRunnerManager() {
 #if DCHECK_IS_ON()
   size_t workers_unregistered_during_join =
       subtle::NoBarrier_Load(&workers_unregistered_during_join_);
   DCHECK_EQ(workers_unregistered_during_join, workers_.size())
       << "There cannot be outstanding SingleThreadTaskRunners upon destruction "
          "of SchedulerSingleThreadTaskRunnerManager or the Task Scheduler";
 #endif
 }
 
+void SchedulerSingleThreadTaskRunnerManager::Start() {
+  decltype(workers_) workers_to_start;
+  {
+    AutoSchedulerLock auto_lock(lock_);
+    started_ = true;
+    workers_to_start = workers_;
+  }
+
+  // Start workers that were created before this method was called. Other
+  // workers are started as they are created.
+  for (scoped_refptr<SchedulerWorker> worker : workers_to_start) {
+    worker->Start();
+    worker->WakeUp();
+  }
+}
+
 scoped_refptr<SingleThreadTaskRunner>
 SchedulerSingleThreadTaskRunnerManager::CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits) {
   return CreateSingleThreadTaskRunnerWithDelegate<SchedulerWorkerDelegate>(
       traits);
 }
 
 #if defined(OS_WIN)
 scoped_refptr<SingleThreadTaskRunner>
 SchedulerSingleThreadTaskRunnerManager::CreateCOMSTATaskRunnerWithTraits(
     const TaskTraits& traits) {
   return CreateSingleThreadTaskRunnerWithDelegate<SchedulerWorkerCOMDelegate>(
       traits);
 }
 #endif  // defined(OS_WIN)
 
 void SchedulerSingleThreadTaskRunnerManager::JoinForTesting() {
   decltype(workers_) local_workers;
   {
-    AutoSchedulerLock auto_lock(workers_lock_);
+    AutoSchedulerLock auto_lock(lock_);
     local_workers = std::move(workers_);
   }
 
   for (const auto& worker : local_workers)
     worker->JoinForTesting();
 
   {
-    AutoSchedulerLock auto_lock(workers_lock_);
+    AutoSchedulerLock auto_lock(lock_);
     DCHECK(workers_.empty())
         << "New worker(s) unexpectedly registered during join.";
     workers_ = std::move(local_workers);
   }
 }
 
 template <typename DelegateType>
 scoped_refptr<SingleThreadTaskRunner> SchedulerSingleThreadTaskRunnerManager::
     CreateSingleThreadTaskRunnerWithDelegate(const TaskTraits& traits) {
   size_t index = worker_pool_index_for_traits_callback_.Run(traits);
@@ skipping 22 matching lines @@
       StringPrintf("TaskSchedulerSingleThreadWorker%d%sCOMSTA", id,
                    params.name().c_str()),
       task_tracker_);
 }
 #endif  // defined(OS_WIN)
 
 template <typename DelegateType>
 SchedulerWorker*
 SchedulerSingleThreadTaskRunnerManager::CreateAndRegisterSchedulerWorker(
     const SchedulerWorkerPoolParams& params) {
-  AutoSchedulerLock auto_lock(workers_lock_);
-  int id = next_worker_id_++;
+  SchedulerWorker* worker;
+  bool start_worker;
 
-  workers_.emplace_back(SchedulerWorker::Create(
-      params.priority_hint(),
-      CreateSchedulerWorkerDelegate<DelegateType>(params, id), task_tracker_,
-      SchedulerWorker::InitialState::DETACHED));
-  return workers_.back().get();
+  {
+    AutoSchedulerLock auto_lock(lock_);
+    int id = next_worker_id_++;
+    workers_.emplace_back(make_scoped_refptr(new SchedulerWorker(
+        params.priority_hint(),
+        CreateSchedulerWorkerDelegate<DelegateType>(params, id),
+        task_tracker_)));
+    worker = workers_.back().get();
+    start_worker = started_;
+  }
+
+  if (start_worker)
+    worker->Start();
+
+  return worker;
 }
 
 void SchedulerSingleThreadTaskRunnerManager::UnregisterSchedulerWorker(
     SchedulerWorker* worker) {
   // Cleanup uses a SchedulerLock, so call Cleanup() after releasing
-  // |workers_lock_|.
+  // |lock_|.
   scoped_refptr<SchedulerWorker> worker_to_destroy;
   {
-    AutoSchedulerLock auto_lock(workers_lock_);
+    AutoSchedulerLock auto_lock(lock_);
 
     // We might be joining, so record that a worker was unregistered for
     // verification at destruction.
     if (workers_.empty()) {
 #if DCHECK_IS_ON()
       subtle::NoBarrier_AtomicIncrement(&workers_unregistered_during_join_, 1);
 #endif
       return;
     }
 
     auto worker_iter =
         std::find_if(workers_.begin(), workers_.end(),
                      [worker](const scoped_refptr<SchedulerWorker>& candidate) {
                        return candidate.get() == worker;
                      });
     DCHECK(worker_iter != workers_.end());
     worker_to_destroy = std::move(*worker_iter);
     workers_.erase(worker_iter);
   }
   worker_to_destroy->Cleanup();
 }
 
 }  // namespace internal
 }  // namespace base