Convert WindowOpenDisposition to an enum class.

chrome/browser/captive_portal/captive_portal_browsertest.cc

 // Copyright (c) 2012 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 <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1232 matching lines @@
 void CaptivePortalBrowserTest::SlowLoadNoCaptivePortal(
     Browser* browser,
     CaptivePortalResult expected_result) {
   CaptivePortalTabReloader* tab_reloader =
       GetTabReloader(browser->tab_strip_model()->GetActiveWebContents());
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
-  ui_test_utils::NavigateToURLWithDisposition(browser,
-                                              GURL(kMockHttpsUrl),
-                                              CURRENT_TAB,
-                                              ui_test_utils::BROWSER_TEST_NONE);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser, GURL(kMockHttpsUrl), WindowOpenDisposition::CURRENT_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
 
   portal_observer.WaitForResults(1);
 
   ASSERT_EQ(1, browser->tab_strip_model()->count());
   EXPECT_EQ(expected_result, portal_observer.captive_portal_result());
   EXPECT_EQ(1, portal_observer.num_results_received());
   EXPECT_EQ(0, navigation_observer.num_navigations());
   EXPECT_FALSE(CheckPending(browser));
 
   // First tab should still be loading.
@@ skipping 97 matching lines @@
   int initial_active_index = tab_strip_model->active_index();
   int initial_loading_tabs = NumLoadingTabs();
   int expected_broken_tabs = NumBrokenTabs();
   if (CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL !=
           GetStateOfTabReloader(tab_strip_model->GetActiveWebContents())) {
     ++expected_broken_tabs;
   }
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
-  ui_test_utils::NavigateToURLWithDisposition(browser,
-                                              hanging_url,
-                                              CURRENT_TAB,
-                                              ui_test_utils::BROWSER_TEST_NONE);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser, hanging_url, WindowOpenDisposition::CURRENT_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
   portal_observer.WaitForResults(expected_portal_checks);
 
   if (expect_open_login_tab) {
     ASSERT_GE(expected_login_tab_navigations, 1);
 
     navigation_observer.WaitForNavigations(expected_login_tab_navigations);
 
     ASSERT_EQ(initial_tab_count + 1, tab_strip_model->count());
     EXPECT_EQ(initial_tab_count, tab_strip_model->active_index());
 
@@ skipping 65 matching lines @@
     ++expected_broken_tabs;
   }
 
   CaptivePortalService* captive_portal_service =
       CaptivePortalServiceFactory::GetForProfile(browser->profile());
   if (delay_portal_response_until_interstital)
     RespondToProbeRequests(false);
 
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser->profile());
-  ui_test_utils::NavigateToURLWithDisposition(browser,
-                                              error_url,
-                                              CURRENT_TAB,
-                                              ui_test_utils::BROWSER_TEST_NONE);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser, error_url, WindowOpenDisposition::CURRENT_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
 
   if (delay_portal_response_until_interstital) {
     EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
               GetStateOfTabReloaderAt(browser, initial_active_index));
     // Once the interstitial is attached, probe for captive portal.
     WaitForInterstitialAttach(tab_strip_model->GetActiveWebContents());
     RespondToProbeRequests(true);
     captive_portal_service->DetectCaptivePortal();
   }
 
@@ skipping 35 matching lines @@
 void CaptivePortalBrowserTest::FastErrorWithInterstitialTimer(
     Browser* browser,
     const GURL& cert_error_url) {
   TabStripModel* tab_strip_model = browser->tab_strip_model();
   WebContents* broken_tab_contents = tab_strip_model->GetActiveWebContents();
 
   // Disable captive portal checks indefinitely.
   RespondToProbeRequests(false);
 
   SSLInterstitialTimerObserver interstitial_timer_observer(broken_tab_contents);
-  ui_test_utils::NavigateToURLWithDisposition(browser,
-                                              cert_error_url,
-                                              CURRENT_TAB,
-                                              ui_test_utils::BROWSER_TEST_NONE);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser, cert_error_url, WindowOpenDisposition::CURRENT_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
   interstitial_timer_observer.WaitForTimerStarted();
 
   // The tab should be in loading state, waiting for the interstitial timer to
   // expire or a captive portal result to arrive. Since captive portal checks
   // are disabled and timer set to expire after a very long time, the tab should
   // hang indefinitely.
   EXPECT_TRUE(broken_tab_contents->IsLoading());
   EXPECT_EQ(1, NumLoadingTabs());
 }
 
