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/test/test_file_util.h"
@@ skipping 21 matching lines @@
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/cancelable_request.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/page_transition_types.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+enum SelectExpectation {
+  EXPECT_NO_SELECT_DIALOG = -1,
+  EXPECT_NOTHING,
+  EXPECT_SELECT_DIALOG
+};
+
 // Construction of this class defines a system state, based on some number
 // of downloads being seen in a particular state + other events that
 // may occur in the download system.  That state will be recorded if it
 // occurs at any point after construction.  When that state occurs, the class
 // is considered finished.  Callers may either probe for the finished state, or
 // wait on it.
 //
 // TODO(rdsmith): Detect manager going down, remove pointer to
 // DownloadManager, transition to finished.  (For right now we
 // just use a scoped_refptr<> to keep it around, but that may cause
@@ skipping 29 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_; }
+  // Checks if the select file dialog was displayed as we expected.
+  // If displayed, checks the suggested path in the dialog.
+  bool CheckSelectFileDialogState(SelectExpectation expectation,
+                                  const FilePath& expected_suggested_path) {
+    if (expectation == EXPECT_NO_SELECT_DIALOG) {
+      return !select_file_dialog_seen_;
+    } else if (expectation == EXPECT_SELECT_DIALOG) {
+      return select_file_dialog_seen_ &&
+        suggested_path_ == expected_suggested_path;
+    }
+    return true;
+  }
 
   // Wait for whatever state was specified in the constructor.
   void WaitForFinished() {
     if (!IsFinished()) {
       waiting_ = true;
       ui_test_utils::RunMessageLoop();
       waiting_ = false;
     }
   }
 
@@ skipping 41 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();
   }
 
  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
   // final state; multiple notifications may occur once the item is in
   // that state.  So we keep our own track of transitions into final.
   void DownloadInFinalState(DownloadItem* download) {
     if (finished_downloads_.find(download) != finished_downloads_.end()) {
@@ skipping 45 matching lines @@
   // The state on which to consider the DownloadItem finished.
   DownloadItem::DownloadState download_finished_state_;
 
   // True if we should transition the DownloadsObserver to finished if
   // the select file dialog comes up.
   bool finish_on_select_file_;
 
   // True if we've seen the select file dialog.
   bool select_file_dialog_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 48 matching lines @@
     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) {
     DownloadManager* download_mananger =
         browser->profile()->GetDownloadManager();
     return download_mananger->download_prefs()->download_path();
   }
 
@@ skipping 16 matching lines @@
         browser->profile()->GetDownloadManager();
     return new DownloadsObserver(
         download_manager, num_downloads,
         DownloadItem::IN_PROGRESS,      // Has started
         true);                          // Bail on select file
   }
 
   // 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
+  // |expectation| indicates whether or not 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.
+  // |expected_suggested_path| is the path expected to be suggested in the
+  // select file dialog. This |expected_suggested_path| must be specified
+  // if |expectation| is EXPECT_SELECT_DIALOG. If |expectation| is
+  // not EXPECT_SELECT_DIALOG, |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,
+                                      const FilePath& expected_suggested_path,
                                       int browser_test_flags) {
     // Setup notification, navigate, and block.
     scoped_ptr<DownloadsObserver> observer(CreateWaiter(browser, 1));
     // 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 the state of the select file dialog.
+    EXPECT_TRUE(observer->CheckSelectFileDialogState(expectation,
+                                                     expected_suggested_path));

[Randy Smith (Not in Mondays), 2011/06/06 15:31:29]

I'd suggest (i.e. I don't feel very strongly) that you expand the contents of
CheckSelectFileDialogState out here inline into a couple of separate EXPECT_*
calls.  I have two reasons for the suggestion:
* If a function's only used in one place and I don't see likely future uses of
it elsewhere, it can produce simpler code to have all the code in the same
place.  In this case I think it does, since you don't need to remember/know the
definition of CheckSelectFileDialogState.
* Multiple EXPECT statements mean that if there's a test failure, you get a
narrower pointer to what actually failed in the failure status.

