Make EarlGrey matchers compliant with Chromium style.

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 14 matching lines @@
 #import "ios/chrome/test/app/histogram_test_util.h"
 #include "ios/chrome/test/app/navigation_test_util.h"
 #import "ios/chrome/test/app/tab_test_util.h"
 #include "ios/chrome/test/app/web_view_interaction_test_util.h"
 #import "ios/chrome/test/earl_grey/chrome_assertions.h"
 #import "ios/chrome/test/earl_grey/chrome_earl_grey.h"
 #import "ios/chrome/test/earl_grey/chrome_earl_grey_ui.h"
 #import "ios/chrome/test/earl_grey/chrome_matchers.h"
 #import "ios/chrome/test/earl_grey/chrome_test_case.h"
 #import "ios/testing/wait_util.h"
+#import "ios/web/public/test/earl_grey/web_view_matchers.h"
 #import "ios/web/public/test/http_server.h"
 #import "ios/web/public/test/http_server_util.h"
 #include "ios/web/public/test/response_providers/delayed_response_provider.h"
 #include "ios/web/public/test/response_providers/html_response_provider.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
 namespace {
 
 const char kTestUrl1[] =
@@ skipping 34 matching lines @@
   [[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)]
+      selectElementWithMatcher:chrome_test_util::WebViewContainingText(word)]
       assertWithMatcher:grey_notNil()];
   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);