@@ skipping 232 matching lines @@
 
   // Navigate the error tab to another slow loading page.  Can't have
   // ui_test_utils do the navigation because it will wait for loading tabs to
   // stop loading before navigating.
   //
   // This may result in either 0 or 1 DidStopLoading events.  If there is one,
   // it must happen before the CaptivePortalService sends out its test request,
   // so waiting for PortalObserver to see that request prevents it from
   // confusing the MultiNavigationObservers used later.
   tab_strip_model->ActivateTabAt(0, true);
-  browser->OpenURL(content::OpenURLParams(timeout_url,
-                                          content::Referrer(),
-                                          CURRENT_TAB,
-                                          ui::PAGE_TRANSITION_TYPED,
-                                          false));
+  browser->OpenURL(content::OpenURLParams(timeout_url, content::Referrer(),
+                                          WindowOpenDisposition::CURRENT_TAB,
+                                          ui::PAGE_TRANSITION_TYPED, false));
   portal_observer.WaitForResults(1);
   EXPECT_FALSE(CheckPending(browser));
   EXPECT_EQ(1, NumLoadingTabs());
   EXPECT_EQ(CaptivePortalTabReloader::STATE_BROKEN_BY_PORTAL,
             GetStateOfTabReloaderAt(browser, 0));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser, 1));
   ASSERT_TRUE(IsLoginTab(tab_strip_model->GetWebContentsAt(1)));
 
   // Need to make sure the request has been issued before logging in.
@@ skipping 320 matching lines @@
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   WebContents* broken_tab_contents = tab_strip_model->GetActiveWebContents();
 
   CaptivePortalObserver portal_observer(browser()->profile());
   FastErrorWithInterstitialTimer(browser(), cert_error_url);
 
   // Page appears loading. Reloading it cancels the page load. Since the load is
   // stopped, no cert error occurs and SSLErrorHandler isn't instantiated.
   MultiNavigationObserver test_navigation_observer;
-  chrome::Reload(browser(), CURRENT_TAB);
+  chrome::Reload(browser(), WindowOpenDisposition::CURRENT_TAB);
   test_navigation_observer.WaitForNavigations(2);
 
   // Make sure that the |ssl_error_handler| is deleted.
   EXPECT_TRUE(nullptr == SSLErrorHandler::FromWebContents(broken_tab_contents));
 
   EXPECT_FALSE(broken_tab_contents->ShowingInterstitialPage());
   EXPECT_FALSE(broken_tab_contents->IsLoading());
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_EQ(2, test_navigation_observer.num_navigations());
   EXPECT_EQ(0, NumLoadingTabs());
