When the download folder does not exist, change the download folder to a user's "Downloads"

chrome/browser/download/download_browsertest.cc

 // Copyright (c) 2011 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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util.h"
+#include "base/string_util.h"
 #include "base/test/test_file_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_file_manager.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_item.h"
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/history/download_history_info.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/webui/active_downloads_ui.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/random.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/cancelable_request.h"
 #include "content/browser/net/url_request_mock_http_job.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/net/url_request_slow_download_job.h"
 #include "content/common/page_transition_types.h"
 #include "net/base/net_util.h"
+#include "net/url_request/url_request_filter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // IDs and paths of CRX files used in tests.
 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const FilePath kGoodCrxPath(FILE_PATH_LITERAL("extensions/good.crx"));
 
 const char kLargeThemeCrxId[] = "pjpgmfcmabopnnfonnhmdjglfpjjfkbf";
 const FilePath kLargeThemePath(FILE_PATH_LITERAL("extensions/theme2.crx"));
 
+// The test file used in SavePageBrowserTest.SaveFolder3.
+static const FilePath kTestFile(FILE_PATH_LITERAL("download-test1.lib"));
+
 // Action a test should take if a dangerous download is encountered.
 enum DangerousDownloadAction {
   ON_DANGEROUS_DOWNLOAD_ACCEPT,  // Accept the download
   ON_DANGEROUS_DOWNLOAD_DENY,  // Deny the download
   ON_DANGEROUS_DOWNLOAD_FAIL  // Fail if a dangerous download is seen
 };
 
 // Fake user click on "Accept".
 void AcceptDangerousDownload(scoped_refptr<DownloadManager> download_manager,
                              int32 download_id) {
@@ skipping 55 matching lines @@
   ~DownloadsObserver() {
     std::set<DownloadItem*>::iterator it = downloads_observed_.begin();
     for (; it != downloads_observed_.end(); ++it)
       (*it)->RemoveObserver(this);
 
     download_manager_->RemoveObserver(this);
   }
 
   // State accessors.
   bool select_file_dialog_seen() { return select_file_dialog_seen_; }
+  const FilePath& suggested_path() { return suggested_path_; }
 
   // Wait for whatever state was specified in the constructor.
   void WaitForFinished() {
     if (!IsFinished()) {
       waiting_ = true;
       ui_test_utils::RunMessageLoop();
       waiting_ = false;
     }
   }
 
@@ skipping 92 matching lines @@
       // If it is finished and we are observing it, stop.
       if (finished_it != finished_downloads_.end() &&
           observed_it != downloads_observed_.end()) {
         (*it)->RemoveObserver(this);
         downloads_observed_.erase(observed_it);
         continue;
       }
     }
   }
 
-  virtual void SelectFileDialogDisplayed(int32 /* id */) {
+  virtual void SelectFileDialogDisplayed(
+      int32 /* id */, const FilePath& suggested_path) {
     select_file_dialog_seen_ = true;
+    suggested_path_ = suggested_path;
     SignalIfFinished();
   }
 
   virtual size_t NumDangerousDownloadsSeen() const {
     return dangerous_downloads_seen_.size();
   }
 
  private:
   // Called when we know that a download item is in a final state.
   // Note that this is not the same as it first transitioning in to the
@@ skipping 55 matching lines @@
 
   // True if we've seen the select file dialog.
   bool select_file_dialog_seen_;
 
   // Action to take if a dangerous download is encountered.
   DangerousDownloadAction dangerous_download_action_;
 
   // Holds the download ids which were dangerous.
   std::set<int32> dangerous_downloads_seen_;
 
+  // The suggested file path in the select file dialog.
+  FilePath suggested_path_;
+
   DISALLOW_COPY_AND_ASSIGN(DownloadsObserver);
 };
 
 // WaitForFlush() returns after:
 //      * There are no IN_PROGRESS download items remaining on the
 //        DownloadManager.
 //      * There have been two round trip messages through the file and
 //        IO threads.
 // This almost certainly means that a Download cancel has propagated through
 // the system.
