Used scoped temp dir for download files in DownloadErrorsFile Test.

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 <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 255 matching lines @@
   };
 
   DownloadTest() {
     EnableDOMAutomation();
   }
 
   void SetUpOnMainThread() OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
+    ASSERT_TRUE(InitialSetup());
   }
 
   // Returning false indicates a failure of the setup, and should be asserted
   // in the caller.
-  virtual bool InitialSetup(bool prompt_for_download) {
+  virtual bool InitialSetup() {
     bool have_test_dir = PathService::Get(chrome::DIR_TEST_DATA, &test_dir_);
     EXPECT_TRUE(have_test_dir);
     if (!have_test_dir)
       return false;
 
     // Sanity check default values for window / tab count and shelf visibility.
     int window_count = BrowserList::size();
     EXPECT_EQ(1, window_count);
     EXPECT_EQ(1, browser()->tab_count());
     EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
     // Set up the temporary download folder.
     bool created_downloads_dir = CreateAndSetDownloadsDirectory(browser());
     EXPECT_TRUE(created_downloads_dir);
     if (!created_downloads_dir)
       return false;
-    browser()->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
-                                                 prompt_for_download);
+    browser()->profile()->GetPrefs()->SetBoolean(
+        prefs::kPromptForDownload, false);
 
     DownloadManager* manager = DownloadManagerForBrowser(browser());
     DownloadPrefs::FromDownloadManager(manager)->ResetAutoOpen();
     manager->RemoveAllDownloads();
 
     return true;
   }
 
  protected:
 
@@ skipping 176 matching lines @@
     bool downloaded_file_deleted =
         file_util::DieFileDie(downloaded_file, false);
     EXPECT_TRUE(downloaded_file_deleted);
     return downloaded_file_deleted;
   }
 
   bool RunSizeTest(Browser* browser,
                    SizeTestType type,
                    const std::string& partial_indication,
                    const std::string& total_indication) {
-    if (!InitialSetup(false))
-      return false;
-
     EXPECT_TRUE(type == SIZE_TEST_TYPE_UNKNOWN || type == SIZE_TEST_TYPE_KNOWN);
     if (type != SIZE_TEST_TYPE_KNOWN && type != SIZE_TEST_TYPE_UNKNOWN)
       return false;
     GURL url(type == SIZE_TEST_TYPE_KNOWN ?
              URLRequestSlowDownloadJob::kKnownSizeUrl :
              URLRequestSlowDownloadJob::kUnknownSizeUrl);
 
     // TODO(ahendrickson) -- |expected_title_in_progress| and
     // |expected_title_finished| need to be checked.
     FilePath filename;
@@ skipping 298 matching lines @@
       info[i].error_info.url = url.spec();
 
       DownloadInsertFilesErrorCheckErrorsLoopBody(injector, info[i], i);
     }
   }
 
   // Attempts to download a file to a read-only folder, based on information
   // in |download_info|.
   void DownloadFilesToReadonlyFolder(size_t count,
                                      DownloadInfo* download_info) {
-    ASSERT_TRUE(InitialSetup(false));  // Creates temporary download folder.
-
     DownloadFilesCheckErrorsSetup();
 
     // Make the test folder unwritable.
     FilePath destination_folder = GetDownloadDirectory(browser());
     DVLOG(1) << " " << __FUNCTION__ << "()"
              << " folder = '" << destination_folder.value() << "'";
     file_util::PermissionRestorer permission_restorer(destination_folder);
     EXPECT_TRUE(file_util::MakeFileUnwritable(destination_folder));
 
     for (size_t i = 0; i < count; ++i) {
@@ skipping 26 matching lines @@
 };
 
 // NOTES:
 //
 // Files for these tests are found in DIR_TEST_DATA (currently
 // "chrome\test\data\", see chrome_paths.cc).
 // Mock responses have extension .mock-http-headers appended to the file name.
 
 // Download a file due to the associated MIME type.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeType) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 }
 
 #if defined(OS_WIN)
 // Download a file and confirm that the zone identifier (on windows)
 // is set to internet.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CheckInternetZone) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Check state.  Special file state must be checked before CheckDownload,
   // as CheckDownload will delete the output file.
   EXPECT_EQ(1, browser()->tab_count());
   FilePath downloaded_file(DestinationFile(browser(), file));
   if (file_util::VolumeSupportsADS(downloaded_file))
     EXPECT_TRUE(file_util::HasInternetZoneIdentifier(downloaded_file));
   CheckDownload(browser(), file, file);
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 }
 #endif
 
 // Put up a Select File dialog when the file is downloaded, due to
 // downloads preferences settings.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadMimeTypeSelect) {
