Create ChromeEarlGrey waitForWebViewContainingText.

ios/chrome/browser/web/navigation_egtest.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 <XCTest/XCTest.h>
 
 #include "base/ios/ios_util.h"
+#include "base/strings/sys_string_conversions.h"
 #include "components/strings/grit/components_strings.h"
 #include "ios/chrome/test/app/web_view_interaction_test_util.h"
 #import "ios/chrome/test/earl_grey/chrome_earl_grey.h"
 #import "ios/chrome/test/earl_grey/chrome_matchers.h"
 #import "ios/chrome/test/earl_grey/chrome_test_case.h"
 #import "ios/web/public/test/http_server.h"
 #include "ios/web/public/test/http_server_util.h"
 #include "ios/web/public/test/response_providers/data_response_provider.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using chrome_test_util::BackButton;
 using chrome_test_util::ForwardButton;
 using chrome_test_util::TapWebViewElementWithId;
-using chrome_test_util::WebViewContainingText;
 
 namespace {
 
 // URL for the test window.history.go() test file.  The page at this URL
 // contains several buttons that trigger window.history commands.  Additionally
 // the page contains several divs used to display the state of the page:
 // - A div that is populated with |kOnLoadText| when the onload event fires.
 // - A div that is populated with |kNoOpText| 1s after a button is tapped.
 // - A div that is populated with |kPopStateReceivedText| when a popstate event
 //   is received by the page.
 // - A div that is populated with the state object (if it's a string) upon the
 //   receipt of a popstate event.
 // - A div that is populated with |kHashChangeReceivedText| when a hashchange
 //   event is received.
 // When a button on the page is tapped, all pre-existing div text is cleared,
 // so matching against this webview text after a button is tapped ensures that
 // the state is set in response to the most recently executed script.
 const char kWindowHistoryGoTestURL[] =
     "http://ios/testing/data/http_server_files/history_go.html";
 
 // URL of a sample file-based page.
 const char kSampleFileBasedURL[] =
     "http://ios/testing/data/http_server_files/chromium_logo_page.html";
 
 // Strings used by history_go.html.
-const char kOnLoadText[] = "OnLoadText";
-const char kNoOpText[] = "NoOpText";
+NSString* const kOnLoadText = @"OnLoadText";
+NSString* const kNoOpText = @"NoOpText";
 
 // Button ids for history_go.html.
 NSString* const kGoNoParameterID = @"go-no-parameter";
 NSString* const kGoZeroID = @"go-zero";
 NSString* const kGoTwoID = @"go-2";
 NSString* const kGoBackTwoID = @"go-back-2";
 
 // URLs and labels for tests that navigate back and forward.
 const char kBackHTMLButtonLabel[] = "BackHTMLButton";
 const char kForwardHTMLButtonLabel[] = "ForwardHTMLButton";
-const char kForwardHTMLSentinel[] = "Forward page loaded";
-const char kTestPageSentinel[] = "Test Page";
 const char kBackURL[] = "http://back";
 const char kForwardURL[] = "http://forward";
 const char kTestURL[] = "http://test";
+NSString* const kForwardHTMLSentinel = @"Forward page loaded";
+NSString* const kTestPageSentinel = @"Test Page";
 
 // URLs and labels for scenarioWindowLocation* tests.
 const char kHashChangeWithHistoryLabel[] = "hashChangedWithHistory";
 const char kHashChangeWithoutHistoryLabel[] = "hashChangedWithoutHistory";
 const char kPage1URL[] = "http://page1";
 const char kHashChangedWithHistoryURL[] =
     "http://page1/#hashChangedWithHistory";
 const char kHashChangedWithoutHistoryURL[] =
     "http://page1/#hashChangedWithoutHistory";
 const char kNoHashChangeText[] = "No hash change";
@@ skipping 123 matching lines @@
 #pragma mark window.history.go operations
 
 // Tests reloading the current page via window.history.go() with no parameters.
 - (void)testHistoryGoNoParameter {
   web::test::SetUpFileBasedHttpServer();
 
   // Load the history test page and ensure that its onload text is visible.
   const GURL windowHistoryURL =
       web::test::HttpServer::MakeUrl(kWindowHistoryGoTestURL);
   [ChromeEarlGrey loadURL:windowHistoryURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 
   // Tap on the window.history.go() button.  This will clear |kOnLoadText|, so
   // the subsequent check for |kOnLoadText| will only pass if a reload has
   // occurred.
   [ChromeEarlGrey tapWebViewElementWithID:kGoNoParameterID];
 
   // Verify that the onload text is reset.
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 }
 
 // Tests reloading the current page via history.go(0).
 - (void)testHistoryGoDeltaZero {
   web::test::SetUpFileBasedHttpServer();
 
   // Load the history test page and ensure that its onload text is visible.
   const GURL windowHistoryURL =
       web::test::HttpServer::MakeUrl(kWindowHistoryGoTestURL);
   [ChromeEarlGrey loadURL:windowHistoryURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 
   // Tap on the window.history.go() button.  This will clear |kOnLoadText|, so
   // the subsequent check for |kOnLoadText| will only pass if a reload has
   // occurred.
   [ChromeEarlGrey tapWebViewElementWithID:kGoZeroID];
 
   // Verify that the onload text is reset.
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 }
 
 // Tests that calling window.history.go() with an offset that is out of bounds
 // is a no-op.
 - (void)testHistoryGoOutOfBounds {
   web::test::SetUpFileBasedHttpServer();
 
   // Load the history test page and ensure that its onload text is visible.
   const GURL windowHistoryURL =
       web::test::HttpServer::MakeUrl(kWindowHistoryGoTestURL);
   [ChromeEarlGrey loadURL:windowHistoryURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 
   // Tap on the window.history.go(2) button.  This will clear all div text, so
   // the subsequent check for |kNoOpText| will only pass if no navigations have
   // occurred.
   [ChromeEarlGrey tapWebViewElementWithID:kGoTwoID];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kNoOpText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kNoOpText];
 
   // Tap on the window.history.go(-2) button.  This will clear all div text, so
   // the subsequent check for |kNoOpText| will only pass if no navigations have
   // occurred.
   [ChromeEarlGrey tapWebViewElementWithID:kGoBackTwoID];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kNoOpText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kNoOpText];
 }
 
 // Tests going back and forward via history.go().
 - (void)testHistoryGoDelta {
   std::map<GURL, std::string> responses;
   const GURL firstURL = web::test::HttpServer::MakeUrl("http://page1");
   const GURL secondURL = web::test::HttpServer::MakeUrl("http://page2");
   const GURL thirdURL = web::test::HttpServer::MakeUrl("http://page3");
   const GURL fourthURL = web::test::HttpServer::MakeUrl("http://page4");
   responses[firstURL] =
       "page1 <input type='button' value='goForward' id='goForward' "
       "onclick='window.history.go(2)' />";
   responses[secondURL] = "page2";
   responses[thirdURL] = "page3";
   responses[fourthURL] =
       "page4 <input type='button' value='goBack' id='goBack' "
       "onclick='window.history.go(-3)' />";
   web::test::SetUpSimpleHttpServer(responses);
 
   // Load 4 pages.
   [ChromeEarlGrey loadURL:firstURL];
   [ChromeEarlGrey loadURL:secondURL];
   [ChromeEarlGrey loadURL:thirdURL];
   [ChromeEarlGrey loadURL:fourthURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText("page4")]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:@"page4"];
 
   // Tap button to go back 3 pages.
   TapWebViewElementWithId("goBack");
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText("page1")]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:@"page1"];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           firstURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Tap button to go forward 2 pages.
   TapWebViewElementWithId("goForward");
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText("page3")]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:@"page3"];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           thirdURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that calls to window.history.go() that span multiple documents causes
 // a load to occur.
 - (void)testHistoryCrossDocumentLoad {
   web::test::SetUpFileBasedHttpServer();
 
   // Load the history test page and ensure that its onload text is visible.
   const GURL windowHistoryURL =
       web::test::HttpServer::MakeUrl(kWindowHistoryGoTestURL);
   [ChromeEarlGrey loadURL:windowHistoryURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 
   const GURL sampleURL = web::test::HttpServer::MakeUrl(kSampleFileBasedURL);
   [ChromeEarlGrey loadURL:sampleURL];
 
   [ChromeEarlGrey loadURL:windowHistoryURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 
   // Tap the window.history.go(-2) button.  This will clear the current page's
   // |kOnLoadText|, so the subsequent check will only pass if another load
   // occurs.
   [ChromeEarlGrey tapWebViewElementWithID:kGoBackTwoID];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kOnLoadText)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kOnLoadText];
 }
 
 #pragma mark window.history.[back/forward] operations
 
 // Tests going back via history.back() then forward via forward button.
 - (void)testHistoryBackNavigation {
   SetupBackAndForwardResponseProvider();
 
   // Navigate to a URL.
   const GURL firstURL = web::test::HttpServer::MakeUrl(kTestURL);
@@ skipping 25 matching lines @@
   const GURL firstURL = web::test::HttpServer::MakeUrl(kForwardURL);
   [ChromeEarlGrey loadURL:firstURL];
 
   // Navigate to some other page.
   const GURL secondURL = web::test::HttpServer::MakeUrl(kTestURL);
   [ChromeEarlGrey loadURL:secondURL];
 
   // Tap the back button in the toolbar and verify the page with forward button
   // is loaded.
   [[EarlGrey selectElementWithMatcher:BackButton()] performAction:grey_tap()];
-  [[EarlGrey
-      selectElementWithMatcher:WebViewContainingText(kForwardHTMLSentinel)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kForwardHTMLSentinel];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           firstURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Tap the forward button in the HTML and verify the second URL is loaded.
   TapWebViewElementWithId(kForwardHTMLButtonLabel);
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(kTestPageSentinel)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kTestPageSentinel];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           secondURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Verify that the forward button is not enabled.
   // TODO(crbug.com/638674): Evaluate if size class determination can move to
   // shared code.
   if (UIApplication.sharedApplication.keyWindow.traitCollection
           .horizontalSizeClass == UIUserInterfaceSizeClassCompact) {
     // In horizontally compact environments, the forward button is not visible.
@@ skipping 59 matching lines @@
   // Click link to update location.hash and go to new URL (same page).
   chrome_test_util::TapWebViewElementWithId(kHashChangeWithHistoryLabel);
 
   // Navigate back to original URL. This should fire a hashchange event.
   std::string backHashChangeContent = "backHashChange";
   [self addHashChangeListenerWithContent:backHashChangeContent];
   [[EarlGrey selectElementWithMatcher:BackButton()] performAction:grey_tap()];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           page1URL.GetContent())]
       assertWithMatcher:grey_notNil()];
