TaskScheduler [9] Delayed Task Manager

base/task_scheduler/utils.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/utils.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/priority_queue.h"
 #include "base/task_scheduler/sequence_sort_key.h"
 #include "base/task_scheduler/task_tracker.h"
 
 namespace base {
 namespace internal {
 
-bool PostTaskHelper(std::unique_ptr<Task> task,
-                    scoped_refptr<Sequence> sequence,
-                    PriorityQueue* priority_queue,
-                    TaskTracker* task_tracker) {
+void BASE_EXPORT PostTaskNowHelper(std::unique_ptr<Task> task,
+                                   scoped_refptr<Sequence> sequence,
+                                   PriorityQueue* priority_queue) {
   DCHECK(task);
   DCHECK(sequence);
   DCHECK(priority_queue);
-  DCHECK(task_tracker);
-
-  if (!task_tracker->WillPostTask(task.get()))
-    return false;
 
   const bool sequence_was_empty = sequence->PushTask(std::move(task));
   if (sequence_was_empty) {
     // Insert |sequence| in |priority_queue| if it was empty before |task| was
     // inserted into it. When that's not the case, one of these must be true:
     // - |sequence| is already in a PriorityQueue, or,
     // - A worker thread is running a Task from |sequence|. It will insert
     //   |sequence| in a PriorityQueue once it's done running the Task.
     const auto sequence_sort_key = sequence->GetSortKey();
     priority_queue->BeginTransaction()->Push(
         WrapUnique(new PriorityQueue::SequenceAndSortKey(std::move(sequence),
                                                          sequence_sort_key)));
   }
+}
+
+bool PostTaskHelper(std::unique_ptr<Task> task,
+                    scoped_refptr<Sequence> sequence,
+                    PriorityQueue* priority_queue,
+                    TaskTracker* task_tracker,
+                    DelayedTaskManager* delayed_task_manager) {
+  DCHECK(task);
+  DCHECK(sequence);
+  DCHECK(priority_queue);
+  DCHECK(task_tracker);
+
+  if (!task_tracker->WillPostTask(task.get()))
+    return false;
+
+  if (task->delayed_run_time.is_null()) {
+    PostTaskNowHelper(std::move(task), std::move(sequence), priority_queue);
+  } else {
+    delayed_task_manager->AddDelayedTask(std::move(task), std::move(sequence),
+                                         priority_queue);
+  }
 
   return true;
 }
 
 }  // namespace internal
 }  // namespace base