[downloads] Move platform specific code out of DownloadTargetDeterminer.

chrome/browser/download/download_target_determiner.h

 // 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.
 
 #ifndef CHROME_BROWSER_DOWNLOAD_DOWNLOAD_TARGET_DETERMINER_H_
 #define CHROME_BROWSER_DOWNLOAD_DOWNLOAD_TARGET_DETERMINER_H_
 
 #include <memory>
+#include <string>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/download_path_reservation_tracker.h"
 #include "chrome/browser/download/download_target_determiner_delegate.h"
 #include "chrome/browser/download/download_target_info.h"
@@ skipping 29 matching lines @@
 // determining the download target. It observes the DownloadItem and aborts the
 // process if the download is removed. DownloadTargetDeterminerDelegate is
 // responsible for providing external dependencies and prompting the user if
 // necessary.
 //
 // The only public entrypoint is the static Start() method which creates an
 // instance of DownloadTargetDeterminer.
 class DownloadTargetDeterminer
     : public content::DownloadItem::Observer {
  public:
-  typedef base::Callback<void(std::unique_ptr<DownloadTargetInfo>)>
-      CompletionCallback;
+  using CompletionCallback =
+      base::Callback<void(std::unique_ptr<DownloadTargetInfo>)>;
 
   // Start the process of determing the target of |download|.
   //
   // |initial_virtual_path| if non-empty, defines the initial virtual path for
   //   the target determination process. If one isn't specified, one will be
   //   generated based on the response data specified in |download| and the
   //   users' downloads directory.
   //   Note: |initial_virtual_path| is only used if download has prompted the
   //       user before and doesn't have a forced path.
   // |download_prefs| is required and must outlive |download|. It is used for
   //   determining the user's preferences regarding the default downloads
   //   directory, prompting and auto-open behavior.
   // |delegate| is required and must live until |callback| is invoked.
   // |callback| will be scheduled asynchronously on the UI thread after download
   //   determination is complete or after |download| is destroyed.
   //
   // Start() should be called on the UI thread.
-  static void Start(content::DownloadItem* download,
-                    const base::FilePath& initial_virtual_path,
-                    DownloadPrefs* download_prefs,
-                    DownloadTargetDeterminerDelegate* delegate,
-                    const CompletionCallback& callback);
+  static void Start(
+      content::DownloadItem* download,
+      const base::FilePath& initial_virtual_path,
+      DownloadPathReservationTracker::FilenameConflictAction conflict_action,
+      DownloadPrefs* download_prefs,
+      DownloadTargetDeterminerDelegate* delegate,
+      const CompletionCallback& callback);
 
   // Returns a .crdownload intermediate path for the |suggested_path|.
   static base::FilePath GetCrDownloadPath(const base::FilePath& suggested_path);
 
 #if defined(OS_WIN)
   // Returns true if Adobe Reader is up to date. This information refreshed
   // only when Start() gets called for a PDF and Adobe Reader is the default
   // System PDF viewer.
   static bool IsAdobeReaderUpToDate();
 #endif
@@ skipping 38 matching lines @@
 
   // Used with GetDangerLevel to indicate whether the user has visited the
   // referrer URL for the download prior to today.
   enum PriorVisitsToReferrer {
     NO_VISITS_TO_REFERRER,
     VISITED_REFERRER,
   };
 
   // Construct a DownloadTargetDeterminer object. Constraints on the arguments
   // are as per Start() above.
-  DownloadTargetDeterminer(content::DownloadItem* download,
-                           const base::FilePath& initial_virtual_path,
-                           DownloadPrefs* download_prefs,
-                           DownloadTargetDeterminerDelegate* delegate,
-                           const CompletionCallback& callback);
+  DownloadTargetDeterminer(
+      content::DownloadItem* download,
+      const base::FilePath& initial_virtual_path,
+      DownloadPathReservationTracker::FilenameConflictAction conflict_action,
+      DownloadPrefs* download_prefs,
+      DownloadTargetDeterminerDelegate* delegate,
+      const CompletionCallback& callback);
 
   ~DownloadTargetDeterminer() override;
 
   // Invoke each successive handler until a handler returns QUIT_DOLOOP or
   // COMPLETE. Note that as a result, this object might be deleted. So |this|
   // should not be accessed after calling DoLoop().
   void DoLoop();
 
   // === Main workflow ===
 
@@ skipping 17 matching lines @@
       const base::FilePath& new_path,
       DownloadPathReservationTracker::FilenameConflictAction conflict_action);
 
   // Invokes ReserveVirtualPath() on the delegate to acquire a reservation for
   // the path. See DownloadPathReservationTracker.
   // Next state:
   // - STATE_PROMPT_USER_FOR_DOWNLOAD_PATH.
   Result DoReserveVirtualPath();
 
   // Callback invoked after the delegate aquires a path reservation.