@@ skipping 38 matching lines @@
   WebContents* broken_tab_contents = tab_strip_model->GetActiveWebContents();
 
   CaptivePortalObserver portal_observer(browser()->profile());
   FastErrorWithInterstitialTimer(browser(), cert_error_url);
 
   // Page appears loading. Navigating away shouldn't result in any interstitial.
   // Can't use ui_test_utils::NavigateToURLWithDisposition because it waits for
   // a load stop notification before starting a new navigation.
   MultiNavigationObserver test_navigation_observer;
   browser()->OpenURL(content::OpenURLParams(
-      URLRequestMockHTTPJob::GetMockUrl("title2.html"),
-      content::Referrer(),
-      CURRENT_TAB,
-      ui::PAGE_TRANSITION_TYPED, false));
+      URLRequestMockHTTPJob::GetMockUrl("title2.html"), content::Referrer(),
+      WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
   // Expect two navigations: First one for stopping the hanging page, second one
   // for completing the load of the above navigation.
   test_navigation_observer.WaitForNavigations(2);
 
   // Make sure that the |ssl_error_handler| is deleted.
   EXPECT_TRUE(nullptr == SSLErrorHandler::FromWebContents(broken_tab_contents));
 
   EXPECT_FALSE(broken_tab_contents->ShowingInterstitialPage());
   EXPECT_FALSE(broken_tab_contents->IsLoading());
   EXPECT_EQ(0, portal_observer.num_results_received());
@@ skipping 46 matching lines @@
   FastErrorWithInterstitialTimer(browser(), cert_error_url);
   // Page appears loading. Turn on response to probe request again, and navigate
   // to the same page. This should result in a cert error which should
   // instantiate an |SSLErrorHandler| and end up showing an SSL interstitial.
   RespondToProbeRequests(true);
   // Can't have ui_test_utils do the navigation because it will wait for loading
   // tabs to stop loading before navigating.
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver test_navigation_observer;
   browser()->OpenURL(content::OpenURLParams(cert_error_url, content::Referrer(),
-                                            CURRENT_TAB,
+                                            WindowOpenDisposition::CURRENT_TAB,
                                             ui::PAGE_TRANSITION_TYPED, false));
   // Expect two navigations: First one for stopping the hanging page, second one
   // for completing the load of the above navigation.
   test_navigation_observer.WaitForNavigations(2);
   // Should end up with an SSL interstitial.
   WaitForInterstitialAttach(broken_tab_contents);
   ASSERT_TRUE(broken_tab_contents->ShowingInterstitialPage());
   EXPECT_EQ(SSLBlockingPage::kTypeForTesting,
             broken_tab_contents->GetInterstitialPage()
                 ->GetDelegateForTesting()
@@ skipping 28 matching lines @@
   FastErrorWithInterstitialTimer(browser(), cert_error_url);
   // Page appears loading. Turn on response to probe request again, and navigate
   // to the same page. This should result in a cert error which should
   // instantiate an |SSLErrorHandler| and end up showing an SSL.
   RespondToProbeRequests(true);
   // Can't have ui_test_utils do the navigation because it will wait for loading
   // tabs to stop loading before navigating.
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver test_navigation_observer;
   browser()->OpenURL(content::OpenURLParams(cert_error_url, content::Referrer(),
-                                            CURRENT_TAB,
+                                            WindowOpenDisposition::CURRENT_TAB,
                                             ui::PAGE_TRANSITION_TYPED, false));
   // Expect three navigations:
   // 1- For stopping the hanging page.
   // 2- For completing the load of the above navigation.
   // 3- For completing the load of the login tab.
   test_navigation_observer.WaitForNavigations(3);
   // Should end up with a captive portal interstitial and a new login tab.
   WaitForInterstitialAttach(broken_tab_contents);
   ASSERT_TRUE(broken_tab_contents->ShowingInterstitialPage());
   EXPECT_EQ(CaptivePortalBlockingPage::kTypeForTesting,
@@ skipping 94 matching lines @@
 // tabs only timeout after logging in.
 IN_PROC_BROWSER_TEST_F(CaptivePortalBrowserTest, TwoBrokenTabs) {
   SlowLoadBehindCaptivePortal(browser(), true);
 
   // Can't set the TabReloader HTTPS timeout on a new tab without doing some
   // acrobatics, so open a new tab at a normal page, and then navigate it to a
   // timeout.
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser()->profile());
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      URLRequestMockHTTPJob::GetMockUrl("title2.html"),
-      NEW_FOREGROUND_TAB,
+      browser(), URLRequestMockHTTPJob::GetMockUrl("title2.html"),
+      WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   ASSERT_EQ(3, tab_strip_model->count());
   EXPECT_FALSE(CheckPending(browser()));
   EXPECT_EQ(0, portal_observer.num_results_received());
   EXPECT_EQ(1, NumLoadingTabs());
   EXPECT_EQ(1, navigation_observer.num_navigations());
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
                    tab_strip_model->GetWebContentsAt(2)));