-  ASSERT_TRUE(InitialSetup(true));
+  // Re-enable prompting.
+  browser()->profile()->GetPrefs()->SetBoolean(
+      prefs::kPromptForDownload, true);
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   NullSelectFile(browser());
 
   // Download the file and wait.  We expect the Select File dialog to appear
   // due to the MIME type, but we still wait until the download completes.
   scoped_ptr<DownloadTestObserver> observer(
       new DownloadTestObserverTerminal(
           DownloadManagerForBrowser(browser()),
@@ skipping 10 matching lines @@
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Access a file with a viewable mime-type, verify that a download
 // did not initiate.
 IN_PROC_BROWSER_TEST_F(DownloadTest, NoDownload) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test2.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath file_path(DestinationFile(browser(), file));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Check that we did not download the web page.
   EXPECT_FALSE(file_util::PathExists(file_path));
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Verify that when the DownloadResourceThrottle cancels a download, the
 // download never makes it to the downloads system.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadResourceThrottleCancels) {
-  ASSERT_TRUE(InitialSetup(false));
-
   // Navigate to a page with the same domain as the file to download.  We can't
   // navigate directly to the file we don't want to download because cross-site
   // navigations reset the TabDownloadState.
   FilePath same_site_path(FILE_PATH_LITERAL("download_script.html"));
   GURL same_site_url(URLRequestMockHTTPJob::GetMockUrl(same_site_path));
   ui_test_utils::NavigateToURL(browser(), same_site_url);
 
   // Make sure the initial navigation didn't trigger a download.
   EXPECT_TRUE(EnsureNoPendingDownloads());
 
@@ skipping 38 matching lines @@
 
   // Verify that there's no pending download.
   EXPECT_TRUE(EnsureNoPendingDownloads());
 }
 
 // Download a 0-size file with a content-disposition header, verify that the
 // download tab opened and the file exists as the filename specified in the
 // header.  This also ensures we properly handle empty file downloads.
 // The download shelf should be visible in the current tab.
 IN_PROC_BROWSER_TEST_F(DownloadTest, ContentDisposition) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath download_file(FILE_PATH_LITERAL("download-test3-attachment.gif"));
 
   // Download a file and wait.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Test that the download shelf is per-window by starting a download in one
 // tab, opening a second tab, closing the shelf, going back to the first tab,
 // and checking that the shelf is closed.
 IN_PROC_BROWSER_TEST_F(DownloadTest, PerWindowShelf) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test3.gif"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath download_file(FILE_PATH_LITERAL("download-test3-attachment.gif"));
 
   // Download a file and wait.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
@@ skipping 15 matching lines @@
   browser()->ActivateTabAt(0, true);
   EXPECT_EQ(2, browser()->tab_count());
 
   // The download shelf should not be visible.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Check whether the downloads shelf is closed when the downloads tab is
 // invoked.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseShelfOnDownloadsTab) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 
@@ skipping 19 matching lines @@
 IN_PROC_BROWSER_TEST_F(DownloadTest, KnownSize) {
   ASSERT_TRUE(RunSizeTest(browser(), SIZE_TEST_TYPE_KNOWN,
                           "71% - ", "100% - "));
 }
 
 // Test that when downloading an item in Incognito mode, we don't crash when
 // closing the last Incognito window (http://crbug.com/13983).
 // Also check that the download shelf is not visible after closing the
 // Incognito window.
 IN_PROC_BROWSER_TEST_F(DownloadTest, IncognitoDownload) {
-  ASSERT_TRUE(InitialSetup(false));
   // Open an Incognito window.
   Browser* incognito = CreateIncognitoBrowser();  // Waits.
   ASSERT_TRUE(incognito);
   int window_count = BrowserList::size();
   EXPECT_EQ(2, window_count);
 
   // Download a file in the Incognito window and wait.
   CreateAndSetDownloadsDirectory(incognito);
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
@@ skipping 29 matching lines @@
   // On ChromeOS, the download panel is common to both profiles, so
   // it is still visible.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   CheckDownload(browser(), file, file);
 }
 
 // Navigate to a new background page, but don't download.  Confirm that the
 // download shelf is not visible and that we have two tabs.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab1) {
-  ASSERT_TRUE(InitialSetup(false));
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   FilePath file1(FILE_PATH_LITERAL("download-test2.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       url,
       NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // We should have two tabs now.
   EXPECT_EQ(2, browser()->tab_count());
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Download a file in a background tab. Verify that the tab is closed
 // automatically, and that the download shelf is visible in the current tab.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab1) {
-  ASSERT_TRUE(InitialSetup(false));
-
   // Download a file in a new background tab and wait.  The tab is automatically
   // closed when the download begins.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   DownloadAndWaitWithDisposition(
       browser(),
       url,
       NEW_BACKGROUND_TAB,
       EXPECT_NO_SELECT_DIALOG,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // When the download finishes, we should still have one tab.
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
   EXPECT_EQ(1, browser()->tab_count());
 
   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, and the download shelf is visible in the current
 // tab.
 //
 // 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) {
-  ASSERT_TRUE(InitialSetup(false));
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   FilePath file1(FILE_PATH_LITERAL("download_page1.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url);
 
   // Download a file in a new tab and wait (via Javascript).
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
@@ skipping 11 matching lines @@
 }
 
 // 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, and the download shelf is visible in the current
 // tab.
 //
 // The download_page2.html page contains an openNew() function that opens a
 // tab.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DontCloseNewTab3) {
-  ASSERT_TRUE(InitialSetup(false));
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   FilePath file1(FILE_PATH_LITERAL("download_page2.html"));
   GURL url1(URLRequestMockHTTPJob::GetMockUrl(file1));
 
   // Open a web page and wait.
   ui_test_utils::NavigateToURL(browser(), url1);
 
   // Open a new tab and wait.
   ui_test_utils::NavigateToURLWithDisposition(
@@ skipping 21 matching lines @@
 }
 
 // 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, and the download shelf is visible.
 //
 // 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) {
-  ASSERT_TRUE(InitialSetup(false));
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   FilePath file1(FILE_PATH_LITERAL("download_page3.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
 
   // 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".
@@ skipping 12 matching lines @@
 }
 
 // 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, and the download shelf is visible.
 //
 // The download_page4.html page contains a form with download-test1.lib as the
 // action.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CloseNewTab3) {
-  ASSERT_TRUE(InitialSetup(false));
   // Because it's an HTML link, it should open a web page rather than
   // downloading.
   FilePath file1(FILE_PATH_LITERAL("download_page4.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file1));
 
   // 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.
@@ skipping 14 matching lines @@
 }
 
 // Download a file in a new window.
 // Verify that we have 2 windows, and the download shelf is not visible in the
 // first window, but is visible in the second window.
 // Close the new window.
 // Verify that we have 1 window, and the download shelf is not visible.
 //
 // Regression test for http://crbug.com/44454
 IN_PROC_BROWSER_TEST_F(DownloadTest, NewWindow) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 #if !defined(OS_MACOSX)
   // See below.
   Browser* first_browser = browser();
 #endif
 
   // Download a file in a new window and wait.
   DownloadAndWaitWithDisposition(browser(),
                                  url,
@@ skipping 39 matching lines @@
   EXPECT_EQ(1, browser()->tab_count());
   // Download shelf should close. Download panel stays open on ChromeOS.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   CheckDownload(browser(), file, file);
 }
 
 // Check that downloading multiple (in this case, 2) files does not result in
 // corrupted files.
 IN_PROC_BROWSER_TEST_F(DownloadTest, MultiDownload) {
-  ASSERT_TRUE(InitialSetup(false));
   EXPECT_EQ(1, browser()->tab_count());
 
   // Create a download, wait until it's started, and confirm
   // we're in the expected state.
   scoped_ptr<DownloadTestObserver> observer1(
       CreateInProgressWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(
       browser(), GURL(URLRequestSlowDownloadJob::kUnknownSizeUrl));
   observer1->WaitForFinished();
 
@@ skipping 49 matching lines @@
   size_t file_size1 = URLRequestSlowDownloadJob::kFirstDownloadSize +
                       URLRequestSlowDownloadJob::kSecondDownloadSize;
   std::string expected_contents(file_size1, '*');
   ASSERT_TRUE(VerifyFile(file1, expected_contents, file_size1));
 
   FilePath file2(download2->GetFullPath());
   ASSERT_TRUE(file_util::ContentsEqual(OriginFile(file), file2));
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadCancelled) {
-  ASSERT_TRUE(InitialSetup(false));
   EXPECT_EQ(1, browser()->tab_count());
 
   // TODO(rdsmith): Fragile code warning!  The code below relies on the
   // DownloadTestObserverInProgress only finishing when the new download
   // has reached the state of being entered into the history and being
   // user-visible (that's what's required for the Remove to be valid and
   // for the download shelf to be visible).  By the pure semantics of
   // DownloadTestObserverInProgress, that's not guaranteed; DownloadItems
   // are created in the IN_PROGRESS state and made known to the DownloadManager
   // immediately, so any ModelChanged event on the DownloadManager after
@@ skipping 31 matching lines @@
   EXPECT_TRUE(EnsureNoPendingDownloads());
 
   // Using "DownloadItem::Remove" follows the discard dangerous download path,
   // which completely removes the browser from the shelf and closes the shelf
   // if it was there. Download panel stays open on ChromeOS.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Confirm a download makes it into the history properly.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadHistoryCheck) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   FilePath origin_file(OriginFile(file));
   int64 origin_size;
   file_util::GetFileSize(origin_file, &origin_size);
 
   // Download the file and wait.  We do not expect the Select File dialog.
   DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
 
   // Get details of what downloads have just happened.
@@ skipping 17 matching lines @@
   EXPECT_EQ(url, info.url);
   // Ignore start_time.
   EXPECT_EQ(origin_size, info.received_bytes);
   EXPECT_EQ(origin_size, info.total_bytes);
   EXPECT_EQ(DownloadItem::COMPLETE, info.state);
 }
 
 // Test for crbug.com/14505. This tests that chrome:// urls are still functional
 // after download of a file while viewing another chrome://.
 IN_PROC_BROWSER_TEST_F(DownloadTest, ChromeURLAfterDownload) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
   GURL flags_url(chrome::kChromeUIFlagsURL);
   GURL extensions_url(chrome::kChromeUIExtensionsFrameURL);
 
   ui_test_utils::NavigateToURL(browser(), flags_url);
   DownloadAndWait(browser(), download_url, EXPECT_NO_SELECT_DIALOG);
   ui_test_utils::NavigateToURL(browser(), extensions_url);
   WebContents* contents = browser()->GetSelectedWebContents();
   ASSERT_TRUE(contents);
   bool webui_responded = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       contents->GetRenderViewHost(),
       L"",
       L"window.domAutomationController.send(window.webui_responded_);",
       &webui_responded));
   EXPECT_TRUE(webui_responded);
 }
 
 // Test for crbug.com/12745. This tests that if a download is initiated from
 // a chrome:// page that has registered and onunload handler, the browser
 // will be able to close.
 IN_PROC_BROWSER_TEST_F(DownloadTest, BrowserCloseAfterDownload) {
-  ASSERT_TRUE(InitialSetup(false));
   GURL downloads_url(chrome::kChromeUIFlagsURL);
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL download_url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   ui_test_utils::NavigateToURL(browser(), downloads_url);
   WebContents* contents = browser()->GetSelectedWebContents();
   ASSERT_TRUE(contents);
   bool result = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       contents->GetRenderViewHost(),
       L"",
       L"window.onunload = function() { var do_nothing = 0; }; "
       L"window.domAutomationController.send(true);",
       &result));
   EXPECT_TRUE(result);
 
   DownloadAndWait(browser(), download_url, EXPECT_NO_SELECT_DIALOG);
 
   ui_test_utils::WindowedNotificationObserver signal(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(browser()));
   browser()->CloseWindow();
   signal.Wait();
 }
 
 // Test to make sure the 'download' attribute in anchor tag is respected.
 IN_PROC_BROWSER_TEST_F(DownloadTest, AnchorDownloadTag) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-anchor-attrib.html"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Create a download, wait until it's complete, and confirm
   // we're in the expected state.
   scoped_ptr<DownloadTestObserver> observer(CreateWaiter(browser(), 1));
   ui_test_utils::NavigateToURL(browser(), url);
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // Confirm the downloaded data exists.
   FilePath downloaded_file = GetDownloadDirectory(browser());
   downloaded_file = downloaded_file.Append(FILE_PATH_LITERAL("a_red_dot.png"));
   EXPECT_TRUE(file_util::PathExists(downloaded_file));
 }
 
 // crbug.com/118159
 #if defined(OS_LINUX)
 #define MAYBE_AutoOpen DISABLED_AutoOpen
 #else
 #define MAYBE_AutoOpen AutoOpen
 #endif
 
 // Test to make sure auto-open works.
 IN_PROC_BROWSER_TEST_F(DownloadTest, MAYBE_AutoOpen) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-autoopen.txt"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   ASSERT_TRUE(
       GetDownloadPrefs(browser())->EnableAutoOpenBasedOnExtension(file));
 
   // Mock out external opening on all downloads until end of test.
   MockDownloadOpeningObserver observer(
       DownloadManagerForBrowser(browser()));
 