[haraken1, 2011/06/08 04:12:08]

Done.

   }
 
   // Download a file in the current tab, then wait for the download to finish.
   void DownloadAndWait(Browser* browser,
                        const GURL& url,
-                       SelectExpectation expectation) {
+                       SelectExpectation expectation,
+                       const FilePath& expected_suggested_path) {

[Randy Smith (Not in Mondays), 2011/06/06 15:31:29]

I'm inclined to say you should make a new variant of DownloadAndWait rather than
expand the current one.  Most of the calls to this just get a null FilePath(),
so for them it's just extra work.  DownloadAndWaitWithDisposition() is complex
enough so duplicating it for caller convenience probably doesn't make sense, but
my judgement goes the other way for DownloadAndWait().

[haraken1, 2011/06/08 04:12:08]

I made DownloadAndWaitWithoutDialog() and DownloadAndWaitWithDialog(). 

     DownloadAndWaitWithDisposition(
         browser,
         url,
         CURRENT_TAB,
         expectation,
+        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) {
@@ skipping 217 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.  We do not expect the select file dialog.
+  DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
 }
 
+// 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.
+IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadedFolder1) {
+  ASSERT_TRUE(InitialSetup(false));
+  FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
+  GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
+
+  // Temporarily change the user's "Downloads" folder.
+  FilePath prev_default_downloads_dir;
+  ASSERT_TRUE(PathService::Get(
+      chrome::DIR_DEFAULT_DOWNLOADS, &prev_default_downloads_dir));
+  ScopedTempDir default_downloads_dir;
+  ASSERT_TRUE(default_downloads_dir.CreateUniqueTempDir());
+  PathService::Set(chrome::DIR_DEFAULT_DOWNLOADS, default_downloads_dir.path());
+  FilePath downloaded_file = default_downloads_dir.path().Append(file);
+
+  // Delete the default folder for downloaded files.
+  ASSERT_TRUE(DeleteDownloadsDirectory());
+  ASSERT_FALSE(file_util::PathExists(GetDownloadDirectory(browser())));
+
+  // Download the file and wait.  We expect the select file dialog.
+  DownloadAndWait(browser(), url, EXPECT_SELECT_DIALOG, downloaded_file);
+
+  EXPECT_FALSE(file_util::PathExists(downloaded_file));
+  EXPECT_FALSE(file_util::PathExists(GetDownloadDirectory(browser())));
+  EXPECT_EQ(1, browser()->tab_count());
+
+  // Restore the user's "Downloads" folder.
+  PathService::Set(chrome::DIR_DEFAULT_DOWNLOADS, prev_default_downloads_dir);
+}
+
+// Checks if the default folder for downloaded files is created
+// and a file is saved to the folder in the following situation:
+// The default folder for downloaded files does not exist.
+// The user's "Downloads" folder does not exist.
+IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadedFolder2) {
+  ASSERT_TRUE(InitialSetup(false));
+  FilePath file(FILE_PATH_LITERAL("download-test1.lib"));
+  GURL url(URLRequestMockHTTPJob::GetMockUrl(file));
+  FilePath downloaded_file(DestinationFile(browser(), file));
+
+  // Temporarily change the user's "Downloads" folder.
+  FilePath prev_default_downloads_dir;
+  ASSERT_TRUE(PathService::Get(
+      chrome::DIR_DEFAULT_DOWNLOADS, &prev_default_downloads_dir));
+  FilePath nonexistent_dir("/tmp/koakuma_andre_moemoe_nyannyannyan");
+  PathService::Set(chrome::DIR_DEFAULT_DOWNLOADS, nonexistent_dir);
+
+  // Delete the default folder for downloaded files.
+  ASSERT_TRUE(DeleteDownloadsDirectory());
+  ASSERT_FALSE(file_util::PathExists(GetDownloadDirectory(browser())));
+
+  // Download the file and wait.  We expect the select file dialog.
+  DownloadAndWait(browser(), url, EXPECT_SELECT_DIALOG, downloaded_file);
+
+  EXPECT_FALSE(file_util::PathExists(downloaded_file));
+  EXPECT_FALSE(file_util::PathExists(nonexistent_dir));
+  EXPECT_TRUE(file_util::PathExists(GetDownloadDirectory(browser())));
+  EXPECT_EQ(1, browser()->tab_count());
+
+  // Restore the user's "Downloads" folder.
+  PathService::Set(chrome::DIR_DEFAULT_DOWNLOADS, prev_default_downloads_dir);
+}
+
 #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.  We do not expect the select file dialog.
