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

BUG=720058

Review-Url: https://codereview.chromium.org/2917433002
Cr-Commit-Position: refs/heads/master@{#475804}

base/task_scheduler/environment_config.h

@@ -7,6 +7,7 @@
 
 #include <stddef.h>
 
+#include "base/base_export.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread.h"
 

base/task_scheduler/scheduler_single_thread_task_runner_manager.cc

@@ -330,19 +330,9 @@ class SchedulerSingleThreadTaskRunnerManager::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_),
@@ -427,7 +417,8 @@ SchedulerSingleThreadTaskRunnerManager::CreateTaskRunnerWithTraitsImpl(
   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
@@ -460,7 +451,8 @@ SchedulerSingleThreadTaskRunnerManager::CreateTaskRunnerWithTraitsImpl(
   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() {
@@ -569,8 +561,10 @@ void SchedulerSingleThreadTaskRunnerManager::ReleaseSharedSchedulerWorkers() {
     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
     }
   }

base/task_scheduler/scheduler_single_thread_task_runner_manager.h

@@ -40,9 +40,10 @@ class SchedulerWorkerDelegate;
 // Manages a pool of threads which are each associated with one or more
 // SingleThreadTaskRunners.
 //
-// SingleThreadTaskRunners using SingleThreadTaskRunnerThreadMode::SHARED, are
+// SingleThreadTaskRunners using SingleThreadTaskRunnerThreadMode::SHARED are
 // backed by shared SchedulerWorkers for each COM+task environment combination.
-// These workers are only reclaimed during JoinForTesting().
+// These workers are lazily instantiated and then only reclaimed during
+// JoinForTesting()
 //
 // No threads are created (and hence no tasks can run) before Start() is called.
 //
@@ -61,9 +62,7 @@ class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
   // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a thread
   // named "TaskSchedulerSingleThread[Shared]" + |name| +
   // kEnvironmentParams[GetEnvironmentIndexForTraits(traits)].name_suffix +
-  // index. "Shared" will be in the thread name when |thread_mode| is SHARED. If
-  // |thread_mode| is DEDICATED, a thread will be dedicated to the returned task
-  // runner, otherwise it could be shared with other SingleThreadTaskRunners.
+  // index.
   scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
       const std::string& name,
       const TaskTraits& traits,
@@ -73,9 +72,7 @@ class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
   // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a COM
   // STA thread named "TaskSchedulerSingleThreadCOMSTA[Shared]" + |name| +
   // kEnvironmentParams[GetEnvironmentIndexForTraits(traits)].name_suffix +
-  // index. "Shared" will be in the thread name when |thread_mode| is SHARED. If
-  // |thread_mode| is DEDICATED, a thread will be dedicated to the returned task
-  // runner, otherwise it could be shared with other SingleThreadTaskRunners.
+  // index.
   scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
       const std::string& name,
       const TaskTraits& traits,
@@ -122,10 +119,10 @@ class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
   std::vector<scoped_refptr<SchedulerWorker>> workers_;
   int next_worker_id_ = 0;
 
-  SchedulerWorker* shared_scheduler_workers_[4];
+  SchedulerWorker* shared_scheduler_workers_[ENVIRONMENT_COUNT] = {};
 
 #if defined(OS_WIN)
-  SchedulerWorker* shared_com_scheduler_workers_[4];
+  SchedulerWorker* shared_com_scheduler_workers_[ENVIRONMENT_COUNT] = {};
 #endif  // defined(OS_WIN)
 
   // Set to true when Start() is called.