Fire off work in outer run loops when inner loops exit

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 575 matching lines @@
 const wchar_t* const kMessageBoxTitle = L"MessageLoop Unit Test";
 
 enum TaskType {
   MESSAGEBOX,
   ENDDIALOG,
   RECURSIVE,
   TIMEDMESSAGELOOP,
   QUITMESSAGELOOP,
   ORDERERD,
   PUMPS,
+  SLEEP,
 };
 
 // Saves the order in which the tasks executed.
 struct TaskItem {
   TaskItem(TaskType t, int c, bool s)
       : type(t),
         cookie(c),
         start(s) {
   }
 
@@ skipping 10 matching lines @@
 
 std::ostream& operator <<(std::ostream& os, TaskType type) {
   switch (type) {
   case MESSAGEBOX:        os << "MESSAGEBOX"; break;
   case ENDDIALOG:         os << "ENDDIALOG"; break;
   case RECURSIVE:         os << "RECURSIVE"; break;
   case TIMEDMESSAGELOOP:  os << "TIMEDMESSAGELOOP"; break;
   case QUITMESSAGELOOP:   os << "QUITMESSAGELOOP"; break;
   case ORDERERD:          os << "ORDERERD"; break;
   case PUMPS:             os << "PUMPS"; break;
+  case SLEEP:             os << "SLEEP"; break;
   default:
     NOTREACHED();
     os << "Unknown TaskType";
     break;
   }
   return os;
 }
 
 std::ostream& operator <<(std::ostream& os, const TaskItem& item) {
   if (item.start)
@@ skipping 122 matching lines @@
       : OrderedTasks(order, QUITMESSAGELOOP, cookie) {
   }
 
   virtual void Run() {
     RunStart();
     MessageLoop::current()->Quit();
     RunEnd();
   }
 };
 
+class SleepTask : public OrderedTasks {
+ public:
+  SleepTask(TaskList* order, int cookie, int ms)
+      : OrderedTasks(order, SLEEP, cookie), ms_(ms) {
+  }
+
+  virtual void Run() {
+    RunStart();
+    PlatformThread::Sleep(ms_);
+    RunEnd();
+  }
+
+ private:
+  int ms_;
+};
+
 #if defined(OS_WIN)
 
 class Recursive2Tasks : public Task {
  public:
   Recursive2Tasks(MessageLoop* target,
                   HANDLE event,
                   bool expect_window,
                   TaskList* order,
                   bool is_reentrant)
       : target_(target),
@@ skipping 242 matching lines @@
   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) {
+void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type,
+                                     bool use_delayed) {
   MessageLoop loop(message_loop_type);
 
   TaskList order;
 
   MessageLoop::current()->PostTask(FROM_HERE,
                                    new TaskThatPumps(&order, 1));
   Task* task = new OrderedTasks(&order, 2);
-  MessageLoop::current()->PostNonNestableTask(FROM_HERE, task);
+  if (use_delayed) {
+    MessageLoop::current()->PostNonNestableDelayedTask(FROM_HERE, task, 1);
+  } else {
+    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);
-  MessageLoop::current()->PostNonNestableTask(FROM_HERE, non_nestable_quit);
+  MessageLoop::current()->PostTask(FROM_HERE, new SleepTask(&order, 4, 50));
+  MessageLoop::current()->PostTask(FROM_HERE, new OrderedTasks(&order, 5));
+  Task* non_nestable_quit = new QuitTask(&order, 6);
+  if (use_delayed) {
+    MessageLoop::current()->PostNonNestableDelayedTask(FROM_HERE,
+                                                       non_nestable_quit,
+                                                       2);
+  } else {
+    MessageLoop::current()->PostNonNestableTask(FROM_HERE, non_nestable_quit);
+  }
 
   MessageLoop::current()->Run();
 
   // FIFO order.
-  ASSERT_EQ(10U, order.size());
+  ASSERT_EQ(12U, 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));
-  EXPECT_EQ(order[ 5], TaskItem(PUMPS, 1, false));
-  EXPECT_EQ(order[ 6], TaskItem(ORDERERD, 2, true));
-  EXPECT_EQ(order[ 7], TaskItem(ORDERERD, 2, false));
-  EXPECT_EQ(order[ 8], TaskItem(QUITMESSAGELOOP, 5, true));
-  EXPECT_EQ(order[ 9], TaskItem(QUITMESSAGELOOP, 5, false));
+  EXPECT_EQ(order[ 3], TaskItem(SLEEP, 4, true));
+  EXPECT_EQ(order[ 4], TaskItem(SLEEP, 4, false));
+  EXPECT_EQ(order[ 5], TaskItem(ORDERERD, 5, true));
+  EXPECT_EQ(order[ 6], TaskItem(ORDERERD, 5, false));
+  EXPECT_EQ(order[ 7], TaskItem(PUMPS, 1, false));
+  EXPECT_EQ(order[ 8], TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order[ 9], TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order[10], TaskItem(QUITMESSAGELOOP, 6, true));
+  EXPECT_EQ(order[11], TaskItem(QUITMESSAGELOOP, 6, false));
 }
 
 #if defined(OS_WIN)
 
 class DispatcherImpl : public MessageLoopForUI::Dispatcher {
  public:
   DispatcherImpl() : dispatch_count_(0) {}
 
   virtual bool Dispatch(const MSG& msg) {
     ::TranslateMessage(&msg);
@@ skipping 290 matching lines @@
 }
 #endif  // defined(OS_WIN)
 
 TEST(MessageLoopTest, NonNestableWithNoNesting) {
   RunTest_NonNestableWithNoNesting(MessageLoop::TYPE_DEFAULT);
   RunTest_NonNestableWithNoNesting(MessageLoop::TYPE_UI);
   RunTest_NonNestableWithNoNesting(MessageLoop::TYPE_IO);
 }
 
 TEST(MessageLoopTest, NonNestableInNestedLoop) {
-  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_DEFAULT);
-  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI);
-  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO);
+  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_DEFAULT, false);
+  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, false);
+  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, false);
+}
+
+TEST(MessageLoopTest, NonNestableDelayedInNestedLoop) {
+  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_DEFAULT, true);
+  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, true);
+  RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, true);
 }
 
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 }
 
 TEST(MessageLoopTest, IOHandler) {
   RunTest_IOHandler();
@@ skipping 68 matching lines @@
       message_loop.WatchFileDescriptor(fd,
           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
       controller.StopWatchingFileDescriptor();
     }
   }
   close(pipefds[0]);
   close(pipefds[1]);
 }
 
 #endif  // defined(OS_LINUX)