Initialize TaskScheduler with InitParams in service_process.cc.

chrome/service/service_process.cc

 // Copyright (c) 2012 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 "chrome/service/service_process.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 145 matching lines @@
   io_thread_.reset(new ServiceIOThread("ServiceProcess_IO"));
   file_thread_.reset(new base::Thread("ServiceProcess_File"));
   if (!io_thread_->StartWithOptions(options) ||
       !file_thread_->StartWithOptions(options)) {
     NOTREACHED();
     Teardown();
     return false;
   }
 
   // Initialize TaskScheduler and redirect SequencedWorkerPool tasks to it.
-  constexpr int kMaxTaskSchedulerThreads = 3;
-  std::vector<base::SchedulerWorkerPoolParams> worker_pool_params_vector;
-  worker_pool_params_vector.emplace_back(
-      "CloudPrintServiceProcess", base::ThreadPriority::NORMAL,
-      base::SchedulerWorkerPoolParams::StandbyThreadPolicy::LAZY,
-      kMaxTaskSchedulerThreads, base::TimeDelta::FromSeconds(30),
-      base::SchedulerBackwardCompatibility::INIT_COM_STA);
+  using StandbyThreadPolicy =
+      base::SchedulerWorkerPoolParams::StandbyThreadPolicy;
+  constexpr int kMaxBackgroundThreads = 1;
+  constexpr int kMaxBackgroundBlockingThreads = 1;
+  constexpr int kMaxForegroundThreads = 3;
+  constexpr int kMaxForegroundBlockingThreads = 3;
+  constexpr base::TimeDelta kSuggestedReclaimTime =
+      base::TimeDelta::FromSeconds(30);
+
   base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
-      worker_pool_params_vector,
-      base::Bind([](const base::TaskTraits&) -> size_t { return 0; }));
+      "CloudPrintServiceProcess",
+      {{StandbyThreadPolicy::LAZY, kMaxBackgroundThreads,
+        kSuggestedReclaimTime},
+       {StandbyThreadPolicy::LAZY, kMaxBackgroundBlockingThreads,
+        kSuggestedReclaimTime},
+       {StandbyThreadPolicy::LAZY, kMaxForegroundThreads,
+        kSuggestedReclaimTime},
+       {StandbyThreadPolicy::LAZY, kMaxForegroundBlockingThreads,
+        kSuggestedReclaimTime,
+        base::SchedulerBackwardCompatibility::INIT_COM_STA}});
+
   base::SequencedWorkerPool::EnableWithRedirectionToTaskSchedulerForProcess();
 
+  // Since SequencedWorkerPool is redirected to TaskScheduler, the value of
+  // |kMaxBlockingPoolThreads| is ignored.
+  constexpr int kMaxBlockingPoolThreads = 3;
   blocking_pool_ =
-      new base::SequencedWorkerPool(kMaxTaskSchedulerThreads, "ServiceBlocking",
+      new base::SequencedWorkerPool(kMaxBlockingPoolThreads, "ServiceBlocking",
                                     base::TaskPriority::USER_VISIBLE);
 
   // Initialize Mojo early so things can use it.
   mojo::edk::Init();
   mojo_ipc_support_.reset(new mojo::edk::ScopedIPCSupport(
       io_thread_->task_runner(),
       mojo::edk::ScopedIPCSupport::ShutdownPolicy::FAST));
 
   request_context_getter_ = new ServiceURLRequestContextGetter();
 
@@ skipping 245 matching lines @@
     } else {
       Shutdown();
     }
   }
 }
 
 ServiceProcess::~ServiceProcess() {
   Teardown();
   g_service_process = NULL;
 }