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();
+    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 default_download_dir =
+      download_util::GetDefaultDownloadDirectoryFromPathService();
+  FilePath downloaded_file = default_download_dir.Append(random_string);
+  // Make sure that the target file does not exist.
+  file_util::Delete(downloaded_file, false);
+  // Make sure that the temporary file does not exist.
+  FilePath temporary_file =
+      default_download_dir.Append(random_string + ".crdownload");
+  std::cout << temporary_file.value() << std::endl;
+  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));
 }