Convert WindowOpenDisposition to an enum class.

chrome/browser/download/download_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/download/download_browsertest.h"
 
 #include <stdint.h>
 #include <sstream>
 #include <utility>
 
@@ skipping 587 matching lines @@
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
     // We don't expect a file chooser to be shown.
     EXPECT_FALSE(DidShowFileChooser());
   }
 
   // Download a file in the current tab, then wait for the download to finish.
   void DownloadAndWait(Browser* browser,
                        const GURL& url) {
     DownloadAndWaitWithDisposition(
-        browser,
-        url,
-        CURRENT_TAB,
+        browser, url, WindowOpenDisposition::CURRENT_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   }
 
   // Should only be called when the download is known to have finished
   // (in error or not).
   // Returning false indicates a failure of the function, and should be asserted
   // in the caller.
   bool CheckDownload(Browser* browser,
                      const base::FilePath& downloaded_filename,
                      const base::FilePath& origin_filename) {
@@ skipping 105 matching lines @@
     //  - Add a member function to |DownloadShelf| to get the status text
     //    of a given member (for example, via the name in |DownloadItemView|'s
     //    GetAccessibleState() member function), by index.
     //  - Iterate over browser->window()->GetDownloadShelf()'s members
     //    to see if any match the status text we want.  Start with the last one.
 
     // Allow the request to finish.  We do this by loading a second URL in a
     // separate tab.
     GURL finish_url(net::URLRequestSlowDownloadJob::kFinishDownloadUrl);
     ui_test_utils::NavigateToURLWithDisposition(
-        browser,
-        finish_url,
-        NEW_FOREGROUND_TAB,
+        browser, finish_url, WindowOpenDisposition::NEW_FOREGROUND_TAB,
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
     observer->WaitForFinished();
     EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
     CheckDownloadStatesForBrowser(browser, 1, DownloadItem::COMPLETE);
 
     EXPECT_EQ(2, browser->tab_strip_model()->count());
 
     // TODO(ahendrickson): check download status text after downloading.
 
     base::FilePath basefilename(filename.BaseName());
@@ skipping 694 matching lines @@
   EXPECT_TRUE(base::GetFileSize(origin, &origin_file_size));
   std::string original_contents;
   EXPECT_TRUE(base::ReadFileToString(origin, &original_contents));
 
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_TRUE(download_items.empty());
 
   // Download a file in the on-record browser and check that it was downloaded
   // correctly.
-  DownloadAndWaitWithDisposition(browser(),
-                                 url,
-                                 CURRENT_TAB,
+  DownloadAndWaitWithDisposition(browser(), url,
+                                 WindowOpenDisposition::CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_NONE);
   GetDownloads(browser(), &download_items);
   ASSERT_EQ(1UL, download_items.size());
   ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file.zip")),
             download_items[0]->GetTargetFilePath().BaseName());
   ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
   EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
                          original_contents, origin_file_size));
 
   // Setup an incognito window.
   Browser* incognito = CreateIncognitoBrowser();
   ASSERT_TRUE(incognito);
   int window_count = BrowserList::GetInstance()->size();
   EXPECT_EQ(2, window_count);
   incognito->profile()->GetPrefs()->SetFilePath(
       prefs::kDownloadDefaultDirectory,
       GetDownloadsDirectory());
   incognito->profile()->GetPrefs()->SetFilePath(
       prefs::kSaveFileDefaultDirectory,
       GetDownloadsDirectory());
 
   download_items.clear();
   GetDownloads(incognito, &download_items);
   ASSERT_TRUE(download_items.empty());
 
   // Download a file in the incognito browser and check that it was downloaded
   // correctly.
-  DownloadAndWaitWithDisposition(incognito,
-                                 url,
-                                 CURRENT_TAB,
+  DownloadAndWaitWithDisposition(incognito, url,
+                                 WindowOpenDisposition::CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_NONE);
   GetDownloads(incognito, &download_items);
   ASSERT_EQ(1UL, download_items.size());
   ASSERT_EQ(base::FilePath(FILE_PATH_LITERAL("a_zip_file (1).zip")),
             download_items[0]->GetTargetFilePath().BaseName());
   ASSERT_TRUE(base::PathExists(download_items[0]->GetTargetFilePath()));
   EXPECT_TRUE(VerifyFile(download_items[0]->GetTargetFilePath(),
                          original_contents, origin_file_size));
 }
 
 // Navigate to a new background page, but don't download.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab1) {
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   GURL url(URLRequestMockHTTPJob::GetMockUrl("download-test2.html"));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      url,
-      NEW_BACKGROUND_TAB,
+      browser(), url, WindowOpenDisposition::NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // We should have two tabs now.
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
   EXPECT_TRUE(VerifyNoDownloads());
 }
 
 // Download a file in a background tab. Verify that the tab is closed
 // automatically.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab1) {
   // Download a file in a new background tab and wait.  The tab is automatically
   // closed when the download begins.
   GURL url(URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path));
