Convert WindowOpenDisposition to an enum class.

chrome/browser/extensions/api/tabs/tabs_test.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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 1116 matching lines @@
       base::MatchPattern(RunCreateWindowExpectError(
                              "[{\"state\": \"maximized\", \"width\": 500}]"),
                          keys::kInvalidWindowStateError));
   EXPECT_TRUE(
       base::MatchPattern(RunCreateWindowExpectError(
                              "[{\"state\": \"fullscreen\", \"width\": 500}]"),
                          keys::kInvalidWindowStateError));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTab) {
-  content::OpenURLParams params(GURL(url::kAboutBlankURL),
-                                content::Referrer(),
-                                NEW_FOREGROUND_TAB,
-                                ui::PAGE_TRANSITION_LINK,
-                                false);
+  content::OpenURLParams params(GURL(url::kAboutBlankURL), content::Referrer(),
+                                WindowOpenDisposition::NEW_FOREGROUND_TAB,
+                                ui::PAGE_TRANSITION_LINK, false);
   content::WebContents* web_contents = browser()->OpenURL(params);
   int tab_id = ExtensionTabUtil::GetTabId(web_contents);
   int window_id = ExtensionTabUtil::GetWindowIdOfTab(web_contents);
   int tab_index = -1;
   TabStripModel* tab_strip;
   ExtensionTabUtil::GetTabStripModel(web_contents, &tab_strip, &tab_index);
 
   scoped_refptr<TabsDuplicateFunction> duplicate_tab_function(
       new TabsDuplicateFunction());
   std::unique_ptr<base::DictionaryValue> test_extension_value(
@@ skipping 19 matching lines @@
   EXPECT_NE(tab_id, duplicate_tab_id);
   EXPECT_EQ(window_id, duplicate_tab_window_id);
   EXPECT_EQ(tab_index + 1, duplicate_tab_index);
   // The test empty tab extension has tabs permissions, therefore
   // |duplicate_result| should contain url, title, and faviconUrl
   // in the function result.
   EXPECT_TRUE(utils::HasPrivacySensitiveFields(duplicate_result.get()));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DuplicateTabNoPermission) {
-  content::OpenURLParams params(GURL(url::kAboutBlankURL),
-                                content::Referrer(),
-                                NEW_FOREGROUND_TAB,
-                                ui::PAGE_TRANSITION_LINK,
-                                false);
+  content::OpenURLParams params(GURL(url::kAboutBlankURL), content::Referrer(),
+                                WindowOpenDisposition::NEW_FOREGROUND_TAB,
+                                ui::PAGE_TRANSITION_LINK, false);
   content::WebContents* web_contents = browser()->OpenURL(params);
   int tab_id = ExtensionTabUtil::GetTabId(web_contents);
   int window_id = ExtensionTabUtil::GetWindowIdOfTab(web_contents);
   int tab_index = -1;
   TabStripModel* tab_strip;
   ExtensionTabUtil::GetTabStripModel(web_contents, &tab_strip, &tab_index);
 
   scoped_refptr<TabsDuplicateFunction> duplicate_tab_function(
       new TabsDuplicateFunction());
   scoped_refptr<Extension> empty_extension(test_util::CreateEmptyExtension());
@@ skipping 119 matching lines @@
   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 }
 
 // TODO(georgesak): change this browsertest to an unittest.
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DiscardedProperty) {
   ASSERT_TRUE(g_browser_process && g_browser_process->GetTabManager());
   memory::TabManager* tab_manager = g_browser_process->GetTabManager();
 
   // Create two aditional tabs.
   content::OpenURLParams params(GURL(url::kAboutBlankURL), content::Referrer(),
-                                NEW_BACKGROUND_TAB, ui::PAGE_TRANSITION_LINK,
-                                false);
+                                WindowOpenDisposition::NEW_BACKGROUND_TAB,
+                                ui::PAGE_TRANSITION_LINK, false);
   content::WebContents* web_contents_a = browser()->OpenURL(params);
   content::WebContents* web_contents_b = browser()->OpenURL(params);
 
   // Set up query function with an extension.
   scoped_refptr<const Extension> extension = test_util::CreateEmptyExtension();
   auto RunQueryFunction = [this, &extension](const char* query_info) {
     scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
     function->set_extension(extension.get());
     return utils::ToList(utils::RunFunctionAndReturnSingleResult(
         function.get(), query_info, browser()));
@@ skipping 96 matching lines @@
   // Get discarded tabs after activating a discarded tab.
   {
     std::unique_ptr<base::ListValue> result(
         RunQueryFunction("[{\"discarded\": true}]"));
     EXPECT_EQ(1u, result->GetSize());
   }
 }
 
 // Tests chrome.tabs.discard(tabId).
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DiscardWithId) {
-  // Create an aditional tab.
+  // Create an additional tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(), GURL(url::kAboutBlankURL), NEW_BACKGROUND_TAB,
+      browser(), GURL(url::kAboutBlankURL),
+      WindowOpenDisposition::NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetWebContentsAt(1);
 
   // Set up the function with an extension.
   scoped_refptr<const Extension> extension = test_util::CreateEmptyExtension();
   scoped_refptr<TabsDiscardFunction> discard(new TabsDiscardFunction());
   discard->set_extension(extension.get());
 
   // Run function passing the tab id as argument.
@@ skipping 17 matching lines @@
   // return the error stating that the tab couldn't be discarded.
   scoped_refptr<TabsDiscardFunction> discarded(new TabsDiscardFunction());
   discarded->set_extension(extension.get());
   std::string error = utils::RunFunctionAndReturnError(
       discarded.get(), base::StringPrintf("[%u]", tab_id), browser());
   EXPECT_TRUE(base::MatchPattern(error, keys::kCannotDiscardTab));
 }
 
 // Tests chrome.tabs.discard(invalidId).
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DiscardWithInvalidId) {
-  // Create an aditional tab.
+  // Create an additional tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(), GURL(url::kAboutBlankURL), NEW_BACKGROUND_TAB,
+      browser(), GURL(url::kAboutBlankURL),
+      WindowOpenDisposition::NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Set up the function with an extension.
   scoped_refptr<const Extension> extension = test_util::CreateEmptyExtension();
   scoped_refptr<TabsDiscardFunction> discard(new TabsDiscardFunction());
   discard->set_extension(extension.get());
 
   // Run function passing an invalid id as argument.
   int tab_invalid_id = ExtensionTabUtil::GetTabId(
       browser()->tab_strip_model()->GetWebContentsAt(0));
   tab_invalid_id = std::max(
       tab_invalid_id, ExtensionTabUtil::GetTabId(
                           browser()->tab_strip_model()->GetWebContentsAt(1)));
   tab_invalid_id++;
 
   std::string error = utils::RunFunctionAndReturnError(
       discard.get(), base::StringPrintf("[%u]", tab_invalid_id), browser());
 
   // Discarded state should still be false as no tab was discarded.
   EXPECT_FALSE(g_browser_process->GetTabManager()->IsTabDiscarded(
       browser()->tab_strip_model()->GetWebContentsAt(1)));
 
   // Check error message.
   EXPECT_TRUE(base::MatchPattern(error, keys::kTabNotFoundError));
 }
 
 // Tests chrome.tabs.discard().
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DiscardWithoutId) {
-  // Create an aditional tab.
+  // Create an additional tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(), GURL(url::kAboutBlankURL), NEW_BACKGROUND_TAB,
+      browser(), GURL(url::kAboutBlankURL),
+      WindowOpenDisposition::NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetWebContentsAt(1);
 
   // Set up the function with an extension.
   scoped_refptr<const Extension> extension = test_util::CreateEmptyExtension();
   scoped_refptr<TabsDiscardFunction> discard(new TabsDiscardFunction());
   discard->set_extension(extension.get());
 
   // Disable protection time to discard the tab without passing id.
@@ skipping 11 matching lines @@
 
   // Make sure the returned tab is the one discarded and its discarded state is
   // correct.
   EXPECT_EQ(ExtensionTabUtil::GetTabId(web_contents),
             api_test_utils::GetInteger(result.get(), "id"));
   EXPECT_TRUE(api_test_utils::GetBoolean(result.get(), "discarded"));
 }
 
 // Tests chrome.tabs.discard() without disabling protection time.
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DiscardNoTabProtection) {
-  // Create an aditional tab.
+  // Create an additional tab.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(), GURL(url::kAboutBlankURL), NEW_BACKGROUND_TAB,
+      browser(), GURL(url::kAboutBlankURL),
+      WindowOpenDisposition::NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Make sure protection time isn't disabled.
   g_browser_process->GetTabManager()->set_minimum_protection_time_for_tests(
       base::TimeDelta::FromMinutes(10));
 
   // Set up the function with an extension.
   scoped_refptr<const Extension> extension = test_util::CreateEmptyExtension();
   scoped_refptr<TabsDiscardFunction> discard(new TabsDiscardFunction());
   discard->set_extension(extension.get());
 
   // Run without passing an id. In this case the tab couldn't be discarded
   // because of protection time.
   std::string error =
       utils::RunFunctionAndReturnError(discard.get(), "[]", browser());
 
   // Discarded state should be false for both tabs as no tab was discarded.
   EXPECT_FALSE(g_browser_process->GetTabManager()->IsTabDiscarded(
       browser()->tab_strip_model()->GetWebContentsAt(1)));
   EXPECT_FALSE(g_browser_process->GetTabManager()->IsTabDiscarded(
       browser()->tab_strip_model()->GetWebContentsAt(0)));
 
   // Check error message.
   EXPECT_TRUE(base::MatchPattern(error, keys::kCannotFindTabToDiscard));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, AutoDiscardableProperty) {
   // Create two aditional tabs.
   content::OpenURLParams params(GURL(url::kAboutBlankURL), content::Referrer(),
-                                NEW_BACKGROUND_TAB, ui::PAGE_TRANSITION_LINK,
-                                false);
+                                WindowOpenDisposition::NEW_BACKGROUND_TAB,
+                                ui::PAGE_TRANSITION_LINK, false);
   content::WebContents* web_contents_a = browser()->OpenURL(params);
   content::WebContents* web_contents_b = browser()->OpenURL(params);
 
   // Creates Tab object to ensure the property is correct for the extension.
   TabStripModel* tab_strip_model = browser()->tab_strip_model();
   std::unique_ptr<api::tabs::Tab> tab_object_a =
       ExtensionTabUtil::CreateTabObject(web_contents_a, tab_strip_model, 0);
   EXPECT_TRUE(tab_object_a->auto_discardable);
 
   // Set up query and update functions with the extension.
