Task Scheduler.

base/task_scheduler/utils_unittest.cc

Index: base/task_scheduler/utils_unittest.cc
diff --git a/base/task_scheduler/utils_unittest.cc b/base/task_scheduler/utils_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..18e31238752588b6d509d6aee27476ae33a2c4f1
--- /dev/null
+++ b/base/task_scheduler/utils_unittest.cc
@@ -0,0 +1,139 @@
+// 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 <utility>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.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/shutdown_manager.h"
+#include "base/task_scheduler/task.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace task_scheduler {
+
+namespace {
+
+class TestDelayedTaskManager : public DelayedTaskManager {
+ public:
+  TestDelayedTaskManager(ShutdownManager* shutdown_manager)
+      : DelayedTaskManager(Bind(&DoNothing), shutdown_manager) {}
+
+  TimeTicks Now() override { return TimeTicks(); }
+};
+
+}  // namespace
+
+// Checks that when PostTaskHelper is called with a task that has a
+// |delayed_run_time|, the task is added to the provided DelayedTaskManager.
+TEST(TaskSchedulerUtilsTest, PostTaskHelperWithDelayedRunTime) {
+  const TimeDelta delay(TimeDelta::FromSeconds(1));
+  Task task(FROM_HERE, Bind(&DoNothing), TaskTraits(), TimeTicks::Now());
+  task.delayed_run_time = TimeTicks() + delay;
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+  ShutdownManager shutdown_manager;
+  TestDelayedTaskManager delayed_task_manager(&shutdown_manager);
+
+  // Post a delayed task.
+  PostTaskHelper(task, sequence, &priority_queue, &shutdown_manager,
+                 &delayed_task_manager);
+
+  // Expect the sequence and the priority queue to be empty.
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+  EXPECT_TRUE(priority_queue.UnsynchronizedEmpty());
+
+  // Expect to find the task in the delayed task manager.
+  EXPECT_EQ(task.delayed_run_time,
+            delayed_task_manager.GetNextDelayedTaskReadyTime());
+}
+
+// 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(TaskSchedulerUtilsTest, PostTaskNowHelperEmptySequence) {
+  const Task task(FROM_HERE, Bind(&DoNothing), TaskTraits(), TimeTicks::Now());
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+  ShutdownManager shutdown_manager;
+
+  // Post a task.
+  PostTaskNowHelper(task, sequence, &priority_queue, &shutdown_manager);
+
+  // Expect to find the sequence in the priority queue.
+  SequenceSortKey sequence_sort_key;
+  EXPECT_EQ(sequence, priority_queue.BeginTransaction()->PeekSequence(
+                          &sequence_sort_key));
+
+  // Expect to find the task in the sequence.
+  EXPECT_EQ(task.posted_from, sequence->PeekTask()->posted_from);
+  size_t prev_num_tasks;
+  sequence->PopTask(&prev_num_tasks);
+  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(TaskSchedulerUtilsTest, PostTaskNowHelperSequenceWithTasks) {
+  const Task task(FROM_HERE, Bind(&DoNothing), TaskTraits(), TimeTicks::Now());
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+  ShutdownManager shutdown_manager;
+
+  // Add an initial task in |sequence|.
+  size_t prev_num_tasks;
+  sequence->PushTask(make_scoped_ptr(new Task(FROM_HERE, Closure(),
+                                              TaskTraits(), TimeTicks::Now())),
+                     &prev_num_tasks);
+
+  // Post a task.
+  PostTaskNowHelper(task, sequence, &priority_queue, &shutdown_manager);
+
+  // Expect to find the priority queue empty.
+  SequenceSortKey sequence_sort_key;
+  EXPECT_EQ(nullptr, priority_queue.BeginTransaction()
+                         ->PeekSequence(&sequence_sort_key)
+                         .get());
+
+  // Expect to find the posted task at the end of the sequence.
+  sequence->PopTask(&prev_num_tasks);
+  EXPECT_EQ(task.posted_from, sequence->PeekTask()->posted_from);
+  sequence->PopTask(&prev_num_tasks);
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+}
+
+// Checks that when PostTaskHelper is called with a SKIP_ON_SHUTDOWN task after
+// shutdown has started, the sequence and the priority queue remain unchanged.
+TEST(TaskSchedulerUtilsTest, PostTaskNowHelperAfterShutdown) {
+  const Task task(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().WithShutdownBehavior(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),
+      TimeTicks::Now());
+  scoped_refptr<Sequence> sequence(new Sequence);
+  PriorityQueue priority_queue(Bind(&DoNothing));
+  ShutdownManager shutdown_manager;
+
+  // Post a SKIP_ON_SHUTDOWN task after shutdown.
+  shutdown_manager.Shutdown();
+  PostTaskNowHelper(task, sequence, &priority_queue, &shutdown_manager);
+
+  // Expect to find the priority queue empty.
+  SequenceSortKey sequence_sort_key;
+  EXPECT_EQ(nullptr, priority_queue.BeginTransaction()
+                         ->PeekSequence(&sequence_sort_key)
+                         .get());
+
+  // Expect to find the sequence empty.
+  EXPECT_EQ(nullptr, sequence->PeekTask());
+}
+
+}  // namespace task_scheduler
+}  // namespace base