Convert WindowOpenDisposition to an enum class.

chrome/browser/ui/browser_navigator_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 "chrome/browser/ui/browser_navigator_browsertest.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 74 matching lines @@
   chrome::NavigateParams params(browser, GetGoogleURL(),
                                 ui::PAGE_TRANSITION_LINK);
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   return params;
 }
 
 bool BrowserNavigatorTest::OpenPOSTURLInNewForegroundTabAndGetTitle(
     const GURL& url, const std::string& post_data, bool is_browser_initiated,
     base::string16* title) {
   chrome::NavigateParams param(MakeNavigateParams());
-  param.disposition = NEW_FOREGROUND_TAB;
+  param.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   param.url = url;
   param.is_renderer_initiated = !is_browser_initiated;
   param.uses_post = true;
   param.post_data = content::ResourceRequestBody::CreateFromBytes(
       post_data.data(), post_data.size());
 
   ui_test_utils::NavigateToURL(&param);
   if (!param.target_contents)
     return false;
 
@@ skipping 51 matching lines @@
 
 void BrowserNavigatorTest::RunUseNonIncognitoWindowTest(const GURL& url) {
   Browser* incognito_browser = CreateIncognitoBrowser();
 
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, incognito_browser->tab_strip_model()->count());
 
   // Navigate to the page.
   chrome::NavigateParams params(MakeNavigateParams(incognito_browser));
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = url;
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   chrome::Navigate(&params);
 
   // This page should be opened in browser() window.
   EXPECT_NE(incognito_browser, params.browser);
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(url,
             browser()->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
 
 void BrowserNavigatorTest::RunDoNothingIfIncognitoIsForcedTest(
     const GURL& url) {
   Browser* browser = CreateIncognitoBrowser();
 
   // Set kIncognitoModeAvailability to FORCED.
   PrefService* prefs1 = browser->profile()->GetPrefs();
   prefs1->SetInteger(prefs::kIncognitoModeAvailability,
                      IncognitoModePrefs::FORCED);
   PrefService* prefs2 = browser->profile()->GetOriginalProfile()->GetPrefs();
   prefs2->SetInteger(prefs::kIncognitoModeAvailability,
                      IncognitoModePrefs::FORCED);
 
   // Navigate to the page.
   chrome::NavigateParams params(MakeNavigateParams(browser));
-  params.disposition = OFF_THE_RECORD;
+  params.disposition = WindowOpenDisposition::OFF_THE_RECORD;
   params.url = url;
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   chrome::Navigate(&params);
 
   // The page should not be opened.
   EXPECT_EQ(browser, params.browser);
   EXPECT_EQ(1, browser->tab_strip_model()->count());
   EXPECT_EQ(GURL(url::kAboutBlankURL),
             browser->tab_strip_model()->GetActiveWebContents()->GetURL());
 }
@@ skipping 50 matching lines @@
 
   // We should have one browser with 3 tabs, the 3rd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 
   unsigned int previous_tab_contents_count =
       created_tab_contents_count_ = 0;
 
   // Navigate to singleton_url1.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_url1;
   chrome::Navigate(&params);
 
   // The middle tab should now be selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // No tab contents should have been created
   EXPECT_EQ(previous_tab_contents_count,
             created_tab_contents_count_);
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabRespectingRef) {
   GURL singleton_ref_url1("http://maps.google.com/#a");
   GURL singleton_ref_url2("http://maps.google.com/#b");
   GURL singleton_ref_url3("http://maps.google.com/");
 
   chrome::AddSelectedTabWithURL(browser(), singleton_ref_url1,
                                 ui::PAGE_TRANSITION_LINK);
 
   // We should have one browser with 2 tabs, 2nd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url2.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_ref_url2;
   chrome::Navigate(&params);
 
   // We should now have 2 tabs, the 2nd one selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url2, but with respect ref set.
   params = MakeNavigateParams();
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_ref_url2;
   params.ref_behavior = chrome::NavigateParams::RESPECT_REF;
   chrome::Navigate(&params);
 
   // We should now have 3 tabs, the 3th one selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url3.
   params = MakeNavigateParams();
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_ref_url3;
   params.ref_behavior = chrome::NavigateParams::RESPECT_REF;
   chrome::Navigate(&params);
 
   // We should now have 4 tabs, the 4th one selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(4, browser()->tab_strip_model()->count());
   EXPECT_EQ(3, browser()->tab_strip_model()->active_index());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabNoneExisting) {
   GURL singleton_url1("http://maps.google.com/");
 
   // We should have one browser with 1 tab.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(0, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url1.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_url1;
   chrome::Navigate(&params);
 
   // We should now have 2 tabs, the 2nd one selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 }
 
 // This test verifies that when a navigation results in a foreground tab, the
 // tab count of the Browser increases and the selected tab shifts to the new
 // foreground tab.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewForegroundTab) {
   WebContents* old_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
   EXPECT_NE(old_contents,
             browser()->tab_strip_model()->GetActiveWebContents());
   EXPECT_EQ(browser()->tab_strip_model()->GetActiveWebContents(),
             params.target_contents);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 // This test verifies that when a navigation results in a background tab, the
 // tab count of the Browser increases but the selected tab remains the same.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewBackgroundTab) {
   WebContents* old_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_BACKGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_BACKGROUND_TAB;
   chrome::Navigate(&params);
   WebContents* new_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   // The selected tab should have remained unchanged, since the new tab was
   // opened in the background.
   EXPECT_EQ(old_contents, new_contents);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 // This test verifies that when a navigation requiring a new foreground tab
 // occurs in a Browser that cannot host multiple tabs, the new foreground tab
 // is created in an existing compatible Browser.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_IncompatibleWindow_Existing) {
   // Open a foreground tab in a window that cannot open popups when there is an
   // existing compatible window somewhere else that they can be opened within.
   Browser* popup = CreateEmptyBrowserForType(Browser::TYPE_POPUP,
                                              browser()->profile());
   chrome::NavigateParams params(MakeNavigateParams(popup));
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 
   // Navigate() should have opened the tab in a different browser since the
   // one we supplied didn't support additional tabs.
   EXPECT_NE(popup, params.browser);
 
   // Since browser() is an existing compatible tabbed browser, it should have
   // opened the tab there.
   EXPECT_EQ(browser(), params.browser);
 
@@ skipping 12 matching lines @@
   // We want to simulate not being able to find an existing window compatible
   // with our non-tabbed browser window so Navigate() is forced to create a
   // new compatible window. Because browser() supplied by the in-process
   // browser testing framework is compatible with browser()->profile(), we
   // need a different profile, and creating a popup window with an incognito
   // profile is a quick and dirty way of achieving this.
   Browser* popup = CreateEmptyBrowserForType(
       Browser::TYPE_POPUP,
       browser()->profile()->GetOffTheRecordProfile());
   chrome::NavigateParams params(MakeNavigateParams(popup));
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   chrome::Navigate(&params);
 
   // Navigate() should have opened the tab in a different browser since the
   // one we supplied didn't support additional tabs.
   EXPECT_NE(popup, params.browser);
 
   // This time, browser() is _not_ compatible with popup since it is not an
   // incognito window.
   EXPECT_NE(browser(), params.browser);
 
   // We should have three windows, each with one tab:
   // 1. the browser() provided by the framework (unchanged in this test)
   // 2. the incognito popup we created originally
   // 3. the new incognito tabbed browser that was created by Navigate().
   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, popup->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
   EXPECT_TRUE(params.browser->is_type_tabbed());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // from a normal Browser results in a new Browser with TYPE_POPUP.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopup) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_POPUP;
+  params.disposition = WindowOpenDisposition::NEW_POPUP;
   params.window_bounds = gfx::Rect(0, 0, 200, 200);
   // Wait for new popup to to load and gain focus.
   ui_test_utils::NavigateToURL(&params);
 
   // Navigate() should have opened a new, focused popup window.
   EXPECT_NE(browser(), params.browser);
 #if 0
   // TODO(stevenjb): Enable this test. See: crbug.com/79493
   EXPECT_TRUE(browser->window()->IsActive());
 #endif
   EXPECT_TRUE(params.browser->is_type_popup());
   EXPECT_FALSE(params.browser->is_app());
 
   // We should have two windows, the browser() provided by the framework and the
   // new popup window.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // from a normal Browser results in a new Browser with is_app() true.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopup_ExtensionId) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_POPUP;
+  params.disposition = WindowOpenDisposition::NEW_POPUP;
   params.extension_app_id = "extensionappid";
   params.window_bounds = gfx::Rect(0, 0, 200, 200);
   // Wait for new popup to to load and gain focus.
   ui_test_utils::NavigateToURL(&params);
 
   // Navigate() should have opened a new, focused popup window.
   EXPECT_NE(browser(), params.browser);
   EXPECT_TRUE(params.browser->is_type_popup());
   EXPECT_TRUE(params.browser->is_app());
 
   // We should have two windows, the browser() provided by the framework and the
   // new popup window.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // from a normal popup results in a new Browser with TYPE_POPUP.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopupFromPopup) {
   // Open a popup.
   chrome::NavigateParams params1(MakeNavigateParams());
-  params1.disposition = NEW_POPUP;
+  params1.disposition = WindowOpenDisposition::NEW_POPUP;
   params1.window_bounds = gfx::Rect(0, 0, 200, 200);
   chrome::Navigate(&params1);
   // Open another popup.
   chrome::NavigateParams params2(MakeNavigateParams(params1.browser));
-  params2.disposition = NEW_POPUP;
+  params2.disposition = WindowOpenDisposition::NEW_POPUP;
   params2.window_bounds = gfx::Rect(0, 0, 200, 200);
   chrome::Navigate(&params2);
 
   // Navigate() should have opened a new normal popup window.
   EXPECT_NE(params1.browser, params2.browser);
   EXPECT_TRUE(params2.browser->is_type_popup());
   EXPECT_FALSE(params2.browser->is_app());
 
   // We should have three windows, the browser() provided by the framework,
   // the first popup window, and the second popup window.
   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, params1.browser->tab_strip_model()->count());
   EXPECT_EQ(1, params2.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // from an app frame results in a new Browser with TYPE_POPUP.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_NewPopupFromAppWindow) {
   Browser* app_browser = CreateEmptyBrowserForApp(browser()->profile());
   chrome::NavigateParams params(MakeNavigateParams(app_browser));
-  params.disposition = NEW_POPUP;
+  params.disposition = WindowOpenDisposition::NEW_POPUP;
   params.window_bounds = gfx::Rect(0, 0, 200, 200);
   chrome::Navigate(&params);
 
   // Navigate() should have opened a new popup app window.
   EXPECT_NE(app_browser, params.browser);
   EXPECT_NE(browser(), params.browser);
   EXPECT_TRUE(params.browser->is_type_popup());
   EXPECT_TRUE(params.browser->is_app());
 
   // We should now have three windows, the app window, the app popup it created,
   // and the original browser() provided by the framework.
   EXPECT_EQ(3u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, app_browser->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // from an app popup results in a new Browser also of TYPE_POPUP.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_NewPopupFromAppPopup) {
   Browser* app_browser = CreateEmptyBrowserForApp(browser()->profile());
   // Open an app popup.
   chrome::NavigateParams params1(MakeNavigateParams(app_browser));
-  params1.disposition = NEW_POPUP;
+  params1.disposition = WindowOpenDisposition::NEW_POPUP;
   params1.window_bounds = gfx::Rect(0, 0, 200, 200);
   chrome::Navigate(&params1);
   // Now open another app popup.
   chrome::NavigateParams params2(MakeNavigateParams(params1.browser));
-  params2.disposition = NEW_POPUP;
+  params2.disposition = WindowOpenDisposition::NEW_POPUP;
   params2.window_bounds = gfx::Rect(0, 0, 200, 200);
   chrome::Navigate(&params2);
 
   // Navigate() should have opened a new popup app window.
   EXPECT_NE(browser(), params1.browser);
   EXPECT_NE(params1.browser, params2.browser);
   EXPECT_TRUE(params2.browser->is_type_popup());
   EXPECT_TRUE(params2.browser->is_app());
 
   // We should now have four windows, the app window, the first app popup,
   // the second app popup, and the original browser() provided by the framework.
   EXPECT_EQ(4u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, app_browser->tab_strip_model()->count());
   EXPECT_EQ(1, params1.browser->tab_strip_model()->count());
   EXPECT_EQ(1, params2.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // from an extension app tab results in a new Browser with TYPE_APP_POPUP.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_NewPopupFromExtensionApp) {
   // TODO(beng): TBD.
 }
 
 // This test verifies that navigating with window_action = SHOW_WINDOW_INACTIVE
 // does not focus a new new popup window.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopupUnfocused) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_POPUP;
+  params.disposition = WindowOpenDisposition::NEW_POPUP;
   params.window_bounds = gfx::Rect(0, 0, 200, 200);
   params.window_action = chrome::NavigateParams::SHOW_WINDOW_INACTIVE;
   // Wait for new popup to load (and gain focus if the test fails).
   ui_test_utils::NavigateToURL(&params);
 
   // Navigate() should have opened a new, unfocused, popup window.
   EXPECT_NE(browser(), params.browser);
   EXPECT_EQ(Browser::TYPE_POPUP, params.browser->type());
 #if 0
 // TODO(stevenjb): Enable this test. See: crbug.com/79493
   EXPECT_FALSE(p.browser->window()->IsActive());
 #endif
 }
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_POPUP
 // and trusted_source = true results in a new Browser where is_trusted_source()
 // is true.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewPopupTrusted) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_POPUP;
+  params.disposition = WindowOpenDisposition::NEW_POPUP;
   params.trusted_source = true;
   params.window_bounds = gfx::Rect(0, 0, 200, 200);
   // Wait for new popup to to load and gain focus.
   ui_test_utils::NavigateToURL(&params);
 
   // Navigate() should have opened a new popup window of TYPE_TRUSTED_POPUP.
   EXPECT_NE(browser(), params.browser);
   EXPECT_TRUE(params.browser->is_type_popup());
   EXPECT_TRUE(params.browser->is_trusted_source());
 }
 
 
 // This test verifies that navigating with WindowOpenDisposition = NEW_WINDOW
 // always opens a new window.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_NewWindow) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_WINDOW;
+  params.disposition = WindowOpenDisposition::NEW_WINDOW;
   chrome::Navigate(&params);
 
   // Navigate() should have opened a new toplevel window.
   EXPECT_NE(browser(), params.browser);
   EXPECT_TRUE(params.browser->is_type_tabbed());
 
   // We should now have two windows, the browser() provided by the framework and
   // the new normal window.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = INCOGNITO
 // opens a new incognito window if no existing incognito window is present.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_Incognito) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = OFF_THE_RECORD;
+  params.disposition = WindowOpenDisposition::OFF_THE_RECORD;
   chrome::Navigate(&params);
 
   // Navigate() should have opened a new toplevel incognito window.
   EXPECT_NE(browser(), params.browser);
   EXPECT_EQ(browser()->profile()->GetOffTheRecordProfile(),
             params.browser->profile());
 
   // |source_contents| should be set to NULL because the profile for the new
   // page is different from the originating page.
   EXPECT_EQ(NULL, params.source_contents);
 
   // We should now have two windows, the browser() provided by the framework and
   // the new incognito window.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
 }
 
 // This test verifies that navigating with WindowOpenDisposition = INCOGNITO
 // reuses an existing incognito window when possible.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_IncognitoRefocus) {
   Browser* incognito_browser =
       CreateEmptyBrowserForType(Browser::TYPE_TABBED,
                                 browser()->profile()->GetOffTheRecordProfile());
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = OFF_THE_RECORD;
+  params.disposition = WindowOpenDisposition::OFF_THE_RECORD;
   chrome::Navigate(&params);
 
   // Navigate() should have opened a new tab in the existing incognito window.
   EXPECT_NE(browser(), params.browser);
   EXPECT_EQ(params.browser, incognito_browser);
 
   // We should now have two windows, the browser() provided by the framework and
   // the incognito window we opened earlier.
   EXPECT_EQ(2u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(2, incognito_browser->tab_strip_model()->count());
 }
 
 // This test verifies that no navigation action occurs when
 // WindowOpenDisposition = SAVE_TO_DISK.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_SaveToDisk) {
