Eliminate the TimerManager by pulling its priority queue into MessageLoop....

base/message_loop_unittest.cc

 // Copyright (c) 2006-2008 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/logging.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 119 matching lines @@
 
   // Now kick things off with the SEH block active.
   MessageLoop::current()->set_exception_restoration(true);
   MessageLoop::current()->Run();
   MessageLoop::current()->set_exception_restoration(false);
 
   EXPECT_EQ(foo->test_count(), 105);
   EXPECT_EQ(foo->result(), "abacad");
 }
 
+// This class runs slowly to simulate a large amount of work being done.
+class SlowTask : public Task {
+ public:
+  SlowTask(int pause_ms, int* quit_counter)
+      : pause_ms_(pause_ms), quit_counter_(quit_counter) {
+  }
+  virtual void Run() {
+    PlatformThread::Sleep(pause_ms_);
+    if (--(*quit_counter_) == 0)
+      MessageLoop::current()->Quit();
+  }
+ private:
+  int pause_ms_;
+  int* quit_counter_;
+};
+
+// This class records the time when Run was called in a Time object, which is
+// useful for building a variety of MessageLoop tests.
+class RecordRunTimeTask : public SlowTask {
+ public:
+  RecordRunTimeTask(Time* run_time, int* quit_counter)
+      : SlowTask(10, quit_counter), run_time_(run_time) {
+  }
+  virtual void Run() {
+    *run_time_ = Time::Now();
+    // Cause our Run function to take some time to execute.  As a result we can
+    // count on subsequent RecordRunTimeTask objects running at a future time,
+    // without worry about the resolution of our system clock being an issue.
+    SlowTask::Run();
+  }
+ private:
+  Time* run_time_;
+};
+
+void RunTest_PostDelayedTask_Basic(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that PostDelayedTask results in a delayed task.
+
+  const int kDelayMS = 100;
+
+  int num_tasks = 1;
+  Time run_time;
+
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time, &num_tasks), kDelayMS);
+
+  Time time_before_run = Time::Now();
+  loop.Run();
+  Time time_after_run = Time::Now();
+
+  EXPECT_EQ(0, num_tasks);
+  EXPECT_LT(kDelayMS, (time_after_run - time_before_run).InMilliseconds());
+}
+
+void RunTest_PostDelayedTask_InDelayOrder(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that two tasks with different delays run in the right order.
+
+  int num_tasks = 2;
+  Time run_time1, run_time2;
+
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time1, &num_tasks), 200);
+  // If we get a large pause in execution (due to a context switch) here, this
+  // test could fail.
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), 10);
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_TRUE(run_time2 < run_time1);
+}
+
+void RunTest_PostDelayedTask_InPostOrder(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that two tasks with the same delay run in the order in which they
+  // were posted.
+  //
+  // NOTE: This is actually an approximate test since the API only takes a
+  // "delay" parameter, so we are not exactly simulating two tasks that get
+  // posted at the exact same time.  It would be nice if the API allowed us to
+  // specify the desired run time.
+
+  const int kDelayMS = 100;
+
+  int num_tasks = 2;
+  Time run_time1, run_time2;
+
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time1, &num_tasks), kDelayMS);
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), kDelayMS);
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_TRUE(run_time1 < run_time2);
+}
+
+void RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that a delayed task still runs after a normal tasks even if the
+  // normal tasks take a long time to run.
+
+  const int kPauseMS = 50;
+
+  int num_tasks = 2;
+  Time run_time;
+
+  loop.PostTask(
+      FROM_HERE, new SlowTask(kPauseMS, &num_tasks));
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time, &num_tasks), 10);
+
+  Time time_before_run = Time::Now();
+  loop.Run();
+  Time time_after_run = Time::Now();
+
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_LT(kPauseMS, (time_after_run - time_before_run).InMilliseconds());
+}
+
+void RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  // Test that a delayed task still runs after a pile of normal tasks.  The key
+  // difference between this test and the previous one is that here we return
+  // the MessageLoop a lot so we give the MessageLoop plenty of opportunities
+  // to maybe run the delayed task.  It should know not to do so until the
+  // delayed task's delay has passed.
+
+  int num_tasks = 11;
+  Time run_time1, run_time2;
+
+  // Clutter the ML with tasks.
+  for (int i = 1; i < num_tasks; ++i)
+    loop.PostTask(FROM_HERE, new RecordRunTimeTask(&run_time1, &num_tasks));
+
+  loop.PostDelayedTask(
+      FROM_HERE, new RecordRunTimeTask(&run_time2, &num_tasks), 1);
+
+  loop.Run();
+  EXPECT_EQ(0, num_tasks);
+
+  EXPECT_TRUE(run_time2 > run_time1);
+}
+
 class NestingTest : public Task {
  public:
   explicit NestingTest(int* depth) : depth_(depth) {
   }
   void Run() {
     if (*depth_ > 0) {
       *depth_ -= 1;
       MessageLoop::current()->PostTask(FROM_HERE, new NestingTest(depth_));
 
       MessageLoop::current()->SetNestableTasksAllowed(true);
@@ skipping 548 matching lines @@
   }
 };
 
 // Tests that non nestable tasks run in FIFO if there are no nested loops.
 void RunTest_NonNestableWithNoNesting(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   Task* task = new OrderedTasks(&order, 1);
-  task->set_nestable(false);
-  MessageLoop::current()->PostTask(FROM_HERE, task);
+  MessageLoop::current()->PostNonNestableTask(FROM_HERE, task);
   MessageLoop::current()->PostTask(FROM_HERE, new OrderedTasks(&order, 2));
   MessageLoop::current()->PostTask(FROM_HERE, new QuitTask(&order, 3));
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(6U, order.size());
   EXPECT_EQ(order[ 0], TaskItem(ORDERERD, 1, true));
   EXPECT_EQ(order[ 1], TaskItem(ORDERERD, 1, false));
   EXPECT_EQ(order[ 2], TaskItem(ORDERERD, 2, true));
   EXPECT_EQ(order[ 3], TaskItem(ORDERERD, 2, false));
   EXPECT_EQ(order[ 4], TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order[ 5], TaskItem(QUITMESSAGELOOP, 3, false));
 }
 
 // Tests that non nestable tasks don't run when there's code in the call stack.
 void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new TaskThatPumps(&order, 1));
   Task* task = new OrderedTasks(&order, 2);