-  DownloadAndWaitWithDisposition(
-      browser(),
-      url,
-      NEW_BACKGROUND_TAB,
-      0);
+  DownloadAndWaitWithDisposition(browser(), url,
+                                 WindowOpenDisposition::NEW_BACKGROUND_TAB, 0);
 
   // When the download finishes, we should still have one tab.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then download a file in another tab via
 // a Javascript call.
 // Verify that we have 2 tabs.
 //
 // The download_page1.html page contains an openNew() function that opens a
 // tab and then downloads download-test1.lib.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab2) {
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   GURL url(URLRequestMockHTTPJob::GetMockUrl("download_page1.html"));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Download a file in a new tab and wait (via Javascript).
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
-  DownloadAndWaitWithDisposition(browser(),
-                                 GURL("javascript:openNew()"),
-                                 CURRENT_TAB,
+  DownloadAndWaitWithDisposition(browser(), GURL("javascript:openNew()"),
+                                 WindowOpenDisposition::CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should have two tabs.
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, open another tab via a Javascript call,
 // then download a file in the new tab.
 // Verify that we have 2 tabs.
 //
 // The download_page2.html page contains an openNew() function that opens a
 // tab.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab3) {
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   GURL url1(URLRequestMockHTTPJob::GetMockUrl("download_page2.html"));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url1);
 
   // Open a new tab and wait.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      GURL("javascript:openNew()"),
-      CURRENT_TAB,
+      browser(), GURL("javascript:openNew()"),
+      WindowOpenDisposition::CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 
   // Download a file and wait.
   GURL url(URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path));
