Index: base/task_scheduler/delayed_task_manager.cc |
diff --git a/base/task_scheduler/delayed_task_manager.cc b/base/task_scheduler/delayed_task_manager.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..39891c77d11fa7f3471ffbfd7f92187552b2d44b |
--- /dev/null |
+++ b/base/task_scheduler/delayed_task_manager.cc |
@@ -0,0 +1,162 @@ |
+// 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
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
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 |