-  task->set_nestable(false);
-  MessageLoop::current()->PostTask(FROM_HERE, task);
+  MessageLoop::current()->PostNonNestableTask(FROM_HERE, task);
   MessageLoop::current()->PostTask(FROM_HERE, new OrderedTasks(&order, 3));
   MessageLoop::current()->PostTask(FROM_HERE, new OrderedTasks(&order, 4));
   Task* non_nestable_quit = new QuitTask(&order, 5);
-  non_nestable_quit->set_nestable(false);
-  MessageLoop::current()->PostTask(FROM_HERE, non_nestable_quit);
+  MessageLoop::current()->PostNonNestableTask(FROM_HERE, non_nestable_quit);
 
   MessageLoop::current()->Run();
 
   // FIFO order.
   ASSERT_EQ(10U, order.size());
   EXPECT_EQ(order[ 0], TaskItem(PUMPS, 1, true));
   EXPECT_EQ(order[ 1], TaskItem(ORDERERD, 3, true));
   EXPECT_EQ(order[ 2], TaskItem(ORDERERD, 3, false));
   EXPECT_EQ(order[ 3], TaskItem(ORDERERD, 4, true));
   EXPECT_EQ(order[ 4], TaskItem(ORDERERD, 4, false));
@@ skipping 112 matching lines @@
   RunTest_PostTask(MessageLoop::TYPE_UI);
   RunTest_PostTask(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, PostTask_SEH) {
   RunTest_PostTask_SEH(MessageLoop::TYPE_DEFAULT);
   RunTest_PostTask_SEH(MessageLoop::TYPE_UI);
   RunTest_PostTask_SEH(MessageLoop::TYPE_IO);
 }
 
+TEST(MessageLoopTest, PostDelayedTask_Basic) {
+  RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedTask_Basic(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, PostDelayedTask_InDelayOrder) {
+  RunTest_PostDelayedTask_InDelayOrder(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedTask_InDelayOrder(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedTask_InDelayOrder(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, PostDelayedTask_InPostOrder) {
+  RunTest_PostDelayedTask_InPostOrder(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedTask_InPostOrder(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedTask_InPostOrder(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, PostDelayedTask_InPostOrder_2) {
+  RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedTask_InPostOrder_2(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, PostDelayedTask_InPostOrder_3) {
+  RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_DEFAULT);
+  RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_UI);
+  RunTest_PostDelayedTask_InPostOrder_3(MessageLoop::TYPE_IO);
+}
+
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Crasher) {
   RunTest_Crasher(MessageLoop::TYPE_DEFAULT);
   RunTest_Crasher(MessageLoop::TYPE_UI);
   RunTest_Crasher(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, CrasherNasty) {
   RunTest_CrasherNasty(MessageLoop::TYPE_DEFAULT);
   RunTest_CrasherNasty(MessageLoop::TYPE_UI);
@@ skipping 48 matching lines @@
 TEST(MessageLoopTest, AutoresetEvents) {
   // This test requires an IO loop
   RunTest_AutoresetEvents(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 }
 #endif  // defined(OS_WIN)