[reference - do not submit] Always create four pools in TaskSchedulerImpl.

base/task_scheduler/task_scheduler_impl.cc

Index: base/task_scheduler/task_scheduler_impl.cc
diff --git a/base/task_scheduler/task_scheduler_impl.cc b/base/task_scheduler/task_scheduler_impl.cc
index e5c8abf716306f8602b0cde8786e10dc292f1739..a82877cb7cd82e234776217bf16d605fed58a755 100644
--- a/base/task_scheduler/task_scheduler_impl.cc
+++ b/base/task_scheduler/task_scheduler_impl.cc
@@ -24,14 +24,56 @@
 namespace base {
 namespace internal {
 
+namespace {
+
+enum EnvironmentType {
+  BACKGROUND = 0,
+  BACKGROUND_BLOCKING,
+  FOREGROUND,
+  FOREGROUND_BLOCKING,
+  ENVIRONMENT_COUNT  // Always last.
+};
+
+// Order must match the EnvironmentType enum.
+constexpr struct {
+  // The threads and histograms of this environment will be labeled with
+  // task scheduler name + |name_suffix|.
+  const char* name_suffix;
+
+  // Preferred priority for threads in this environment; the actual thread
+  // priority depends on shutdown state and platform capabilities.
+  ThreadPriority priority_hint;
+
+  // Offset of the SchedulerWorkerPoolParams corresponding to this environement
+  // in TaskSchedulerInitParams.
+  size_t offset;
+} kEnvironmentParams[] = {
+    {"Background", base::ThreadPriority::BACKGROUND,
+     offsetof(TaskSchedulerInitParams, background_worker_pool_params)},
+    {"BackgroundBlocking", base::ThreadPriority::BACKGROUND,
+     offsetof(TaskSchedulerInitParams, background_blocking_worker_pool_params)},
+    {"Foreground", base::ThreadPriority::NORMAL,
+     offsetof(TaskSchedulerInitParams, foreground_worker_pool_params)},
+    {"ForegroundBlocking", base::ThreadPriority::NORMAL,
+     offsetof(TaskSchedulerInitParams, foreground_blocking_worker_pool_params)},
+};
+
+size_t GetEnvironmentIndexForTraits(const TaskTraits& traits) {
+  const bool is_background =
+      traits.priority() == base::TaskPriority::BACKGROUND;
+  if (traits.may_block() || traits.with_base_sync_primitives())
+    return is_background ? BACKGROUND_BLOCKING : FOREGROUND_BLOCKING;
+  return is_background ? BACKGROUND : FOREGROUND;
+}
+
+}  // namespace
+
 // static
 std::unique_ptr<TaskSchedulerImpl> TaskSchedulerImpl::Create(
-    const std::vector<SchedulerWorkerPoolParams>& worker_pool_params_vector,
-    const WorkerPoolIndexForTraitsCallback&
-        worker_pool_index_for_traits_callback) {
-  std::unique_ptr<TaskSchedulerImpl> scheduler(
-      new TaskSchedulerImpl(worker_pool_index_for_traits_callback));
-  scheduler->Initialize(worker_pool_params_vector);
+    const std::string& name,
+    const TaskSchedulerInitParams& init_params) {
+  std::unique_ptr<TaskSchedulerImpl> scheduler(new TaskSchedulerImpl(name));
+  scheduler->Initialize(init_params);
   return scheduler;
 }
 
@@ -67,8 +109,11 @@ TaskSchedulerImpl::CreateSequencedTaskRunnerWithTraits(
 scoped_refptr<SingleThreadTaskRunner>
 TaskSchedulerImpl::CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits) {
+  const auto& environment =
+      kEnvironmentParams[GetEnvironmentIndexForTraits(traits)];
   return single_thread_task_runner_manager_
-      ->CreateSingleThreadTaskRunnerWithTraits(traits);
+      ->CreateSingleThreadTaskRunnerWithTraits(
+          name_ + environment.name_suffix, environment.priority_hint, traits);
 }
 
 std::vector<const HistogramBase*> TaskSchedulerImpl::GetHistograms() const {
@@ -110,18 +155,22 @@ void TaskSchedulerImpl::JoinForTesting() {
 #endif
 }
 
-TaskSchedulerImpl::TaskSchedulerImpl(const WorkerPoolIndexForTraitsCallback&
-                                         worker_pool_index_for_traits_callback)
-    : service_thread_("TaskSchedulerServiceThread"),
-      worker_pool_index_for_traits_callback_(
-          worker_pool_index_for_traits_callback) {
-  DCHECK(!worker_pool_index_for_traits_callback_.is_null());
+TaskSchedulerImpl::TaskSchedulerImpl(const std::string& name)
+    : name_(name), service_thread_("TaskSchedulerServiceThread") {
+  static_assert(
+      sizeof(TaskSchedulerInitParams) / sizeof(SchedulerWorkerPoolParams) ==
+          ENVIRONMENT_COUNT,
+      "There must be the same number of elements in "
+      "TaskSchedulerInitParams and EnvironmentType.");
+  static_assert(arraysize(kEnvironmentParams) == ENVIRONMENT_COUNT,
+                "There must be the same number of elements in "
+                "|kEnvironmentParams| and EnvironmentType.");
+  static_assert(arraysize(worker_pools_) == ENVIRONMENT_COUNT,
+                "There must be the same number of elements in |worker_pools_| "
+                "and EnvironmentType.");
 }
 
-void TaskSchedulerImpl::Initialize(
-    const std::vector<SchedulerWorkerPoolParams>& worker_pool_params_vector) {
-  DCHECK(!worker_pool_params_vector.empty());
-
+void TaskSchedulerImpl::Initialize(const TaskSchedulerInitParams& init_params) {
   // Start the service thread. On platforms that support it (POSIX except NaCL
   // SFI), the service thread runs a MessageLoopForIO which is used to support
   // FileDescriptorWatcher in the scope in which tasks run.
@@ -152,7 +201,6 @@ void TaskSchedulerImpl::Initialize(
 
   single_thread_task_runner_manager_ =
       MakeUnique<SchedulerSingleThreadTaskRunnerManager>(
-          worker_pool_params_vector, worker_pool_index_for_traits_callback_,
           task_tracker_.get(), delayed_task_manager_.get());
 
   // Callback invoked by workers to re-enqueue a sequence in the appropriate
@@ -162,22 +210,25 @@ void TaskSchedulerImpl::Initialize(
           Bind(&TaskSchedulerImpl::ReEnqueueSequenceCallback, Unretained(this));
 
   // Start worker pools.
-  for (const auto& worker_pool_params : worker_pool_params_vector) {
+  for (size_t index = 0; index < ENVIRONMENT_COUNT; ++index) {
     // Passing pointers to objects owned by |this| to
     // SchedulerWorkerPoolImpl::Create() is safe because a TaskSchedulerImpl
     // can't be deleted before all its worker pools have been joined.
-    worker_pools_.push_back(SchedulerWorkerPoolImpl::Create(
-        worker_pool_params, re_enqueue_sequence_callback, task_tracker_.get(),
-        delayed_task_manager_.get()));
-    CHECK(worker_pools_.back());
+    worker_pools_[index] = SchedulerWorkerPoolImpl::Create(
+        name_ + kEnvironmentParams[index].name_suffix,
+        kEnvironmentParams[index].priority_hint,
+        *reinterpret_cast<const SchedulerWorkerPoolParams*>(
+            reinterpret_cast<const char*>(&init_params) +
+            kEnvironmentParams[index].offset),
+        re_enqueue_sequence_callback, task_tracker_.get(),
+        delayed_task_manager_.get());
+    CHECK(worker_pools_[index]);
   }
 }
 
 SchedulerWorkerPoolImpl* TaskSchedulerImpl::GetWorkerPoolForTraits(
     const TaskTraits& traits) const {
-  const size_t index = worker_pool_index_for_traits_callback_.Run(traits);
-  DCHECK_LT(index, worker_pools_.size());
-  return worker_pools_[index].get();
+  return worker_pools_[GetEnvironmentIndexForTraits(traits)].get();
 }
 
 void TaskSchedulerImpl::ReEnqueueSequenceCallback(