@@ skipping 10 matching lines @@
   // As long as we're here, confirmed everything else is good.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   // Download shelf should close. Download panel stays open on ChromeOS.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Deny the download.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxDenyInstall) {
-  ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
 
   scoped_ptr<DownloadTestObserver> observer(
       DangerousDownloadWaiter(
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_DENY));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::CANCELLED));
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   // Check that the CRX is not installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Allow the download, deny the install.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallDenysPermissions) {
-  ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
 
   // Install a mock install UI that simulates a user denying permission to
   // finish the install.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAbortExtensionInstallUI());
 
   scoped_ptr<DownloadTestObserver> observer(
       DangerousDownloadWaiter(
           browser(), 1,
@@ skipping 10 matching lines @@
 
   // Check that the extension was not installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Download an extension.  Expect a dangerous download warning.
 // Allow the download, and the install.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInstallAcceptPermissions) {
-  ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kGoodCrxPath));
 
   // Install a mock install UI that simulates a user allowing permission to
   // finish the install.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAutoConfirmExtensionInstallUI(browser()->profile()));
 
   scoped_ptr<DownloadTestObserver> observer(
       DangerousDownloadWaiter(
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Test installing a CRX that fails integrity checks.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxInvalid) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("extensions/bad_signature.crx"));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // Install a mock install UI that simulates a user allowing permission to
   // finish the install, and dismisses any error message.  We check that the
   // install failed below.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAutoConfirmExtensionInstallUI(browser()->profile()));
 
   scoped_ptr<DownloadTestObserver> observer(
       DangerousDownloadWaiter(
           browser(), 1,
           DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), extension_url);
 
   observer->WaitForFinished();
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   CheckDownloadStates(1, DownloadItem::COMPLETE);
 
   // Check that the extension was not installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_FALSE(extension_service->GetExtensionById(kGoodCrxId, false));
 }
 
 // Install a large (100kb) theme.
 IN_PROC_BROWSER_TEST_F(DownloadTest, CrxLargeTheme) {
-  ASSERT_TRUE(InitialSetup(false));
   GURL extension_url(URLRequestMockHTTPJob::GetMockUrl(kLargeThemePath));
 
   // Install a mock install UI that simulates a user allowing permission to
   // finish the install.
   download_crx_util::SetMockInstallUIForTesting(
       new MockAutoConfirmExtensionInstallUI(browser()->profile()));
 
   scoped_ptr<DownloadTestObserver> observer(
       DangerousDownloadWaiter(
           browser(), 1,
@@ skipping 14 matching lines @@
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }
 
 // Sort download items by db_handle.
 static bool DownloadItemSorter(DownloadItem* d1, DownloadItem* d2) {
   return d1->GetDbHandle() < d2->GetDbHandle();
 }
 
 // Confirm that searching through the history works properly
 IN_PROC_BROWSER_TEST_F(DownloadTest, SearchDownloads) {
-  ASSERT_TRUE(InitialSetup(false));
-
   // Downloads to populate history with.
   base::Time current(base::Time::Now());
   DownloadPersistentStoreInfo population_entries[] = {
     DownloadPersistentStoreInfo(
         FilePath(FILE_PATH_LITERAL("/path/to/file")),
         GURL("http://www.google.com/fantasy_download"),
         GURL(""),
         current - base::TimeDelta::FromMinutes(5),
         current,
         128,
@@ skipping 105 matching lines @@
   ASSERT_EQ(2u, search_results.size());
   std::sort(search_results.begin(), search_results.end(),
             DownloadItemSorter);
   EXPECT_EQ(2, search_results[0]->GetDbHandle());
   EXPECT_EQ(3, search_results[1]->GetDbHandle());
   search_results.clear();
 }
 
 // Tests for download initiation functions.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrl) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   // DownloadUrl always prompts; return acceptance of whatever it prompts.
   NullSelectFile(browser());
 
   WebContents* web_contents = browser()->GetSelectedWebContents();
   ASSERT_TRUE(web_contents);
 
   DownloadTestObserver* observer(
@@ skipping 11 matching lines @@
   CheckDownloadStates(1, DownloadItem::COMPLETE);
   EXPECT_TRUE(observer->select_file_dialog_seen());
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   ASSERT_TRUE(CheckDownload(browser(), file, file));
   EXPECT_TRUE(browser()->window()->IsDownloadShelfVisible());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadUrlToPath) {
-  ASSERT_TRUE(InitialSetup(false));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
 
   WebContents* web_contents = browser()->GetSelectedWebContents();
   ASSERT_TRUE(web_contents);
 
   ScopedTempDir other_directory;
   ASSERT_TRUE(other_directory.CreateUniqueTempDir());
   FilePath target_file_full_path
       = other_directory.path().Append(file.BaseName());
@@ skipping 12 matching lines @@
   ASSERT_TRUE(CheckDownloadFullPaths(browser(),
                                      target_file_full_path,
                                      OriginFile(file)));
 
   // Temporary downloads won't be visible.
   EXPECT_FALSE(browser()->window()->IsDownloadShelfVisible());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaGet) {
   // Do initial setup.
-  ASSERT_TRUE(InitialSetup(false));
   ASSERT_TRUE(test_server()->Start());
   NullSelectFile(browser());
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_TRUE(download_items.empty());
 
   // Navigate to a non-HTML resource. The resource also has
   // Cache-Control: no-cache set, which normally requires revalidation
   // each time.
   GURL url = test_server()->GetURL("files/downloads/image.jpg");
@@ skipping 41 matching lines @@
   download_items.clear();
   GetDownloads(browser(), &download_items);
   EXPECT_TRUE(waiter_context_menu->select_file_dialog_seen());
   ASSERT_EQ(2u, download_items.size());
   ASSERT_EQ(url, download_items[0]->GetOriginalUrl());
   ASSERT_EQ(url, download_items[1]->GetOriginalUrl());
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaPost) {
   // Do initial setup.
-  ASSERT_TRUE(InitialSetup(false));
   ASSERT_TRUE(test_server()->Start());
   NullSelectFile(browser());
   std::vector<DownloadItem*> download_items;
   GetDownloads(browser(), &download_items);
   ASSERT_TRUE(download_items.empty());
 
   // Navigate to a form page.
   GURL form_url = test_server()->GetURL(
       "files/downloads/form_page_to_post.html");
   ASSERT_TRUE(form_url.is_valid());
@@ skipping 102 matching lines @@
     },
     {  // Navigated download with 400 error.
       "zip_file_not_found.zip",
       DOWNLOAD_NAVIGATE,
       content::DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED,
       false,
       false
     }
   };
 
-  // Do initial setup.
-  ASSERT_TRUE(InitialSetup(false));
-
   DownloadFilesCheckErrors(ARRAYSIZE_UNSAFE(download_info), download_info);
 }
 
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadErrorsFile) {
   FileErrorInjectInfo error_info[] = {
     {  // Navigated download with injected "Disk full" error in Initialize().
       { "a_zip_file.zip",
         DOWNLOAD_NAVIGATE,
         content::DOWNLOAD_INTERRUPT_REASON_FILE_NO_SPACE,
         1
@@ skipping 186 matching lines @@
       true
     }
   };
 
   DownloadFilesToReadonlyFolder(ARRAYSIZE_UNSAFE(download_info), download_info);
 }
 
 // Test that we show a dangerous downloads warning for a dangerous file
 // downloaded through a blob: URL.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadDangerousBlobData) {
-  ASSERT_TRUE(InitialSetup(false));
-
 #if defined(OS_WIN)
   // On Windows, if SafeBrowsing is enabled, certain file types (.exe, .cab,
   // .msi) will be handled by the DownloadProtectionService. However, if the URL
   // is non-standard (e.g. blob:) then those files won't be handled by the
   // DPS. We should be showing the dangerous download warning for any file
   // considered dangerous and isn't handled by the DPS.
   const char kFilename[] = "foo.exe";
 #else
   const char kFilename[] = "foo.jar";
 #endif
 
   std::string path("files/downloads/download-dangerous-blob.html?filename=");
   path += kFilename;
 
   // Need to use http urls because the blob js doesn't work on file urls for
   // security reasons.
   ASSERT_TRUE(test_server()->Start());
   GURL url(test_server()->GetURL(path));
 
   DownloadTestObserver* observer(DangerousDownloadWaiter(
       browser(), 1, DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT));
   ui_test_utils::NavigateToURL(browser(), url);
   observer->WaitForFinished();
 
   EXPECT_EQ(1u, observer->NumDownloadsSeenInState(DownloadItem::COMPLETE));
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 }