Create ChromeEarlGrey waitForWebViewContainingText.

ios/chrome/browser/metrics/tab_usage_recorder_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 <EarlGrey/EarlGrey.h>
 #import <XCTest/XCTest.h>
 
 #include "base/mac/bind_objc_block.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 33 matching lines @@
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
 #endif
 
 using chrome_test_util::OpenLinkInNewTabButton;
 
 namespace {
 
 const char kTestUrl1[] =
     "http://ios/testing/data/http_server_files/memory_usage.html";
-const char kURL1FirstWord[] = "Page";
+NSString* const kURL1FirstWord = @"Page";
 const char kTestUrl2[] =
     "http://ios/testing/data/http_server_files/fullscreen.html";
-const char kURL2FirstWord[] = "Rugby";
+NSString* const kURL2FirstWord = @"Rugby";
 const char kClearPageScript[] = "document.body.innerHTML='';";
 
 // The delay to use to serve slow URLs.
 const CGFloat kSlowURLDelay = 3;
 
 // The delay to wait for an element to appear before tapping on it.
 const CGFloat kWaitElementTimeout = 3;
 
 void ResetTabUsageRecorder() {
   GREYAssertTrue(chrome_test_util::ResetTabUsageRecorder(),
@@ skipping 14 matching lines @@
 }
 
 // Wait until |matcher| is accessible (not nil) and tap on it.
 void WaitAndTap(id<GREYMatcher> matcher, NSString* name) {
   Wait(matcher, name);
   [[EarlGrey selectElementWithMatcher:matcher] performAction:grey_tap()];
 }
 
 // Creates a new main tab and load |url|. Wait until |word| is visible on the
 // page.
-void NewMainTabWithURL(const GURL& url, const std::string& word) {
+void NewMainTabWithURL(const GURL& url, NSString* word) {
   int number_of_tabs = chrome_test_util::GetMainTabCount();
   chrome_test_util::OpenNewTab();
   [ChromeEarlGrey loadURL:url];
-  [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::WebViewContainingText(word)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:word];
   chrome_test_util::AssertMainTabCount(number_of_tabs + 1);
 }
 
 // Opens 2 new tabs with different URLs.
 void OpenTwoTabs() {
   chrome_test_util::CloseAllTabsInCurrentMode();
 
   const GURL url1 = web::test::HttpServer::MakeUrl(kTestUrl1);
   const GURL url2 = web::test::HttpServer::MakeUrl(kTestUrl2);
   NewMainTabWithURL(url1, kURL1FirstWord);
@@ skipping 158 matching lines @@
   histogramTester.ExpectUniqueSample(
       kSelectedTabHistogramName, TabUsageRecorder::IN_MEMORY, 1, failureBlock);
 
   // Evict the tab.
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   GREYAssertTrue(chrome_test_util::IsIncognitoMode(),
                  @"Failed to switch to incognito mode");
 
   // Switch back to the normal tabs. Should be on tab one.
   SwitchToNormalMode();
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL1FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
 
   histogramTester.ExpectTotalCount(kSelectedTabHistogramName, 2, failureBlock);
   histogramTester.ExpectBucketCount(kSelectedTabHistogramName,
                                     TabUsageRecorder::EVICTED, 1, failureBlock);
 }
 
 // Verifies the UMA metric for page loads before a tab eviction by loading
 // some tabs, forcing a tab eviction, then checking the histogram.
 - (void)testPageLoadCountBeforeEvictedTab {
   web::test::SetUpFileBasedHttpServer();
   chrome_test_util::HistogramTester histogramTester;
   ResetTabUsageRecorder();
   const GURL url1 = web::test::HttpServer::MakeUrl(kTestUrl1);
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
 
   // This test opens three tabs.
   const int numberOfTabs = 3;
   chrome_test_util::CloseAllTabsInCurrentMode();
   // Open three tabs with http:// urls.
   for (NSUInteger i = 0; i < numberOfTabs; i++) {
     chrome_test_util::OpenNewTab();
     [ChromeEarlGrey loadURL:url1];
-    [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                            kURL1FirstWord)]
-        assertWithMatcher:grey_notNil()];
+    [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
   }
   chrome_test_util::AssertMainTabCount(numberOfTabs);
 
   // Switch between the tabs. They are currently in memory.
   chrome_test_util::SelectTabAtIndexInCurrentMode(0);
 
   // Verify that no page-load count has been recorded.
   histogramTester.ExpectTotalCount(kPageLoadsBeforeEvictedTabSelected, 0,
                                    failureBlock);
 
   // Reload each tab.
   for (NSUInteger i = 0; i < numberOfTabs; i++) {
     chrome_test_util::SelectTabAtIndexInCurrentMode(i);
     // Clear the page so that we can check when page reload is complete.
     __block bool finished = false;
     chrome_test_util::GetCurrentWebState()->ExecuteJavaScript(
         base::UTF8ToUTF16(kClearPageScript),
         base::BindBlockArc(^(const base::Value*) {
           finished = true;
         }));
 
     GREYAssert(testing::WaitUntilConditionOrTimeout(1.0,
                                                     ^{
                                                       return finished;
                                                     }),
                @"JavaScript to reload each tab did not finish");
     [ChromeEarlGreyUI reload];
-    [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                            kURL1FirstWord)]
-        assertWithMatcher:grey_notNil()];
+    [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
   }
 
   // Evict the tab. Create a dummy tab so that switching back to normal mode
   // does not trigger a reload immediatly.
   chrome_test_util::OpenNewTab();
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   chrome_test_util::AssertIncognitoTabCount(1);
 
   // Switch back to the normal tabs. Should be on tab one.
   SwitchToNormalMode();
   chrome_test_util::SelectTabAtIndexInCurrentMode(0);
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL1FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
 
   // Verify that one page-load count has been recorded. It should contain two
   // page loads for each tab created.
   histogramTester.ExpectTotalCount(kPageLoadsBeforeEvictedTabSelected, 1,
                                    failureBlock);
 
   std::unique_ptr<base::HistogramSamples> samples =
       histogramTester.GetHistogramSamplesSinceCreation(
           kPageLoadsBeforeEvictedTabSelected);
   int sampleSum = samples ? samples->sum() : 0;
@@ skipping 16 matching lines @@
   GREYAssertTrue(chrome_test_util::SetCurrentTabsToBeColdStartTabs(),
                  @"Fail to state tabs as cold start tabs");
 
   // Open two incognito tabs with urls, clearing normal tabs from memory.
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   chrome_test_util::AssertIncognitoTabCount(2);
 
   // Switch back to the normal tabs.
   SwitchToNormalMode();
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL2FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL2FirstWord];
 
   // Select the other one so it also reloads.
   chrome_test_util::SelectTabAtIndexInCurrentMode(0);
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL1FirstWord)]
-      assertWithMatcher:grey_notNil()];
-
+  [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
   // Make sure that one of the 2 tab loads (excluding the selected tab) is
   // counted as a cold start eviction.
   histogramTester.ExpectBucketCount(kSelectedTabHistogramName,
                                     TabUsageRecorder::EVICTED_DUE_TO_COLD_START,
                                     1, failureBlock);
 
   histogramTester.ExpectBucketCount(
       kSelectedTabHistogramName, TabUsageRecorder::IN_MEMORY, 0, failureBlock);
   // Re-select the same tab and make sure it is not counted again as evicted.
   chrome_test_util::SelectTabAtIndexInCurrentMode(1);
   chrome_test_util::SelectTabAtIndexInCurrentMode(0);
 
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL1FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
   histogramTester.ExpectBucketCount(kSelectedTabHistogramName,
                                     TabUsageRecorder::EVICTED_DUE_TO_COLD_START,
                                     1, failureBlock);
 
   histogramTester.ExpectBucketCount(
       kSelectedTabHistogramName, TabUsageRecorder::IN_MEMORY, 2, failureBlock);
 }
 
 // Tests that tabs reloads after backgrounding and eviction.
 - (void)testBackgroundingReloadCount {
@@ skipping 13 matching lines @@
                  @"Fail to simulate tab backgrounding.");
 
   // Open incognito and clear normal tabs from memory.
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   GREYAssertTrue(chrome_test_util::IsIncognitoMode(),
                  @"Failed to switch to incognito mode");
   histogramTester.ExpectTotalCount(kEvictedTabReloadTime, 0, failureBlock);
 
   // Switch back to the normal tabs.
   SwitchToNormalMode();
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL2FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL2FirstWord];
 
   const GURL url1 = web::test::HttpServer::MakeUrl(kTestUrl1);
   const GURL url2 = web::test::HttpServer::MakeUrl(kTestUrl2);
   [[EarlGrey
       selectElementWithMatcher:chrome_test_util::OmniboxText(url2.GetContent())]
       assertWithMatcher:grey_notNil()];
   histogramTester.ExpectTotalCount(kEvictedTabReloadTime, 1, failureBlock);
 
   chrome_test_util::SelectTabAtIndexInCurrentMode(0);
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL1FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
   [[EarlGrey
       selectElementWithMatcher:chrome_test_util::OmniboxText(url1.GetContent())]
       assertWithMatcher:grey_notNil()];
   histogramTester.ExpectTotalCount(kEvictedTabReloadTime, 2, failureBlock);
 }
 
 // Verify correct recording of metrics when the reloading of an evicted tab
 // succeeds.
 - (void)testEvictedTabReloadSuccess {
   web::test::SetUpFileBasedHttpServer();
   chrome_test_util::HistogramTester histogramTester;
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
 
   GURL URL = web::test::HttpServer::MakeUrl(kTestUrl1);
   NewMainTabWithURL(URL, kURL1FirstWord);
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   SwitchToNormalMode();
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          kURL1FirstWord)]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:kURL1FirstWord];
 
   histogramTester.ExpectUniqueSample(kEvictedTabReloadSuccessRate,
                                      TabUsageRecorder::LOAD_SUCCESS, 1,
                                      failureBlock);
   histogramTester.ExpectUniqueSample(kDidUserWaitForEvictedTabReload,
                                      TabUsageRecorder::USER_WAITED, 1,
                                      failureBlock);
   histogramTester.ExpectTotalCount(kEvictedTabReloadTime, 1, failureBlock);
 }
 
