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 43 matching lines @@
 #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/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 99 matching lines @@
 #if defined(OS_CHROMEOS)
   drive::DownloadHandler* drive_download_handler =
       drive::DownloadHandler::GetForProfile(profile);
   if (drive_download_handler &&
       drive_download_handler->IsDriveDownload(download))
     return drive_download_handler->GetTargetPath(download);
 #endif
   return download->GetFullPath();
 }
 
+void VirtualSavePathChosen(content::BrowserContext* context,
+                           const base::FilePath& path) {
+  StringPrefMember save_file_path;
+  save_file_path.Init(prefs::kSaveFileDefaultDirectory,
+                      Profile::FromBrowserContext(context)->GetPrefs());
+#if defined(OS_POSIX)
+  std::string path_string = path.DirName().value();
+#elif defined(OS_WIN)
+  std::string path_string = WideToUTF8(path.DirName().value());

[Randy Smith (Not in Mondays), 2013/04/25 17:58:55]

Is this the usual method of persisting file paths on Windows?  I'm concerned
that WideToUTF8 could lose information that users on Windows actually care
about--should we find some way of encoding all the information into the
preference?

[asanka, 2013/04/25 19:01:39]

kSaveFileDefaultDirectory is registered in CDMD as a FilePath pref.
save_file_path should be a FilePathPrefMember and no conversion should be done
when storing/retrieving the pref value.

[benjhayden, 2013/04/30 21:11:12]

Done.

[benjhayden, 2013/04/30 21:11:12]

Done.

+#endif
+  // If user change the default saving directory, we will remember it just
+  // like IE and FireFox.
+  if (!context->IsOffTheRecord() &&
+      (save_file_path.GetValue() != path_string)) {
+    save_file_path.SetValue(path_string);
+  }
+}
+
 }  // 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);
@@ skipping 13 matching lines @@
 }
 
 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.
@@ skipping 23 matching lines @@
     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,
+      base::Bind(&VirtualSavePathChosen, web_contents->GetBrowserContext()),
       callback);
 #else
   new SavePackageFilePicker(
       web_contents,
       suggested_path,
       default_extension,
       can_save_as_complete,
       download_prefs_.get(),
+      base::Bind(&VirtualSavePathChosen, web_contents->GetBrowserContext()),
       callback);
 #endif
 }
 
 void ChromeDownloadManagerDelegate::OpenDownload(DownloadItem* download) {
   platform_util::OpenItem(GetPlatformDownloadPath(profile_, download));
 }
 
 void ChromeDownloadManagerDelegate::ShowDownloadInShell(
     DownloadItem* download) {
@@ skipping 459 matching lines @@
     // 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();
   }
   callback.Run(target_path, disposition, danger_type, intermediate_path);
 }