Add TaskScheduler::InitParams and accept it in TaskSchedulerImpl constructor.

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
+  // the task scheduler name concatenated to this.
+  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;
+} kEnvironmentParams[] = {
+    {"Background", base::ThreadPriority::BACKGROUND},
+    {"BackgroundBlocking", base::ThreadPriority::BACKGROUND},
+    {"Foreground", base::ThreadPriority::NORMAL},
+    {"ForegroundBlocking", base::ThreadPriority::NORMAL},
+};
+
+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;
+}
+
+void AddAugmentedSchedulerWorkerPoolParamsToVector(
+    EnvironmentType environment_type,
+    const std::string& task_scheduler_name,
+    const SchedulerWorkerPoolParams& params,
+    std::vector<SchedulerWorkerPoolParams>*
+        scheduler_worker_pool_params_vector) {
+  DCHECK_EQ(static_cast<size_t>(environment_type),
+            scheduler_worker_pool_params_vector->size());
+  scheduler_worker_pool_params_vector->emplace_back(
+      task_scheduler_name + kEnvironmentParams[environment_type].name_suffix,
+      kEnvironmentParams[environment_type].priority_hint,
+      params.standby_thread_policy(), params.max_threads(),
+      params.suggested_reclaim_time(), params.backward_compatibility());
+}
+
+}  // 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);
   return scheduler;
 }
 
+// static
+std::unique_ptr<TaskSchedulerImpl> TaskSchedulerImpl::Create(
+    const std::string& name,
+    const TaskScheduler::InitParams& init_params) {
+  // Create a vector of SchedulerWorkerPoolParams using names and priority hints
+  // derived from |kEnvironmentParams| and other params from |init_params|.
+  std::vector<SchedulerWorkerPoolParams> worker_pool_params_vector;
+  AddAugmentedSchedulerWorkerPoolParamsToVector(
+      BACKGROUND, name, init_params.background_worker_pool_params,
+      &worker_pool_params_vector);
+  AddAugmentedSchedulerWorkerPoolParamsToVector(
+      BACKGROUND_BLOCKING, name,
+      init_params.background_blocking_worker_pool_params,
+      &worker_pool_params_vector);
+  AddAugmentedSchedulerWorkerPoolParamsToVector(
+      FOREGROUND, name, init_params.foreground_worker_pool_params,
+      &worker_pool_params_vector);
+  AddAugmentedSchedulerWorkerPoolParamsToVector(
+      FOREGROUND_BLOCKING, name,
+      init_params.foreground_blocking_worker_pool_params,
+      &worker_pool_params_vector);
+  DCHECK_EQ(static_cast<size_t>(ENVIRONMENT_COUNT),
+            worker_pool_params_vector.size());
+
+  return Create(worker_pool_params_vector, Bind(&GetEnvironmentIndexForTraits));
+}
+
 TaskSchedulerImpl::~TaskSchedulerImpl() {
 #if DCHECK_IS_ON()
   DCHECK(join_for_testing_returned_.IsSet());
 #endif
 }
 
 void TaskSchedulerImpl::PostDelayedTaskWithTraits(
     const tracked_objects::Location& from_here,
     const TaskTraits& traits,
     const Closure& task,
@@ skipping 143 matching lines @@
   // in |sequence|.
   const TaskTraits traits =
       sequence->PeekTaskTraits().WithPriority(sort_key.priority());
 
   GetWorkerPoolForTraits(traits)->ReEnqueueSequence(std::move(sequence),
                                                     sort_key);
 }
 
 }  // namespace internal
 }  // namespace base