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..8c38a16f199083415346257515d2526d9f589c41 100644
--- a/base/message_loop_unittest.cc
+++ b/base/message_loop_unittest.cc
@@ -599,9 +599,10 @@ enum TaskType {
   RECURSIVE,
   TIMEDMESSAGELOOP,
   QUITMESSAGELOOP,
-  ORDERERD,
+  ORDERED,
   PUMPS,
   SLEEP,
+  RUNS,
 };
 
 // Saves the order in which the tasks executed.
@@ -628,7 +629,7 @@ std::ostream& operator <<(std::ostream& os, TaskType type) {
   case RECURSIVE:         os << "RECURSIVE"; break;
   case TIMEDMESSAGELOOP:  os << "TIMEDMESSAGELOOP"; break;
   case QUITMESSAGELOOP:   os << "QUITMESSAGELOOP"; break;
-  case ORDERERD:          os << "ORDERERD"; break;
+  case ORDERED:          os << "ORDERED"; break;
   case PUMPS:             os << "PUMPS"; break;
   case SLEEP:             os << "SLEEP"; break;
   default:
@@ -674,8 +675,8 @@ class TaskList {
 
 // Saves the order the tasks ran.
 void OrderedFunc(TaskList* order, int cookie) {
-  order->RecordStart(ORDERERD, cookie);
-  order->RecordEnd(ORDERERD, cookie);
+  order->RecordStart(ORDERED, cookie);
+  order->RecordEnd(ORDERED, cookie);
 }
 
 #if defined(OS_WIN)
@@ -847,8 +848,8 @@ void RunTest_RecursiveDenial3(MessageLoop::Type message_loop_type) {
   EXPECT_EQ(order.Get(3), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(RECURSIVE, 1, true));
   EXPECT_EQ(order.Get(5), TaskItem(RECURSIVE, 1, false));
-  EXPECT_EQ(order.Get(6), TaskItem(ORDERERD, 3, true));
-  EXPECT_EQ(order.Get(7), TaskItem(ORDERERD, 3, false));
+  EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 3, true));
+  EXPECT_EQ(order.Get(7), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(8), TaskItem(RECURSIVE, 2, true));
   EXPECT_EQ(order.Get(9), TaskItem(RECURSIVE, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 4, true));
@@ -997,6 +998,20 @@ void FuncThatPumps(TaskList* order, int cookie) {
   order->RecordEnd(PUMPS, cookie);
 }
 
+void FuncThatRuns(TaskList* order, int cookie,
+                  base::WeakPtr<MessageLoop::RunLoop> run_loop) {
+  order->RecordStart(RUNS, cookie);
+  {
+    MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
+    run_loop->Run();
+  }
+  order->RecordEnd(RUNS, cookie);
+}
+
+void FuncThatQuitsNow() {
+  MessageLoop::current()->QuitNow();
+}
+
 // Tests that non nestable tasks run in FIFO if there are no nested loops.
 void RunTest_NonNestableWithNoNesting(
     MessageLoop::Type message_loop_type) {
@@ -1015,10 +1030,10 @@ void RunTest_NonNestableWithNoNesting(
 
   // FIFO order.
   ASSERT_EQ(6U, order.Size());
-  EXPECT_EQ(order.Get(0), TaskItem(ORDERERD, 1, true));
-  EXPECT_EQ(order.Get(1), TaskItem(ORDERERD, 1, false));
-  EXPECT_EQ(order.Get(2), TaskItem(ORDERERD, 2, true));
-  EXPECT_EQ(order.Get(3), TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order.Get(0), TaskItem(ORDERED, 1, true));
+  EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 1, false));
+  EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(3), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(4), TaskItem(QUITMESSAGELOOP, 3, true));
   EXPECT_EQ(order.Get(5), TaskItem(QUITMESSAGELOOP, 3, false));
 }
