Followup to https://codereview.chromium.org/2902753003/

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 312 matching lines @@
   const TaskTraits traits_;
   SchedulerWorker* const worker_;
   const SingleThreadTaskRunnerThreadMode thread_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerSingleThreadTaskRunner);
 };
 
 SchedulerSingleThreadTaskRunnerManager::SchedulerSingleThreadTaskRunnerManager(
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
-    : task_tracker_(task_tracker),
-      delayed_task_manager_(delayed_task_manager),
-      shared_scheduler_workers_ {}
-#if defined(OS_WIN)
-      ,
-      shared_com_scheduler_workers_ {}
-#endif  // defined(OS_WIN)
-{
+    : task_tracker_(task_tracker), delayed_task_manager_(delayed_task_manager) {
   DCHECK(task_tracker_);
   DCHECK(delayed_task_manager_);
-  static_assert(
-      arraysize(shared_scheduler_workers_) == ENVIRONMENT_COUNT,
-      "The size of |shared_scheduler_workers_| must match ENVIRONMENT_COUNT");
 #if defined(OS_WIN)
   static_assert(arraysize(shared_com_scheduler_workers_) ==
                     arraysize(shared_scheduler_workers_),
                 "The size of |shared_com_scheduler_workers_| must match "
                 "|shared_scheduler_workers_|");
 #endif  // defined(OS_WIN)
 }
 
 SchedulerSingleThreadTaskRunnerManager::
     ~SchedulerSingleThreadTaskRunnerManager() {
@@ skipping 64 matching lines @@
 template <typename DelegateType>
 scoped_refptr<
     SchedulerSingleThreadTaskRunnerManager::SchedulerSingleThreadTaskRunner>
 SchedulerSingleThreadTaskRunnerManager::CreateTaskRunnerWithTraitsImpl(
     const std::string& name,
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
   DCHECK(thread_mode != SingleThreadTaskRunnerThreadMode::SHARED ||
          !traits.with_base_sync_primitives())
       << "Using WithBaseSyncPrimitives() on a shared SingleThreadTaskRunner "
-         "may cause deadlocks. Either reevaluate your usage pattern or use "
+         "may cause deadlocks. Either reevaluate your usage (e.g. use "
+         "SequencedTaskRunner) or use "
          "SingleThreadTaskRunnerThreadMode::DEDICATED.";
   // To simplify the code, |dedicated_worker| is a local only variable that
   // allows the code to treat both the DEDICATED and SHARED cases similarly for
   // SingleThreadTaskRunnerThreadMode. In DEDICATED, the scoped_refptr is backed
   // by a local variable and in SHARED, the scoped_refptr is backed by a member
   // variable.
   SchedulerWorker* dedicated_worker = nullptr;
   SchedulerWorker*& worker =
       thread_mode == SingleThreadTaskRunnerThreadMode::DEDICATED
           ? dedicated_worker
@@ skipping 12 matching lines @@
       worker = CreateAndRegisterSchedulerWorker<DelegateType>(
           processed_name, environment_params.priority_hint);
       new_worker = true;
     }
     started = started_;
   }
 
   if (new_worker && started)
     worker->Start();
 
-  return new SchedulerSingleThreadTaskRunner(this, traits, worker, thread_mode);
+  return MakeRefCounted<SchedulerSingleThreadTaskRunner>(this, traits, worker,
+                                                         thread_mode);
 }
 
 void SchedulerSingleThreadTaskRunnerManager::JoinForTesting() {
   ReleaseSharedSchedulerWorkers();
 
   decltype(workers_) local_workers;
   {
     AutoSchedulerLock auto_lock(lock_);
     local_workers = std::move(workers_);
   }
@@ skipping 88 matching lines @@
 
 void SchedulerSingleThreadTaskRunnerManager::ReleaseSharedSchedulerWorkers() {
   decltype(shared_scheduler_workers_) local_shared_scheduler_workers;
 #if defined(OS_WIN)
   decltype(shared_com_scheduler_workers_) local_shared_com_scheduler_workers;
 #endif
   {
     AutoSchedulerLock auto_lock(lock_);
     for (size_t i = 0; i < arraysize(shared_scheduler_workers_); ++i) {
       local_shared_scheduler_workers[i] = shared_scheduler_workers_[i];
+      shared_scheduler_workers_[i] = nullptr;
 #if defined(OS_WIN)
       local_shared_com_scheduler_workers[i] = shared_com_scheduler_workers_[i];
+      shared_com_scheduler_workers_[i] = nullptr;
 #endif
     }
   }
 
   for (size_t i = 0; i < arraysize(local_shared_scheduler_workers); ++i) {
     if (local_shared_scheduler_workers[i])
       UnregisterSchedulerWorker(local_shared_scheduler_workers[i]);
 #if defined(OS_WIN)
     if (local_shared_com_scheduler_workers[i])
       UnregisterSchedulerWorker(local_shared_com_scheduler_workers[i]);
 #endif
   }
 }
 
 }  // namespace internal
 }  // namespace base