-  RunSuppressTest(SAVE_TO_DISK);
+  RunSuppressTest(WindowOpenDisposition::SAVE_TO_DISK);
 }
 
 // This test verifies that no navigation action occurs when
 // WindowOpenDisposition = IGNORE_ACTION.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Disposition_IgnoreAction) {
-  RunSuppressTest(IGNORE_ACTION);
+  RunSuppressTest(WindowOpenDisposition::IGNORE_ACTION);
 }
 
 // This tests adding a foreground tab with a predefined WebContents.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, TargetContents_ForegroundTab) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   params.target_contents = CreateWebContents(false);
   chrome::Navigate(&params);
 
   // Navigate() should have opened the contents in a new foreground tab in the
   // current Browser.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(browser()->tab_strip_model()->GetActiveWebContents(),
             params.target_contents);
 
   // We should have one window, with two tabs.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 #if defined(OS_WIN)
 // This tests adding a popup with a predefined WebContents.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, DISABLED_TargetContents_Popup) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_POPUP;
+  params.disposition = WindowOpenDisposition::NEW_POPUP;
   params.target_contents = CreateWebContents(false);
   params.window_bounds = gfx::Rect(10, 10, 500, 500);
   chrome::Navigate(&params);
 
   // Navigate() should have opened a new popup window.
   EXPECT_NE(browser(), params.browser);
   EXPECT_TRUE(params.browser->is_type_popup());
   EXPECT_FALSE(params.browser->is_app());
 
   // The web platform is weird. The window bounds specified in