@@ -1066,19 +1081,296 @@ void RunTest_NonNestableInNestedLoop(MessageLoop::Type message_loop_type,
   // FIFO order.
   ASSERT_EQ(12U, order.Size());
   EXPECT_EQ(order.Get(0), TaskItem(PUMPS, 1, true));
-  EXPECT_EQ(order.Get(1), TaskItem(ORDERERD, 3, true));
-  EXPECT_EQ(order.Get(2), TaskItem(ORDERERD, 3, false));
+  EXPECT_EQ(order.Get(1), TaskItem(ORDERED, 3, true));
+  EXPECT_EQ(order.Get(2), TaskItem(ORDERED, 3, false));
   EXPECT_EQ(order.Get(3), TaskItem(SLEEP, 4, true));
   EXPECT_EQ(order.Get(4), TaskItem(SLEEP, 4, false));
-  EXPECT_EQ(order.Get(5), TaskItem(ORDERERD, 5, true));
-  EXPECT_EQ(order.Get(6), TaskItem(ORDERERD, 5, false));
+  EXPECT_EQ(order.Get(5), TaskItem(ORDERED, 5, true));
+  EXPECT_EQ(order.Get(6), TaskItem(ORDERED, 5, false));
   EXPECT_EQ(order.Get(7), TaskItem(PUMPS, 1, false));
-  EXPECT_EQ(order.Get(8), TaskItem(ORDERERD, 2, true));
-  EXPECT_EQ(order.Get(9), TaskItem(ORDERERD, 2, false));
+  EXPECT_EQ(order.Get(8), TaskItem(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(9), TaskItem(ORDERED, 2, false));
   EXPECT_EQ(order.Get(10), TaskItem(QUITMESSAGELOOP, 6, true));
   EXPECT_EQ(order.Get(11), TaskItem(QUITMESSAGELOOP, 6, false));
 }
 
+// Tests RunLoopStop only quits the corresponding MessageLoop::Run.
+void RunTest_QuitNow(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop run_loop;
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, run_loop.AsWeakPtr()));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 3));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+  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(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests RunLoopStop works before RunWithID.
+void RunTest_RunLoopStopOrderBefore(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop run_loop;
+
+  run_loop.Stop();
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 1)); // never runs
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatQuitsNow)); // never runs
+
+  run_loop.Run();
+
+  ASSERT_EQ(0U, order.Size());
+}
+
+// Tests RunLoopStop works during RunWithID.
+void RunTest_RunLoopStopOrderDuring(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop run_loop;
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 1));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, run_loop.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2)); // never runs
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatQuitsNow)); // never runs
+
+  run_loop.Run();
+
+  ASSERT_EQ(2U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 1, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests RunLoopStop works after RunWithID.
+void RunTest_RunLoopStopOrderAfter(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop run_loop;
+
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatRuns, &order, 1, run_loop.AsWeakPtr()));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 3));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, run_loop.StopClosure()); // has no affect
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 4));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&FuncThatQuitsNow));
+
+  MessageLoop::RunLoop outer_run_loop;
+  outer_run_loop.Run();
+
+  ASSERT_EQ(8U, order.Size());
+  int task_index = 0;
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 3, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 4, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests RunLoopStop only quits the corresponding MessageLoop::Run.
+void RunTest_RunLoopStopTop(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop outer_run_loop;
+  MessageLoop::RunLoop nested_run_loop;
+
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 1, nested_run_loop.AsWeakPtr()));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, outer_run_loop.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop.StopClosure());
+
+  outer_run_loop.Run();
+
+  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(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests RunLoopStop only quits the corresponding MessageLoop::Run.
+void RunTest_RunLoopStopNested(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop outer_run_loop;
+  MessageLoop::RunLoop nested_run_loop;
+
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 1, nested_run_loop.AsWeakPtr()));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, outer_run_loop.StopClosure());
+
+  outer_run_loop.Run();
+
+  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(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests RunLoopStop only quits the corresponding MessageLoop::Run.
+void RunTest_RunLoopStopBogus(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop outer_run_loop;
+  MessageLoop::RunLoop nested_run_loop;
+  MessageLoop::RunLoop bogus_run_loop;
+
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 1, nested_run_loop.AsWeakPtr()));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, bogus_run_loop.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 2));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, outer_run_loop.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop.StopClosure());
+
+  outer_run_loop.Run();
+
+  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(ORDERED, 2, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 2, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(RUNS, 1, false));
+  EXPECT_EQ(static_cast<size_t>(task_index), order.Size());
+}
+
+// Tests RunLoopStop only quits the corresponding MessageLoop::Run.
+void RunTest_RunLoopStopDeep(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  TaskList order;
+
+  MessageLoop::RunLoop outer_run_loop;
+  MessageLoop::RunLoop nested_run_loop1;
+  MessageLoop::RunLoop nested_run_loop2;
+  MessageLoop::RunLoop nested_run_loop3;
+  MessageLoop::RunLoop nested_run_loop4;
+
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 1, nested_run_loop1.AsWeakPtr()));
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 2, nested_run_loop2.AsWeakPtr()));
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 3, nested_run_loop3.AsWeakPtr()));
+  MessageLoop::current()->PostTask(FROM_HERE,
+      base::Bind(&FuncThatRuns, &order, 4, nested_run_loop4.AsWeakPtr()));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 5));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, outer_run_loop.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 6));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop1.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 7));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop2.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 8));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop3.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 9));
+  MessageLoop::current()->PostTask(
+      FROM_HERE, nested_run_loop4.StopClosure());
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&OrderedFunc, &order, 10));
+
+  outer_run_loop.Run();
+
+  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(ORDERED, 5, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 5, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 6, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 7, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 8, false));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 9, true));
+  EXPECT_EQ(order.Get(task_index++), TaskItem(ORDERED, 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 +1726,54 @@ 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, RunLoopStopTop) {
+  RunTest_RunLoopStopTop(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopTop(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopTop(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, RunLoopStopNested) {
+  RunTest_RunLoopStopNested(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopNested(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopNested(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, RunLoopStopBogus) {
+  RunTest_RunLoopStopBogus(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopBogus(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopBogus(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, RunLoopStopDeep) {
+  RunTest_RunLoopStopDeep(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopDeep(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopDeep(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, RunLoopStopOrderBefore) {
+  RunTest_RunLoopStopOrderBefore(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopOrderBefore(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopOrderBefore(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, RunLoopStopOrderDuring) {
+  RunTest_RunLoopStopOrderDuring(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopOrderDuring(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopOrderDuring(MessageLoop::TYPE_IO);
+}
+
+TEST(MessageLoopTest, RunLoopStopOrderAfter) {
+  RunTest_RunLoopStopOrderAfter(MessageLoop::TYPE_DEFAULT);
+  RunTest_RunLoopStopOrderAfter(MessageLoop::TYPE_UI);
+  RunTest_RunLoopStopOrderAfter(MessageLoop::TYPE_IO);
+}
+
 void PostNTasksThenQuit(int posts_remaining) {
   if (posts_remaining > 1) {
     MessageLoop::current()->PostTask(