Separate the create and start phases in SchedulerSingleThreadTaskRunnerManager.

base/task_scheduler/scheduler_single_thread_task_runner_manager.cc

Index: base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
diff --git a/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc b/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
index d4c26d6a404e04110ed0c38b35dbe7d798024208..e2ff1ef1058a49e61724b2bfdd211a1f7a7a1564 100644
--- a/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
+++ b/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
@@ -340,6 +340,22 @@ SchedulerSingleThreadTaskRunnerManager::
 #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) {
@@ -359,7 +375,7 @@ SchedulerSingleThreadTaskRunnerManager::CreateCOMSTATaskRunnerWithTraits(
 void SchedulerSingleThreadTaskRunnerManager::JoinForTesting() {
   decltype(workers_) local_workers;
   {
-    AutoSchedulerLock auto_lock(workers_lock_);
+    AutoSchedulerLock auto_lock(lock_);
     local_workers = std::move(workers_);
   }
 
@@ -367,7 +383,7 @@ void SchedulerSingleThreadTaskRunnerManager::JoinForTesting() {
     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);
@@ -410,23 +426,33 @@ template <typename DelegateType>
 SchedulerWorker*
 SchedulerSingleThreadTaskRunnerManager::CreateAndRegisterSchedulerWorker(
     const SchedulerWorkerPoolParams& params) {
-  AutoSchedulerLock auto_lock(workers_lock_);
-  int id = next_worker_id_++;
-
-  workers_.emplace_back(SchedulerWorker::Create(
-      params.priority_hint(),
-      CreateSchedulerWorkerDelegate<DelegateType>(params, id), task_tracker_,
-      SchedulerWorker::InitialState::DETACHED));
-  return workers_.back().get();
+  SchedulerWorker* worker;
+  bool start_worker;
+
+  {
+    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.