-  DownloadAndWaitWithDisposition(browser(),
-                                 url,
-                                 CURRENT_TAB,
+  DownloadAndWaitWithDisposition(browser(), url,
+                                 WindowOpenDisposition::CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_NONE);
 
   // When the download finishes, we should have two tabs.
   EXPECT_EQ(2, browser()->tab_strip_model()->count());
 
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then download a file via Javascript,
 // which will do so in a temporary tab. Verify that we have 1 tab.
 //
 // The download_page3.html page contains an openNew() function that opens a
 // tab with download-test1.lib in the URL.  When the URL is determined to be
 // a download, the tab is closed automatically.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab2) {
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   GURL url(URLRequestMockHTTPJob::GetMockUrl("download_page3.html"));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Download a file and wait.
   // The file to download is "download-test1.lib".
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
-  DownloadAndWaitWithDisposition(browser(),
-                                 GURL("javascript:openNew()"),
-                                 CURRENT_TAB,
+  DownloadAndWaitWithDisposition(browser(), GURL("javascript:openNew()"),
+                                 WindowOpenDisposition::CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then call Javascript via a button to
 // download a file in a new tab, which is closed automatically when the
 // download begins.
 // Verify that we have 1 tab.
 //
 // The download_page4.html page contains a form with download-test1.lib as the
 // action.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab3) {
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   GURL url(URLRequestMockHTTPJob::GetMockUrl("download_page4.html"));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Download a file in a new tab and wait.  The tab will automatically close
   // when the download begins.
   // The file to download is "download-test1.lib".
   base::FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   DownloadAndWaitWithDisposition(
-      browser(),
-      GURL("javascript:document.getElementById('form').submit()"),
-      CURRENT_TAB,
+      browser(), GURL("javascript:document.getElementById('form').submit()"),
+      WindowOpenDisposition::CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a second tab, then download a file in that tab. However, have the
 // download be canceled by having the file picker act like the user canceled
@@ skipping 1244 matching lines @@
   }
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_Remove) {
   GURL url = net::URLRequestMockHTTPJob::GetMockUrl("downloads/a_zip_file.zip");
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_TRUE(download_items.empty());
 
   // Download a file.
-  DownloadAndWaitWithDisposition(browser(),
-                                 url,
-                                 CURRENT_TAB,
+  DownloadAndWaitWithDisposition(browser(), url,
+                                 WindowOpenDisposition::CURRENT_TAB,
                                  ui_test_utils::BROWSER_TEST_NONE);
   GetDownloads(browser(), &download_items);
   ASSERT_EQ(1UL, download_items.size());
   base::FilePath downloaded(download_items[0]->GetTargetFilePath());
 
   // Remove the DownloadItem but not the file, then check that the file still
   // exists.
   download_items[0]->Remove();
   download_items.clear();
   GetDownloads(browser(), &download_items);
@@ skipping 51 matching lines @@
   int64_t free_space =
       base::SysInfo::AmountOfFreeDiskSpace(GetDownloadDirectory(browser()));
   ASSERT_LE(size, free_space) << "Not enough disk space to download. Got "
                               << free_space;
   GURL file_url(net::FilePathToFileURL(file_path));
   std::unique_ptr<content::DownloadTestObserver> progress_waiter(
       CreateInProgressWaiter(browser(), 1));
 
   // Start downloading a file, wait for it to be created.
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(), file_url, CURRENT_TAB, ui_test_utils::BROWSER_TEST_NONE);
+      browser(), file_url, WindowOpenDisposition::CURRENT_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
   progress_waiter->WaitForFinished();
   EXPECT_EQ(1u, progress_waiter->NumDownloadsSeenInState(
       DownloadItem::IN_PROGRESS));
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_EQ(1UL, download_items.size());
 
   // Wait for the download to complete, checking along the way that the
   // PercentComplete() never regresses.
   PercentWaiter waiter(download_items[0]);
@@ skipping 229 matching lines @@
   browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
                                                true);
   GURL download_url =
       net::URLRequestMockHTTPJob::GetMockUrl(kDangerousMockFilePath);
   std::unique_ptr<content::DownloadTestObserver> dangerous_observer(
       DangerousDownloadWaiter(
           browser(), 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
   std::unique_ptr<content::DownloadTestObserver> in_progress_observer(
       new DisableSafeBrowsingOnInProgressDownload(browser()));
-  ui_test_utils::NavigateToURLWithDisposition(browser(),
-                                              download_url,
-                                              NEW_BACKGROUND_TAB,
-                                              ui_test_utils::BROWSER_TEST_NONE);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), download_url, WindowOpenDisposition::NEW_BACKGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
   in_progress_observer->WaitForFinished();
 
   // SafeBrowsing should have been disabled by our observer.
   ASSERT_FALSE(browser()->profile()->GetPrefs()->GetBoolean(
       prefs::kSafeBrowsingEnabled));
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
   DownloadItem* download = downloads[0];
@@ skipping 10 matching lines @@
   // Disable SafeBrowsing
   browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
                                                false);
 
   GURL download_url =
       net::URLRequestMockHTTPJob::GetMockUrl(kDangerousMockFilePath);
   std::unique_ptr<content::DownloadTestObserver> dangerous_observer(
       DangerousDownloadWaiter(
           browser(), 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
-  ui_test_utils::NavigateToURLWithDisposition(browser(),
-                                              download_url,
-                                              NEW_BACKGROUND_TAB,
-                                              ui_test_utils::BROWSER_TEST_NONE);
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(), download_url, WindowOpenDisposition::NEW_BACKGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
   dangerous_observer->WaitForFinished();
 
   std::vector<DownloadItem*> downloads;
   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
 
   DownloadItem* download = downloads[0];
   EXPECT_TRUE(download->IsDangerous());
   EXPECT_EQ(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE,
             download->GetDangerType());
@@ skipping 20 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, FeedbackService) {
   // Make a dangerous file.
   GURL download_url(net::URLRequestMockHTTPJob::GetMockUrl(
       "downloads/dangerous/dangerous.swf"));
   std::unique_ptr<content::DownloadTestObserverInterrupted> observer(
       new content::DownloadTestObserverInterrupted(
           DownloadManagerForBrowser(browser()), 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_QUIT));
   ui_test_utils::NavigateToURLWithDisposition(
-      browser(),
-      GURL(download_url),
-      NEW_BACKGROUND_TAB,
+      browser(), GURL(download_url), WindowOpenDisposition::NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   observer->WaitForFinished();
 
   // Get the download from the DownloadManager.
   std::vector<DownloadItem*> downloads;
   DownloadManagerForBrowser(browser())->GetAllDownloads(&downloads);
   ASSERT_EQ(1u, downloads.size());
   EXPECT_TRUE(downloads[0]->IsDangerous());
 
   // Save fake pings for the download.
@@ skipping 186 matching lines @@
 //
 // Regression test for http://crbug.com/44454
 IN_PROC_BROWSER_TEST_F(DownloadTest, NewWindow) {
   GURL url(URLRequestMockHTTPJob::GetMockUrl(kDownloadTest1Path));
 #if !defined(OS_MACOSX)
   // See below.
   Browser* first_browser = browser();
 #endif
 
   // Download a file in a new window and wait.
-  DownloadAndWaitWithDisposition(browser(), url, NEW_WINDOW,
+  DownloadAndWaitWithDisposition(browser(), url,
+                                 WindowOpenDisposition::NEW_WINDOW,
                                  ui_test_utils::BROWSER_TEST_NONE);
 
   // When the download finishes, the download shelf SHOULD NOT be visible in
   // the first window.
   ExpectWindowCountAfterDownload(2);
   EXPECT_EQ(1, browser()->tab_strip_model()->count());
   // Download shelf should close.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   // The download shelf SHOULD be visible in the second window.
@@ skipping 125 matching lines @@
           browser(), 1,
           content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
 
   // Download shelf should close.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 #endif  // defined(OS_CHROMEOS)