@@ skipping 40 matching lines @@
   ConditionBlock condition = ^{
     return chrome_test_util::GetMainTabCount() == (nb_main_tab - 1);
   };
   GREYAssert(
       testing::WaitUntilConditionOrTimeout(kWaitElementTimeout, condition),
       @"Waiting for tab to close");
 }
 
 // Closes the tabs switcher.
 void CloseTabSwitcher() {
-  id<GREYMatcher> matcher = chrome_test_util::buttonWithAccessibilityLabelId(
+  id<GREYMatcher> matcher = chrome_test_util::ButtonWithAccessibilityLabelId(
       IDS_IOS_TAB_STRIP_LEAVE_TAB_SWITCHER);
   [[EarlGrey selectElementWithMatcher:matcher] performAction:grey_tap()];
 }
 
 // Swithches to normal mode using swith button (iPad) or stack view (iPhone).
 // Assumes current mode is Incognito.
 void SwitchToNormalMode() {
   GREYAssertTrue(chrome_test_util::IsIncognitoMode(),
                  @"Switching to normal mode is only allowed from Incognito.");
   if (IsIPadIdiom()) {
     if (experimental_flags::IsTabSwitcherEnabled()) {
       // Enter the tab switcher.
       id<GREYMatcher> tabSwitcherEnterButton =
           grey_accessibilityLabel(l10n_util::GetNSStringWithFixup(
               IDS_IOS_TAB_STRIP_ENTER_TAB_SWITCHER));
       [[EarlGrey selectElementWithMatcher:tabSwitcherEnterButton]
           performAction:grey_tap()];
 
       // Select the non incognito panel.
       id<GREYMatcher> tabSwitcherHeaderPanelButton =
           grey_accessibilityLabel(l10n_util::GetNSStringWithFixup(
               IDS_IOS_TAB_SWITCHER_HEADER_NON_INCOGNITO_TABS));
       [[EarlGrey selectElementWithMatcher:tabSwitcherHeaderPanelButton]
           performAction:grey_tap()];
 
       // Leave the tab switcher.
       CloseTabSwitcher();
     } else {
       [[EarlGrey selectElementWithMatcher:
-                     chrome_test_util::buttonWithAccessibilityLabelId(
+                     chrome_test_util::ButtonWithAccessibilityLabelId(
                          IDS_IOS_SWITCH_BROWSER_MODE_LEAVE_INCOGNITO)]
           performAction:grey_tap()];
     }
   } else {
     [[EarlGrey selectElementWithMatcher:
-                   chrome_test_util::buttonWithAccessibilityLabelId(
+                   chrome_test_util::ButtonWithAccessibilityLabelId(
                        IDS_IOS_TOOLBAR_SHOW_TABS)] performAction:grey_tap()];
     [[EarlGrey selectElementWithMatcher:
-                   chrome_test_util::buttonWithAccessibilityLabelId(
+                   chrome_test_util::ButtonWithAccessibilityLabelId(
                        IDS_IOS_TOOLS_MENU_NEW_INCOGNITO_TAB)]
         performAction:grey_swipeSlowInDirection(kGREYDirectionRight)];
     [[EarlGrey selectElementWithMatcher:
-                   chrome_test_util::buttonWithAccessibilityLabelId(
+                   chrome_test_util::ButtonWithAccessibilityLabelId(
                        IDS_IOS_TOOLBAR_SHOW_TABS)] performAction:grey_tap()];
   }
   ConditionBlock condition = ^bool {
     return !chrome_test_util::IsIncognitoMode();
   };
   GREYAssert(
       testing::WaitUntilConditionOrTimeout(kWaitElementTimeout, condition),
       @"Waiting switch to normal mode.");
 }
 
 // Check that the error page is visible.
 void CheckErrorPageIsVisible() {
   // The DNS error page is static HTML content, so it isn't part of the webview
   // owned by the webstate.
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::
-                                          webViewBelongingToWebController()]
+  id<GREYMatcher> webViewMatcher =
+      web::WebViewInWebState(chrome_test_util::GetCurrentWebState());
+  [[EarlGrey selectElementWithMatcher:webViewMatcher]
       assertWithMatcher:grey_nil()];
   NSString* const kError =
       l10n_util::GetNSString(IDS_ERRORPAGES_HEADING_NOT_AVAILABLE);
   [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::staticHtmlViewContainingText(
+      selectElementWithMatcher:chrome_test_util::StaticHtmlViewContainingText(
                                    kError)] assertWithMatcher:grey_notNil()];
 }
 
 // Open the settings submenu. Assumes that settings menu is visible.
 void OpenSettingsSubMenuUnsynced(int submenu) {
   id<GREYMatcher> settings_button_matcher =
       grey_text(l10n_util::GetNSString(submenu));
   [[[EarlGrey selectElementWithMatcher:settings_button_matcher]
          usingSearchAction:grey_swipeSlowInDirection(kGREYDirectionUp)
       onElementWithMatcher:grey_accessibilityID(kSettingsCollectionViewId)]
@@ skipping 10 matching lines @@
       grey_accessibilityID(kToolsMenuSettingsId);
 
   WaitAndTap(settings_button_matcher, @"Settings menu");
   Wait(grey_accessibilityID(kSettingsCollectionViewId), @"Setting view");
 }
 
 // Select the tab with title |title| using UI (tab strip on iPad, stack view on
 // iPhone).
 void SelectTabUsingUI(NSString* title) {
   if (IsCompact()) {
-    WaitAndTap(chrome_test_util::buttonWithAccessibilityLabelId(
+    WaitAndTap(chrome_test_util::ButtonWithAccessibilityLabelId(
                    IDS_IOS_TOOLBAR_SHOW_TABS),
                @"Tab switcher");
   }
   WaitAndTap(grey_text(title),
              [NSString stringWithFormat:@"tab with title %@", title]);
 }
 }  // namespace
 
 // Test for the TabUsageRecorder class.
 @interface TabUsageRecorderTestCase : ChromeTestCase
@@ skipping 29 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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL1FirstWord)]
       assertWithMatcher:grey_notNil()];
 
   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(
+    [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                             kURL1FirstWord)]
         assertWithMatcher:grey_notNil()];
   }
   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 pade reload is complete.
     __block bool finished = false;
     chrome_test_util::GetCurrentWebState()->ExecuteJavaScript(
         base::UTF8ToUTF16(kClearPageScript),
         base::BindBlock(^(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(
+    [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                             kURL1FirstWord)]
         assertWithMatcher:grey_notNil()];
   }
 
   // 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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL1FirstWord)]
       assertWithMatcher:grey_notNil()];
 
   // 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(
@@ skipping 19 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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL2FirstWord)]
       assertWithMatcher:grey_notNil()];
 
   // Select the other one so it also reloads.
   chrome_test_util::SelectTabAtIndexInCurrentMode(0);
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::webViewContainingText(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL1FirstWord)]
       assertWithMatcher:grey_notNil()];
 
   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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL1FirstWord)]
       assertWithMatcher:grey_notNil()];
   histogramTester.ExpectBucketCount(kSelectedTabHistogramName,
                                     TabUsageRecorder::EVICTED_DUE_TO_COLD_START,
                                     1, failureBlock);
 
   histogramTester.ExpectBucketCount(
       kSelectedTabHistogramName, TabUsageRecorder::IN_MEMORY, 2, failureBlock);
 }
 