@@ skipping 269 matching lines @@
                                               "\"scope\": \"%s\"}]",
                                               tab_id,
                                               mode,
                                               scope),
                                           browser());
 }
 
 content::WebContents* ExtensionTabsZoomTest::OpenUrlAndWaitForLoad(
     const GURL& url) {
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      url,
-      NEW_FOREGROUND_TAB,
+      browser(), url, WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   return  browser()->tab_strip_model()->GetActiveWebContents();
 }
 
 namespace {
 
 double GetZoomLevel(const content::WebContents* web_contents) {
   return zoom::ZoomController::FromWebContents(web_contents)->GetZoomLevel();
 }
 
 content::OpenURLParams GetOpenParams(const char* url) {
-  return content::OpenURLParams(GURL(url),
-                                content::Referrer(),
-                                NEW_FOREGROUND_TAB,
-                                ui::PAGE_TRANSITION_LINK,
-                                false);
+  return content::OpenURLParams(GURL(url), content::Referrer(),
+                                WindowOpenDisposition::NEW_FOREGROUND_TAB,
+                                ui::PAGE_TRANSITION_LINK, false);
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsZoomTest, SetAndGetZoom) {
   content::OpenURLParams params(GetOpenParams(url::kAboutBlankURL));
   content::WebContents* web_contents = OpenUrlAndWaitForLoad(params.url);
   int tab_id = ExtensionTabUtil::GetTabId(web_contents);
 
   // Test default values before we set anything.
@@ skipping 212 matching lines @@
   EXPECT_TRUE(
       base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
   EXPECT_TRUE(
       base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions