Move Task Scheduler Single Thread Task Runners to Dedicated Threads

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_worker_pool_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
 
@@ skipping 36 matching lines @@
 scoped_refptr<SequencedTaskRunner>
 TaskSchedulerImpl::CreateSequencedTaskRunnerWithTraits(
     const TaskTraits& traits) {
   return GetWorkerPoolForTraits(traits)->CreateSequencedTaskRunnerWithTraits(
       traits);
 }
 
 scoped_refptr<SingleThreadTaskRunner>
 TaskSchedulerImpl::CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits) {
-  return GetWorkerPoolForTraits(traits)->CreateSingleThreadTaskRunnerWithTraits(
-      traits);
+  return scheduler_single_thread_worker_pool_manager_
+      ->CreateSingleThreadTaskRunnerWithTraits(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;
 }
 
 void TaskSchedulerImpl::Shutdown() {
   // TODO(fdoray): Increase the priority of BACKGROUND tasks blocking shutdown.
   DCHECK(task_tracker_);
   task_tracker_->Shutdown();
 }
 
 void TaskSchedulerImpl::FlushForTesting() {
   DCHECK(task_tracker_);
   task_tracker_->Flush();
 }
 
 void TaskSchedulerImpl::JoinForTesting() {
 #if DCHECK_IS_ON()
   DCHECK(!join_for_testing_returned_.IsSet());
 #endif
   for (const auto& worker_pool : worker_pools_)
     worker_pool->DisallowWorkerDetachmentForTesting();
   for (const auto& worker_pool : worker_pools_)
     worker_pool->JoinForTesting();
+  scheduler_single_thread_worker_pool_manager_->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_(
@@ skipping 26 matching lines @@
           static_cast<MessageLoopForIO*>(service_thread_.message_loop()));
 #else
       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());
 
+  scheduler_single_thread_worker_pool_manager_ =
+      base::MakeUnique<SchedulerSingleThreadWorkerPoolManager>(
+          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) {
     // Passing pointers to objects owned by |this| to
     // SchedulerWorkerPoolImpl::Create() is safe because a TaskSchedulerImpl
@@ skipping 23 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