@@ skipping 155 matching lines @@
   ResourceDispatcherHost* resource_dispatcher_host_;
   DownloadFileManager* download_file_manager_;
   int rdh_pending_requests_;
   int dfm_pending_downloads_;
 
   DISALLOW_COPY_AND_ASSIGN(CancelTestDataCollector);
 };
 
 class DownloadTest : public InProcessBrowserTest {
  public:
-  enum SelectExpectation {
-    EXPECT_NO_SELECT_DIALOG = -1,
-    EXPECT_NOTHING,
-    EXPECT_SELECT_DIALOG
-  };
-
   DownloadTest() {
     EnableDOMAutomation();
   }
 
   // Returning false indicates a failure of the setup, and should be asserted
   // in the caller.
   virtual bool InitialSetup(bool prompt_for_download) {
     bool have_test_dir = PathService::Get(chrome::DIR_TEST_DATA, &test_dir_);
     EXPECT_TRUE(have_test_dir);
     if (!have_test_dir)
@@ skipping 27 matching lines @@
     SIZE_TEST_TYPE_UNKNOWN,
   };
 
   // Location of the file source (the place from which it is downloaded).
   FilePath OriginFile(FilePath file) {
     return test_dir_.Append(file);
   }
 
   // Location of the file destination (place to which it is downloaded).
   FilePath DestinationFile(Browser* browser, FilePath file) {
-    return GetDownloadDirectory(browser).Append(file);
+    return GetDownloadSaveDirectory(browser).Append(file);
   }
 
   // Must be called after browser creation.  Creates a temporary
   // directory for downloads that is auto-deleted on destruction.
   // Returning false indicates a failure of the function, and should be asserted
   // in the caller.
   bool CreateAndSetDownloadsDirectory(Browser* browser) {
     if (!browser)
       return false;
 
     if (!downloads_directory_.CreateUniqueTempDir())
       return false;
 
     browser->profile()->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory,
         downloads_directory_.path());
 
     return true;
   }
 
+  // Delete the default folder for downloaded files.
+  bool DeleteDownloadsDirectory() {
+    return downloads_directory_.Delete();
+  }
+
   DownloadPrefs* GetDownloadPrefs(Browser* browser) {
     return browser->profile()->GetDownloadManager()->download_prefs();
   }
 
-  FilePath GetDownloadDirectory(Browser* browser) {
+  FilePath GetDownloadSaveDirectory(Browser* browser) {
     DownloadManager* download_mananger =
         browser->profile()->GetDownloadManager();
     return download_mananger->download_prefs()->download_path();
   }
 
   // Create a DownloadsObserver that will wait for the
   // specified number of downloads to finish.
-  DownloadsObserver* CreateWaiter(Browser* browser, int num_downloads) {
+  // If |finish_on_select_file| is true, the object will also be
+  // considered finished when the select file dialog is displayed.
+  DownloadsObserver* CreateWaiter(Browser* browser,
+                                  int num_downloads,
+                                  bool finish_on_select_file) {
     DownloadManager* download_manager =
         browser->profile()->GetDownloadManager();
     return new DownloadsObserver(
         download_manager, num_downloads,
         DownloadItem::COMPLETE,  // Really done
-        false,                   // Bail on select file
+        finish_on_select_file,  // Bail on select file
         ON_DANGEROUS_DOWNLOAD_FAIL);
   }
 
   // Create a DownloadsObserver that will wait for the
   // specified number of downloads to start.
   DownloadsObserver* CreateInProgressWaiter(Browser* browser,
                                             int num_downloads) {
     DownloadManager* download_manager =
         browser->profile()->GetDownloadManager();
     return new DownloadsObserver(
@@ skipping 16 matching lines @@
     return new DownloadsObserver(
         download_manager, num_downloads,
         final_state,
         true,                         // Bail on select file
         dangerous_download_action);
   }
 
   // Download |url|, then wait for the download to finish.
   // |disposition| indicates where the navigation occurs (current tab, new
   // foreground tab, etc).
-  // |expectation| indicates whether or not a Select File dialog should be
+  // |expect_file_dialog| indicates whether a select file dialog should be
   // open when the download is finished, or if we don't care.
-  // If the dialog appears, the routine exits.  The only effect |expectation|
-  // has is whether or not the test succeeds.
+  // If the dialog appears, the routine exits. The only effect
+  // |expect_file_dialog| has is whether or not the test succeeds.
+  // |expected_suggested_path| is the path expected to be suggested in the
+  // select file dialog. This |expected_suggested_path| must be specified
+  // if |expect_file_dialog| is true. If |expect_file_dialog| is false,
+  // |expected_suggested_path| is ignored.
   // |browser_test_flags| indicate what to wait for, and is an OR of 0 or more
   // values in the ui_test_utils::BrowserTestWaitFlags enum.
   void DownloadAndWaitWithDisposition(Browser* browser,
                                       const GURL& url,
                                       WindowOpenDisposition disposition,
-                                      SelectExpectation expectation,
+                                      bool expect_file_dialog,
+                                      const FilePath& expected_suggested_path,
                                       int browser_test_flags) {
     // Setup notification, navigate, and block.
-    scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser, 1));
+    scoped_ptr<DownloadsObserver> observer(
+        CreateWaiter(browser, 1, expect_file_dialog));
     // This call will block until the condition specified by
     // |browser_test_flags|, but will not wait for the download to finish.
     ui_test_utils::NavigateToURLWithDisposition(browser,
                                                 url,
                                                 disposition,
                                                 browser_test_flags);
     // Waits for the download to complete.
     observer->WaitForFinished();
 
-    // If specified, check the state of the select file dialog.
-    if (expectation != EXPECT_NOTHING) {
-      EXPECT_EQ(expectation == EXPECT_SELECT_DIALOG,
-                observer->select_file_dialog_seen());
+    // Checks if the select file dialog was displayed as expected.
+    // If displayed, checks the suggested path in the dialog.
+    if (expect_file_dialog) {
+      EXPECT_TRUE(observer->select_file_dialog_seen());
+      EXPECT_EQ(observer->suggested_path(), expected_suggested_path);
+    } else {
+      EXPECT_FALSE(observer->select_file_dialog_seen());
     }
   }
 
   // Download a file in the current tab, then wait for the download to finish.
-  void DownloadAndWait(Browser* browser,
-                       const GURL& url,
-                       SelectExpectation expectation) {
+  // Expect that no select file dialog is displayed.
+  void DownloadAndWait(Browser* browser, const GURL& url) {
     DownloadAndWaitWithDisposition(
-        browser,
-        url,
-        CURRENT_TAB,
-        expectation,
+        browser, url, CURRENT_TAB, false, FilePath(),
         ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   }
 
+  // Download a file in the current tab, then wait for the download to finish.
+  // Expect that a select file dialog suggesting |expected_suggested_path|
+  // is displayed.
+  void DownloadAndWaitWithDialog(Browser* browser, const GURL& url,
+                                 const FilePath& expected_suggested_path) {
+    DownloadAndWaitWithDisposition(
+        browser, url, CURRENT_TAB, true, expected_suggested_path,
+        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 FilePath& downloaded_filename,
                      const FilePath& origin_filename) {
     // Find the path to which the data will be downloaded.
     FilePath downloaded_file(DestinationFile(browser, downloaded_filename));
 
@@ skipping 42 matching lines @@
     // |expected_title_finished| need to be checked.
     FilePath filename;
     net::FileURLToFilePath(url, &filename);
     string16 expected_title_in_progress(
         ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
     string16 expected_title_finished(
         ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
 
     // Download a partial web page in a background tab and wait.
     // The mock system will not complete until it gets a special URL.
-    scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser, 1));
+    scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser, 1, false));
     ui_test_utils::NavigateToURL(browser, url);
 
     // TODO(ahendrickson): check download status text before downloading.
     // Need to:
     //  - Add a member function to the |DownloadShelf| interface class, that
     //    indicates how many members it has.
     //  - 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
@@ skipping 61 matching lines @@
         exists = true;
         break;
       }
     }
     EXPECT_TRUE(exists);
 #else
     EXPECT_EQ(expected_non_cros, browser->window()->IsDownloadShelfVisible());
     // TODO: Check for filename match in download shelf.
 #endif
   }
+
   static void ExpectWindowCountAfterDownload(size_t expected) {
 #if defined(OS_CHROMEOS)
     // On ChromeOS, a download panel is created to display
     // download information, and this counts as a window.
     expected++;
 #endif
     EXPECT_EQ(expected, BrowserList::size());
   }
 
+  // Returns "src/chrome/test/data/{kTestFile}", whatever URL is given.
+  static net::URLRequestJob* FactoryForTestFile(
+      net::URLRequest* request, const std::string& scheme) {
+    FilePath test_dir;
+    if (!PathService::Get(chrome::DIR_TEST_DATA, &test_dir))
+      NOTREACHED();

[Paweł Hajdan Jr., 2011/08/12 17:00:59]

This is a browser_test, please use gtest macros. EXPECT_TRUE?

[haraken1, 2011/08/15 00:44:15]

Done.

+    return new URLRequestMockHTTPJob(request, test_dir.Append(kTestFile));
+  }
+
  private:
   // Location of the test data.
   FilePath test_dir_;
 
   // Location of the downloads directory for these tests
   ScopedTempDir downloads_directory_;
 };
 
 // Get History Information.
 class DownloadsHistoryDataCollector {
@@ skipping 114 matching lines @@
 // 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);
+  // Download the file and wait.
+  DownloadAndWait(browser(), url);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   CheckDownloadUI(browser(), true, true, file);
 }
 
+// Checks if a file is saved to the user's "Downloads" folder
+// in the following situation:
+// The default folder for downloaded files does not exist.
+// The user's "Downloads" folder exists.
+//
+// This test creates and deletes a file on the user's real "Downloads" folder,
+// which is globally shared among all tests on the testing environment.
+// Therefore, if we run browser tests in parallel, the file created by one
+// browser test may be deleted by another broswer test when the file name
+// conflicts. In order to avoid this problem, we use a special mock URL
+// "http://mock.testfile.http/<random path>" for this download test.
+// Since we redirect "http://mock.testfile.http/<random path>" to
+// "chrome/test/data/{kTestFile}" using FactoryForTestFile(),
+// "chrome/test/data/{kTestFile}" is used for the file to be downloaded.
+// Then, the downloaded file is saved as a name "Downloads/<random path>",
+// which is a unique file name in the user's real "Downloads" folder.
+//
+// Ideally, in the first place, we should not use the user's "Downloads" folder.
+// Instead, we should create a temporary "Downloads" folder for each test.
+// However, we concluded that creating temporary "Downloads" folder for each
+// test requires very invasive code changes to many places. See also here:
+// http://codereview.chromium.org/6973052/
+IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadFolder) {
+  ASSERT_TRUE(InitialSetup(false));
+  FilePath file(kTestFile);
+
+  // Redirects "http://mock.testfile.http/<random path>"
+  // to "src/chrome/test/data/{kTestFile}", whatever the <random path> is.
+  std::string kMockHostnameForTestFile = "mock.testfile.http";
+  net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
+  filter->AddHostnameHandler(
+      "http", kMockHostnameForTestFile, FactoryForTestFile);
+  std::string random_string = Generate128BitRandomBase64String();
+  RemoveChars(random_string, "/", &random_string);
+  GURL url("http://" + kMockHostnameForTestFile + "/" + random_string);
+
+  FilePath::StringType basename;
+#if defined(OS_WIN)
+  basename = UTF8ToWide(random_string);
+#else
+  basename = random_string;
+#endif
+  FilePath default_download_dir =
+      download_util::GetDefaultDownloadDirectoryFromPathService();
+  FilePath downloaded_file = default_download_dir.Append(basename);
+  // Make sure that the target file does not exist.
+  file_util::Delete(downloaded_file, false);

[Paweł Hajdan Jr., 2011/08/12 17:00:59]

Check return value, applies to all file_util functions.

[haraken1, 2011/08/15 00:44:15]

This Delete() can fail when the file does not exist. However, it is OK, since
what is important is just that the file does not exist after this statement, and
we are not interested in the return value of Delete(). I described this as a
comment.

Also, I added return value checks in the following (line 1066 and line 1067)
file_util::Delete(). 

+  // Make sure that the temporary file does not exist.
+  FilePath temporary_file = default_download_dir.Append(
+      basename + FILE_PATH_LITERAL(".crdownload"));
+  std::cout << temporary_file.value() << std::endl;

[Paweł Hajdan Jr., 2011/08/12 17:00:59]

Don't use cout directly, but rather the LOG macros. Applies to entire CL.

[haraken1, 2011/08/15 00:44:15]

Sorry, removed this cout. This cout is just for my debugging use.

+  file_util::Delete(temporary_file, false);
+
+  // Delete the default folder for downloaded files.
+  ASSERT_TRUE(DeleteDownloadsDirectory());
+  ASSERT_FALSE(file_util::PathExists(GetDownloadSaveDirectory(browser())));
+
+  // Download the file and wait.
+  DownloadAndWaitWithDialog(browser(), url, downloaded_file);
+
+  EXPECT_FALSE(file_util::PathExists(downloaded_file));
+  EXPECT_FALSE(file_util::PathExists(GetDownloadSaveDirectory(browser())));
+  EXPECT_EQ(1, browser()->tab_count());
+
+  // Clean up the generated files.
+  file_util::Delete(downloaded_file, false);
+  file_util::Delete(temporary_file, false);
+}
+
 #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);
