TaskScheduler [9] Delayed Task Manager

base/task_scheduler/delayed_task_manager.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/delayed_task_manager.h"
+
+#include <utility>
+
+#include "base/logging.h"
+#include "base/task_scheduler/utils.h"
+
+namespace base {
+namespace internal {
+
+struct DelayedTaskManager::DelayedTask {
+  DelayedTask(std::unique_ptr<Task> task,
+              scoped_refptr<Sequence> sequence,
+              PriorityQueue* priority_queue,
+              uint64_t index)
+      : task(std::move(task)),
+        sequence(std::move(sequence)),
+        priority_queue(priority_queue),
+        index(index) {}
+
+  DelayedTask(DelayedTask&& other)
+      : task(std::move(other.task)),
+        sequence(std::move(other.sequence)),
+        priority_queue(other.priority_queue),
+        index(other.index) {}
+
+  ~DelayedTask() = default;
+
+  DelayedTask& operator=(DelayedTask&& other) {
+    task = std::move(other.task);
+    sequence = std::move(other.sequence);
+    priority_queue = other.priority_queue;
+    index = other.index;
+    return *this;
+  }
+
+  std::unique_ptr<Task> task;
+
+  // The sequence and priority queue in which |task| is inserted once it
+  // becomes ripe for execution.
+  scoped_refptr<Sequence> sequence;
+  PriorityQueue* priority_queue;
+
+  // Ensures that tasks that have the same |delayed_run_time| are sorted
+  // according to the order in which they were added to the DelayedTaskManager.
+  uint64_t index;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DelayedTask);
+};
+
+DelayedTaskManager::DelayedTaskManager(
+    const Closure& on_delayed_run_time_updated)
+    : on_delayed_run_time_updated_(on_delayed_run_time_updated) {
+  DCHECK(!on_delayed_run_time_updated_.is_null());
+}
+
+DelayedTaskManager::~DelayedTaskManager() = default;
+
+void DelayedTaskManager::AddDelayedTask(std::unique_ptr<Task> task,
+                                        scoped_refptr<Sequence> sequence,
+                                        PriorityQueue* priority_queue) {
+  DCHECK(task);
+  DCHECK(sequence);
+  DCHECK(priority_queue);
+
+  const TimeTicks new_task_delayed_run_time = task->delayed_run_time;
+  TimeTicks current_delayed_run_time;
+
+  {
+    AutoSchedulerLock auto_lock(lock_);
+
+    if (!delayed_tasks_.empty()) {
+      current_delayed_run_time = delayed_tasks_.top().task->delayed_run_time;
+    }
+
+    delayed_tasks_.emplace(std::move(task), std::move(sequence), priority_queue,
+                           delayed_task_index_++);
+  }
+
+  if (current_delayed_run_time.is_null() ||
+      new_task_delayed_run_time < current_delayed_run_time) {
+    on_delayed_run_time_updated_.Run();
+  }
+}
+
+void DelayedTaskManager::PostReadyTasks() {
+  const TimeTicks now = Now();
+
+  // Move delayed tasks that are ready for execution into |ready_tasks|. Don't
+  // post them right away to avoid imposing an unecessary lock dependency on
+  // PostTaskNowHelper.
+  std::vector<DelayedTask> ready_tasks;
+
+  {
+    AutoSchedulerLock auto_lock(lock_);
+    while (!delayed_tasks_.empty() &&
+           delayed_tasks_.top().task->delayed_run_time <= now) {
+      // The const_cast for std::move is okay since we're immediately popping
+      // the task from |delayed_tasks_|. See DelayedTaskComparator::operator()
+      // for minor debug-check implications.
+      ready_tasks.emplace_back(
+          std::move(const_cast<DelayedTask&>(delayed_tasks_.top())));
+      delayed_tasks_.pop();
+    }
+  }
+
+  // Post delayed tasks that are ready for execution.
+  for (auto& delayed_task : ready_tasks) {
+    PostTaskNowHelper(std::move(delayed_task.task),
+                      std::move(delayed_task.sequence),
+                      delayed_task.priority_queue);
+  }
+}
+
+TimeTicks DelayedTaskManager::GetDelayedRunTime() const {
+  AutoSchedulerLock auto_lock(lock_);
+
+  if (delayed_tasks_.empty())
+    return TimeTicks();
+
+  return delayed_tasks_.top().task->delayed_run_time;
+}
+
+// In std::priority_queue, the largest element is on top. Therefore, this
+// comparator returns true if the delayed run time of |right| is earlier than
+// the delayed run time of |left|.
+bool DelayedTaskManager::DelayedTaskComparator::operator()(
+    const DelayedTask& left,
+    const DelayedTask& right) const {
+#ifndef NDEBUG
+  // Due to STL consistency checks in Windows and const_cast'ing right before
+  // popping the DelayedTask, a null task can be passed to this comparator in
+  // Debug builds. To satisfy these consistency checks, this comparator
+  // considers null tasks to be the larger than anything.
+  DCHECK(left.task || right.task);
+  if (!left.task)
+    return false;
+  if (!right.task)
+    return true;
+#else
+  DCHECK(left.task);
+  DCHECK(right.task);
+#endif  // NDEBUG
+  if (left.task->delayed_run_time > right.task->delayed_run_time)
+    return true;
+  if (left.task->delayed_run_time < right.task->delayed_run_time)
+    return false;
+  return left.index > right.index;
+}
+
+TimeTicks DelayedTaskManager::Now() const {
+  return TimeTicks::Now();
+}
+
+}  // namespace internal
+}  // namespace base