-  void ReserveVirtualPathDone(const base::FilePath& path, bool verified);
+  void ReserveVirtualPathDone(PathValidationResult result,
+                              const base::FilePath& path);
 
   // Presents a file picker to the user if necessary.
   // Next state:
   // - STATE_DETERMINE_LOCAL_PATH.
-  Result DoPromptUserForDownloadPath();
+  Result DoRequestConfirmation();
 
   // Callback invoked after the file picker completes. Cancels the download if
   // the user cancels the file picker.
-  void PromptUserForDownloadPathDone(const base::FilePath& virtual_path);
+  void RequestConfirmationDone(DownloadConfirmationResult result,
+                               const base::FilePath& virtual_path);
 
   // Up until this point, the path that was used is considered to be a virtual
   // path. This step determines the local file system path corresponding to this
   // virtual path. The translation is done by invoking the DetermineLocalPath()
   // method on the delegate.
   // Next state:
   // - STATE_DETERMINE_MIME_TYPE.
   Result DoDetermineLocalPath();
 
   // Callback invoked when the delegate has determined local path.
@@ skipping 61 matching lines @@
   // target determination is complete. The determination assumes that the
   // intermediate file will never be overwritten (always uniquified if needed).
   // Next state:
   // - STATE_NONE: Returns COMPLETE.
   Result DoDetermineIntermediatePath();
 
   // === End of main workflow ===
 
   // Utilities:
 
-  void ScheduleCallbackAndDeleteSelf();
-
-  void CancelOnFailureAndDeleteSelf();
+  // Schedules the completion callback to be run on the UI thread and deletes
+  // this object. The determined target info will be passed into the callback
+  // if |interrupt_reason| is NONE. Otherwise, only the interrupt reason will be
+  // passed on.
+  void ScheduleCallbackAndDeleteSelf(content::DownloadInterruptReason result);
 
   Profile* GetProfile() const;
 
   // Determine whether to prompt the user for the download location. For regular
   // downloads, this determination is based on the target disposition, auto-open
   // behavior, among other factors. For an interrupted download, this
   // determination will be based on the interrupt reason. It is assumed that
   // download interruptions always occur after the first round of download
   // target determination is complete.
-  bool ShouldPromptForDownload(const base::FilePath& filename) const;
+  DownloadConfirmationReason ShouldPromptForDownload(
+      const base::FilePath& filename) const;
 
   // Returns true if the user has been prompted for this download at least once
   // prior to this target determination operation. This method is only expected
   // to return true for a resuming interrupted download that has prompted the
   // user before interruption. The return value does not depend on whether the
   // user will be or has been prompted during the current target determination
   // operation.
   bool HasPromptedForPath() const;
 
   // Returns true if this download should show the "dangerous file" warning.
   // Various factors are considered, such as the type of the file, whether a
   // user action initiated the download, and whether the user has explicitly
   // marked the file type as "auto open". Protected virtual for testing.
   //
   // If |require_explicit_consent| is non-null then the pointed bool will be set
   // to true if the download requires explicit user consent.
   safe_browsing::DownloadFileType::DangerLevel GetDangerLevel(
       PriorVisitsToReferrer visits) const;
 
   // content::DownloadItem::Observer
   void OnDownloadDestroyed(content::DownloadItem* download) override;
 
   // state
   State next_state_;
-  bool should_prompt_;
+  DownloadConfirmationReason confirmation_reason_;
   bool should_notify_extensions_;
   bool create_target_directory_;
   DownloadPathReservationTracker::FilenameConflictAction conflict_action_;
   content::DownloadDangerType danger_type_;
   safe_browsing::DownloadFileType::DangerLevel danger_level_;
   base::FilePath virtual_path_;
   base::FilePath local_path_;
   base::FilePath intermediate_path_;
   std::string mime_type_;
   bool is_filetype_handled_safely_;
 
   content::DownloadItem* download_;
   const bool is_resumption_;
   DownloadPrefs* download_prefs_;
   DownloadTargetDeterminerDelegate* delegate_;
   CompletionCallback completion_callback_;
   base::CancelableTaskTracker history_tracker_;
 
   base::WeakPtrFactory<DownloadTargetDeterminer> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadTargetDeterminer);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_DOWNLOAD_TARGET_DETERMINER_H_