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,
+              size_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.
+  size_t index;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DelayedTask);
+};
+
+DelayedTaskManager::DelayedTaskManager(
+    const Closure& on_next_delayed_run_time_updated)
+    : on_next_delayed_run_time_updated_(on_next_delayed_run_time_updated) {
+  DCHECK(!on_next_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 existing_next_delayed_run_time;

[gab, 2016/04/11 18:28:30]

How about s/existing_next_delayed_run_time/current_delayed_run_time/ ?

And reading the rest of this algorithm maybe
s/on_next_delayed_run_time_updated_/on_delayed_run_time_updated_/ would also
make this less wordy?

[fdoray, 2016/04/11 19:57:05]

Done.

+
+  {
+    AutoSchedulerLock auto_lock(lock_);
+
+    if (!delayed_tasks_.empty()) {
+      existing_next_delayed_run_time =
+          delayed_tasks_.top().task->delayed_run_time;
+    }
+
+    delayed_tasks_.emplace(std::move(task), std::move(sequence), priority_queue,
+                           next_delayed_task_index_++);
+  }
+
+  if (existing_next_delayed_run_time.is_null() ||
+      new_task_delayed_run_time < existing_next_delayed_run_time) {
+    on_next_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 almost okay since we're immediately

[gab, 2016/04/11 18:28:30]

"almost okay" sound weird here, how about:

// The const_cast for std::move is okay since we're immediately moving it to
|ready_tasks|. See DelayedTaskComparator::operator() for minor debug-check
implications.

[fdoray, 2016/04/11 19:57:06]

Done.

+      // moving it to |ready_tasks|. See DelayedTaskComparator::operator() for
+      // why it's almost.
+      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::GetNextDelayedRunTime() 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