TaskScheduler [9] Delayed Task Manager

base/task_scheduler/delayed_task_manager.h

Index: base/task_scheduler/delayed_task_manager.h
diff --git a/base/task_scheduler/delayed_task_manager.h b/base/task_scheduler/delayed_task_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..badfea1896b7deb3ede393b8fa86a6d79f9c7562
--- /dev/null
+++ b/base/task_scheduler/delayed_task_manager.h
@@ -0,0 +1,82 @@
+// 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.
+
+#ifndef BASE_TASK_SCHEDULER_DELAYED_TASK_MANAGER_H_
+#define BASE_TASK_SCHEDULER_DELAYED_TASK_MANAGER_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <queue>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/task_scheduler/scheduler_lock.h"
+#include "base/task_scheduler/sequence.h"
+#include "base/task_scheduler/task.h"
+#include "base/time/time.h"
+
+namespace base {
+namespace internal {
+
+class PriorityQueue;
+
+// A DelayedTaskManager holds delayed Tasks until they become ripe for
+// execution. When they become ripe for execution, it posts them to their
+// associated Sequence and PriorityQueue. This class is thread-safe.
+class BASE_EXPORT DelayedTaskManager {
+ public:
+  // |on_next_delayed_run_time_updated| is invoked when the next delayed run
+  // time is updated as a result of adding a delayed task to the manager.
+  explicit DelayedTaskManager(const Closure& on_next_delayed_run_time_updated);
+  ~DelayedTaskManager();
+
+  // Adds |task| to a queue of delayed tasks. The task will be inserted into
+  // |sequence| and |priority_queue| the first time that PostReadyTasks() is
+  // called while Now() is passed |task->delayed_run_time|.
+  void AddDelayedTask(std::unique_ptr<Task> task,
+                      scoped_refptr<Sequence> sequence,
+                      PriorityQueue* priority_queue);
+
+  // Posts delayed tasks that are ripe for execution.
+  void PostReadyTasks();
+
+  // Returns the next time at which a delayed task will become ripe for
+  // execution, or a null TimeTicks if there are no pending delayed tasks.
+  TimeTicks GetNextDelayedRunTime() const;
+
+ private:
+  struct DelayedTask;
+  struct DelayedTaskComparator {
+    bool operator()(const DelayedTask& left, const DelayedTask& right) const;
+  };
+
+  // Returns the current time. Can be overridden for tests.
+  virtual TimeTicks Now() const;
+
+  const Closure on_next_delayed_run_time_updated_;
+
+  // Synchronizes access to all members below.
+  mutable SchedulerLock lock_;
+
+  // Priority queue of delayed tasks. The delayed task with the smallest
+  // |task->delayed_run_time| is in front of the priority queue.
+  using DelayedTaskQueue = std::priority_queue<DelayedTask,
+                                               std::vector<DelayedTask>,
+                                               DelayedTaskComparator>;
+  DelayedTaskQueue delayed_tasks_;
+
+  // The index to assign to the next delayed task added to the manager.
+  size_t next_delayed_task_index_ = 0;

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

According to http://stackoverflow.com/questions/22514803/maximum-size-of-size-t,
the C++ standard says that size_t's max size must be >= 65535 but that does
sound pretty low to me for this index.

It does appear to be a uint (unsigned 32-bit int, MAX == 4294967295) in practice
but we shouldn't rely on that.

How about explicitly using a uint32 or uint64? uint64 is probably safer once we
get to renderer lands where there are tons of short lived timers using delayed
tasks?

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

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(DelayedTaskManager);
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_TASK_SCHEDULER_DELAYED_TASK_MANAGER_H_