Remove call to MessageLoop::RunUntilIdle from wait_util.mm.

base/test/ios/wait_util.mm

Index: base/test/ios/wait_util.mm
diff --git a/base/test/ios/wait_util.mm b/base/test/ios/wait_util.mm
index 05fc5147f9b6df5c931dc8944e96cf72c69d0917..651d1c6581f919e348d1ab6a9ad3a39f47a69362 100644
--- a/base/test/ios/wait_util.mm
+++ b/base/test/ios/wait_util.mm
@@ -8,7 +8,7 @@
 
 #include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
-#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/timer/elapsed_timer.h"
 
@@ -18,7 +18,7 @@ namespace ios {
 
 TimeDelta TimeUntilCondition(ProceduralBlock action,
                              ConditionBlock condition,
-                             MessageLoop* message_loop,
+                             bool run_message_loop,

[sdefresne, 2016/09/23 09:08:17]

It look like you are passing "true" for this variable in all callsite while
previously the value was null if MessageLoop::current() was returning null
(which is possible).

If this does not break anything, it's good, but there is a semantic change here.

In addition, if we only ever call this method with "true", then maybe we should
remove the extra parameter.

WDYT?

[fdoray, 2016/09/23 12:13:47]

You're right, this changes the semantic. But since the CL didn't break anything,
I don't think that MessageLoop::current() returned nullptr at any
TimeUntilCondition() call site before.

In ios_internal, there are call sites where nullptr is passed (will be migrated
to false). Therefore, we can't remove the extra parameter.

                              TimeDelta timeout) {
   ElapsedTimer timer;
   if (action)
@@ -28,11 +28,10 @@ TimeDelta TimeUntilCondition(ProceduralBlock action,
   const TimeDelta spin_delay(TimeDelta::FromMilliseconds(10));
   while (timer.Elapsed() < timeout && (!condition || !condition())) {
     SpinRunLoopWithMaxDelay(spin_delay);
-    if (message_loop) {
-      message_loop->RunUntilIdle();
-    }
+    if (run_message_loop)
+      RunLoop().RunUntilIdle();
   }
-  TimeDelta elapsed = timer.Elapsed();
+  const TimeDelta elapsed = timer.Elapsed();
   // If DCHECK is ever hit, check if |action| is doing something that is
   // taking an unreasonably long time, or if |condition| does not come
   // true quickly enough. Increase |timeout| only if necessary.
@@ -41,9 +40,9 @@ TimeDelta TimeUntilCondition(ProceduralBlock action,
 }
 
 void WaitUntilCondition(ConditionBlock condition,
-                        MessageLoop* message_loop,
+                        bool run_message_loop,
                         TimeDelta timeout) {
-  TimeUntilCondition(nil, condition, message_loop, timeout);
+  TimeUntilCondition(nil, condition, run_message_loop, timeout);
 }
 
 void WaitUntilCondition(ConditionBlock condition) {
@@ -60,10 +59,24 @@ void SpinRunLoopWithMaxDelay(TimeDelta max_delay) {
 void SpinRunLoopWithMinDelay(TimeDelta min_delay) {
   ElapsedTimer timer;
   while (timer.Elapsed() < min_delay) {
-    SpinRunLoopWithMaxDelay(base::TimeDelta::FromMilliseconds(10));
+    SpinRunLoopWithMaxDelay(TimeDelta::FromMilliseconds(10));
   }
 }
 
+TimeDelta TimeUntilCondition(ProceduralBlock action,
+                             ConditionBlock condition,
+                             MessageLoop* message_loop,
+                             TimeDelta timeout) {
+  return TimeUntilCondition(action, condition, message_loop != nullptr,
+                            timeout);
+}
+
+void WaitUntilCondition(ConditionBlock condition,
+                        MessageLoop* message_loop,
+                        TimeDelta timeout) {
+  WaitUntilCondition(condition, message_loop != nullptr, timeout);
+}
+
 }  // namespace ios
 }  // namespace test
 }  // namespace base