Add base::RunLoop and update ui_test_utils to use it to reduce flakiness

base/message_loop_unittest.cc

Index: base/message_loop_unittest.cc
diff --git a/base/message_loop_unittest.cc b/base/message_loop_unittest.cc
index 7167c5ea4f386cab0bb1a207d074a0ddb515c03c..c72db2e26bbedd82a898a88b0ae314f0f8e9acde 100644
--- a/base/message_loop_unittest.cc
+++ b/base/message_loop_unittest.cc
@@ -602,6 +602,7 @@ enum TaskType {
   ORDERERD,

[jar (doing other things), 2012/06/18 19:43:21]

nit: Although you didn't type this.... I think this is a misspelling of:

ORDERED

[jbates, 2012/06/18 23:14:03]

Done.

   PUMPS,
   SLEEP,
+  RUNS,
 };
 
 // Saves the order in which the tasks executed.
@@ -997,6 +998,15 @@ void FuncThatPumps(TaskList* order, int cookie) {
   order->RecordEnd(PUMPS, cookie);
 }
 
+void FuncThatRuns(TaskList* order, int cookie, MessageLoop::RunID run_id) {
+  order->RecordStart(RUNS, cookie);
+  {
+    MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
+    MessageLoop::current()->RunWithID(run_id);
+  }
+  order->RecordEnd(RUNS, cookie);
+}
+
 // Tests that non nestable tasks run in FIFO if there are no nested loops.
 void RunTest_NonNestableWithNoNesting(
     MessageLoop::Type message_loop_type) {
@@ -1079,6 +1089,198 @@ void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type,
   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false));
 }
 
+// Tests QuitNowWithID only quits the corresponding MessageLoop::Run.
+void RunTest_QuitNow(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunID nested_run_id = MessageLoop::current()->GetRunID();
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, nested_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 3));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 4)); // never runs
+
+  MessageLoop::current()->Run();
+
+  ASSERT_EQ(6U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 3, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 3, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests QuitNowWithID only quits the corresponding MessageLoop::Run.
+void RunTest_QuitNowWithIDTop(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunID top_most_run_id = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id = MessageLoop::current()->GetRunID();
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, nested_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(top_most_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id));
+
+  MessageLoop::current()->RunWithID(top_most_run_id);
+
+  ASSERT_EQ(4U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests QuitNowWithID only quits the corresponding MessageLoop::Run.
+void RunTest_QuitNowWithIDNested(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunID top_most_run_id = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id = MessageLoop::current()->GetRunID();
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, nested_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(top_most_run_id));
+
+  MessageLoop::current()->RunWithID(top_most_run_id);
+
+  ASSERT_EQ(4U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests QuitNowWithID only quits the corresponding MessageLoop::Run.
+void RunTest_QuitNowWithIDBogus(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunID top_most_run_id = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID bogus_run_id = MessageLoop::current()->GetRunID();
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, nested_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(bogus_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(top_most_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id));
+
+  MessageLoop::current()->RunWithID(top_most_run_id);
+
+  ASSERT_EQ(4U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests QuitNowWithID only quits the corresponding MessageLoop::Run.
+void RunTest_QuitNowWithIDDeep(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunID top_most_run_id = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id1 = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id2 = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id3 = MessageLoop::current()->GetRunID();
+  MessageLoop::RunID nested_run_id4 = MessageLoop::current()->GetRunID();
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, nested_run_id1));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 2, nested_run_id2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 3, nested_run_id3));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 4, nested_run_id4));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 5));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(top_most_run_id));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 6));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id1));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 7));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 8));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id3));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 9));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, MessageLoop::QuitNowWithIDClosure(nested_run_id4));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 10));
+
+  MessageLoop::current()->RunWithID(top_most_run_id);
+
+  ASSERT_EQ(18U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 5, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 5, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 6, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 6, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 7, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 7, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 8, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 8, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 9, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERERD, 9, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 4, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 3, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
 #if defined(OS_WIN)
 
 class DispatcherImpl : public MessageLoopForUI::Dispatcher {
@@ -1434,6 +1636,36 @@ TEST(MessageLoopTest, NonNestableDelayedInNestedLoop) {
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, true);
 }
 
+TEST(MessageLoopTest, QuitNow) {
+  RunTest_QuitNow(MessageLoop::TYPE_DEFAULT);
+  RunTest_QuitNow(MessageLoop::TYPE_UI);
+  RunTest_QuitNow(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, QuitNowWithIDTop) {
+  RunTest_QuitNowWithIDTop(MessageLoop::TYPE_DEFAULT);
+  RunTest_QuitNowWithIDTop(MessageLoop::TYPE_UI);
+  RunTest_QuitNowWithIDTop(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, QuitNowWithIDNested) {
+  RunTest_QuitNowWithIDNested(MessageLoop::TYPE_DEFAULT);
+  RunTest_QuitNowWithIDNested(MessageLoop::TYPE_UI);
+  RunTest_QuitNowWithIDNested(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, QuitNowWithIDBogus) {
+  RunTest_QuitNowWithIDBogus(MessageLoop::TYPE_DEFAULT);
+  RunTest_QuitNowWithIDBogus(MessageLoop::TYPE_UI);
+  RunTest_QuitNowWithIDBogus(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, QuitNowWithIDDeep) {
+  RunTest_QuitNowWithIDDeep(MessageLoop::TYPE_DEFAULT);
+  RunTest_QuitNowWithIDDeep(MessageLoop::TYPE_UI);
+  RunTest_QuitNowWithIDDeep(MessageLoop::TYPE_IO);
+}
+
 void PostNTasksThenQuit(int posts_remaining) {
   if (posts_remaining > 1) {
     MessageLoop::current()->PostTask(