@@ skipping 19 matching lines @@
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, params.browser->tab_strip_model()->count());
 }
 #endif
 
 // This test checks that we can create WebContents with renderer process and
 // RenderFrame without navigating it.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        CreateWebContentsWithRendererProcess) {
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   params.target_contents = CreateWebContents(true);
   ASSERT_TRUE(params.target_contents);
 
   // There is no navigation (to about:blank or something like that).
   EXPECT_FALSE(params.target_contents->IsLoading());
 
   ASSERT_TRUE(params.target_contents->GetMainFrame());
   EXPECT_TRUE(params.target_contents->GetMainFrame()->IsRenderFrameLive());
   EXPECT_TRUE(
       params.target_contents->GetController().IsInitialBlankNavigation());
@@ skipping 21 matching lines @@
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 // This tests adding a tab at a specific index.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest, Tabstrip_InsertAtIndex) {
   // This is not meant to be a comprehensive test of whether or not the tab
   // implementation of the browser observes the insertion index. That is
   // covered by the unit tests for TabStripModel. This merely verifies that
   // insertion index preference is reflected in common cases.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   params.tabstrip_index = 0;
   params.tabstrip_add_types = TabStripModel::ADD_FORCE_INDEX;
   chrome::Navigate(&params);
 
   // Navigate() should have inserted a new tab at slot 0 in the tabstrip.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(0, browser()->tab_strip_model()->GetIndexOfWebContents(
       static_cast<const WebContents*>(params.target_contents)));
 
   // We should have one window - the browser() provided by the framework.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 }
 
 // This test verifies that constructing params with disposition = SINGLETON_TAB
 // and IGNORE_AND_NAVIGATE opens a new tab navigated to the specified URL if
 // no previous tab with that URL (minus the path) exists.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        Disposition_SingletonTabNew_IgnorePath) {
   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
                                 ui::PAGE_TRANSITION_LINK);
 
   // We should have one browser with 2 tabs, the 2nd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Navigate to a new singleton tab with a sub-page.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = GetContentSettingsURL();
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   chrome::Navigate(&params);
 
   // The last tab should now be selected and navigated to the sub-page of the
   // URL.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
