Merge SavePackageFilePicker{,ChromeOS}

chrome/browser/download/chrome_download_manager_delegate.cc

 // Copyright (c) 2012 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/chrome_download_manager_delegate.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 40 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/download_handler.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/download/download_file_picker_chromeos.h"
-#include "chrome/browser/download/save_package_file_picker_chromeos.h"
 #endif
 
-using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::WebContents;
 using safe_browsing::DownloadProtectionService;
 
 namespace {
 
 // String pointer used for identifying safebrowing data associated with
@@ skipping 101 matching lines @@
       drive::DownloadHandler::GetForProfile(profile);
   if (drive_download_handler &&
       drive_download_handler->IsDriveDownload(download))
     return drive_download_handler->GetTargetPath(download);
 #endif
   return download->GetFullPath();
 }
 
 }  // namespace
 
-// static
-void ChromeDownloadManagerDelegate::RegisterUserPrefs(
-    PrefRegistrySyncable* registry) {
-  const base::FilePath& default_download_path =
-      download_util::GetDefaultDownloadDirectory();
-  registry->RegisterFilePathPref(prefs::kSaveFileDefaultDirectory,
-                                 default_download_path,
-                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
-}
-
 ChromeDownloadManagerDelegate::ChromeDownloadManagerDelegate(Profile* profile)
     : profile_(profile),
       next_download_id_(0),
       download_prefs_(new DownloadPrefs(profile)) {
 }
 
 ChromeDownloadManagerDelegate::~ChromeDownloadManagerDelegate() {
 }
 
 void ChromeDownloadManagerDelegate::SetDownloadManager(DownloadManager* dm) {
   download_manager_ = dm;
 }
 
 void ChromeDownloadManagerDelegate::Shutdown() {
   download_prefs_.reset();
 }
 
 DownloadId ChromeDownloadManagerDelegate::GetNextId() {
   if (!profile_->IsOffTheRecord())
     return DownloadId(this, next_download_id_++);
 
-  return BrowserContext::GetDownloadManager(profile_->GetOriginalProfile())->
-      GetDelegate()->GetNextId();
+  return content::BrowserContext::GetDownloadManager(
+      profile_->GetOriginalProfile())->GetDelegate()->GetNextId();
 }
 
 bool ChromeDownloadManagerDelegate::DetermineDownloadTarget(
     DownloadItem* download,
     const content::DownloadTargetCallback& callback) {
 #if defined(FULL_SAFE_BROWSING)
   DownloadProtectionService* service = GetDownloadProtectionService();
   if (service) {
     VLOG(2) << __FUNCTION__ << "() Start SB URL check for download = "
             << download->DebugString(false);
@@ skipping 132 matching lines @@
 bool ChromeDownloadManagerDelegate::GenerateFileHash() {
 #if defined(FULL_SAFE_BROWSING)
   return profile_->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled) &&
       g_browser_process->safe_browsing_service()->DownloadBinHashNeeded();
 #else
   return false;
 #endif
 }
 
 void ChromeDownloadManagerDelegate::GetSaveDir(
-    BrowserContext* browser_context,
+    content::BrowserContext* browser_context,
     base::FilePath* website_save_dir,
     base::FilePath* download_save_dir,
     bool* skip_dir_check) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
   PrefService* prefs = profile->GetPrefs();
 
-  // Check whether the preference for the preferred directory for
-  // saving file has been explicitly set. If not, and the preference
-  // for the default download directory has been set, initialize it
-  // with the latter. Note that the defaults for both are the same.
-  const PrefService::Preference* download_default_directory =
-      prefs->FindPreference(prefs::kDownloadDefaultDirectory);
-  if (!download_default_directory->IsDefaultValue() &&
-      prefs->FindPreference(
-          prefs::kSaveFileDefaultDirectory)->IsDefaultValue()) {
-    prefs->Set(prefs::kSaveFileDefaultDirectory,
-               *(download_default_directory->GetValue()));
-  }
-
   // Get the directory from preference.
-  *website_save_dir = prefs->GetFilePath(prefs::kSaveFileDefaultDirectory);
+  *website_save_dir = download_prefs_->SaveFilePath();
   DCHECK(!website_save_dir->empty());
 
   *download_save_dir = prefs->GetFilePath(prefs::kDownloadDefaultDirectory);
 
   *skip_dir_check = false;
 #if defined(OS_CHROMEOS)
   *skip_dir_check = drive::util::IsUnderDriveMountPoint(*website_save_dir);
 #endif
 }
 
 void ChromeDownloadManagerDelegate::ChooseSavePath(
     WebContents* web_contents,
     const base::FilePath& suggested_path,
     const base::FilePath::StringType& default_extension,
     bool can_save_as_complete,
     const content::SavePackagePathPickedCallback& callback) {
   // Deletes itself.
-#if defined(OS_CHROMEOS)
-  new SavePackageFilePickerChromeOS(
-      web_contents,
-      suggested_path,
-      can_save_as_complete,
-      callback);
-#else
   new SavePackageFilePicker(
       web_contents,
       suggested_path,
       default_extension,
       can_save_as_complete,
       download_prefs_.get(),
       callback);
-#endif
 }
 
 void ChromeDownloadManagerDelegate::OpenDownload(DownloadItem* download) {
   platform_util::OpenItem(GetPlatformDownloadPath(profile_, download));
 }
 
 void ChromeDownloadManagerDelegate::ShowDownloadInShell(
     DownloadItem* download) {
   platform_util::ShowItemInFolder(GetPlatformDownloadPath(profile_, download));
 }
 
 void ChromeDownloadManagerDelegate::CheckForFileExistence(
     DownloadItem* download,
     const content::CheckForFileExistenceCallback& callback) {
 #if defined(OS_CHROMEOS)
   drive::DownloadHandler* drive_download_handler =
       drive::DownloadHandler::GetForProfile(profile_);
   if (drive_download_handler &&
       drive_download_handler->IsDriveDownload(download)) {
     drive_download_handler->CheckForFileExistence(download, callback);
     return;
   }
 #endif
   BrowserThread::PostTaskAndReplyWithResult(BrowserThread::FILE, FROM_HERE,
                                             base::Bind(&file_util::PathExists,
                                                        download->GetFullPath()),
                                             callback);
 }
 
-void ChromeDownloadManagerDelegate::ClearLastDownloadPath() {
-  last_download_path_.clear();
-}
-
 DownloadProtectionService*
     ChromeDownloadManagerDelegate::GetDownloadProtectionService() {
 #if defined(FULL_SAFE_BROWSING)
   SafeBrowsingService* sb_service = g_browser_process->safe_browsing_service();
   if (sb_service && sb_service->download_protection_service() &&
       profile_->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled)) {
     return sb_service->download_protection_service();
   }
 #endif
   return NULL;
@@ skipping 160 matching lines @@
 ChromeDownloadManagerDelegate::ContinueFilenameDeterminationInfo::
     ~ContinueFilenameDeterminationInfo() {}
 
 void ChromeDownloadManagerDelegate::CheckVisitedReferrerBeforeDone(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     content::DownloadDangerType danger_type,
     bool visited_referrer_before) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DownloadItem* download =
-      download_manager_->GetDownload(download_id);
+  DownloadItem* download = download_manager_->GetDownload(download_id);
   if (!download || (download->GetState() != DownloadItem::IN_PROGRESS))
     return;
 
   bool should_prompt = (download->GetTargetDisposition() ==
                         DownloadItem::TARGET_DISPOSITION_PROMPT);
   bool is_forced_path = !download->GetForcedFilePath().empty();
   base::FilePath generated_name;
   base::FilePath suggested_path;
 
   // Check whether this download is for an extension install or not.
@@ skipping 17 matching lines @@
       if (!download_crx_util::IsExtensionDownload(*download) &&
           !ShouldOpenFileBasedOnExtension(generated_name))
         should_prompt = true;
     }
     if (download_prefs_->IsDownloadPathManaged())
       should_prompt = false;
 
     // Determine the proper path for a download, by either one of the following:
     // 1) using the default download directory.
     // 2) prompting the user.
