Convert WindowOpenDisposition to an enum class.

chrome/browser/ui/login/login_handler_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 <algorithm>
 #include <list>
 #include <map>
 
 #include "base/metrics/field_trial.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 136 matching lines @@
   } set_prefetch_for_test(true);
 
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   WindowedLoadStopObserver load_stop_waiter(controller, 1);
-  browser()->OpenURL(OpenURLParams(
-      test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-      false));
+  browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
+                                   ui::PAGE_TRANSITION_TYPED, false));
 
   load_stop_waiter.Wait();
   EXPECT_TRUE(observer.handlers().empty());
 }
 
 // Test that "Basic" HTTP authentication works.
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, TestBasicAuth) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL test_page = embedded_test_server()->GetURL(kAuthBasicPage);
 
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   ASSERT_FALSE(observer.handlers().empty());
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers().begin();
 
     ASSERT_TRUE(handler);
@@ skipping 27 matching lines @@
 
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   ASSERT_FALSE(observer.handlers().empty());
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers().begin();
 
     ASSERT_TRUE(handler);
@@ skipping 26 matching lines @@
 
   content::WebContents* contents1 =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller1 = &contents1->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller1));
 
   // Open a new tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      GURL("about:blank"),
-      NEW_FOREGROUND_TAB,
+      browser(), GURL("about:blank"), WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   content::WebContents* contents2 =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_NE(contents1, contents2);
   NavigationController* controller2 = &contents2->GetController();
   observer.Register(content::Source<NavigationController>(controller2));
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller1);
     contents1->OpenURL(OpenURLParams(
         embedded_test_server()->GetURL(kAuthBasicPage), Referrer(),
-        CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller2);
     contents2->OpenURL(OpenURLParams(
         embedded_test_server()->GetURL(kAuthDigestPage), Referrer(),
-        CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   ASSERT_EQ(2u, observer.handlers().size());
 
   LoginHandler* handler1 = *observer.handlers().begin();
   LoginHandler* handler2 = *(++(observer.handlers().begin()));
 
   base::string16 expected_title1 = ExpectedTitleFromAuth(
       base::UTF8ToUTF16(username_basic_), base::UTF8ToUTF16(password_));
@@ skipping 17 matching lines @@
   const GURL kAuthURL = embedded_test_server()->GetURL(kAuthBasicPage);
 
   NavigationController* controller =
       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
 
   LoginPromptBrowserTestObserver observer;
   observer.Register(content::Source<NavigationController>(controller));
 
   WindowedLoadStopObserver load_stop_waiter(controller, 1);
   WindowedAuthNeededObserver auth_needed_waiter(controller);
-  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   auth_needed_waiter.Wait();
   WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
   LoginHandler* handler = *observer.handlers().begin();
   ASSERT_TRUE(handler);
   handler->CancelAuth();
   auth_cancelled_waiter.Wait();
   load_stop_waiter.Wait();
   EXPECT_TRUE(observer.handlers().empty());
 }
 
 // Test login prompt cancellation on navigation to a new page.
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, TestCancelAuth_OnNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
   const GURL kAuthURL = embedded_test_server()->GetURL(kAuthBasicPage);
   const GURL kNoAuthURL = embedded_test_server()->GetURL(kNoAuthPage1);
 
   NavigationController* controller =
       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
 
   LoginPromptBrowserTestObserver observer;
   observer.Register(content::Source<NavigationController>(controller));
 
   // One LOAD_STOP event for kAuthURL and one for kNoAuthURL.
   const int kLoadStopEvents = 2;
   WindowedLoadStopObserver load_stop_waiter(controller, kLoadStopEvents);
   WindowedAuthNeededObserver auth_needed_waiter(controller);
-  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   auth_needed_waiter.Wait();
   WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
   // Navigating while auth is requested is the same as cancelling.
-  browser()->OpenURL(OpenURLParams(kNoAuthURL, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(kNoAuthURL, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   auth_cancelled_waiter.Wait();
   load_stop_waiter.Wait();
   EXPECT_TRUE(observer.handlers().empty());
 }
 
 // Test login prompt cancellation on navigation to back.
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, TestCancelAuth_OnBack) {
   ASSERT_TRUE(embedded_test_server()->Start());
   const GURL kAuthURL = embedded_test_server()->GetURL(kAuthBasicPage);
   const GURL kNoAuthURL = embedded_test_server()->GetURL(kNoAuthPage1);
 
   NavigationController* controller =
       &browser()->tab_strip_model()->GetActiveWebContents()->GetController();
 
   LoginPromptBrowserTestObserver observer;
   observer.Register(content::Source<NavigationController>(controller));
 
   // First navigate to an unauthenticated page so we have something to
   // go back to.
   ui_test_utils::NavigateToURL(browser(), kNoAuthURL);
 
   // One LOAD_STOP event for kAuthURL and one for kNoAuthURL.
   const int kLoadStopEvents = 2;
   WindowedLoadStopObserver load_stop_waiter(controller, kLoadStopEvents);
   WindowedAuthNeededObserver auth_needed_waiter(controller);
-  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   auth_needed_waiter.Wait();
   WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
   // Navigating back while auth is requested is the same as cancelling.
   ASSERT_TRUE(controller->CanGoBack());
   controller->GoBack();
   auth_cancelled_waiter.Wait();
   load_stop_waiter.Wait();
   EXPECT_TRUE(observer.handlers().empty());
 }
@@ skipping 19 matching lines @@
     WindowedLoadStopObserver load_stop_waiter(controller, 1);
     ASSERT_TRUE(controller->CanGoBack());
     controller->GoBack();
     load_stop_waiter.Wait();
   }
 
   // One LOAD_STOP event for kAuthURL and one for kNoAuthURL.
   const int kLoadStopEvents = 2;
   WindowedLoadStopObserver load_stop_waiter(controller, kLoadStopEvents);
   WindowedAuthNeededObserver auth_needed_waiter(controller);
-  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(kAuthURL, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   auth_needed_waiter.Wait();
   WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
   ASSERT_TRUE(controller->CanGoForward());
   controller->GoForward();
   auth_cancelled_waiter.Wait();
   load_stop_waiter.Wait();
   EXPECT_TRUE(observer.handlers().empty());
 }
 
@@ skipping 10 matching lines @@
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   WindowedLoadStopObserver load_stop_waiter(controller, 1);
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   int n_handlers = 0;
 
   while (n_handlers < kMultiRealmTestRealmCount) {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
 
     while (!observer.handlers().empty()) {
       WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
@@ skipping 29 matching lines @@
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   WindowedLoadStopObserver load_stop_waiter(controller, 1);
   int n_handlers = 0;
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
 
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   while (n_handlers < kMultiRealmTestRealmCount) {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
 
     while (!observer.handlers().empty()) {
       WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
       LoginHandler* handler = *observer.handlers().begin();
 
@@ skipping 23 matching lines @@
 
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   EXPECT_FALSE(observer.handlers().empty());
 
   if (!observer.handlers().empty()) {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers().begin();
 
@@ skipping 49 matching lines @@
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // First load a page that has a favicon that requires
   // authentication.  There should be no login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kFaviconTestPage);
     WindowedLoadStopObserver load_stop_waiter(controller, 1);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     load_stop_waiter.Wait();
   }
 
   // Now request the same favicon, but directly as the document.
   // There should be one login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kFaviconResource);
     WindowedLoadStopObserver load_stop_waiter(controller, 1);
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
     ASSERT_EQ(1u, observer.handlers().size());
 
     while (!observer.handlers().empty()) {
       WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
       LoginHandler* handler = *observer.handlers().begin();
 
       ASSERT_TRUE(handler);
       handler->CancelAuth();
       auth_cancelled_waiter.Wait();
@@ skipping 28 matching lines @@
     GURL test_page = embedded_test_server()->GetURL(kTestPage);
     ASSERT_EQ("127.0.0.1", test_page.host());
 
     // Change the host from 127.0.0.1 to www.a.com so that when the
     // page tries to load from b, it will be cross-origin.
     GURL::Replacements replacements;
     replacements.SetHostStr("www.a.com");
     test_page = test_page.ReplaceComponents(replacements);
 
     WindowedLoadStopObserver load_stop_waiter(controller, 1);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     load_stop_waiter.Wait();
   }
 
   EXPECT_EQ(0, observer.auth_needed_count());
 
   // Now request the same page, but from the same origin.
   // There should be one login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kTestPage);
     ASSERT_EQ("127.0.0.1", test_page.host());
 
     // Change the host from 127.0.0.1 to www.b.com so that when the
     // page tries to load from b, it will be same-origin.
     GURL::Replacements replacements;
     replacements.SetHostStr("www.b.com");
     test_page = test_page.ReplaceComponents(replacements);
 
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
     ASSERT_EQ(1u, observer.handlers().size());
 
     while (!observer.handlers().empty()) {
       WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
       LoginHandler* handler = *observer.handlers().begin();
 
       ASSERT_TRUE(handler);
       handler->CancelAuth();
       auth_cancelled_waiter.Wait();
@@ skipping 24 matching lines @@
     ASSERT_EQ("127.0.0.1", test_page.host());
 
     // Change the host from 127.0.0.1 to www.a.com so that when the
     // page tries to load from b, it will be cross-origin.
     static const char kNewHost[] = "www.a.com";
     GURL::Replacements replacements;
     replacements.SetHostStr(kNewHost);
     test_page = test_page.ReplaceComponents(replacements);
 
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
     ASSERT_EQ(1u, observer.handlers().size());
 
     while (!observer.handlers().empty()) {
       WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
       LoginHandler* handler = *observer.handlers().begin();
 
       ASSERT_TRUE(handler);
       // When a cross origin iframe displays a login prompt, the blank
       // interstitial shouldn't be displayed and the omnibox should show the
@@ skipping 14 matching lines @@
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, SupplyRedundantAuths) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   // Get NavigationController for tab 1.
   content::WebContents* contents_1 =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller_1 = &contents_1->GetController();
 
   // Open a new tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      GURL("about:blank"),
-      NEW_FOREGROUND_TAB,
+      browser(), GURL("about:blank"), WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // Get NavigationController for tab 2.
   content::WebContents* contents_2 =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_NE(contents_1, contents_2);
   NavigationController* controller_2 = &contents_2->GetController();
 
   LoginPromptBrowserTestObserver observer;
   observer.Register(content::Source<NavigationController>(controller_1));
   observer.Register(content::Source<NavigationController>(controller_2));
 
   {
     // Open different auth urls in each tab.
     WindowedAuthNeededObserver auth_needed_waiter_1(controller_1);
     WindowedAuthNeededObserver auth_needed_waiter_2(controller_2);
     contents_1->OpenURL(OpenURLParams(
-        embedded_test_server()->GetURL("/auth-basic/1"),
-        content::Referrer(),
-        CURRENT_TAB,
-        ui::PAGE_TRANSITION_TYPED,
-        false));
+        embedded_test_server()->GetURL("/auth-basic/1"), content::Referrer(),
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     contents_2->OpenURL(OpenURLParams(
-        embedded_test_server()->GetURL("/auth-basic/2"),
-        content::Referrer(),
-        CURRENT_TAB,
-        ui::PAGE_TRANSITION_TYPED,
-        false));
+        embedded_test_server()->GetURL("/auth-basic/2"), content::Referrer(),
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter_1.Wait();
     auth_needed_waiter_2.Wait();
 
     ASSERT_EQ(2U, observer.handlers().size());
 
     // Supply auth in one of the tabs.
     WindowedAuthSuppliedObserver auth_supplied_waiter_1(controller_1);
     WindowedAuthSuppliedObserver auth_supplied_waiter_2(controller_2);
     LoginHandler* handler_1 = *observer.handlers().begin();
     ASSERT_TRUE(handler_1);
@@ skipping 12 matching lines @@
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, CancelRedundantAuths) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   // Get NavigationController for tab 1.
   content::WebContents* contents_1 =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller_1 = &contents_1->GetController();
 
   // Open a new tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      GURL("about:blank"),
-      NEW_FOREGROUND_TAB,
+      browser(), GURL("about:blank"), WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // Get NavigationController for tab 2.
   content::WebContents* contents_2 =
       browser()->tab_strip_model()->GetActiveWebContents();
   ASSERT_NE(contents_1, contents_2);
   NavigationController* controller_2 = &contents_2->GetController();
 
   LoginPromptBrowserTestObserver observer;
   observer.Register(content::Source<NavigationController>(controller_1));
   observer.Register(content::Source<NavigationController>(controller_2));
 
   {
     // Open different auth urls in each tab.
     WindowedAuthNeededObserver auth_needed_waiter_1(controller_1);
     WindowedAuthNeededObserver auth_needed_waiter_2(controller_2);
     contents_1->OpenURL(OpenURLParams(
-        embedded_test_server()->GetURL("/auth-basic/1"),
-        content::Referrer(),
-        CURRENT_TAB,
-        ui::PAGE_TRANSITION_TYPED,
-        false));
+        embedded_test_server()->GetURL("/auth-basic/1"), content::Referrer(),
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     contents_2->OpenURL(OpenURLParams(
-        embedded_test_server()->GetURL("/auth-basic/2"),
-        content::Referrer(),
-        CURRENT_TAB,
-        ui::PAGE_TRANSITION_TYPED,
-        false));
+        embedded_test_server()->GetURL("/auth-basic/2"), content::Referrer(),
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter_1.Wait();
     auth_needed_waiter_2.Wait();
 
     ASSERT_EQ(2U, observer.handlers().size());
 
     // Cancel auth in one of the tabs.
     WindowedAuthCancelledObserver auth_cancelled_waiter_1(controller_1);
     WindowedAuthCancelledObserver auth_cancelled_waiter_2(controller_2);
     LoginHandler* handler_1 = *observer.handlers().begin();
     ASSERT_TRUE(handler_1);
@@ skipping 33 matching lines @@
   LoginPromptBrowserTestObserver observer_incognito;
   observer_incognito.Register(
       content::Source<NavigationController>(controller_incognito));
 
   {
     // Open an auth url in each window.
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthNeededObserver auth_needed_waiter_incognito(
         controller_incognito);
     contents->OpenURL(OpenURLParams(
-        embedded_test_server()->GetURL("/auth-basic/1"),
-        content::Referrer(),
-        CURRENT_TAB,
-        ui::PAGE_TRANSITION_TYPED,
-        false));
+        embedded_test_server()->GetURL("/auth-basic/1"), content::Referrer(),
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     contents_incognito->OpenURL(OpenURLParams(
-        embedded_test_server()->GetURL("/auth-basic/2"),
-        content::Referrer(),
-        CURRENT_TAB,
-        ui::PAGE_TRANSITION_TYPED,
-        false));
+        embedded_test_server()->GetURL("/auth-basic/2"), content::Referrer(),
+        WindowOpenDisposition::CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
     auth_needed_waiter_incognito.Wait();
 
     ASSERT_EQ(1U, observer.handlers().size());
     ASSERT_EQ(1U, observer_incognito.handlers().size());
 
     // Supply auth in regular tab.
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers().begin();
     ASSERT_TRUE(handler);
@@ skipping 30 matching lines @@
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page which makes a synchronous XMLHttpRequest for an authenticated
   // resource with the wrong credentials.  There should be no login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kXHRTestPage);
     WindowedLoadStopObserver load_stop_waiter(controller, 1);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     load_stop_waiter.Wait();
   }
 
   base::string16 expected_title(base::UTF8ToUTF16("status=401"));
 
   EXPECT_EQ(expected_title, contents->GetTitle());
   EXPECT_EQ(0, observer.auth_supplied_count());
   EXPECT_EQ(0, observer.auth_needed_count());
   EXPECT_EQ(0, observer.auth_cancelled_count());
 }
@@ skipping 11 matching lines @@
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page which makes a synchronous XMLHttpRequest for an authenticated
   // resource with the wrong credentials.  There should be no login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kXHRTestPage);
     WindowedLoadStopObserver load_stop_waiter(controller, 1);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     load_stop_waiter.Wait();
   }
 
   base::string16 expected_title(base::UTF8ToUTF16("status=200"));
 
   EXPECT_EQ(expected_title, contents->GetTitle());
   EXPECT_EQ(0, observer.auth_supplied_count());
   EXPECT_EQ(0, observer.auth_needed_count());
   EXPECT_EQ(0, observer.auth_cancelled_count());
 }
@@ skipping 11 matching lines @@
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page which makes a synchronous XMLHttpRequest for an authenticated
   // resource with the wrong credentials.  There should be no login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kXHRTestPage);
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   ASSERT_FALSE(observer.handlers().empty());
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers().begin();
 
     ASSERT_TRUE(handler);
@@ skipping 40 matching lines @@
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page which makes a synchronous XMLHttpRequest for an authenticated
   // resource with the wrong credentials.  There should be no login prompt.
   {
     GURL test_page = embedded_test_server()->GetURL(kXHRTestPage);
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     auth_needed_waiter.Wait();
   }
 
   ASSERT_EQ(1u, observer.handlers().size());
   WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
   LoginHandler* handler = *observer.handlers().begin();
 
   handler->CancelAuth();
   auth_cancelled_waiter.Wait();
 
@@ skipping 16 matching lines @@
     bool cancel_prompt) const {
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page which will trigger a login prompt.
   WindowedAuthNeededObserver auth_needed_waiter(controller);
-  browser()->OpenURL(OpenURLParams(visit_url, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(visit_url, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   ASSERT_EQ(visit_url.host(), contents->GetVisibleURL().host());
   auth_needed_waiter.Wait();
   ASSERT_EQ(1u, observer.handlers().size());
   content::WaitForInterstitialAttach(contents);
 
   // The omnibox should show the correct origin for the new page when the
   // login prompt is shown.
   EXPECT_EQ(expected_hostname, contents->GetVisibleURL().host());
   EXPECT_TRUE(contents->ShowingInterstitialPage());
@@ skipping 121 matching lines @@
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page which triggers an SSL interstitial. Proceeding through it
   // should show the login page with the blank interstitial.
   {
     GURL test_page = https_server.GetURL(kAuthBasicPage);
     ASSERT_EQ("127.0.0.1", test_page.host());
 
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(
-        test_page, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED,
-        false));
+    browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
+                                     ui::PAGE_TRANSITION_TYPED, false));
     ASSERT_EQ("127.0.0.1", contents->GetURL().host());
     content::WaitForInterstitialAttach(contents);
 
     EXPECT_EQ(SSLBlockingPage::kTypeForTesting, contents->GetInterstitialPage()
                                                     ->GetDelegateForTesting()
                                                     ->GetTypeForTesting());
     // An overrideable SSL interstitial is now being displayed. Proceed through
     // the interstitial to see the login prompt.
     contents->GetInterstitialPage()->Proceed();
     auth_needed_waiter.Wait();
@@ skipping 48 matching lines @@
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   GURL auth_url = embedded_test_server()->GetURL(kAuthBasicPage);
   GURL broken_ssl_page = https_server.GetURL("/");
 
   // Navigate to an auth url and wait for the login prompt.
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(auth_url, Referrer(), CURRENT_TAB,
+    browser()->OpenURL(OpenURLParams(auth_url, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
                                      ui::PAGE_TRANSITION_TYPED, false));
     ASSERT_EQ("127.0.0.1", contents->GetURL().host());
     ASSERT_TRUE(contents->GetURL().SchemeIs("http"));
     auth_needed_waiter.Wait();
     ASSERT_EQ(1u, observer.handlers().size());
     content::WaitForInterstitialAttach(contents);
     ASSERT_TRUE(contents->ShowingInterstitialPage());
     EXPECT_EQ(LoginInterstitialDelegate::kTypeForTesting,
               contents->GetInterstitialPage()
                   ->GetDelegateForTesting()
                   ->GetTypeForTesting());
     // Cancel the auth prompt. This commits the navigation.
     LoginHandler* handler = *observer.handlers().begin();
     content::RunTaskAndWaitForInterstitialDetach(
         contents, base::Bind(&LoginHandler::CancelAuth, handler));
     EXPECT_EQ("127.0.0.1", contents->GetVisibleURL().host());
     EXPECT_FALSE(contents->ShowingInterstitialPage());
     EXPECT_EQ(auth_url, contents->GetLastCommittedURL());
   }
 
   // Navigate to a broken SSL page. This is a cross origin navigation since
   // schemes don't match (http vs https).
   {
     ASSERT_EQ("127.0.0.1", broken_ssl_page.host());
-    browser()->OpenURL(OpenURLParams(broken_ssl_page, Referrer(), CURRENT_TAB,
+    browser()->OpenURL(OpenURLParams(broken_ssl_page, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
                                      ui::PAGE_TRANSITION_TYPED, false));
     ASSERT_EQ("127.0.0.1", contents->GetURL().host());
     ASSERT_TRUE(contents->GetURL().SchemeIs("https"));
     content::WaitForInterstitialAttach(contents);
     EXPECT_TRUE(contents->ShowingInterstitialPage());
     EXPECT_EQ(SSLBlockingPage::kTypeForTesting, contents->GetInterstitialPage()
                                                     ->GetDelegateForTesting()
                                                     ->GetTypeForTesting());
     EXPECT_EQ(auth_url, contents->GetLastCommittedURL());
   }
 
   // An overrideable SSL interstitial is now being displayed. Navigate to the
   // auth URL again. This is again a cross origin navigation, but last committed
   // URL is the same as the auth URL (since SSL navigation never committed).
   // Should still replace SSL interstitial with an auth interstitial even though
   // last committed URL and the new URL is the same.
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
-    browser()->OpenURL(OpenURLParams(auth_url, Referrer(), CURRENT_TAB,
+    browser()->OpenURL(OpenURLParams(auth_url, Referrer(),
+                                     WindowOpenDisposition::CURRENT_TAB,
                                      ui::PAGE_TRANSITION_TYPED, false));
     ASSERT_EQ("127.0.0.1", contents->GetURL().host());
     ASSERT_TRUE(contents->GetURL().SchemeIs("http"));
     ASSERT_TRUE(contents->ShowingInterstitialPage());
 
     auth_needed_waiter.Wait();
     ASSERT_EQ(1u, observer.handlers().size());
     content::WaitForInterstitialAttach(contents);
     EXPECT_EQ(LoginInterstitialDelegate::kTypeForTesting,
               contents->GetInterstitialPage()
@@ skipping 22 matching lines @@
   NavigationController* controller = &contents->GetController();
   LoginPromptBrowserTestObserver observer;
   observer.Register(content::Source<NavigationController>(controller));
 
   // Load a page that has a cross-domain iframe authentication. This should
   // trigger a login prompt but no login interstitial.
   GURL test_page = embedded_test_server()->GetURL(kTestPage);
   GURL broken_ssl_page = https_server.GetURL("/");
   ASSERT_EQ("127.0.0.1", test_page.host());
   WindowedAuthNeededObserver auth_needed_waiter(controller);
-  browser()->OpenURL(OpenURLParams(test_page, Referrer(), CURRENT_TAB,
+  browser()->OpenURL(OpenURLParams(test_page, Referrer(),
+                                   WindowOpenDisposition::CURRENT_TAB,
                                    ui::PAGE_TRANSITION_TYPED, false));
   auth_needed_waiter.Wait();
   ASSERT_EQ(1u, observer.handlers().size());
   EXPECT_FALSE(contents->ShowingInterstitialPage());
 
   // Redirect to a broken SSL page. This redirect should not accidentally
   // proceed through the SSL interstitial.
   WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
   EXPECT_TRUE(content::ExecuteScript(
       browser()->tab_strip_model()->GetActiveWebContents(),
       std::string("window.location = '") + broken_ssl_page.spec() + "'"));
   content::WaitForInterstitialAttach(contents);
   auth_cancelled_waiter.Wait();
 
   // If the interstitial was accidentally clicked through, this wait may time
   // out.
   EXPECT_TRUE(
       WaitForRenderFrameReady(contents->GetInterstitialPage()->GetMainFrame()));
   EXPECT_TRUE(contents->ShowingInterstitialPage());
   EXPECT_EQ(SSLBlockingPage::kTypeForTesting, contents->GetInterstitialPage()
                                                   ->GetDelegateForTesting()
                                                   ->GetTypeForTesting());
 }
 
 }  // namespace