@@ skipping 13 matching lines @@
   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
                                 ui::PAGE_TRANSITION_LINK);
 
   // We should have one browser with 3 tabs, the 3rd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url1.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = GetContentSettingsURL();
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   chrome::Navigate(&params);
 
   // The middle tab should now be selected and navigated to the sub-page of the
   // URL.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
@@ skipping 13 matching lines @@
   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
                                 ui::PAGE_TRANSITION_LINK);
 
   // We should have one browser with 3 tabs, the 3rd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url1.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = GetClearBrowsingDataURL();
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   chrome::Navigate(&params);
 
   // The middle tab should now be selected and navigated to the sub-page of the
   // URL.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
@@ skipping 13 matching lines @@
   chrome::AddSelectedTabWithURL(browser(), GetGoogleURL(),
                                 ui::PAGE_TRANSITION_LINK);
 
   // We should have one browser with 3 tabs, the 3rd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(2, browser()->tab_strip_model()->active_index());
 
   // Navigate to singleton_url1.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = GetClearBrowsingDataURL();
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_STAY_PUT;
   chrome::Navigate(&params);
 
   // The middle tab should now be selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(3, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(singleton_url1,
@@ skipping 11 matching lines @@
                                 ui::PAGE_TRANSITION_LINK);
 
   // We should have one browser with 2 tabs, the 2nd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Navigate to a different settings path.
   GURL singleton_url_target(GetClearBrowsingDataURL());
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_url_target;
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   chrome::Navigate(&params);
 
   // The second tab should still be selected, but navigated to the new path.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
   EXPECT_EQ(singleton_url_target,
@@ skipping 12 matching lines @@
                                 ui::PAGE_TRANSITION_LINK);
 
   EXPECT_EQ(initial_tab_count + 1, browser()->tab_strip_model()->count());
   EXPECT_EQ(initial_tab_count, browser()->tab_strip_model()->active_index());
 
   // Navigate to a different settings path.
   GURL singleton_url_target(
       "chrome://settings/internet?"
       "guid=ethernet_00aa00aa00aa&networkType=1");
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_url_target;
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   chrome::Navigate(&params);
 
   // Last tab should still be selected.
   EXPECT_EQ(browser(), params.browser);
   EXPECT_EQ(initial_tab_count + 1, browser()->tab_strip_model()->count());
   EXPECT_EQ(initial_tab_count, browser()->tab_strip_model()->active_index());
 }