-    base::FilePath target_directory;
-    if (should_prompt && !last_download_path_.empty())
-      target_directory = last_download_path_;
-    else
-      target_directory = download_prefs_->DownloadPath();
+    base::FilePath target_directory = should_prompt ?
+      download_prefs_->SaveFilePath() : download_prefs_->DownloadPath();
     suggested_path = target_directory.Append(generated_name);
   } else {
     DCHECK(!should_prompt);
     suggested_path = download->GetForcedFilePath();
   }
 
   ContinueFilenameDeterminationInfo continue_info;
   continue_info.download_id = download_id;
   continue_info.callback = callback;
   continue_info.danger_type = danger_type;
@@ skipping 24 matching lines @@
         download, generated_name, filename_determined, overriding);
   }
 #endif
 }
 
 void ChromeDownloadManagerDelegate::OnExtensionOverridingFilename(
     const ContinueFilenameDeterminationInfo& continue_info,
     const base::FilePath& changed_filename,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadItem* download =
-      download_manager_->GetDownload(continue_info.download_id);
+  DownloadItem* download = download_manager_->GetDownload(
+      continue_info.download_id);
   if (!download || (download->GetState() != DownloadItem::IN_PROGRESS))
     return;
 
   // If an extension overrides the filename, then the target directory will be
   // forced to download_prefs_->DownloadPath() since extensions cannot place
   // downloaded files anywhere except there. This prevents subdirectories from
   // accumulating: if an extension is allowed to say that a file should go in
   // last_download_path/music/foo.mp3, then last_download_path will accumulate
   // the subdirectory /music/ so that the next download may end up in
   // Downloads/music/music/music/bar.mp3.
@@ skipping 10 matching lines @@
 void ChromeDownloadManagerDelegate::ContinueDeterminingFilename(
     const ContinueFilenameDeterminationInfo& continue_info,
     const base::FilePath& suggested_path,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   int32 download_id = continue_info.download_id;
   const content::DownloadTargetCallback& callback = continue_info.callback;
   content::DownloadDangerType danger_type = continue_info.danger_type;
   bool visited_referrer_before = continue_info.visited_referrer_before;
   bool should_prompt = continue_info.should_prompt;
-  DownloadItem* download =
-      download_manager_->GetDownload(download_id);
+  DownloadItem* download = download_manager_->GetDownload(download_id);
   if (!download || (download->GetState() != DownloadItem::IN_PROGRESS))
     return;
 
   // If the download hasn't already been marked dangerous (could be
   // DANGEROUS_URL), check if it is a dangerous file.
   if (danger_type == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS) {
     if (!should_prompt &&
         download->GetForcedFilePath().empty() &&
         IsDangerousFile(*download, suggested_path, visited_referrer_before)) {
       danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
@@ skipping 41 matching lines @@
 #if defined (OS_CHROMEOS)
 // TODO(asanka): Merge this logic with the logic in DownloadFilePickerChromeOS.
 void ChromeDownloadManagerDelegate::SubstituteDriveDownloadPathCallback(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     bool should_prompt,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
     content::DownloadDangerType danger_type,
     const base::FilePath& suggested_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadItem* download =
-      download_manager_->GetDownload(download_id);
+  DownloadItem* download = download_manager_->GetDownload(download_id);
   if (!download || (download->GetState() != DownloadItem::IN_PROGRESS))
     return;
 
   if (suggested_path.empty()) {
     // Substitution failed.
     callback.Run(base::FilePath(),
                  DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                  danger_type,
                  base::FilePath());
     return;
   }
 
   GetReservedPath(
       *download, suggested_path, download_prefs_->DownloadPath(),
       conflict_action,
       base::Bind(&ChromeDownloadManagerDelegate::OnPathReservationAvailable,
                  this, download->GetId(), callback, should_prompt,
                  danger_type));
 }
 #endif
 
 void ChromeDownloadManagerDelegate::OnPathReservationAvailable(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     bool should_prompt,
     content::DownloadDangerType danger_type,
     const base::FilePath& reserved_path,
     bool reserved_path_verified) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DownloadItem* download =
-      download_manager_->GetDownload(download_id);
+  DownloadItem* download = download_manager_->GetDownload(download_id);
   if (!download || (download->GetState() != DownloadItem::IN_PROGRESS))
     return;
   if (should_prompt || !reserved_path_verified) {
     // If the target path could not be verified then the path was non-existant,
     // non writeable or could not be uniquified. Prompt the user.
     ChooseDownloadPath(
         download, reserved_path,
         base::Bind(&ChromeDownloadManagerDelegate::OnTargetPathDetermined,
                    this, download_id, callback,
                    DownloadItem::TARGET_DISPOSITION_PROMPT, danger_type));
   } else {
     OnTargetPathDetermined(download_id, callback,
                            DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                            danger_type, reserved_path);
   }
 }
 
 void ChromeDownloadManagerDelegate::OnTargetPathDetermined(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     DownloadItem::TargetDisposition disposition,
     content::DownloadDangerType danger_type,
     const base::FilePath& target_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FilePath intermediate_path;
-  DownloadItem* download =
-      download_manager_->GetDownload(download_id);
+  DownloadItem* download = download_manager_->GetDownload(download_id);
   if (!download || (download->GetState() != DownloadItem::IN_PROGRESS))
     return;
 
   // If |target_path| is empty, then that means that the user wants to cancel
   // the download.
   if (!target_path.empty()) {
     intermediate_path = GetIntermediatePath(
         target_path, danger_type, !download->GetForcedFilePath().empty());
-
-    // Retain the last directory. Exclude temporary downloads since the path
-    // likely points at the location of a temporary file.
-    // TODO(asanka): This logic is a hack. DownloadFilePicker should give us a
-    //               directory to persist. Or perhaps, if the Drive path
-    //               substitution logic is moved here, then we would have a
-    //               persistable path after the DownloadFilePicker is done.
-    if (disposition == DownloadItem::TARGET_DISPOSITION_PROMPT &&
-        !download->IsTemporary())
-      last_download_path_ = target_path.DirName();
+    if (!profile_->IsOffTheRecord()) {
+      base::FilePath target_dir = target_path.DirName();
+#if defined(OS_CHROMEOS)
+      drive::DownloadHandler* drive_handler =
+          drive::DownloadHandler::GetForProfile(profile_);
+      if (drive_handler->IsDriveDownload(download)) {
+        target_dir = drive_handler->GetTargetPath(download);
+      }
+#endif
+      download_prefs_->SetSaveFilePath(target_dir);
+    }
   }
   callback.Run(target_path, disposition, danger_type, intermediate_path);
 }