Merge SavePackageFilePicker{,ChromeOS}

chrome/browser/download/download_target_determiner.cc

 // Copyright 2013 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 "chrome/browser/download/download_target_determiner.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
@@ skipping 41 matching lines @@
 }
 
 } // namespace
 
 DownloadTargetDeterminerDelegate::~DownloadTargetDeterminerDelegate() {
 }
 
 DownloadTargetDeterminer::DownloadTargetDeterminer(
     DownloadItem* download,
     DownloadPrefs* download_prefs,
-    const base::FilePath& last_selected_directory,
     DownloadTargetDeterminerDelegate* delegate,
     const content::DownloadTargetCallback& callback)
     : next_state_(STATE_GENERATE_TARGET_PATH),
       should_prompt_(false),
       create_directory_(false),
       conflict_action_(download->GetForcedFilePath().empty() ?
                        DownloadPathReservationTracker::UNIQUIFY :
                        DownloadPathReservationTracker::OVERWRITE),
       danger_type_(download->GetDangerType()),
       download_(download),
       download_prefs_(download_prefs),
       delegate_(delegate),
-      last_selected_directory_(last_selected_directory),
       completion_callback_(callback),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(download_);
   DCHECK(delegate);
   download_->AddObserver(this);
 
   DoLoop();
 }
 
@@ skipping 66 matching lines @@
         l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME));
     base::FilePath generated_filename = net::GenerateFileName(
         download_->GetURL(),
         download_->GetContentDisposition(),
         GetProfile()->GetPrefs()->GetString(prefs::kDefaultCharset),
         download_->GetSuggestedFilename(),
         download_->GetMimeType(),
         default_filename);
     should_prompt_ = ShouldPromptForDownload(generated_filename);
     base::FilePath target_directory;
-    if (should_prompt_ && !last_selected_directory_.empty()) {
+    if (should_prompt_) {
       DCHECK(!download_prefs_->IsDownloadPathManaged());
       // If the user is going to be prompted and the user has been prompted
       // before, then always prefer the last directory that the user selected.
-      target_directory = last_selected_directory_;
+      target_directory = download_prefs_->SaveFilePath();
     } else {
       target_directory = download_prefs_->DownloadPath();
     }
     virtual_path_ = target_directory.Append(generated_filename);
   } else {
     DCHECK(!should_prompt_);
     virtual_path_ = download_->GetForcedFilePath();
   }
   DCHECK(virtual_path_.IsAbsolute());
   DVLOG(20) << "Generated virtual path: " << virtual_path_.AsUTF8Unsafe();
@@ skipping 100 matching lines @@
 
 void DownloadTargetDeterminer::PromptUserForDownloadPathDone(
     const base::FilePath& virtual_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(20) << "User selected path:" << virtual_path.AsUTF8Unsafe();
   if (virtual_path.empty()) {
     CancelOnFailureAndDeleteSelf();
     return;
   }
   virtual_path_ = virtual_path;
+  download_prefs_->SetSaveFilePath(virtual_path_.DirName());
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineLocalPath() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!virtual_path_.empty());
   DCHECK(local_path_.empty());
 
   next_state_ = STATE_CHECK_DOWNLOAD_URL;
@@ skipping 281 matching lines @@
     DownloadItem* download) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(download_, download);
   CancelOnFailureAndDeleteSelf();
 }
 
 // static
 void DownloadTargetDeterminer::Start(
     content::DownloadItem* download,
     DownloadPrefs* download_prefs,
-    const base::FilePath& last_selected_directory,
     DownloadTargetDeterminerDelegate* delegate,
     const content::DownloadTargetCallback& callback) {
   // DownloadTargetDeterminer owns itself and will self destruct when the job is
   // complete or the download item is destroyed. The callback is always invoked
   // asynchronously.
-  new DownloadTargetDeterminer(download, download_prefs,
-                               last_selected_directory, delegate, callback);
+  new DownloadTargetDeterminer(download, download_prefs, delegate, callback);
 }
 
 // static
 base::FilePath DownloadTargetDeterminer::GetCrDownloadPath(
     const base::FilePath& suggested_path) {
   return base::FilePath(suggested_path.value() +
                         FILE_PATH_LITERAL(".crdownload"));
 }