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 d42e915b8d40ee64cd376b100fad00710ce20b9f..cd6a97538cca665ca215a7b77969bd05e3258ba5 100644
--- a/base/task_scheduler/scheduler_thread_pool.cc
+++ b/base/task_scheduler/scheduler_thread_pool.cc
@@ -30,10 +30,12 @@ class SchedulerParallelTaskRunner : public TaskRunner {
  public:
   SchedulerParallelTaskRunner(const TaskTraits& traits,
                               PriorityQueue* priority_queue,
-                              TaskTracker* task_tracker)
+                              TaskTracker* task_tracker,
+                              DelayedTaskManager* delayed_task_manager)
       : traits_(traits),
         priority_queue_(priority_queue),
-        task_tracker_(task_tracker) {}
+        task_tracker_(task_tracker),
+        delayed_task_manager_(delayed_task_manager) {}
 
   // TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
@@ -45,7 +47,7 @@ class SchedulerParallelTaskRunner : public TaskRunner {
     // Post the task as part of a one-off single-task Sequence.
     return PostTaskHelper(WrapUnique(new Task(from_here, closure, traits_)),
                           make_scoped_refptr(new Sequence), priority_queue_,
-                          task_tracker_);
+                          task_tracker_, delayed_task_manager_);
   }
 
   bool RunsTasksOnCurrentThread() const override {
@@ -58,6 +60,7 @@ class SchedulerParallelTaskRunner : public TaskRunner {
   const TaskTraits traits_;
   PriorityQueue* const priority_queue_;
   TaskTracker* const task_tracker_;
+  DelayedTaskManager* const delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerParallelTaskRunner);
 };
@@ -67,10 +70,12 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
  public:
   SchedulerSequencedTaskRunner(const TaskTraits& traits,
                                PriorityQueue* priority_queue,
-                               TaskTracker* task_tracker)
+                               TaskTracker* task_tracker,
+                               DelayedTaskManager* delayed_task_manager)
       : traits_(traits),
         priority_queue_(priority_queue),
-        task_tracker_(task_tracker) {}
+        task_tracker_(task_tracker),
+        delayed_task_manager_(delayed_task_manager) {}
 
   // SequencedTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
@@ -81,7 +86,8 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
 
     // Post the task as part of |sequence_|.
     return PostTaskHelper(WrapUnique(new Task(from_here, closure, traits_)),
-                          sequence_, priority_queue_, task_tracker_);
+                          sequence_, priority_queue_, task_tracker_,
+                          delayed_task_manager_);
   }
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
@@ -104,6 +110,7 @@ class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
   const TaskTraits traits_;
   PriorityQueue* const priority_queue_;
   TaskTracker* const task_tracker_;
+  DelayedTaskManager* const delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerSequencedTaskRunner);
 };
@@ -135,9 +142,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;
@@ -158,11 +166,13 @@ scoped_refptr<TaskRunner> SchedulerThreadPool::CreateTaskRunnerWithTraits(
   switch (execution_mode) {
     case ExecutionMode::PARALLEL:
       return make_scoped_refptr(new SchedulerParallelTaskRunner(
-          traits, &shared_priority_queue_, task_tracker_));
+          traits, &shared_priority_queue_, task_tracker_,
+          delayed_task_manager_));
 
     case ExecutionMode::SEQUENCED:
       return make_scoped_refptr(new SchedulerSequencedTaskRunner(
-          traits, &shared_priority_queue_, task_tracker_));
+          traits, &shared_priority_queue_, task_tracker_,
+          delayed_task_manager_));
 
     case ExecutionMode::SINGLE_THREADED:
       // TODO(fdoray): Support SINGLE_THREADED TaskRunners.
@@ -258,7 +268,8 @@ void SchedulerThreadPool::SchedulerWorkerThreadDelegateImpl::EnqueueSequence(
 
 SchedulerThreadPool::SchedulerThreadPool(
     const EnqueueSequenceCallback& enqueue_sequence_callback,
-    TaskTracker* task_tracker)
+    TaskTracker* task_tracker,
+    DelayedTaskManager* delayed_task_manager)
     : shared_priority_queue_(
           Bind(&SchedulerThreadPool::WakeUpOneThread, Unretained(this))),
       worker_threads_lock_(shared_priority_queue_.container_lock()),
@@ -268,8 +279,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,