[downloads] Move platform specific code out of DownloadTargetDeterminer.

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/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/page_navigator.h"
 #include "net/base/filename_util.h"
 #include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include "chrome/browser/android/download/chrome_download_manager_overwrite_infobar_delegate.h"
+#include "chrome/browser/android/download/download_controller.h"
+#include "chrome/browser/android/download/download_manager_service.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/download_handler.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #endif
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/downloads/downloads_api.h"
@@ skipping 114 matching lines @@
 // Reason for why danger type is DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE.
 // Used by "Download.DangerousFile.Reason" UMA metric.
 // Do not change the ordering or remove items.
 enum DangerousFileReason {
   SB_NOT_AVAILABLE = 0,
   SB_RETURNS_UNKOWN = 1,
   SB_RETURNS_SAFE = 2,
   DANGEROUS_FILE_REASON_MAX
 };
 
+// On Android, Chrome wants to warn the user of file overwrites rather than
+// uniquify.
+#if BUILDFLAG(ANDROID_JAVA_UI)
+const DownloadPathReservationTracker::FilenameConflictAction
+    kDefaultPlatformConflictAction = DownloadPathReservationTracker::PROMPT;
+#else
+const DownloadPathReservationTracker::FilenameConflictAction
+    kDefaultPlatformConflictAction = DownloadPathReservationTracker::UNIQUIFY;
+#endif
+
 }  // namespace
 
 ChromeDownloadManagerDelegate::ChromeDownloadManagerDelegate(Profile* profile)
     : profile_(profile),
       next_download_id_(content::DownloadItem::kInvalidId),
       download_prefs_(new DownloadPrefs(profile)),
       weak_ptr_factory_(this) {
 }
 
 ChromeDownloadManagerDelegate::~ChromeDownloadManagerDelegate() {
@@ skipping 65 matching lines @@
     DownloadItem* download,
     const content::DownloadTargetCallback& callback) {
   DownloadTargetDeterminer::CompletionCallback target_determined_callback =
       base::Bind(&ChromeDownloadManagerDelegate::OnDownloadTargetDetermined,
                  weak_ptr_factory_.GetWeakPtr(),
                  download->GetId(),
                  callback);
   DownloadTargetDeterminer::Start(
       download,
       GetPlatformDownloadPath(profile_, download, PLATFORM_TARGET_PATH),
-      download_prefs_.get(),
-      this,
+      kDefaultPlatformConflictAction, download_prefs_.get(), this,
       target_determined_callback);
   return true;
 }
 
 bool ChromeDownloadManagerDelegate::ShouldOpenFileBasedOnExtension(
     const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (path.Extension().empty())
     return false;
 #if defined(ENABLE_EXTENSIONS)
@@ skipping 299 matching lines @@
     const base::FilePath& virtual_path,
     bool create_directory,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
     const DownloadTargetDeterminerDelegate::ReservedPathCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!virtual_path.empty());
 #if defined(OS_CHROMEOS)
   // TODO(asanka): Handle path reservations for virtual paths as well.
   //               http://crbug.com/151618
   if (drive::util::IsUnderDriveMountPoint(virtual_path)) {
-    callback.Run(virtual_path, true);
+    callback.Run(virtual_path, DownloadTargetResult::SUCCESS);
     return;
   }
 #endif
   DownloadPathReservationTracker::GetReservedPath(
       download,
       virtual_path,
       download_prefs_->DownloadPath(),
       create_directory,
       conflict_action,
       callback);
 }
 
