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 26 matching lines @@
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_source.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/save_package_file_picker_chromeos.h"
 #endif
 
-using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 using content::DownloadManager;
 using safe_browsing::DownloadProtectionService;
 
 namespace {
 
 // String pointer used for identifying safebrowing data associated with
 // a download item.
@@ skipping 69 matching lines @@
   } else {
     // If the URL is malicious, we'll use that as the danger type. The results
     // of the content check, if one is performed, will be ignored.
     danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_URL;
   }
   callback.Run(danger_type);
 }
 
 }  // namespace
 
-// static
-void ChromeDownloadManagerDelegate::RegisterUserPrefs(
-    user_prefs::PrefRegistrySyncable* registry) {
-  const base::FilePath& default_download_path =
-      download_util::GetDefaultDownloadDirectory();
-  registry->RegisterFilePathPref(
-      prefs::kSaveFileDefaultDirectory,
-      default_download_path,
-      user_prefs::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) {
   DownloadTargetDeterminer::Start(download,
                                   download_prefs_.get(),
-                                  last_download_path_,
                                   this,
                                   callback);
   return true;
 }
 
 bool ChromeDownloadManagerDelegate::ShouldOpenFileBasedOnExtension(
     const base::FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (path.Extension().empty())
     return false;
@@ skipping 97 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(
     content::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() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #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
@@ skipping 49 matching lines @@
     const DownloadTargetDeterminerDelegate::FileSelectedCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadFilePicker::ShowFilePicker(
       download,
       suggested_path,
       base::Bind(&ChromeDownloadManagerDelegate::OnDownloadPathSelected,
                  this,
                  callback));
 }
 
 void ChromeDownloadManagerDelegate::OnDownloadPathSelected(

[asanka, 2013/05/07 15:15:12]

Suggestion: This callback isn't required since setting the last download path is
something that DTD can do. However, you'll also need to redo the corresponding
test in d_t_d_unittests.cc.

[benjhayden, 2013/05/17 20:31:54]

Done.

     const DownloadTargetDeterminerDelegate::FileSelectedCallback& callback,
     const base::FilePath& virtual_path) {
   if (!virtual_path.empty())
-    last_download_path_ = virtual_path.DirName();
+    download_prefs_->SetSaveFilePath(virtual_path.DirName());
   callback.Run(virtual_path);
 }
 
 void ChromeDownloadManagerDelegate::DetermineLocalPath(
     DownloadItem* download,
     const base::FilePath& virtual_path,
     const DownloadTargetDeterminerDelegate::LocalPathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #if defined(OS_CHROMEOS)
   drive::DownloadHandler* drive_download_handler =
@@ skipping 79 matching lines @@
   registrar_.Remove(this,
                     chrome::NOTIFICATION_CRX_INSTALLER_DONE,
                     source);
 
   scoped_refptr<extensions::CrxInstaller> installer =
       content::Source<extensions::CrxInstaller>(source).ptr();
   content::DownloadOpenDelayedCallback callback = crx_installers_[installer];
   crx_installers_.erase(installer.get());
   callback.Run(installer->did_handle_successfully());
 }