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

base/task_scheduler/scheduler_single_thread_task_runner_manager.h

 // 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.
 
 #ifndef BASE_TASK_SCHEDULER_SCHEDULER_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
 #define BASE_TASK_SCHEDULER_SCHEDULER_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 22 matching lines @@
 
 namespace {
 
 class SchedulerWorkerDelegate;
 
 }  // namespace
 
 // 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.
 //
 // This class is thread-safe.
 class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
  public:
   SchedulerSingleThreadTaskRunnerManager(
       TaskTracker* task_tracker,
       DelayedTaskManager* delayed_task_manager);
   ~SchedulerSingleThreadTaskRunnerManager();
 
   // Starts threads for existing SingleThreadTaskRunners and allows threads to
   // be started when SingleThreadTaskRunners are created in the future.
   void Start();
 
   // 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,
       SingleThreadTaskRunnerThreadMode thread_mode);
 
 #if defined(OS_WIN)
   // 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,
       SingleThreadTaskRunnerThreadMode thread_mode);
 #endif  // defined(OS_WIN)
 
   void JoinForTesting();
 
  private:
   class SchedulerSingleThreadTaskRunner;
@@ skipping 26 matching lines @@
 
 #if DCHECK_IS_ON()
   subtle::Atomic32 workers_unregistered_during_join_ = 0;
 #endif
 
   // Synchronizes access to all members below.
   SchedulerLock lock_;
   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.
   bool started_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerSingleThreadTaskRunnerManager);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_