-void ChromeDownloadManagerDelegate::PromptUserForDownloadPath(
+void ChromeDownloadManagerDelegate::RequestConfirmation(
     DownloadItem* download,
     const base::FilePath& suggested_path,
+    DownloadConfirmationReason reason,
     const DownloadTargetDeterminerDelegate::FileSelectedCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
 #if BUILDFLAG(ANDROID_JAVA_UI)
-  chrome::android::ChromeDownloadManagerOverwriteInfoBarDelegate::Create(
-      InfoBarService::FromWebContents(download->GetWebContents()), download,
-      suggested_path, callback);
-#else
+  switch (reason) {
+    case DownloadConfirmationReason::NONE:
+      NOTREACHED();
+      return;
+
+    case DownloadConfirmationReason::TARGET_NOT_WRITEABLE:
+      DownloadManagerService::OnDownloadCanceled(
+          download, DownloadController::CANCEL_REASON_NO_EXTERNAL_STORAGE);
+      callback.Run(DownloadConfirmationResult::CANCELED, base::FilePath());
+      return;
+
+    case DownloadConfirmationReason::NAME_TOO_LONG:
+    case DownloadConfirmationReason::TARGET_NO_SPACE:

[svaldez, 2016/10/28 17:29:35]

Should this actually continue?

[asanka, 2016/11/07 19:50:15]

This one's a bit odd in that the purpose of continuing is to force the download
back into its interrupted state. I.e. attempting to continue to download will
interrupt it again if there's still no space.

On Android there's [currently] only one download location. Hence the user
doesn't have much of a choice on where to download. Hence we show the download
as interrupted and force a manual resumption, but without the extra prompt that
we do on desktop.

Added a comment to this effect.

+    case DownloadConfirmationReason::SAVE_AS:
+    case DownloadConfirmationReason::PREFERENCE:
+      callback.Run(DownloadConfirmationResult::CONTINUE_WITHOUT_CONFIRMATION,
+                   suggested_path);
+      return;
+
+    case DownloadConfirmationReason::TARGET_CONFLICT:
+      if (download->GetWebContents()) {
+        chrome::android::ChromeDownloadManagerOverwriteInfoBarDelegate::Create(
+            InfoBarService::FromWebContents(download->GetWebContents()),
+            download, suggested_path, callback);
+        return;
+      }
+    // Fallthrough
+
+    // If we cannot reserve the path and the WebContent is already gone, there
+    // is no way to prompt user for an infobar. This could happen after chrome
+    // gets killed, and user tries to resume a download while another app has
+    // created the target file (not the temporary .crdownload file).
+    case DownloadConfirmationReason::UNEXPECTED:
+      DownloadManagerService::OnDownloadCanceled(
+          download,
+          DownloadController::CANCEL_REASON_CANNOT_DETERMINE_DOWNLOAD_TARGET);
+      callback.Run(DownloadConfirmationResult::CANCELED, base::FilePath());
+      return;
+  }
+#else   // !ANDROID_JAVA_UI
   DownloadFilePicker::ShowFilePicker(download, suggested_path, callback);
-#endif
+#endif  // !ANDROID_JAVA_UI
 }
 
 void ChromeDownloadManagerDelegate::DetermineLocalPath(
     DownloadItem* download,
     const base::FilePath& virtual_path,
     const DownloadTargetDeterminerDelegate::LocalPathCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #if defined(OS_CHROMEOS)
   drive::DownloadHandler* drive_download_handler =
       drive::DownloadHandler::GetForProfile(profile_);
@@ skipping 117 matching lines @@
 
   scoped_refptr<extensions::CrxInstaller> installer =
       content::Source<extensions::CrxInstaller>(source).ptr();
   content::DownloadOpenDelayedCallback callback =
       crx_installers_[installer.get()];
   crx_installers_.erase(installer.get());
   callback.Run(installer->did_handle_successfully());
 #endif
 }
 
+namespace {
+
+content::DownloadInterruptReason TargetResultToInterruptReasonAfterCompletion(
+    DownloadTargetResult result) {
+  switch (result) {
+    case DownloadTargetResult::SUCCESS:
+      return content::DOWNLOAD_INTERRUPT_REASON_NONE;
+
+    case DownloadTargetResult::USER_CANCELED:
+      return content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
+
+    case DownloadTargetResult::NAME_TOO_LONG:
+    case DownloadTargetResult::CONFLICT:
+    case DownloadTargetResult::PATH_NOT_WRITEABLE:
+      NOTREACHED();  // These cases should've caused a confirmation prompt.
+    // fallthrough
+
+    case DownloadTargetResult::UNEXPECTED:
+      return content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED;
+  }
+  NOTREACHED();

[svaldez, 2016/10/28 17:29:35]

Can these lines be removed so that there's a compile warning whenever new
DownloadTargetResult values are added without this switch being updated?

[asanka, 2016/11/07 19:50:15]

This is already the case. I.e. the switch above still needs to be exhaustive for
the compilation to succeed.

The extra lines are here to appease clang which complains that control reaches
end of non-void function if I don't have them.

+  return content::DOWNLOAD_INTERRUPT_REASON_FILE_FAILED;
+}
+
+}  // namespace
+
 void ChromeDownloadManagerDelegate::OnDownloadTargetDetermined(
     int32_t download_id,
     const content::DownloadTargetCallback& callback,
     std::unique_ptr<DownloadTargetInfo> target_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DownloadItem* item = download_manager_->GetDownload(download_id);
   if (item) {
     if (!target_info->target_path.empty() &&
         IsOpenInBrowserPreferreredForFile(target_info->target_path) &&
         target_info->is_filetype_handled_safely)
       DownloadItemModel(item).SetShouldPreferOpeningInBrowser(true);
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
     if (item->GetOriginalMimeType() == "application/x-x509-user-cert")
       DownloadItemModel(item).SetShouldPreferOpeningInBrowser(true);
 #endif
 
     DownloadItemModel(item).SetDangerLevel(target_info->danger_level);
   }
-  callback.Run(target_info->target_path,
-               target_info->target_disposition,
-               target_info->danger_type,
-               target_info->intermediate_path);
+  callback.Run(
+      target_info->target_path, target_info->target_disposition,
+      target_info->danger_type, target_info->intermediate_path,
+      TargetResultToInterruptReasonAfterCompletion(target_info->result));
 }
 
 bool ChromeDownloadManagerDelegate::IsOpenInBrowserPreferreredForFile(
     const base::FilePath& path) {
 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
   if (path.MatchesExtension(FILE_PATH_LITERAL(".pdf"))) {
     return !download_prefs_->ShouldOpenPdfInSystemReader();
   }
 #endif
 
@@ skipping 11 matching lines @@
       path.MatchesExtension(FILE_PATH_LITERAL(".xht")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xhtm")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xhtml")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xsl")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xslt"))) {
     return true;
   }
 #endif
   return false;
 }