TaskScheduler: Replace the SchedulerServiceThread with a base::Thread.

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 21 matching lines @@
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 class HistogramBase;
 class TimeDelta;
 
 namespace internal {
 
-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>)>;
 
   // 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.
+  // handle shutdown behavior of Tasks. |service_thread_task_runner| 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);
+      scoped_refptr<TaskRunner> service_thread_task_runner);
 
   // Waits until all workers are idle.
   void WaitForAllWorkersIdleForTesting();
 
   // Joins all workers of this worker pool. Tasks that are already running are
   // allowed to complete their execution. This can only be called once.
   void JoinForTesting();
 
   // Disallows worker thread detachment. If the suggested reclaim time is not
   // TimeDelta::Max(), then the test should call this before the detach code can
   // run. The safest place to do this is before the a set of work is dispatched
   // (the worker pool is idle and steady state) or before the last
   // synchronization point for all workers (all threads are busy and can't be
   // reclaimed).
   void DisallowWorkerDetachmentForTesting();
 
   // SchedulerWorkerPool:
   scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
       const TaskTraits& traits,
       ExecutionMode execution_mode) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence,
                          const SequenceSortKey& sequence_sort_key) override;
   bool PostTaskWithSequence(std::unique_ptr<Task> task,
                             scoped_refptr<Sequence> sequence,
-                            SchedulerWorker* worker) override;
+                            SchedulerWorker* worker,
+                            TimeDelta delay) override;
   void PostTaskWithSequenceNow(std::unique_ptr<Task> task,
                                scoped_refptr<Sequence> sequence,
                                SchedulerWorker* worker) override;
 
   const HistogramBase* num_tasks_between_waits_histogram_for_testing() const {
     return num_tasks_between_waits_histogram_;
   }
 
  private:
   class SchedulerSingleThreadTaskRunner;
   class SchedulerWorkerDelegateImpl;
 
-  SchedulerWorkerPoolImpl(StringPiece name,
-                          SchedulerWorkerPoolParams::IORestriction
-                              io_restriction,
-                          const TimeDelta& suggested_reclaim_time,
-                          TaskTracker* task_tracker,
-                          DelayedTaskManager* delayed_task_manager);
+  SchedulerWorkerPoolImpl(
+      StringPiece name,
+      SchedulerWorkerPoolParams::IORestriction io_restriction,
+      const TimeDelta& suggested_reclaim_time,
+      TaskTracker* task_tracker,
+      scoped_refptr<TaskRunner> service_thread_task_runner);
 
   bool Initialize(
       ThreadPriority priority_hint,
       size_t max_threads,
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback);
 
   // Wakes up the last worker from this worker pool to go idle, if any.
   void WakeUpOneWorker();
 
   // Adds |worker| to |idle_workers_stack_|.
@@ skipping 66 matching lines @@
 
   // TaskScheduler.TaskLatency.[worker pool name].[task priority] histograms.
   // Indexed by task priority. Histograms are allocated on demand to reduce
   // memory usage (some task priorities might never run in this
   // SchedulerThreadPoolImpl). Intentionally leaked.
   subtle::AtomicWord
       task_latency_histograms_[static_cast<int>(TaskPriority::HIGHEST) + 1] =
           {};
 
   TaskTracker* const task_tracker_;
-  DelayedTaskManager* const delayed_task_manager_;
+  const scoped_refptr<TaskRunner> service_thread_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerPoolImpl);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_