Make EarlGrey matchers compliant with Chromium style.

ios/chrome/browser/web/browsing_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 <map>
 #include <memory>
 #include <string>
 
 #include "base/ios/ios_util.h"
@@ skipping 18 matching lines @@
 #import "ios/testing/wait_util.h"
 #import "ios/web/public/test/earl_grey/web_view_actions.h"
 #import "ios/web/public/test/earl_grey/web_view_matchers.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 "net/http/http_response_headers.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
-using chrome_test_util::omniboxText;
-using chrome_test_util::webViewContainingText;
+using chrome_test_util::OmniboxText;
+using chrome_test_util::WebViewContainingText;
 
 namespace {
 
 // URL used for the reload test.
 const char kReloadTestUrl[] = "http://mock/reloadTest";
 
 // Returns the number of serviced requests in HTTP body.
 class ReloadResponseProvider : public web::DataResponseProvider {
  public:
   ReloadResponseProvider() : request_number_(0) {}
@@ skipping 64 matching lines @@
 };
 }  // namespace
 
 // Tests web browsing scenarios.
 @interface BrowsingTestCase : ChromeTestCase
 @end
 
 @implementation BrowsingTestCase
 
 // Matcher for the title of the current tab (on tablet only).
-id<GREYMatcher> tabWithTitle(const std::string& tab_title) {
+id<GREYMatcher> TabWithTitle(const std::string& tab_title) {
   id<GREYMatcher> notPartOfOmnibox =
-      grey_not(grey_ancestor(chrome_test_util::omnibox()));
+      grey_not(grey_ancestor(chrome_test_util::Omnibox()));
   return grey_allOf(grey_accessibilityLabel(base::SysUTF8ToNSString(tab_title)),
                     notPartOfOmnibox, nil);
 }
 
 // Matcher for a Go button that is interactable.
-id<GREYMatcher> goButtonMatcher() {
+id<GREYMatcher> GoButtonMatcher() {
   return grey_allOf(grey_accessibilityID(@"Go"), grey_interactable(), nil);
 }
 
 // Tests that page successfully reloads.
 - (void)testReload {
   // Set up test HTTP server responses.
   std::unique_ptr<web::DataResponseProvider> provider(
       new ReloadResponseProvider());
   web::test::SetUpHttpServer(std::move(provider));
 
   GURL URL = ReloadResponseProvider::GetReloadTestUrl();
   [ChromeEarlGrey loadURL:URL];
   std::string expectedBodyBeforeReload(
       ReloadResponseProvider::GetResponseBody(0 /* request number */));
   [[EarlGrey
-      selectElementWithMatcher:webViewContainingText(expectedBodyBeforeReload)]
+      selectElementWithMatcher:WebViewContainingText(expectedBodyBeforeReload)]
       assertWithMatcher:grey_notNil()];
 
   [ChromeEarlGreyUI reload];
   std::string expectedBodyAfterReload(
       ReloadResponseProvider::GetResponseBody(1 /* request_number */));
   [[EarlGrey
-      selectElementWithMatcher:webViewContainingText(expectedBodyAfterReload)]
+      selectElementWithMatcher:WebViewContainingText(expectedBodyAfterReload)]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that a tab's title is based on the URL when no other information is
 // available.
 - (void)testBrowsingTabTitleSetFromURL {
   if (!IsIPadIdiom()) {
     EARL_GREY_TEST_SKIPPED(@"Tab Title not displayed on handset.");
   }
 
   web::test::SetUpFileBasedHttpServer();
 
   const GURL destinationURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/destination.html");
   [ChromeEarlGrey loadURL:destinationURL];
 
   // Add 3 for the "://" which is not considered part of the scheme
   std::string URLWithoutScheme =
       destinationURL.spec().substr(destinationURL.scheme().length() + 3);
 
-  [[EarlGrey selectElementWithMatcher:tabWithTitle(URLWithoutScheme)]
+  [[EarlGrey selectElementWithMatcher:TabWithTitle(URLWithoutScheme)]
       assertWithMatcher:grey_sufficientlyVisible()];
 }
 
 // Tests that after a PDF is loaded, the title appears in the tab bar on iPad.
 - (void)testPDFLoadTitle {
   if (!IsIPadIdiom()) {
     EARL_GREY_TEST_SKIPPED(@"Tab Title not displayed on handset.");
   }
 
   web::test::SetUpFileBasedHttpServer();
 
   const GURL destinationURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/testpage.pdf");
   [ChromeEarlGrey loadURL:destinationURL];
 
   // Add 3 for the "://" which is not considered part of the scheme
   std::string URLWithoutScheme =
       destinationURL.spec().substr(destinationURL.scheme().length() + 3);
 
-  [[EarlGrey selectElementWithMatcher:tabWithTitle(URLWithoutScheme)]
+  [[EarlGrey selectElementWithMatcher:TabWithTitle(URLWithoutScheme)]
       assertWithMatcher:grey_sufficientlyVisible()];
 }
 
 // Tests that tab title is set to the specified title from a JavaScript.
 - (void)testBrowsingTabTitleSetFromScript {
   if (!IsIPadIdiom()) {
     EARL_GREY_TEST_SKIPPED(@"Tab Title not displayed on handset.");
   }
 
   const char* kPageTitle = "Some title";
   const GURL URL = GURL(base::StringPrintf(
       "data:text/html;charset=utf-8,<script>document.title = "
       "\"%s\"</script>",
       kPageTitle));
   [ChromeEarlGrey loadURL:URL];
 
-  [[EarlGrey selectElementWithMatcher:tabWithTitle(kPageTitle)]
+  [[EarlGrey selectElementWithMatcher:TabWithTitle(kPageTitle)]
       assertWithMatcher:grey_sufficientlyVisible()];
 }
 
 // Tests clicking a link with target="_blank" and "event.stopPropagation()"
 // opens a new tab.
 - (void)testBrowsingStopPropagation {
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL URL = web::test::HttpServer::MakeUrl("http://stopPropagation");
   const GURL destinationURL =
@@ skipping 10 matching lines @@
   ScopedBlockPopupsPref prefSetter(CONTENT_SETTING_ALLOW);
 
   [ChromeEarlGrey loadURL:URL];
   chrome_test_util::AssertMainTabCount(1);
 
   chrome_test_util::TapWebViewElementWithId("link");
 
   chrome_test_util::AssertMainTabCount(2);
 
   // Verify the new tab was opened with the expected URL.
-  [[EarlGrey selectElementWithMatcher:omniboxText(destinationURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests clicking a relative link with target="_blank" and
 // "event.stopPropagation()" opens a new tab.
 - (void)testBrowsingStopPropagationRelativePath {
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL URL = web::test::HttpServer::MakeUrl("http://stopPropRel");
   const GURL destinationURL =
       web::test::HttpServer::MakeUrl("http://stopPropRel/#test");
   // This is page with a relative link to "#test".
   responses[URL] =
       "<a id='link' href='#test' target='_blank' "
       "onclick='event.stopPropagation()'>link</a>";
   // This is the page that should be showing at the end of the test.
   responses[destinationURL] = "You've arrived!";
   web::test::SetUpSimpleHttpServer(responses);
 
   ScopedBlockPopupsPref prefSetter(CONTENT_SETTING_ALLOW);
 
   [ChromeEarlGrey loadURL:URL];
   chrome_test_util::AssertMainTabCount(1);
 
   chrome_test_util::TapWebViewElementWithId("link");
 
   chrome_test_util::AssertMainTabCount(2);
 
   // Verify the new tab was opened with the expected URL.
-  [[EarlGrey selectElementWithMatcher:omniboxText(destinationURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that clicking a link with URL changed by onclick uses the href of the
 // anchor tag instead of the one specified in JavaScript. Also verifies a new
 // tab is opened by target '_blank'.
 - (void)testBrowsingPreventDefaultWithLinkOpenedByJavascript {
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL URL = web::test::HttpServer::MakeUrl(
@@ skipping 17 matching lines @@
   ScopedBlockPopupsPref prefSetter(CONTENT_SETTING_ALLOW);
 
   [ChromeEarlGrey loadURL:URL];
   chrome_test_util::AssertMainTabCount(1);
 
   chrome_test_util::TapWebViewElementWithId("link");
 
   chrome_test_util::AssertMainTabCount(2);
 
   // Verify the new tab was opened with the expected URL.
-  [[EarlGrey selectElementWithMatcher:omniboxText(anchorURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(anchorURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests tapping a link that navigates to a page that immediately navigates
 // again via document.location.href.
 - (void)testBrowsingWindowDataLinkScriptRedirect {
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL URL =
       web::test::HttpServer::MakeUrl("http://windowDataLinkScriptRedirect");
@@ skipping 18 matching lines @@
   ScopedBlockPopupsPref prefSetter(CONTENT_SETTING_ALLOW);
 
   [ChromeEarlGrey loadURL:URL];
   chrome_test_util::AssertMainTabCount(1);
 
   chrome_test_util::TapWebViewElementWithId("link");
 
   chrome_test_util::AssertMainTabCount(2);
 
   // Verify the new tab was opened with the expected URL.
-  [[EarlGrey selectElementWithMatcher:omniboxText(destinationURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that pressing the button on a POST-based form changes the page and that
 // the back button works as expected afterwards.
 - (void)testBrowsingPostEntryWithButton {
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL URL = web::test::HttpServer::MakeUrl("http://postEntryWithButton");
   const GURL destinationURL = web::test::HttpServer::MakeUrl("http://foo");
   // This is a page with a button that posts to the destination.
   responses[URL] = base::StringPrintf(
       "<form action='%s' method='post'>"
       "<input value='button' type='submit' id='button'></form>",
       destinationURL.spec().c_str());
   // This is the page that should be showing at the end of the test.
   responses[destinationURL] = "bar!";
   web::test::SetUpSimpleHttpServer(responses);
 
   [ChromeEarlGrey loadURL:URL];
   chrome_test_util::TapWebViewElementWithId("button");
 
-  [[EarlGrey selectElementWithMatcher:omniboxText(destinationURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Go back and verify the browser navigates to the original URL.
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(URL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(URL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that a link with a JavaScript-based navigation changes the page and
 // that the back button works as expected afterwards.
 - (void)testBrowsingJavaScriptBasedNavigation {
   std::map<GURL, std::string> responses;
   const GURL URL = web::test::HttpServer::MakeUrl("http://origin");
   const GURL destURL = web::test::HttpServer::MakeUrl("http://destination");
   // Page containing a link with onclick attribute that sets window.location
   // to the destination URL.
   responses[URL] = base::StringPrintf(
       "<a href='#' onclick=\"window.location='%s';\" id='link'>Link</a>",
       destURL.spec().c_str());
   // Page with some text.
   responses[destURL] = "You've arrived!";
   web::test::SetUpSimpleHttpServer(responses);
 
   [ChromeEarlGrey loadURL:URL];
   chrome_test_util::TapWebViewElementWithId("link");
 
-  [[EarlGrey selectElementWithMatcher:omniboxText(destURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(destURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(URL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(URL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // TODO(crbug.com/638674): Evaluate if this can move to shared code
 // Navigates back to the previous webpage.
 - (void)goBack {
   base::scoped_nsobject<GenericChromeCommand> backCommand(
       [[GenericChromeCommand alloc] initWithTag:IDC_BACK]);
   chrome_test_util::RunCommandWithActiveViewController(backCommand);
 
@@ skipping 31 matching lines @@
   chrome_test_util::AssertMainTabCount(1U);
   chrome_test_util::AssertIncognitoTabCount(0U);
 
   [ChromeEarlGrey loadURL:URL];
 
   // Tap on chrome://version link.
   [ChromeEarlGrey tapWebViewElementWithID:@"link"];
 
   // Verify that page did not change by checking its URL and message printed by
   // onclick event.
-  [[EarlGrey selectElementWithMatcher:omniboxText("chrome://version")]
+  [[EarlGrey selectElementWithMatcher:OmniboxText("chrome://version")]
       assertWithMatcher:grey_nil()];
-  [[EarlGrey selectElementWithMatcher:webViewContainingText("Hello world!")]
+  [[EarlGrey selectElementWithMatcher:WebViewContainingText("Hello world!")]
       assertWithMatcher:grey_notNil()];
 
   // Verify that no new tabs were open which could load chrome://version.
   chrome_test_util::AssertMainTabCount(1U);
 }
 
 // Tests that pressing the button on a POST-based form with same-page action
 // does not change the page and that the back button works as expected
 // afterwards.
 - (void)testBrowsingPostToSamePage {
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL firstURL = web::test::HttpServer::MakeUrl("http://first");
   const GURL formURL = web::test::HttpServer::MakeUrl("http://form");
   // This is just a page with some text.
   responses[firstURL] = "foo";
   // This is a page with at button that posts to the current URL.
   responses[formURL] =
       "<form method='post'>"
       "<input value='button' type='submit' id='button'></form>";
   web::test::SetUpSimpleHttpServer(responses);
 
   // Open the first URL so it's in history.
   [ChromeEarlGrey loadURL:firstURL];
 
   // Open the second URL, tap the button, and verify the browser navigates to
   // the expected URL.
   [ChromeEarlGrey loadURL:formURL];
   chrome_test_util::TapWebViewElementWithId("button");
-  [[EarlGrey selectElementWithMatcher:omniboxText(formURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(formURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Go back once and verify the browser navigates to the form URL.
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(formURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(formURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Go back a second time and verify the browser navigates to the first URL.
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(firstURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(firstURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that evaluating user JavaScript that causes navigation correctly
 // modifies history.
 - (void)testBrowsingUserJavaScriptNavigation {
   // TODO(crbug.com/640220): Keyboard entry inside the omnibox fails only on
   // iPad running iOS 10.
   if (IsIPadIdiom() && base::ios::IsRunningOnIOS10OrLater())
     return;
 
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL startURL = web::test::HttpServer::MakeUrl("http://startpage");
   responses[startURL] = "<html><body><p>Ready to begin.</p></body></html>";
   const GURL targetURL = web::test::HttpServer::MakeUrl("http://targetpage");
   responses[targetURL] = "<html><body><p>You've arrived!</p></body></html>";
   web::test::SetUpSimpleHttpServer(responses);
 
   // Load the first page and run JS (using the codepath that user-entered JS in
   // the omnibox would take, not page-triggered) that should navigate.
   [ChromeEarlGrey loadURL:startURL];
 
   NSString* script =
       [NSString stringWithFormat:@"javascript:window.location='%s'",
                                  targetURL.spec().c_str()];
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::omnibox()]
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::Omnibox()]
       performAction:grey_typeText(script)];
   [[EarlGrey selectElementWithMatcher:grey_accessibilityID(@"Go")]
       performAction:grey_tap()];
   [ChromeEarlGrey waitForPageToFinishLoading];
 
-  [[EarlGrey selectElementWithMatcher:omniboxText(targetURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(targetURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(startURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(startURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tests that evaluating non-navigation user JavaScript doesn't affect history.
 - (void)testBrowsingUserJavaScriptWithoutNavigation {
   // TODO(crbug.com/640220): Keyboard entry inside the omnibox fails only on
   // iPad running iOS 10.
   if (IsIPadIdiom() && base::ios::IsRunningOnIOS10OrLater())
     return;
 
   // Create map of canned responses and set up the test HTML server.
   std::map<GURL, std::string> responses;
   const GURL firstURL = web::test::HttpServer::MakeUrl("http://firstURL");
   const std::string firstResponse = "Test Page 1";
   const GURL secondURL = web::test::HttpServer::MakeUrl("http://secondURL");
   const std::string secondResponse = "Test Page 2";
   responses[firstURL] = firstResponse;
   responses[secondURL] = secondResponse;
   web::test::SetUpSimpleHttpServer(responses);
 
   [ChromeEarlGrey loadURL:firstURL];
   [ChromeEarlGrey loadURL:secondURL];
 
   // Execute some JavaScript in the omnibox.
-  [[EarlGrey selectElementWithMatcher:chrome_test_util::omnibox()]
+  [[EarlGrey selectElementWithMatcher:chrome_test_util::Omnibox()]
       performAction:grey_typeText(@"javascript:document.write('foo')")];
   [[EarlGrey selectElementWithMatcher:grey_accessibilityID(@"Go")]
       performAction:grey_tap()];
 
-  id<GREYMatcher> webView = chrome_test_util::webViewContainingText("foo");
+  id<GREYMatcher> webView = chrome_test_util::WebViewContainingText("foo");
   [[EarlGrey selectElementWithMatcher:webView] assertWithMatcher:grey_notNil()];
 
   // Verify that the JavaScript did not affect history by going back and then
   // forward again.
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(firstURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(firstURL.GetContent())]
       assertWithMatcher:grey_notNil()];
   [self goForward];
-  [[EarlGrey selectElementWithMatcher:omniboxText(secondURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(secondURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 // Tap the text field indicated by |ID| to open the keyboard, and then
 // press the keyboard's "Go" button.
 - (void)openKeyboardAndTapGoButtonWithTextFieldID:(const std::string&)ID {
   // Disable EarlGrey's synchronization since it is blocked by opening the
   // keyboard from a web view.
   [[GREYConfiguration sharedInstance]
           setValue:@NO
       forConfigKey:kGREYConfigKeySynchronizationEnabled];
 
   // Wait for web view to be interactable before tapping.
   GREYCondition* interactableCondition = [GREYCondition
       conditionWithName:@"Wait for web view to be interactable."
                   block:^BOOL {
                     NSError* error = nil;
-                    id<GREYMatcher> webViewMatcher = webViewInWebState(
+                    id<GREYMatcher> webViewMatcher = WebViewInWebState(
                         chrome_test_util::GetCurrentWebState());
                     [[EarlGrey selectElementWithMatcher:webViewMatcher]
                         assertWithMatcher:grey_interactable()
                                     error:&error];
                     return !error;
                   }];
   GREYAssert(
       [interactableCondition waitWithTimeout:testing::kWaitForUIElementTimeout],
       @"Web view did not become interactable.");
 
   web::WebState* currentWebState = chrome_test_util::GetCurrentWebState();
-  [[EarlGrey selectElementWithMatcher:web::webViewInWebState(currentWebState)]
+  [[EarlGrey selectElementWithMatcher:web::WebViewInWebState(currentWebState)]
       performAction:web::webViewTapElement(currentWebState, ID)];
 
   // Wait until the keyboard shows up before tapping.
   GREYCondition* condition = [GREYCondition
       conditionWithName:@"Wait for the keyboard to show up."
                   block:^BOOL {
                     NSError* error = nil;
-                    [[EarlGrey selectElementWithMatcher:goButtonMatcher()]
+                    [[EarlGrey selectElementWithMatcher:GoButtonMatcher()]
                         assertWithMatcher:grey_notNil()
                                     error:&error];
                     return (error == nil);
                   }];
   GREYAssert([condition waitWithTimeout:10],
              @"No keyboard with 'Go' button showed up.");
 
   [[EarlGrey selectElementWithMatcher:grey_accessibilityID(@"Go")]
       performAction:grey_tap()];
 
@@ skipping 19 matching lines @@
       "<form action='%s' method='post'>"
       "<input value='textfield' id='textfield' type='text'></label>"
       "<input type='submit'></form>",
       destinationURL.spec().c_str());
   // This is the page that should be showing at the end of the test.
   responses[destinationURL] = "baz!";
   web::test::SetUpSimpleHttpServer(responses);
 
   // Open the URL, focus the textfield,and submit via keyboard.
   [ChromeEarlGrey loadURL:URL];
-  [[EarlGrey selectElementWithMatcher:webViewContainingText("hello!")]
+  [[EarlGrey selectElementWithMatcher:WebViewContainingText("hello!")]
       assertWithMatcher:grey_notNil()];
 
   [self openKeyboardAndTapGoButtonWithTextFieldID:"textfield"];
 
   // Verify that the browser navigates to the expected URL.
-  [[EarlGrey selectElementWithMatcher:omniboxText(destinationURL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(destinationURL.GetContent())]
       assertWithMatcher:grey_notNil()];
 
   // Go back and verify that the browser navigates to the original URL.
   [self goBack];
-  [[EarlGrey selectElementWithMatcher:omniboxText(URL.GetContent())]
+  [[EarlGrey selectElementWithMatcher:OmniboxText(URL.GetContent())]
       assertWithMatcher:grey_notNil()];
 }
 
 @end