TaskScheduler [9] Delayed Task Manager

base/task_scheduler/scheduler_thread_pool.cc

Index: base/task_scheduler/scheduler_thread_pool.cc
diff --git a/base/task_scheduler/scheduler_thread_pool.cc b/base/task_scheduler/scheduler_thread_pool.cc
index c43b1d747d888961a3bafcb7cb07a2487c53ce7f..1ac547f5cb6cf13243fde345bef1d8cb6fa693bc 100644
--- a/base/task_scheduler/scheduler_thread_pool.cc
+++ b/base/task_scheduler/scheduler_thread_pool.cc
@@ -31,9 +31,13 @@ class SchedulerParallelTaskRunner : public TaskRunner {
   // long as |executor| is alive.
   // TODO(robliao): Find a concrete way to manage |executor|'s memory.
   SchedulerParallelTaskRunner(const TaskTraits& traits,
+                              SchedulerTaskExecutor* executor,
                               TaskTracker* task_tracker,
-                              SchedulerTaskExecutor* executor)
-      : traits_(traits), task_tracker_(task_tracker), executor_(executor) {}
+                              DelayedTaskManager* delayed_task_manager)
+      : traits_(traits),
+        executor_(executor),
+        task_tracker_(task_tracker),
+        delayed_task_manager_(delayed_task_manager) {}
 
   // TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
@@ -42,7 +46,7 @@ class SchedulerParallelTaskRunner : public TaskRunner {
     // Post the task as part of a one-off single-task Sequence.
     return PostTaskToExecutor(from_here, closure, traits_, delay,
                               make_scoped_refptr(new Sequence), executor_,
-                              task_tracker_);
+                              task_tracker_, delayed_task_manager_);
   }
 
   bool RunsTasksOnCurrentThread() const override {
@@ -53,8 +57,9 @@ class SchedulerParallelTaskRunner : public TaskRunner {
   ~SchedulerParallelTaskRunner() override = default;
 
   const TaskTraits traits_;
-  TaskTracker* const task_tracker_;
   SchedulerTaskExecutor* const executor_;
+  TaskTracker* const task_tracker_;
+  DelayedTaskManager* const delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerParallelTaskRunner);
 };
@@ -66,9 +71,13 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
   // long as |executor| is alive.
   // TODO(robliao): Find a concrete way to manage |executor|'s memory.
   SchedulerSequencedTaskRunner(const TaskTraits& traits,
+                               SchedulerTaskExecutor* executor,
                                TaskTracker* task_tracker,
-                               SchedulerTaskExecutor* executor)
-      : traits_(traits), task_tracker_(task_tracker), executor_(executor) {}
+                               DelayedTaskManager* delayed_task_manager)
+      : traits_(traits),
+        executor_(executor),
+        task_tracker_(task_tracker),
+        delayed_task_manager_(delayed_task_manager) {}
 
   // SequencedTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
@@ -76,7 +85,7 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
                        TimeDelta delay) override {
     // Post the task as part of |sequence|.
     return PostTaskToExecutor(from_here, closure, traits_, delay, sequence_,
-                              executor_, task_tracker_);
+                              executor_, task_tracker_, delayed_task_manager_);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
@@ -97,8 +106,9 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
   const scoped_refptr<Sequence> sequence_ = new Sequence;
 
   const TaskTraits traits_;
-  TaskTracker* const task_tracker_;
   SchedulerTaskExecutor* const executor_;
+  TaskTracker* const task_tracker_;
+  DelayedTaskManager* const delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerSequencedTaskRunner);
 };
@@ -136,9 +146,10 @@ std::unique_ptr<SchedulerThreadPool> SchedulerThreadPool::CreateThreadPool(
     ThreadPriority thread_priority,
     size_t max_threads,
     const EnqueueSequenceCallback& enqueue_sequence_callback,
-    TaskTracker* task_tracker) {
-  std::unique_ptr<SchedulerThreadPool> thread_pool(
-      new SchedulerThreadPool(enqueue_sequence_callback, task_tracker));
+    TaskTracker* task_tracker,
+    DelayedTaskManager* delayed_task_manager) {
+  std::unique_ptr<SchedulerThreadPool> thread_pool(new SchedulerThreadPool(
+      enqueue_sequence_callback, task_tracker, delayed_task_manager));
   if (thread_pool->Initialize(thread_priority, max_threads))
     return thread_pool;
   return nullptr;
@@ -149,12 +160,12 @@ scoped_refptr<TaskRunner> SchedulerThreadPool::CreateTaskRunnerWithTraits(
     ExecutionMode execution_mode) {
   switch (execution_mode) {
     case ExecutionMode::PARALLEL:
-      return make_scoped_refptr(
-          new SchedulerParallelTaskRunner(traits, task_tracker_, this));
+      return make_scoped_refptr(new SchedulerParallelTaskRunner(
+          traits, this, task_tracker_, delayed_task_manager_));
 
     case ExecutionMode::SEQUENCED:
-      return make_scoped_refptr(
-          new SchedulerSequencedTaskRunner(traits, task_tracker_, this));
+      return make_scoped_refptr(new SchedulerSequencedTaskRunner(
+          traits, this, task_tracker_, delayed_task_manager_));
 
     case ExecutionMode::SINGLE_THREADED:
       // TODO(fdoray): Support SINGLE_THREADED TaskRunners.
@@ -263,7 +274,8 @@ void SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::EnqueueSequence(
 
 SchedulerThreadPool::SchedulerThreadPool(
     const EnqueueSequenceCallback& enqueue_sequence_callback,
-    TaskTracker* task_tracker)
+    TaskTracker* task_tracker,
+    DelayedTaskManager* delayed_task_manager)
     : idle_worker_threads_stack_lock_(shared_priority_queue_.container_lock()),
       idle_worker_threads_stack_cv_for_testing_(
           idle_worker_threads_stack_lock_.CreateConditionVariable()),
@@ -271,8 +283,10 @@ SchedulerThreadPool::SchedulerThreadPool(
       worker_thread_delegate_(
           new SchedulerWorkerThreadDelegateImpl(this,
                                                 enqueue_sequence_callback)),
-      task_tracker_(task_tracker) {
+      task_tracker_(task_tracker),
+      delayed_task_manager_(delayed_task_manager) {
   DCHECK(task_tracker_);
+  DCHECK(delayed_task_manager_);
 }
 
 bool SchedulerThreadPool::Initialize(ThreadPriority thread_priority,