@@ skipping 15 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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL2FirstWord)]
       assertWithMatcher:grey_notNil()];
 
   const GURL url1 = web::test::HttpServer::MakeUrl(kTestUrl1);
   const GURL url2 = web::test::HttpServer::MakeUrl(kTestUrl2);
   [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::omniboxText(url2.GetContent())]
+      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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL1FirstWord)]
       assertWithMatcher:grey_notNil()];
   [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::omniboxText(url1.GetContent())]
+      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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           kURL1FirstWord)]
       assertWithMatcher:grey_notNil()];
 
   histogramTester.ExpectUniqueSample(kEvictedTabReloadSuccessRate,
                                      TabUsageRecorder::LOAD_SUCCESS, 1,
                                      failureBlock);
   histogramTester.ExpectUniqueSample(kDidUserWaitForEvictedTabReload,
                                      TabUsageRecorder::USER_WAITED, 1,
                                      failureBlock);
   histogramTester.ExpectTotalCount(kEvictedTabReloadTime, 1, failureBlock);
@@ skipping 134 matching lines @@
       forConfigKey:kGREYConfigKeySynchronizationEnabled];
   OpenSettingsMenuUnsynced();
   OpenSettingsSubMenuUnsynced(IDS_OPTIONS_ADVANCED_SECTION_TITLE_PRIVACY);
   Wait(grey_accessibilityID(kPrivacyCollectionViewId),
        @"Privacy settings view.");
 
   WaitAndTap(grey_accessibilityLabel(
                  l10n_util::GetNSString(IDS_IOS_NAVIGATION_BAR_DONE_BUTTON)),
              @"Close settings");
   [[GREYUIThreadExecutor sharedInstance] drainUntilIdle];
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::webViewContainingText(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           responses[slowURL])]
       assertWithMatcher:grey_notNil()];
 
   [[GREYConfiguration sharedInstance]
           setValue:@(YES)
       forConfigKey:kGREYConfigKeySynchronizationEnabled];
 
   histogramTester.ExpectBucketCount(kDidUserWaitForEvictedTabReload,
                                     TabUsageRecorder::USER_DID_NOT_WAIT, 0,
                                     failureBlock);
@@ skipping 83 matching lines @@
   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");
 
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::omniboxText(
+  [[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(
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::WebViewContainingText(
                                           "arrived")]
       assertWithMatcher:grey_notNil()];
 
   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);
@@ skipping 24 matching lines @@
   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")]
+      selectElementWithMatcher:chrome_test_util::WebViewContainingText("Whee")]
       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("Whee")]
+      selectElementWithMatcher:chrome_test_util::WebViewContainingText("Whee")]
       assertWithMatcher:grey_notNil()];
 
   // 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,
@@ skipping 27 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");
 
   int numberOfTabs = chrome_test_util::GetMainTabCount();
   [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::webViewContainingText("link")]
+      selectElementWithMatcher:chrome_test_util::WebViewContainingText("link")]
       performAction:grey_longPress()];
 
   [[EarlGrey
       selectElementWithMatcher:grey_text(l10n_util::GetNSString(
                                    IDS_IOS_CONTENT_CONTEXT_OPENLINKNEWTAB))]
       performAction:grey_tap()];
   chrome_test_util::AssertMainTabCount(numberOfTabs + 1);
 
   SelectTabUsingUI(base::SysUTF8ToNSString(destinationURL.GetContent()));
 
   [[GREYUIThreadExecutor sharedInstance] drainUntilIdle];
   [[EarlGrey
-      selectElementWithMatcher:chrome_test_util::webViewContainingText("Whee")]
+      selectElementWithMatcher:chrome_test_util::WebViewContainingText("Whee")]
       assertWithMatcher:grey_notNil()];
 
   FailureBlock failureBlock = ^(NSString* error) {
     GREYFail(error);
   };
   histogramTester.ExpectTotalCount(kSelectedTabHistogramName, 1, failureBlock);
   histogramTester.ExpectBucketCount(
       kSelectedTabHistogramName, TabUsageRecorder::IN_MEMORY, 1, failureBlock);
 }
 
@@ skipping 61 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