TaskScheduler [9] Delayed Task Manager

base/task_scheduler/delayed_task_manager_unittest.cc

Index: base/task_scheduler/delayed_task_manager_unittest.cc
diff --git a/base/task_scheduler/delayed_task_manager_unittest.cc b/base/task_scheduler/delayed_task_manager_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ccca55510f4f2cdc13a864cdd4bb40653610bfbc
--- /dev/null
+++ b/base/task_scheduler/delayed_task_manager_unittest.cc
@@ -0,0 +1,160 @@
+// 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 <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/task_scheduler/scheduler_lock.h"
+#include "base/task_scheduler/task.h"
+#include "base/time/time.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace internal {
+namespace {
+
+class TestDelayedTaskManager : public DelayedTaskManager {
+ public:
+  TestDelayedTaskManager()
+      : DelayedTaskManager(
+            Bind(&TestDelayedTaskManager::OnDelayedTaskReadyTimeChanged,
+                 Unretained(this))) {}
+
+  void SetCurrentTime(TimeTicks now) { now_ = now; }
+  TimeTicks Now() const override { return now_; }

[gab, 2016/04/07 21:32:08]

// DelayedTaskManager:

[fdoray, 2016/04/08 17:24:51]

Done.

+
+  MOCK_METHOD0(OnDelayedTaskReadyTimeChanged, void());
+
+  DelayedTaskManager::PostTaskCallback GetPostTaskCallback() {
+    return Bind(&TestDelayedTaskManager::PostTaskCallback, Unretained(this));
+  }
+
+  void PostTaskCallback(std::unique_ptr<Task> task) {

[gab, 2016/04/07 21:32:09]

private since you only use it from GetPostTaskCallback() helper?

[fdoray, 2016/04/08 17:24:51]

Done.

+    PostTaskCallbackMock(task.get());
+
+    // Acquire a SchedulerLock with no predecessor to verify that no lock
+    // dependency is imposed on this callback.
+    SchedulerLock lock;
+    AutoSchedulerLock auto_lock(lock);
+  }
+
+  MOCK_METHOD1(PostTaskCallbackMock, void(const Task*));
+
+ private:
+  TimeTicks now_;
+};

[gab, 2016/04/07 21:32:09]

DISALLOW_COPY_AND_ASSIGN

[fdoray, 2016/04/08 17:24:52]

Done.

+
+// Verify that GetNextDelayedRunTime() returns a null TimeTicks when there are
+// no pending delayed tasks.
+TEST(TaskSchedulerDelayedTaskManagerTest,
+     GetNextDelayedRunTimeNoPendingDelayedTasks) {
+  TestDelayedTaskManager manager;
+  EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime());
+}
+
+// Verify that a delayed task's callback is invoked when PostReadyTasks() is
+// called with the current time equal to the task's delayed run time.
+TEST(TaskSchedulerDelayedTaskManagerTest, AddAndPostTask) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  std::unique_ptr<Task> task(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task->delayed_run_time = TimeTicks() + TimeDelta::FromSeconds(1);

[gab, 2016/04/07 21:32:08]

I'm not sure relying on the null value of TimeTicks being backed by a zero is
kosher. Could maybe initialize |now_| to the actual TimeTicks::Now() and from
then on use manual TimeDeltas from that value?

[fdoray, 2016/04/08 17:24:52]

Is manager.Now() + TimeDelta::FromSeconds(1) ok?

[gab, 2016/04/08 18:03:55]

Yes.

+  const Task* task_raw = task.get();
+
+  EXPECT_CALL(manager, OnDelayedTaskReadyTimeChanged());
+  manager.AddDelayedTask(std::move(task), manager.GetPostTaskCallback());
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime());
+
+  manager.SetCurrentTime(task_raw->delayed_run_time);
+
+  EXPECT_CALL(manager, PostTaskCallbackMock(task_raw));
+  manager.PostReadyTasks();
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime());
+}
+
+// Verify that a delayed task's callback is invoked when PostReadyTasks() is
+// called with the current time greater than the task's delayed run time.
+TEST(TaskSchedulerDelayedTaskManagerTest, AddAndPostTaskLate) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  std::unique_ptr<Task> task(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task->delayed_run_time = TimeTicks() + TimeDelta::FromSeconds(1);
+  const Task* task_raw = task.get();
+
+  EXPECT_CALL(manager, OnDelayedTaskReadyTimeChanged());
+  manager.AddDelayedTask(std::move(task), manager.GetPostTaskCallback());
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime());
+
+  manager.SetCurrentTime(task_raw->delayed_run_time +
+                         TimeDelta::FromSeconds(10));
+
+  EXPECT_CALL(manager, PostTaskCallbackMock(task_raw));
+  manager.PostReadyTasks();
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime());
+}
+
+// Verify that when multiple tasks are added to a DelayedTaskManager, their
+// respective callback is invoked when they become ripe for execution.
+TEST(TaskSchedulerDelayedTaskManagerTest, AddAndPostTasks) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  std::unique_ptr<Task> task_a(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task_a->delayed_run_time = TimeTicks() + TimeDelta::FromSeconds(2);
+  const Task* task_a_raw = task_a.get();
+
+  std::unique_ptr<Task> task_b(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task_b->delayed_run_time = TimeTicks() + TimeDelta::FromSeconds(2);
+  const Task* task_b_raw = task_b.get();
+
+  std::unique_ptr<Task> task_c(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task_c->delayed_run_time = TimeTicks() + TimeDelta::FromSeconds(1);
+  const Task* task_c_raw = task_c.get();
+
+  EXPECT_CALL(manager, OnDelayedTaskReadyTimeChanged());
+  manager.AddDelayedTask(std::move(task_a), manager.GetPostTaskCallback());
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime());
+
+  manager.AddDelayedTask(std::move(task_b), manager.GetPostTaskCallback());
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime());
+
+  EXPECT_CALL(manager, OnDelayedTaskReadyTimeChanged());
+  manager.AddDelayedTask(std::move(task_c), manager.GetPostTaskCallback());
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_c_raw->delayed_run_time, manager.GetNextDelayedRunTime());
+
+  manager.SetCurrentTime(task_c_raw->delayed_run_time);
+
+  EXPECT_CALL(manager, PostTaskCallbackMock(task_c_raw));
+  manager.PostReadyTasks();
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime());
+
+  manager.SetCurrentTime(task_a_raw->delayed_run_time);
+
+  EXPECT_CALL(manager, PostTaskCallbackMock(task_a_raw));
+  EXPECT_CALL(manager, PostTaskCallbackMock(task_b_raw));
+  manager.PostReadyTasks();
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime());
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace base