TaskScheduler [9] Delayed Task Manager

base/task_scheduler/utils_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/utils.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/priority_queue.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 namespace {
 
-// Checks that when PostTaskHelper is called with an empty sequence, the task
-// is added to the sequence and the sequence is added to the priority queue.
-TEST(TaskSchedulerPostTaskHelperTest, PostTaskInEmptySequence) {
+// Checks that when PostTaskHelper is called with an empty sequence, the task is
+// added to the sequence and the sequence is added to the priority queue.
+TEST(TaskSchedulerPostTaskNowHelperTest, PostTaskInEmptySequence) {

[gab, 2016/04/12 13:35:48]

This is using PostTaskHelper not PostTaskNowHelper, fix test name to reflect
that (here and below)

[fdoray, 2016/04/12 14:43:57]

Done.

   std::unique_ptr<Task> task(
       new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
   const Task* task_raw = task.get();
   scoped_refptr<Sequence> sequence(new Sequence);
   PriorityQueue priority_queue(Bind(&DoNothing));
   TaskTracker task_tracker;
+  DelayedTaskManager delayed_task_manager(Bind(&DoNothing));
 
   // Post |task|.
-  EXPECT_TRUE(PostTaskHelper(std::move(task), sequence, &priority_queue,
-                             &task_tracker));
+  PostTaskHelper(std::move(task), sequence, &priority_queue, &task_tracker,
+                 &delayed_task_manager);
 
   // Expect to find the sequence in the priority queue.
   EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence);
 
   // Expect to find |task| alone in |sequence|.
   EXPECT_EQ(task_raw, sequence->PeekTask());
   sequence->PopTask();
   EXPECT_EQ(nullptr, sequence->PeekTask());
 }
 
 // Checks that when PostTaskHelper is called with a sequence that already
 // contains a task, the task is added to the sequence but the sequence is not
 // added to the priority queue.
-TEST(TaskSchedulerPostTaskHelperTest, PostTaskInNonEmptySequence) {
+TEST(TaskSchedulerPostTaskNowHelperTest, PostTaskInNonEmptySequence) {
   std::unique_ptr<Task> task(
       new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
   const Task* task_raw = task.get();
   scoped_refptr<Sequence> sequence(new Sequence);
   PriorityQueue priority_queue(Bind(&DoNothing));
   TaskTracker task_tracker;
+  DelayedTaskManager delayed_task_manager(Bind(&DoNothing));
 
   // Add an initial task in |sequence|.
   sequence->PushTask(
       WrapUnique(new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())));
 
   // Post |task|.
-  EXPECT_TRUE(PostTaskHelper(std::move(task), sequence, &priority_queue,
-                             &task_tracker));
+  PostTaskHelper(std::move(task), sequence, &priority_queue, &task_tracker,
+                 &delayed_task_manager);
 
   // Expect to find the priority queue empty.
   EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null());
 
   // Expect to find |task| in |sequence| behind the initial task.
   EXPECT_NE(task_raw, sequence->PeekTask());
   sequence->PopTask();
   EXPECT_EQ(task_raw, sequence->PeekTask());
   sequence->PopTask();
   EXPECT_EQ(nullptr, sequence->PeekTask());
 }
 
+// Checks that when PostTaskHelper is called with a delayed task, it is added to
+// the DelayedTaskManager.
+TEST(TaskSchedulerPostTaskNowHelperTest, PostDelayedTask) {
+  const TimeTicks delayed_run_time = TimeTicks::Now() + TimeDelta::FromHours(1);
+  std::unique_ptr<Task> task(
+      new Task(FROM_HERE, Bind(&DoNothing), TaskTraits()));
+  task->delayed_run_time = delayed_run_time;
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+  TaskTracker task_tracker;
+  DelayedTaskManager delayed_task_manager(Bind(&DoNothing));
+
+  // Post |task|.
+  PostTaskHelper(std::move(task), sequence, &priority_queue, &task_tracker,
+                 &delayed_task_manager);
+
+  // Expect to find |priority_queue| and |sequence| empty.
+  EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null());
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+
+  // Expect the DelayedTaskManager's delayed run time to have been updated.
+  EXPECT_EQ(delayed_run_time, delayed_task_manager.GetDelayedRunTime());
+}
+
 }  // namespace
 }  // namespace internal
 }  // namespace base