Move Task Scheduler Single Thread Task Runners to Dedicated Threads

base/task_scheduler/scheduler_worker_pool_impl.h

 // 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.
 
 #ifndef BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_
 #define BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 27 matching lines @@
 class DelayedTaskManager;
 class TaskTracker;
 
 // A pool of workers that run Tasks. This class is thread-safe.
 class BASE_EXPORT SchedulerWorkerPoolImpl : public SchedulerWorkerPool {
  public:
   // Callback invoked when a Sequence isn't empty after a worker pops a Task
   // from it.
   using ReEnqueueSequenceCallback = Callback<void(scoped_refptr<Sequence>)>;
 
+  // Callback invoked during destruction of a SingleThreadTaskRunner.
+  using UnregisterSingleThreadWorkerPoolCallback =
+      Callback<void(const SchedulerWorkerPoolImpl* scheduler_worker_pool)>;
+
   // Destroying a SchedulerWorkerPoolImpl returned by Create() is not allowed in
   // production; it is always leaked. In tests, it can only be destroyed after
   // JoinForTesting() has returned.
   ~SchedulerWorkerPoolImpl() override;
 
   // Creates a SchedulerWorkerPoolImpl following the |worker_pool_params|
   // specification. |re_enqueue_sequence_callback| will be invoked after a
   // worker of this worker pool tries to run a Task. |task_tracker| is used to
   // handle shutdown behavior of Tasks. |delayed_task_manager| handles Tasks
   // posted with a delay. Returns nullptr on failure to create a worker pool
   // with at least one thread.
   static std::unique_ptr<SchedulerWorkerPoolImpl> Create(
       const SchedulerWorkerPoolParams& params,
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
       TaskTracker* task_tracker,
       DelayedTaskManager* delayed_task_manager);
 
+  static std::unique_ptr<SchedulerWorkerPoolImpl> CreateSingleThreadWorkerPool(
+      const SchedulerWorkerPoolParams& params,
+      UnregisterSingleThreadWorkerPoolCallback
+          unregister_single_thread_worker_callback,
+      TaskTracker* task_tracker,
+      DelayedTaskManager* delayed_task_manager);
+
   // SchedulerWorkerPool:
   scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence,
                          const SequenceSortKey& sequence_sort_key) override;
   bool PostTaskWithSequence(std::unique_ptr<Task> task,
@@ skipping 27 matching lines @@
   void DisallowWorkerDetachmentForTesting();
 
   // Returns the number of workers alive in this worker pool. The value may
   // change if workers are woken up or detached during this call.
   size_t NumberOfAliveWorkersForTesting();
 
  private:
   class SchedulerSingleThreadTaskRunner;
   class SchedulerWorkerDelegateImpl;
 
+  static std::unique_ptr<SchedulerWorkerPoolImpl> CreateInternal(
+      const SchedulerWorkerPoolParams& params,
+      TaskTracker* task_tracker,
+      DelayedTaskManager* delayed_task_manager,
+      const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
+      UnregisterSingleThreadWorkerPoolCallback
+          unregister_single_thread_worker_callback);
+
   SchedulerWorkerPoolImpl(const SchedulerWorkerPoolParams& params,
                           TaskTracker* task_tracker,
-                          DelayedTaskManager* delayed_task_manager);
+                          DelayedTaskManager* delayed_task_manager,
+                          UnregisterSingleThreadWorkerPoolCallback
+                              unregister_single_thread_worker_pool_callback =
+                                  UnregisterSingleThreadWorkerPoolCallback());
 
   bool Initialize(
       const SchedulerWorkerPoolParams& params,
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback);
 
   // Wakes up |worker|.
   void WakeUpWorker(SchedulerWorker* worker);
 
   // Wakes up the last worker from this worker pool to go idle, if any.
   void WakeUpOneWorker();
@@ skipping 67 matching lines @@
   // Intentionally leaked.
   HistogramBase* const num_tasks_before_detach_histogram_;
 
   // TaskScheduler.NumTasksBetweenWaits.[worker pool name] histogram.
   // Intentionally leaked.
   HistogramBase* const num_tasks_between_waits_histogram_;
 
   TaskTracker* const task_tracker_;
   DelayedTaskManager* const delayed_task_manager_;
 
+  const UnregisterSingleThreadWorkerPoolCallback
+      unregister_single_thread_worker_pool_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerPoolImpl);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_