Redirect SequencedWorkerPool to TaskScheduler in the service process.

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 "base/base_switches.h"
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/task_scheduler/scheduler_worker_pool_params.h"
+#include "base/task_scheduler/task_scheduler.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
@@ skipping 114 matching lines @@
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   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;
   }
   blocking_pool_ = new base::SequencedWorkerPool(

[robliao, 2016/11/15 18:43:57]

Should this happen after TaskScheduler Initialization?

[fdoray, 2016/11/15 21:37:13]

Done.

       3, "ServiceBlocking", base::TaskPriority::USER_VISIBLE);
 
+  // Initialize TaskScheduler and redirect SequencedWorkerPool tasks to it.
+  constexpr int kMaxTaskSchedulerThreads = 3;
+  constexpr base::TimeDelta kTaskSchedulerReclaimTime =
+      base::TimeDelta::FromSeconds(15);

[robliao, 2016/11/15 18:43:57]

Any harm in not using the standard 30 we currently use in other places?

[fdoray, 2016/11/15 21:37:13]

Done. I thought that since the service process doesn't have to be as responsive
as the browser, it could be a good idea to reduce its resource utilization by
using a smaller reclaim time. But there was nothing scientific about that.

+  std::vector<base::SchedulerWorkerPoolParams> worker_pool_params_vector;
+  worker_pool_params_vector.emplace_back(
+      "Service", base::ThreadPriority::NORMAL,
+      base::SchedulerWorkerPoolParams::IORestriction::ALLOWED,
+      kMaxTaskSchedulerThreads, kTaskSchedulerReclaimTime);
+  base::TaskScheduler::CreateAndSetDefaultTaskScheduler(
+      worker_pool_params_vector, base::Bind([](const base::TaskTraits&) {
+        // All TaskTraits are mapped to the single TaskScheduler pool in this
+        // process.
+        return static_cast<size_t>(0);
+      }));
+  base::SequencedWorkerPool::RedirectToTaskSchedulerForProcess();
+
   // Initialize Mojo early so things can use it.
   mojo::edk::Init();
   mojo_ipc_support_.reset(
       new mojo::edk::ScopedIPCSupport(io_thread_->task_runner()));
 
   request_context_getter_ = new ServiceURLRequestContextGetter();
 
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   base::FilePath pref_path =
@@ skipping 73 matching lines @@
   if (blocking_pool_.get()) {
     // The goal is to make it impossible for chrome to 'infinite loop' during
     // shutdown, but to reasonably expect that all BLOCKING_SHUTDOWN tasks
     // queued during shutdown get run. There's nothing particularly scientific
     // about the number chosen.
     const int kMaxNewShutdownBlockingTasks = 1000;
     blocking_pool_->Shutdown(kMaxNewShutdownBlockingTasks);
     blocking_pool_ = NULL;
   }
 
+  base::TaskScheduler::GetInstance()->Shutdown();
+
   // The NetworkChangeNotifier must be destroyed after all other threads that
   // might use it have been shut down.
   network_change_notifier_.reset();
 
   service_process_state_->SignalStopped();
   return true;
 }
 
 // This method is called when a shutdown command is received from IPC channel
 // or there was an error in the IPC channel.
@@ skipping 142 matching lines @@
     } else {
       Shutdown();
     }
   }
 }
 
 ServiceProcess::~ServiceProcess() {
   Teardown();
   g_service_process = NULL;
 }