+  // Download the file and wait.
+  DownloadAndWait(browser(), url);
 
   // 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);
   CheckDownloadUI(browser(), true, true, file);
 }
 #endif
 
-// Put up a Select File dialog when the file is downloaded, due to its MIME
+// Put up a select file dialog when the file is downloaded, due to its MIME
 // type.
 //
 // This test runs correctly, but leaves behind turds in the test user's
 // download directory because of http://crbug.com/62099.  No big loss; it
 // was primarily confirming DownloadsObserver wait on select file dialog
 // functionality anyway.
 IN_PROC_BROWSER_TEST_F(DownloadTest, DISABLED_DownloadMimeTypeSelect) {
   ASSERT_TRUE(InitialSetup(true));
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
+  FilePath file_path(DestinationFile(browser(), file));
 
-  // Download the file and wait.  We expect the Select File dialog to appear
+  // Download the file and wait.  We expect the select file dialog to appear
   // due to the MIME type.
-  DownloadAndWait(browser(), url, EXPECT_SELECT_DIALOG);
+  DownloadAndWaitWithDialog(browser(), url, file_path);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
-  // Since we exited while the Select File dialog was visible, there should not
+  // Since we exited while the select file dialog was visible, there should not
   // be anything in the download shelf and so it should not be visible.
   CheckDownloadUI(browser(), false, false, FilePath());
 }
 
 // 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));
@@ skipping 14 matching lines @@
 // 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);
+  DownloadAndWait(browser(), url);
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownloadUI(browser(), true, true, download_file);
 }
 
 #if !defined(OS_CHROMEOS)  // Download shelf is not per-window on ChromeOS.
 // 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);
+  DownloadAndWait(browser(), url);
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownloadUI(browser(), true, true, download_file);
 
   // Open a second tab and wait.
   EXPECT_NE(static_cast<TabContentsWrapper*>(NULL),
             browser()->AddSelectedTabWithURL(GURL(), PageTransition::TYPED));
@@ skipping 44 matching lines @@
   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));
   // Since |incognito| is a separate browser, we have to set it up explicitly.
   incognito->profile()->GetPrefs()->SetBoolean(prefs::kPromptForDownload,
                                                false);
-  DownloadAndWait(incognito, url, EXPECT_NO_SELECT_DIALOG);
+  DownloadAndWait(incognito, url);
 
   // We should still have 2 windows.
   ExpectWindowCountAfterDownload(2);
 
   // Verify that the download shelf is showing for the Incognito window.
   CheckDownloadUI(incognito, true, true, file);
 
 #if !defined(OS_MACOSX)
   // On Mac OS X, the UI window close is delayed until the outermost
   // message loop runs.  So it isn't possible to get a BROWSER_CLOSED
@@ skipping 46 matching lines @@
   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,
+      false,
+      FilePath(),
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // When the download finishes, we should still have one tab.
   CheckDownloadUI(browser(), true, true, file);
   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