+  DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   // 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(IsDownloadUIVisible(browser()));
 }
 #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);
+  DownloadAndWait(browser(), url, EXPECT_SELECT_DIALOG, 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.
   EXPECT_FALSE(IsDownloadUIVisible(browser()));
 }
 
 // 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, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
 }
 
 #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, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   CheckDownload(browser(), download_file, file);
 
   // Check state.
   EXPECT_EQ(1, browser()->tab_count());
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
 
   // 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, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   // We should still have 2 windows.
   ExpectWindowCountAfterDownload(2);
 
   // Verify that the download shelf is showing for the Incognito window.
   EXPECT_TRUE(IsDownloadUIVisible(incognito));
 
 #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 45 matching lines @@
 
   // 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,
+      FilePath(),
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // When the download finishes, we should still have one tab.
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
   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 12 matching lines @@
 
   // 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,
+                                 FilePath(),
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should have two tabs.
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
   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 22 matching lines @@
 
   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,
+                                 FilePath(),
                                  ui_test_utils::BROWSER_TEST_NONE);
 
   // When the download finishes, we should have two tabs.
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
   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 13 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,
+                                 FilePath(),
                                  ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
   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 15 matching lines @@
 
   // 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,
+      FilePath(),
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 
   // When the download finishes, we should still have one tab.
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
   EXPECT_EQ(1, browser()->tab_count());
 
   CheckDownload(browser(), file, file);
 }
 
 // Download a file in a new window.
@@ skipping 10 matching lines @@
 #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,
+                                 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());
 #if defined(OS_CHROMEOS)
   // Except on chromeos the download UI isn't window-specific.
   EXPECT_TRUE(IsDownloadUIVisible(browser()));
 #else
@@ skipping 101 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.  We do not expect the select file dialog.
+  DownloadAndWait(browser(), url, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   // 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::kAboutFlagsURL);
   GURL extensions_url(chrome::kChromeUIExtensionsURL);
 
   ui_test_utils::NavigateToURL(browser(), flags_url);
-  DownloadAndWait(browser(), download_url, EXPECT_NO_SELECT_DIALOG);
+  DownloadAndWait(browser(), download_url, EXPECT_NO_SELECT_DIALOG, FilePath());
   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, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   ui_test_utils::WindowedNotificationObserver signal(
       NotificationType::BROWSER_CLOSED,
       Source<Browser>(browser()));
   browser()->CloseWindow();
   signal.Wait();
 }
 
 // Test to make sure auto-open works.
 #if defined(OS_CHROMEOS)
 // Always fails on Chrome OS: crbug.com/84058
 #define MAYBE_AutoOpen FAILS_AutoOpen
 #else
 #define MAYBE_AutoOpen AutoOpen
 #endif
 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));
 
   // Mokc 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, EXPECT_NO_SELECT_DIALOG, FilePath());
 
   // 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.
   EXPECT_EQ(1, browser()->tab_count());
   CheckDownload(browser(), file, file);
   EXPECT_FALSE(IsDownloadUIVisible(browser()));  // Auto-opened.
 }