@@ skipping 81 matching lines @@
   const GURL slowURL = web::test::HttpServer::MakeUrl("http://slow");
   responses[slowURL] = "Slow Page";
 
   web::test::SetUpHttpServer(base::MakeUnique<HtmlResponseProvider>(responses));
 
   chrome_test_util::HistogramTester histogramTester;
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
 
-  NewMainTabWithURL(slowURL, "Slow");
+  NewMainTabWithURL(slowURL, @"Slow");
 
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   web::test::SetUpHttpServer(base::MakeUnique<web::DelayedResponseProvider>(
       base::MakeUnique<HtmlResponseProvider>(responses), kSlowURLDelay));
 
   SwitchToNormalMode();
 
   // TODO(crbug.com/640977): EarlGrey synchronize on some animations when a
   // page is loading. Need to handle synchronization manually for this test.
   [[GREYConfiguration sharedInstance]
@@ skipping 16 matching lines @@
   responses[slowURL] = "Slow Page";
 
   web::test::SetUpHttpServer(base::MakeUnique<web::DelayedResponseProvider>(
       base::MakeUnique<HtmlResponseProvider>(responses), kSlowURLDelay));
 
   chrome_test_util::HistogramTester histogramTester;
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
 
-  NewMainTabWithURL(slowURL, responses[slowURL]);
+  NewMainTabWithURL(slowURL, base::SysUTF8ToNSString(responses[slowURL]));
 
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
 
   SwitchToNormalMode();
   // TODO(crbug.com/640977): EarlGrey synchronize on some animations when a
   // page is loading. Need to handle synchronization manually for this test.
   [[GREYConfiguration sharedInstance]
           setValue:@(NO)
       forConfigKey:kGREYConfigKeySynchronizationEnabled];
   OpenSettingsMenuUnsynced();
   OpenSettingsSubMenuUnsynced(IDS_OPTIONS_ADVANCED_SECTION_TITLE_PRIVACY);
   Wait(grey_accessibilityID(kPrivacyCollectionViewId),
        @"Privacy settings view.");
 
   WaitAndTap(chrome_test_util::NavigationBarDoneButton(), @"Close settings");
   [[GREYUIThreadExecutor sharedInstance] drainUntilIdle];
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          responses[slowURL])]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey
+      waitForWebViewContainingText:base::SysUTF8ToNSString(responses[slowURL])];
 
   [[GREYConfiguration sharedInstance]
           setValue:@(YES)
       forConfigKey:kGREYConfigKeySynchronizationEnabled];
 
   histogramTester.ExpectBucketCount(kDidUserWaitForEvictedTabReload,
                                     TabUsageRecorder::USER_DID_NOT_WAIT, 0,
                                     failureBlock);
   histogramTester.ExpectBucketCount(kDidUserWaitForEvictedTabReload,
                                     TabUsageRecorder::USER_WAITED, 1,
@@ skipping 79 matching lines @@
 // Tests that redirecting pages are not reloaded after eviction.
 - (void)testPageRedirect {
   GURL redirectURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/redirect_refresh.html");
   GURL destinationURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/destination.html");
   web::test::SetUpFileBasedHttpServer();
   chrome_test_util::HistogramTester histogramTester;
   ResetTabUsageRecorder();
 
-  NewMainTabWithURL(redirectURL, "arrived");
+  NewMainTabWithURL(redirectURL, @"arrived");
 
   [[EarlGrey selectElementWithMatcher:chrome_test_util::OmniboxText(
                                           destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   NSUInteger tabIndex = chrome_test_util::GetMainTabCount() - 1;
   chrome_test_util::OpenNewTab();
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   SwitchToNormalMode();
   chrome_test_util::SelectTabAtIndexInCurrentMode(tabIndex);
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
-                                          "arrived")]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:@"arrived"];
 
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
   // Verify that one page-load count has been recorded.  It should contain a
   // sum of 1 - one sample with 1 page load.
   histogramTester.ExpectTotalCount(kPageLoadsBeforeEvictedTabSelected, 1,
                                    failureBlock);
 
   std::unique_ptr<base::HistogramSamples> samples =
@@ skipping 15 matching lines @@
       web::test::HttpServer::MakeUrl("http://destination");
   responses[initialURL] = base::StringPrintf(
       "<body><a style='margin-left:50px' href='%s' id='link'>link</a></body>",
       destinationURL.spec().c_str());
   responses[destinationURL] = "Whee!";
   web::test::SetUpHttpServer(base::MakeUnique<HtmlResponseProvider>(responses));
   chrome_test_util::HistogramTester histogramTester;
   ResetTabUsageRecorder();
 
   // Open a tab with a link to click.
-  NewMainTabWithURL(initialURL, "link");
+  NewMainTabWithURL(initialURL, @"link");
   // Click the link.
   chrome_test_util::TapWebViewElementWithId("link");
 
-  [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::WebViewContainingText("Whee")]
-      assertWithMatcher:grey_notNil()];
-
+  [ChromeEarlGrey waitForWebViewContainingText:@"Whee"];
   NSUInteger tabIndex = chrome_test_util::GetMainTabCount() - 1;
   chrome_test_util::OpenNewTab();
   OpenNewIncognitoTabUsingUIAndEvictMainTabs();
   SwitchToNormalMode();
   chrome_test_util::SelectTabAtIndexInCurrentMode(tabIndex);
-  [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::WebViewContainingText("Whee")]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:@"Whee"];
 
   // Verify that the page-load count has been recorded.  It should contain a
   // sum of 2 - one sample with 2 page loads.
   std::unique_ptr<base::HistogramSamples> samples =
       histogramTester.GetHistogramSamplesSinceCreation(
           kPageLoadsBeforeEvictedTabSelected);
   int sampleSum = samples->sum();
   GREYAssertEqual(sampleSum, 2, @"Expected page loads is %d, actual %d.", 2,
                   sampleSum);
 