@@ skipping 11 matching lines @@
   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"));
   DownloadAndWaitWithDisposition(browser(),
                                  GURL("javascript:openNew()"),
                                  CURRENT_TAB,
-                                 EXPECT_NO_SELECT_DIALOG,
+                                 false,
+                                 FilePath(),
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should have two tabs.
   CheckDownloadUI(browser(), true, true, file);
   EXPECT_EQ(2, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, open another tab via a Javascript call,
@@ skipping 21 matching lines @@
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   EXPECT_EQ(2, browser()->tab_count());
 
   // Download a file and wait.
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
   DownloadAndWaitWithDisposition(browser(),
                                  url,
                                  CURRENT_TAB,
-                                 EXPECT_NO_SELECT_DIALOG,
+                                 false,
+                                 FilePath(),
                                  ui_test_utils::BROWSER_TEST_NONE);
 
   // When the download finishes, we should have two tabs.
   CheckDownloadUI(browser(), true, true, file);
   EXPECT_EQ(2, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then download a file via Javascript,
@@ skipping 12 matching lines @@
 
   // 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".
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   DownloadAndWaitWithDisposition(browser(),
                                  GURL("javascript:openNew()"),
                                  CURRENT_TAB,
-                                 EXPECT_NO_SELECT_DIALOG,
+                                 false,
+                                 FilePath(),
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
   CheckDownloadUI(browser(), true, true, file);
   EXPECT_EQ(1, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Open a web page in the current tab, then call Javascript via a button to
@@ skipping 14 matching lines @@
   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".
   FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
   DownloadAndWaitWithDisposition(
       browser(),
       GURL("javascript:document.getElementById('form').submit()"),
       CURRENT_TAB,
-      EXPECT_NO_SELECT_DIALOG,
+      false,
+      FilePath(),
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
   CheckDownloadUI(browser(), true, true, file);
   EXPECT_EQ(1, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // 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,
                                  NEW_WINDOW,
-                                 EXPECT_NO_SELECT_DIALOG,
+                                 false,
+                                 FilePath(),
                                  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_count());
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, file);
 
   // The download shelf SHOULD be visible in the second window.
@@ skipping 86 matching lines @@
 
 // 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);
+  // Download the file and wait.
+  DownloadAndWait(browser(), url);
 
   // Get details of what downloads have just happened.
   std::vector<DownloadItem*> downloads;
   GetDownloads(browser(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   int64 db_handle = downloads[0]->db_handle();
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
@@ skipping 16 matching lines @@
 // 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::kChromeUIExtensionsURL);
 
   ui_test_utils::NavigateToURL(browser(), flags_url);
-  DownloadAndWait(browser(), download_url, EXPECT_NO_SELECT_DIALOG);
+  DownloadAndWait(browser(), download_url);
   ui_test_utils::NavigateToURL(browser(), extensions_url);
   TabContents* contents = browser()->GetSelectedTabContents();
   ASSERT_TRUE(contents);
   bool webui_responded = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       contents->render_view_host(),
       L"",
       L"window.domAutomationController.send(window.webui_responded_);",
       &webui_responded));
   EXPECT_TRUE(webui_responded);
@@ skipping 16 matching lines @@
   ASSERT_TRUE(contents);
   bool result = false;
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       contents->render_view_host(),
       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);
+  DownloadAndWait(browser(), download_url);
 
   ui_test_utils::WindowedNotificationObserver signal(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       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<DownloadsObserver> observer(CreateWaiter(browser(), 1));
+  scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser(), 1, false));
   ui_test_utils::NavigateToURL(browser(), url);
   observer->WaitForFinished();
 
   // Confirm the downloaded data exists.
-  FilePath downloaded_file = GetDownloadDirectory(browser());
-  downloaded_file = downloaded_file.Append(FILE_PATH_LITERAL("a_red_dot.png"));
+  FilePath downloaded_file(
+      DestinationFile(browser(), FilePath(FILE_PATH_LITERAL("a_red_dot.png"))));
   EXPECT_TRUE(file_util::PathExists(downloaded_file));
 }
 
 // Test to make sure auto-open works.
 IN_PROC_BROWSER_TEST_F(DownloadTest, 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(
       browser()->profile()->GetDownloadManager());
 
-  DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG);
+  DownloadAndWait(browser(), url);
 
   // Find the download and confirm it was opened.
   std::vector<DownloadItem*> downloads;
   browser()->profile()->GetDownloadManager()->SearchDownloads(
       string16(), &downloads);
   ASSERT_EQ(1u, downloads.size());
   EXPECT_EQ(DownloadItem::COMPLETE, downloads[0]->state());
   EXPECT_TRUE(downloads[0]->opened());
 
   // As long as we're here, confirmed everything else is good.
@@ skipping 136 matching lines @@
   EXPECT_EQ(1u, observer->NumDangerousDownloadsSeen());
 
   // Download shelf should close. Download panel stays open on ChromeOS.
   CheckDownloadUI(browser(), false, true, FilePath());
 
   // Check that the extension was installed.
   ExtensionService* extension_service =
       browser()->profile()->GetExtensionService();
   ASSERT_TRUE(extension_service->GetExtensionById(kLargeThemeCrxId, false));
 }