@@ skipping 110 matching lines @@
   // Go to the error page.
   SlowLoadBehindCaptivePortal(browser(), true);
   FailLoadsWithoutLogin(browser(), 1);
 
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver navigation_observer;
 
   // Activate the error page tab again and go back.
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   tab_strip_model->ActivateTabAt(0, true);
-  chrome::GoBack(browser(), CURRENT_TAB);
+  chrome::GoBack(browser(), WindowOpenDisposition::CURRENT_TAB);
   navigation_observer.WaitForNavigations(1);
 
   EXPECT_EQ(1, navigation_observer.NumNavigationsForTab(
                    tab_strip_model->GetWebContentsAt(0)));
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NONE,
             GetStateOfTabReloaderAt(browser(), 0));
   EXPECT_EQ(0, portal_observer.num_results_received());
 }
 
 // Checks that navigating back to a timeout triggers captive portal detection.
@@ skipping 14 matching lines @@
 
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   CaptivePortalTabReloader* tab_reloader =
       GetTabReloader(tab_strip_model->GetActiveWebContents());
   ASSERT_TRUE(tab_reloader);
   SetSlowSSLLoadTime(tab_reloader, base::TimeDelta());
 
   // Go to the error page.
   MultiNavigationObserver navigation_observer;
   CaptivePortalObserver portal_observer(browser()->profile());
-  chrome::GoBack(browser(), CURRENT_TAB);
+  chrome::GoBack(browser(), WindowOpenDisposition::CURRENT_TAB);
 
   // Wait for the check triggered by the broken tab and for the login tab to
   // stop loading.
   portal_observer.WaitForResults(1);
   navigation_observer.WaitForNavigations(1);
   // Make sure the request has been issued.
   URLRequestTimeoutOnDemandJob::WaitForJobs(1);
 
   EXPECT_EQ(1, portal_observer.num_results_received());
   ASSERT_FALSE(CheckPending(browser()));
@@ skipping 98 matching lines @@
 
   CaptivePortalObserver portal_observer(browser()->profile());
   MultiNavigationObserver navigation_observer;
 
   // Navigate the tab in the inactive browser to an SSL timeout.  Have to use
   // chrome::NavigateParams and NEW_BACKGROUND_TAB to avoid activating the
   // window.
   chrome::NavigateParams params(inactive_browser,
                                 GURL(kMockHttpsQuickTimeoutUrl),
                                 ui::PAGE_TRANSITION_TYPED);
-  params.disposition = NEW_BACKGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_BACKGROUND_TAB;
   params.window_action = chrome::NavigateParams::NO_ACTION;
   ui_test_utils::NavigateToURL(&params);
   navigation_observer.WaitForNavigations(2);
 
   // Make sure the active window hasn't changed, and its new tab is
   // active.
   ASSERT_EQ(active_browser,
             chrome::FindTabbedBrowser(browser()->profile(), true));
   ASSERT_EQ(1, active_browser->tab_strip_model()->active_index());
 
@@ skipping 123 matching lines @@
 
   EXPECT_EQ(CaptivePortalTabReloader::STATE_NEEDS_RELOAD,
             GetStateOfTabReloaderAt(browser(), broken_tab_index));
 
   WaitForInterstitialAttach(broken_tab_contents);
   portal_observer.WaitForResults(1);
 
   EXPECT_EQ(SSLBlockingPage::kTypeForTesting,
             GetInterstitialType(broken_tab_contents));
 }