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.
 
 #include "base/mac/bind_objc_block.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "base/test/ios/wait_util.h"
@@ skipping 73 matching lines @@
   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) {
   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 91 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 101 matching lines @@
   [[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: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 90 matching lines @@
 
   [[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 19 matching lines @@
   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");
   // 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 36 matching lines @@
       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