Use the most recently used download path when displaying a "save as" dialog....

chrome/browser/download/download_manager.cc

 // Copyright (c) 2006-2008 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 <time.h>
 
 #include "chrome/browser/download/download_manager.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 380 matching lines @@
   SaveAutoOpens();
 
   // Make sure the save as dialog doesn't notify us back if we're gone before
   // it returns.
   if (select_file_dialog_.get())
     select_file_dialog_->ListenerDestroyed();
 
   shutdown_needed_ = false;
 }
 
+// Determines whether the "save as" dialog should be displayed to the user
+// when downloading a file.
+bool DownloadManager::ShouldDisplaySaveAsDialog(
+    const DownloadCreateInfo* info) {
+  return
+      *prompt_for_download_ ||      // User always wants a prompt.
+      info->save_as ||              // "Save as ..." operation.
+      info->path_uniquifier == -1;  // Last attempt to generate a unique file
+                                    // name failed.
+}
+
 // Issue a history query for downloads matching 'search_text'. If 'search_text'
 // is empty, return all downloads that we know about.
 void DownloadManager::GetDownloads(Observer* observer,
                                    const std::wstring& search_text) {
   DCHECK(observer);
 
   // Return a empty list if we've not yet received the set of downloads from the
   // history system (we'll update all observers once we get that list in
   // OnQueryDownloadEntriesComplete), or if there are no downloads at all.
   std::vector<DownloadItem*> download_copy;
@@ skipping 105 matching lines @@
 // point. OnCreateDatabaseEntryComplete() handles that finalization of the the
 // download creation as a callback from the history thread.
 void DownloadManager::StartDownload(DownloadCreateInfo* info) {
   DCHECK(MessageLoop::current() == ui_loop_);
   DCHECK(info);
 
   // Determine the proper path for a download, by choosing either the default
   // download directory, or prompting the user.
   std::wstring generated_name;
   GenerateFilename(info, &generated_name);
-  if (*prompt_for_download_ && !last_download_path_.empty())
+  if (ShouldDisplaySaveAsDialog(info) && !last_download_path_.empty())
     info->suggested_path = last_download_path_;
   else
     info->suggested_path = *download_path_;
   file_util::AppendToPath(&info->suggested_path, generated_name);
 
   // Let's check if this download is dangerous, based on its name.
-  if (!*prompt_for_download_ && !info->save_as) {
+  if (!ShouldDisplaySaveAsDialog(info)) {
     const std::wstring filename =
         file_util::GetFilenameFromPath(info->suggested_path);
     info->is_dangerous = IsDangerous(filename);
   }
 
   // We need to move over to the download thread because we don't want to stat
   // the suggested path on the UI thread.
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::CheckIfSuggestedPathExists,
@@ skipping 46 matching lines @@
   ui_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this,
                         &DownloadManager::OnPathExistenceAvailable,
                         info));
 }
 
 void DownloadManager::OnPathExistenceAvailable(DownloadCreateInfo* info) {
   DCHECK(MessageLoop::current() == ui_loop_);
   DCHECK(info);
 
-  if (*prompt_for_download_ || info->save_as || info->path_uniquifier == -1) {
+  if (ShouldDisplaySaveAsDialog(info)) {
     // We must ask the user for the place to put the download.
     if (!select_file_dialog_.get())
       select_file_dialog_ = SelectFileDialog::Create(this);
 
     TabContents* contents = tab_util::GetTabContentsByID(
         info->render_process_id, info->render_view_id);
     HWND owning_hwnd =
         contents ? GetAncestor(contents->GetContainerHWND(), GA_ROOT) : NULL;
     select_file_dialog_->SelectFile(SelectFileDialog::SELECT_SAVEAS_FILE,
                                     std::wstring(), info->suggested_path,
@@ skipping 592 matching lines @@
       extensions += *it + L":";
     }
     if (!extensions.empty())
       extensions.erase(extensions.size() - 1);
     prefs->SetString(prefs::kDownloadExtensionsToOpen, extensions);
   }
 }
 
 void DownloadManager::FileSelected(const std::wstring& path, void* params) {
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
-  if (*prompt_for_download_)
+  if (ShouldDisplaySaveAsDialog(info))
     last_download_path_ = file_util::GetDirectoryFromPath(path);
   ContinueStartDownload(info, path);
 }
 
 void DownloadManager::FileSelectionCanceled(void* params) {
   // The user didn't pick a place to save the file, so need to cancel the
   // download that's already in progress to the temporary location.
   DownloadCreateInfo* info = reinterpret_cast<DownloadCreateInfo*>(params);
   file_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(file_manager_, &DownloadFileManager::CancelDownload,
@@ skipping 103 matching lines @@
   std::vector<DownloadItem*> searched_downloads;
   for (std::vector<int64>::iterator it = results->begin();
        it != results->end(); ++it) {
     DownloadMap::iterator dit = downloads_.find(*it);
     if (dit != downloads_.end())
       searched_downloads.push_back(dit->second);
   }
 
   requestor->SetDownloads(searched_downloads);
 }
+
+// Clears the last download path, used to initialize "save as" dialogs.  
+void DownloadManager::ClearLastDownloadPath() {
+  last_download_path_.clear();
+}