Refactor wait_util so it isn't coupled to EarlGrey.

ios/web/public/test/web_view_interaction_test_util.mm

 // Copyright 2016 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.
 
 #import "ios/web/public/test/web_view_interaction_test_util.h"
 
 #include "base/mac/bind_objc_block.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/ios/wait_util.h"
-#include "ios/testing/earl_grey/wait_util.h"
+#include "ios/testing/wait_util.h"
 #import "ios/web/public/web_state/crw_web_view_scroll_view_proxy.h"
 #import "ios/web/web_state/crw_web_view_proxy_impl.h"
 #import "ios/web/web_state/ui/crw_web_controller.h"
 #include "ios/web/web_state/web_state_impl.h"
 
 using web::NavigationManager;
 
 namespace web {
 namespace test {
 
 enum ElementAction {
   ELEMENT_ACTION_CLICK,
   ELEMENT_ACTION_FOCUS,
   ELEMENT_ACTION_SUBMIT
 };
 
 std::unique_ptr<base::Value> ExecuteJavaScript(web::WebState* web_state,
                                                const std::string& script) {
   __block std::unique_ptr<base::Value> result;
   __block bool did_finish = false;
   web_state->ExecuteJavaScript(base::UTF8ToUTF16(script),
                                base::BindBlock(^(const base::Value* value) {
                                  if (value)
                                    result = value->CreateDeepCopy();
                                  did_finish = true;
                                }));
 
-  testing::WaitUntilCondition(testing::kWaitForJSCompletionTimeout, ^{
-    return did_finish;
-  });
+  bool completed = testing::WaitUntilConditionOrTimeout(
+      testing::kWaitForJSCompletionTimeout, ^{
+        return did_finish;
+      });
+  if (!completed) {
+    return nullptr;

[baxley, 2016/10/25 00:00:53]

The old implementation issued a GREYAssert, which I don't think is good in
non-EarlGrey code. Let me know if you have a better thing to return from here on
failure.

+  }
 
   // As result is marked __block, this return call does a copy and not a move
   // (marking the variable as __block mean it is allocated in the block object
   // and not the stack). Since the "return std::move()" pattern is discouraged
   // use a local variable.
   //
   // Fixes the following compilation failure:
   //   ../web_view_matchers.mm:ll:cc: error: call to implicitly-deleted copy
   //       constructor of 'std::unique_ptr<base::Value>'
   std::unique_ptr<base::Value> stack_result = std::move(result);
@@ skipping 13 matching lines @@
       " not found'};"
       "  var rect = element.getBoundingClientRect();"
       "  return {"
       "      'left': rect.left,"
       "      'top': rect.top,"
       "      'width': rect.right - rect.left,"
       "      'height': rect.bottom - rect.top,"
       "    };"
       "})();";
 
-  base::DictionaryValue const* rect = nullptr;
-  bool found = false;
-  NSDate* deadline =
-      [NSDate dateWithTimeIntervalSinceNow:testing::kWaitForUIElementTimeout];
-  while (([[NSDate date] compare:deadline] != NSOrderedDescending) && !found) {
-    std::unique_ptr<base::Value> value =
-        ExecuteJavaScript(web_state, kGetBoundsScript);
-    base::DictionaryValue* dictionary = nullptr;
-    if (value && value->GetAsDictionary(&dictionary)) {
-      std::string error;
-      if (dictionary->GetString("error", &error)) {
-        DLOG(ERROR) << "Error getting rect: " << error << ", retrying..";
-      } else {
-        rect = dictionary->DeepCopy();
-        found = true;
-      }
-    }
-    base::test::ios::SpinRunLoopWithMaxDelay(
-        base::TimeDelta::FromSecondsD(testing::kSpinDelaySeconds));
-  }
+  __block base::DictionaryValue const* rect = nullptr;
+
+  bool found = testing::WaitUntilConditionOrTimeout(
+      testing::kWaitForUIElementTimeout, ^bool() {
+        std::unique_ptr<base::Value> value =
+            ExecuteJavaScript(web_state, kGetBoundsScript);
+        base::DictionaryValue* dictionary = nullptr;
+        if (value && value->GetAsDictionary(&dictionary)) {
+          std::string error;
+          if (dictionary->GetString("error", &error)) {
+            DLOG(ERROR) << "Error getting rect: " << error << ", retrying..";
+          } else {
+            rect = dictionary->DeepCopy();
+            return true;
+          }
+        }
+        return false;
+      });
 
   if (!found)
     return CGRectNull;
 
   double left, top, width, height;
   if (!(rect->GetDouble("left", &left) && rect->GetDouble("top", &top) &&
         rect->GetDouble("width", &width) &&
         rect->GetDouble("height", &height))) {
     return CGRectNull;
   }
@@ skipping 33 matching lines @@
                         "})();",
                        element_id.c_str(), js_action];
   __block bool did_complete = false;
   __block bool element_found = false;
   [web_controller executeUserJavaScript:script
                       completionHandler:^(id result, NSError*) {
                         did_complete = true;
                         element_found = [result boolValue];
                       }];
 
-  testing::WaitUntilCondition(testing::kWaitForJSCompletionTimeout, ^{
+  testing::WaitUntilConditionOrTimeout(testing::kWaitForJSCompletionTimeout, ^{
     return did_complete;
   });
 
   return element_found;
 }
 
 bool TapWebViewElementWithId(web::WebState* web_state,
                              const std::string& element_id) {
   return RunActionOnWebViewElementWithId(web_state, element_id,
                                          ELEMENT_ACTION_CLICK);
 }
 
 bool FocusWebViewElementWithId(web::WebState* web_state,
                                const std::string& element_id) {
   return RunActionOnWebViewElementWithId(web_state, element_id,
                                          ELEMENT_ACTION_FOCUS);
 }
 
 bool SubmitWebViewFormWithId(web::WebState* web_state,
                              const std::string& form_id) {
   return RunActionOnWebViewElementWithId(web_state, form_id,
                                          ELEMENT_ACTION_SUBMIT);
 }
 
 }  // namespace test
 }  // namespace web