TaskScheduler [9] Delayed Task Manager

base/task_scheduler/delayed_task_manager_unittest.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 <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/memory/ref_counted.h"
+#include "base/task_scheduler/priority_queue.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"
+#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::OnDelayedRunTimeUpdated,
+                 Unretained(this))) {}
+
+  void SetCurrentTime(TimeTicks now) { now_ = now; }
+
+  // DelayedTaskManager:
+  TimeTicks Now() const override { return now_; }
+
+  MOCK_METHOD0(OnDelayedRunTimeUpdated, void());
+
+ private:
+  TimeTicks now_ = TimeTicks::Now();
+
+  DISALLOW_COPY_AND_ASSIGN(TestDelayedTaskManager);
+};
+
+// Verify that GetDelayedRunTime() returns a null TimeTicks when there are
+// no pending delayed tasks.
+TEST(TaskSchedulerDelayedTaskManagerTest,
+     GetDelayedRunTimeNoPendingDelayedTasks) {
+  TestDelayedTaskManager manager;
+  EXPECT_EQ(TimeTicks(), manager.GetDelayedRunTime());
+}
+
+// Verify that a delayed task isn't posted before it is ripe for execution.
+TEST(TaskSchedulerDelayedTaskManagerTest, PostReadyTaskBeforeDelayedRunTime) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  std::unique_ptr<Task> task(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1);
+  const Task* task_raw = task.get();
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+
+  // Add |task| to the DelayedTaskManager.
+  EXPECT_CALL(manager, OnDelayedRunTimeUpdated());
+  manager.AddDelayedTask(std::move(task), sequence, &priority_queue);
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Ask the DelayedTaskManager to post tasks that are ripe for execution.
+  manager.PostReadyTasks();
+
+  // The delayed run time shouldn't have changed.
+  EXPECT_EQ(task_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // |sequence| and |priority_queue| should be empty.
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+  EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null());
+}
+
+// Verify that a delayed task is posted when PostReadyTasks() is called with the
+// current time equal to the task's delayed run time.
+TEST(TaskSchedulerDelayedTaskManagerTest, PostReadyTasksAtDelayedRunTime) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  std::unique_ptr<Task> task(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1);
+  const Task* task_raw = task.get();
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+
+  // Add |task| to the DelayedTaskManager.
+  EXPECT_CALL(manager, OnDelayedRunTimeUpdated());
+  manager.AddDelayedTask(std::move(task), sequence, &priority_queue);
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Fast-forward time to |task_raw|'s delayed run time.
+  manager.SetCurrentTime(task_raw->delayed_run_time);
+
+  // Ask the DelayedTaskManager to post tasks that are ripe for execution.
+  manager.PostReadyTasks();
+  EXPECT_EQ(TimeTicks(), manager.GetDelayedRunTime());
+
+  // Expect to find |task_raw| in |sequence| and |sequence| in |priority_queue|.
+  EXPECT_EQ(task_raw, sequence->PeekTask());
+  EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence);
+}
+
+// Verify that a delayed task is posted when PostReadyTasks() is called with the
+// current time greater than the task's delayed run time.
+TEST(TaskSchedulerDelayedTaskManagerTest, PostReadyTasksAfterDelayedRunTime) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  std::unique_ptr<Task> task(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1);
+  const Task* task_raw = task.get();
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+
+  // Add |task| to the DelayedTaskManager.
+  EXPECT_CALL(manager, OnDelayedRunTimeUpdated());
+  manager.AddDelayedTask(std::move(task), sequence, &priority_queue);
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Fast-forward time after |task_raw|'s delayed run time.
+  manager.SetCurrentTime(task_raw->delayed_run_time +
+                         TimeDelta::FromSeconds(10));
+
+  // Ask the DelayedTaskManager to post tasks that are ripe for execution.
+  manager.PostReadyTasks();
+  EXPECT_EQ(TimeTicks(), manager.GetDelayedRunTime());
+
+  // Expect to find |task_raw| in |sequence| and |sequence| in |priority_queue|.
+  EXPECT_EQ(task_raw, sequence->PeekTask());
+  EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence);
+}
+
+// Verify that when multiple tasks are added to a DelayedTaskManager, they are
+// posted when they become ripe for execution.
+TEST(TaskSchedulerDelayedTaskManagerTest, AddAndPostReadyTasks) {
+  testing::StrictMock<TestDelayedTaskManager> manager;
+
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+
+  std::unique_ptr<Task> task_a(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task_a->delayed_run_time = manager.Now() + 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 = manager.Now() + 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 = manager.Now() + TimeDelta::FromSeconds(1);
+  const Task* task_c_raw = task_c.get();
+
+  // Add |task_a| to the DelayedTaskManager. The delayed run time should be
+  // updated to |task_a|'s delayed run time.
+  EXPECT_CALL(manager, OnDelayedRunTimeUpdated());
+  manager.AddDelayedTask(std::move(task_a), sequence, &priority_queue);
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Add |task_b| to the DelayedTaskManager. The delayed run time shouldn't
+  // change.
+  manager.AddDelayedTask(std::move(task_b), sequence, &priority_queue);
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Add |task_c| to the DelayedTaskManager. The delayed run time should be
+  // updated to |task_c|'s delayed run time.
+  EXPECT_CALL(manager, OnDelayedRunTimeUpdated());
+  manager.AddDelayedTask(std::move(task_c), sequence, &priority_queue);
+  testing::Mock::VerifyAndClear(&manager);
+  EXPECT_EQ(task_c_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Fast-forward time to |task_c_raw|'s delayed run time.
+  manager.SetCurrentTime(task_c_raw->delayed_run_time);
+
+  // Ask the DelayedTaskManager to post tasks that are ripe for execution.
+  // |sequence| should be added to |priority_queue|, |task_c_raw| should be
+  // added to |sequence| and the delayed run time should become
+  // |task_a_raw|'s delayed run time.
+  manager.PostReadyTasks();
+  EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence);
+  priority_queue.BeginTransaction()->Pop();
+  EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null());
+  EXPECT_EQ(task_c_raw, sequence->PeekTask());
+  sequence->PopTask();
+  EXPECT_FALSE(sequence->PeekTask());
+  EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetDelayedRunTime());
+
+  // Fast-forward time to |task_a_raw|'s delayed run time.
+  manager.SetCurrentTime(task_a_raw->delayed_run_time);
+
+  // Ask the DelayedTaskManager to post tasks that are ripe for execution.
+  // |sequence| should be added to |priority_queue|, |task_a_raw| and
+  // |task_b_raw| should be added to |sequence| and the delayed run time
+  // should become a null TimeTicks.
+  manager.PostReadyTasks();
+  EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence);
+  priority_queue.BeginTransaction()->Pop();
+  EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null());
+  EXPECT_EQ(task_a_raw, sequence->PeekTask());
+  sequence->PopTask();
+  EXPECT_EQ(task_b_raw, sequence->PeekTask());
+  sequence->PopTask();
+  EXPECT_FALSE(sequence->PeekTask());
+  EXPECT_EQ(TimeTicks(), manager.GetDelayedRunTime());
+}
+
+}  // namespace
+}  // namespace internal
+}  // namespace base