@@ skipping 20 matching lines @@
       "<body style='width:auto; height:auto;'><a href='%s' "
       "id='link'><div style='width:100%%; "
       "height:100%%;'>link</div></a></body>",
       destinationURL.spec().c_str());
   responses[destinationURL] = "Whee!";
   web::test::SetUpHttpServer(base::MakeUnique<HtmlResponseProvider>(responses));
   chrome_test_util::HistogramTester histogramTester;
   ResetTabUsageRecorder();
 
   // Open a tab with a link to click.
-  NewMainTabWithURL(initialURL, "link");
+  NewMainTabWithURL(initialURL, @"link");
 
   int numberOfTabs = chrome_test_util::GetMainTabCount();
   id<GREYMatcher> webViewMatcher =
       web::WebViewInWebState(chrome_test_util::GetCurrentWebState());
   [[EarlGrey selectElementWithMatcher:webViewMatcher]
       performAction:chrome_test_util::LongPressElementForContextMenu(
                         "link", true /* menu should appear */)];
 
   [[EarlGrey selectElementWithMatcher:OpenLinkInNewTabButton()]
       performAction:grey_tap()];
   chrome_test_util::AssertMainTabCount(numberOfTabs + 1);
 
   SelectTabUsingUI(base::SysUTF8ToNSString(destinationURL.GetContent()));
 
   [[GREYUIThreadExecutor sharedInstance] drainUntilIdle];
-  [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::WebViewContainingText("Whee")]
-      assertWithMatcher:grey_notNil()];
+  [ChromeEarlGrey waitForWebViewContainingText:@"Whee"];
 
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
   histogramTester.ExpectTotalCount(kSelectedTabHistogramName, 1, failureBlock);
   histogramTester.ExpectBucketCount(
       kSelectedTabHistogramName, TabUsageRecorder::IN_MEMORY, 1, failureBlock);
 }
 
 // Tests that opening tabs from external app will not cause tab eviction.
@@ skipping 60 matching lines @@
     [[GREYUIThreadExecutor sharedInstance] drainUntilIdle];
   }
   // The deleted tabs are purged during foregrounding and backgrounding.
   chrome_test_util::SimulateTabsBackgrounding();
   // Make sure |evicted_tabs_| purged the deleted tabs.
   int evicted = chrome_test_util::GetEvictedMainTabCount();
   GREYAssertEqual(evicted, 0, @"Check number of evicted tabs");
 }
 
 @end