-  [[EarlGrey
-      selectElementWithMatcher:WebViewContainingText(backHashChangeContent)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:base::SysUTF8ToNSString(
+                                                   backHashChangeContent)];
 
   // Navigate forward to the new URL. This should fire a hashchange event.
   std::string forwardHashChangeContent = "forwardHashChange";
   [self addHashChangeListenerWithContent:forwardHashChangeContent];
   [[EarlGrey selectElementWithMatcher:ForwardButton()]
       performAction:grey_tap()];
   [[EarlGrey
       selectElementWithMatcher:chrome_test_util::OmniboxText(
                                    hashChangedWithHistoryURL.GetContent())]
       assertWithMatcher:grey_notNil()];
-  [[EarlGrey
-      selectElementWithMatcher:WebViewContainingText(forwardHashChangeContent)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:base::SysUTF8ToNSString(
+                                                   forwardHashChangeContent)];
 
   // Load a hash URL directly. This shouldn't fire a hashchange event.
   std::string hashChangeContent = "FAIL_loadUrlHashChange";
   [self addHashChangeListenerWithContent:hashChangeContent];
   [ChromeEarlGrey loadURL:hashChangedWithHistoryURL];
-  [[EarlGrey selectElementWithMatcher:WebViewContainingText(hashChangeContent)]
-      assertWithMatcher:grey_nil()];
+  // TODO(crbug.com/714157): Remove matcher that waits.
+  [[EarlGrey
+      selectElementWithMatcher:chrome_test_util::WebViewNotContainingText(
+                                   hashChangeContent)]
+      assertWithMatcher:grey_notNil()];
 }
 
 // Loads a URL and replaces its location, then updates its location.hash
 // and verifies that going back returns to the replaced entry.
 - (void)testWindowLocationReplaceAndChangeHash {
   std::map<GURL, std::string> responses;
   const GURL page1URL = web::test::HttpServer::MakeUrl(kPage1URL);
   const GURL hashChangedWithoutHistoryURL =
       web::test::HttpServer::MakeUrl(kHashChangedWithoutHistoryURL);
   const GURL hashChangedWithHistoryURL =
@@ skipping 172 matching lines @@
   // Navigate forward and assert the the resulting page is the proper
   // destination.
   [[EarlGrey selectElementWithMatcher:ForwardButton()]
       performAction:grey_tap()];
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 @end