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

base/task_scheduler/task_scheduler_impl.cc

 // Copyright 2016 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/task_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/scheduler_single_thread_task_runner_manager.h"
 #include "base/task_scheduler/scheduler_worker_pool_params.h"
 #include "base/task_scheduler/sequence_sort_key.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
 #include "build/build_config.h"
 
 #if defined(OS_POSIX) && !defined(OS_NACL_SFI)
 #include "base/task_scheduler/task_tracker_posix.h"
 #endif
 
 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;
 }
 
 TaskSchedulerImpl::~TaskSchedulerImpl() {
 #if DCHECK_IS_ON()
   DCHECK(join_for_testing_returned_.IsSet());
 #endif
 }
 
 void TaskSchedulerImpl::PostDelayedTaskWithTraits(
@@ skipping 15 matching lines @@
 scoped_refptr<SequencedTaskRunner>
 TaskSchedulerImpl::CreateSequencedTaskRunnerWithTraits(
     const TaskTraits& traits) {
   return GetWorkerPoolForTraits(traits)->CreateSequencedTaskRunnerWithTraits(
       traits);
 }
 
 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 {
   std::vector<const HistogramBase*> histograms;
   for (const auto& worker_pool : worker_pools_)
     worker_pool->GetHistograms(&histograms);
 
   return histograms;
 }
 
@@ skipping 21 matching lines @@
   for (const auto& worker_pool : worker_pools_)
     worker_pool->DisallowWorkerDetachmentForTesting();
   for (const auto& worker_pool : worker_pools_)
     worker_pool->JoinForTesting();
   service_thread_.Stop();
 #if DCHECK_IS_ON()
   join_for_testing_returned_.Set();
 #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.
   Thread::Options service_thread_options;
   service_thread_options.message_loop_type =
 #if defined(OS_POSIX) && !defined(OS_NACL_SFI)
       MessageLoop::TYPE_IO;
 #else
       MessageLoop::TYPE_DEFAULT;
 #endif
@@ skipping 10 matching lines @@
       base::MakeUnique<TaskTracker>();
 #endif
 
   // Instantiate DelayedTaskManager. Needs to happen after starting the service
   // thread to get its task_runner().
   delayed_task_manager_ =
       base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
 
   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
   // PriorityQueue.
   const SchedulerWorkerPoolImpl::ReEnqueueSequenceCallback
       re_enqueue_sequence_callback =
           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(
     scoped_refptr<Sequence> sequence) {
   DCHECK(sequence);
 
   const SequenceSortKey sort_key = sequence->GetSortKey();
 
   // The next task in |sequence| should run in a worker pool suited for its
   // traits, except for the priority which is adjusted to the highest priority
   // in |sequence|.
   const TaskTraits traits =
       sequence->PeekTaskTraits().WithPriority(sort_key.priority());
 
   GetWorkerPoolForTraits(traits)->ReEnqueueSequence(std::move(sequence),
                                                     sort_key);
 }
 
 }  // namespace internal
 }  // namespace base