@@ skipping 28 matching lines @@
   RunUseNonIncognitoWindowTest(GURL(view_source));
 }
 
 // This test verifies that the settings page isn't opened in the incognito
 // window from a non-incognito window (bookmark open-in-incognito trigger).
 // Disabled until fixed for uber settings: http://crbug.com/111243
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
     DISABLED_Disposition_Settings_UseNonIncognitoWindowForBookmark) {
   chrome::NavigateParams params(browser(), GetSettingsURL(),
                                 ui::PAGE_TRANSITION_AUTO_BOOKMARK);
-  params.disposition = OFF_THE_RECORD;
+  params.disposition = WindowOpenDisposition::OFF_THE_RECORD;
   {
     content::WindowedNotificationObserver observer(
         content::NOTIFICATION_LOAD_STOP,
         content::NotificationService::AllSources());
     chrome::Navigate(&params);
     observer.Wait();
   }
 
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(GetSettingsURL(),
@@ skipping 38 matching lines @@
   // We should have one browser with 2 tabs, the 2nd selected.
   EXPECT_EQ(1u, chrome::GetTotalBrowserCount());
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_EQ(1, browser()->tab_strip_model()->active_index());
 
   // Kill the singleton tab.
   web_contents->SetIsCrashed(base::TERMINATION_STATUS_PROCESS_CRASHED, -1);
   EXPECT_TRUE(web_contents->IsCrashed());
 
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = SINGLETON_TAB;
+  params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   params.url = singleton_url;
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   ui_test_utils::NavigateToURL(&params);
 
   // The tab should not be sad anymore.
   EXPECT_FALSE(web_contents->IsCrashed());
 }
 
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
@@ skipping 257 matching lines @@
       chrome::kChromeUIVersionURL;
 
   chrome::NavigateParams viewsource_params(browser(),
                                            GURL(viewsource_ntp_url),
                                            ui::PAGE_TRANSITION_LINK);
   ui_test_utils::NavigateToURL(&viewsource_params);
 
   chrome::NavigateParams singleton_params(browser(),
                                           GURL(chrome::kChromeUIVersionURL),
                                           ui::PAGE_TRANSITION_LINK);
-  singleton_params.disposition = SINGLETON_TAB;
+  singleton_params.disposition = WindowOpenDisposition::SINGLETON_TAB;
   EXPECT_EQ(-1, chrome::GetIndexOfSingletonTab(&singleton_params));
 }
 
 // This test verifies that browser initiated navigations can send requests
 // using POST.
 IN_PROC_BROWSER_TEST_F(BrowserNavigatorTest,
                        SendBrowserInitiatedRequestUsingPOST) {
   // Uses a test sever to verify POST request.
   ASSERT_TRUE(embedded_test_server()->Start());
 
@@ skipping 36 matching lines @@
   std::string data_url = "data:text/html;charset=utf-8,<html><title>" +
                          unescaped_title + "</title></html>";
   // BiDi control chars in URLs are always escaped, so the expected URL should
   // have the title with the escaped RTL mark.
   std::string escaped_title = "%E2%80%8F" + text;
   std::string expected_url = "data:text/html;charset=utf-8,<html><title>" +
                              escaped_title + "</title></html>";
 
   // Navigate to the page.
   chrome::NavigateParams params(MakeNavigateParams());
-  params.disposition = NEW_FOREGROUND_TAB;
+  params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
   params.url = GURL(data_url);
   params.window_action = chrome::NavigateParams::SHOW_WINDOW;
   ui_test_utils::NavigateToURL(&params);
 
   base::string16 expected_title(base::UTF8ToUTF16(unescaped_title));
   EXPECT_TRUE(params.target_contents);
   EXPECT_EQ(expected_title, params.target_contents->GetTitle());
   // GURL always keeps non-ASCII characters escaped, but check them anyways.
   EXPECT_EQ(GURL(expected_url).spec(), params.target_contents->GetURL().spec());
   // Check the omnibox text. It should have escaped RTL with unescaped text.
   LocationBar* location_bar = browser()->window()->GetLocationBar();
   OmniboxView* omnibox_view = location_bar->GetOmniboxView();
   EXPECT_EQ(base::UTF8ToUTF16(expected_url), omnibox_view->GetText());
 }
 
 }  // namespace