[Downloads] Allow acquiring dangerous download file.

content/public/browser/download_item.h

 // 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.
 //
 // Each download is represented by a DownloadItem, and all DownloadItems
 // are owned by the DownloadManager which maintains a global list of all
 // downloads. DownloadItems are created when a user initiates a download,
 // and exist for the duration of the browser life time.
 //
 // Download observers:
 //   DownloadItem::Observer:
 //     - allows observers to receive notifications about one download from start
 //       to completion
 // Use AddObserver() / RemoveObserver() on the appropriate download object to
 // receive state updates.
 
 #ifndef CONTENT_PUBLIC_BROWSER_DOWNLOAD_ITEM_H_
 #define CONTENT_PUBLIC_BROWSER_DOWNLOAD_ITEM_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/string16.h"
 #include "base/supports_user_data.h"
 #include "content/public/browser/download_danger_type.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/common/page_transition_types.h"
 
 class GURL;
 
 namespace base {
@@ skipping 40 matching lines @@
   };
 
   // How the final target path should be used.
   enum TargetDisposition {
     TARGET_DISPOSITION_OVERWRITE, // Overwrite if the target already exists.
     TARGET_DISPOSITION_PROMPT     // Prompt the user for the actual
                                   // target. Implies
                                   // TARGET_DISPOSITION_OVERWRITE.
   };
 
+  // Callback used with AcquireFileAndDeleteDownload().
+  typedef base::Callback<void(const base::FilePath&)> AcquireFileCallback;
+
   static const char kEmptyFileHash[];
 
   // Interface that observers of a particular download must implement in order
   // to receive updates to the download's status.
   class CONTENT_EXPORT Observer {
    public:
     virtual void OnDownloadUpdated(DownloadItem* download) {}
     virtual void OnDownloadOpened(DownloadItem* download) {}
     virtual void OnDownloadRemoved(DownloadItem* download) {}
 
@@ skipping 10 matching lines @@
 
   // Observation ---------------------------------------------------------------
 
   virtual void AddObserver(DownloadItem::Observer* observer) = 0;
   virtual void RemoveObserver(DownloadItem::Observer* observer) = 0;
   virtual void UpdateObservers() = 0;
 
   // User Actions --------------------------------------------------------------
 
   // Called when the user has validated the download of a dangerous file.
-  virtual void DangerousDownloadValidated() = 0;
+  virtual void ValidateDangerousDownload() = 0;
 
   // Pause a download.  Will have no effect if the download is already
   // paused.
   virtual void Pause() = 0;
 
   // Resume a download that has been paused or interrupted. Will have no effect
   // if the download is neither.
   virtual void Resume() = 0;
 
   // Cancel the download operation. We need to distinguish between cancels at
   // exit (DownloadManager destructor) from user interface initiated cancels
   // because at exit, the history system may not exist, and any updates to it
   // require AddRef'ing the DownloadManager in the destructor which results in
   // a DCHECK failure. Set |user_cancel| to false when canceling from at
   // exit to prevent this crash. This may result in a difference between the
   // downloaded file's size on disk, and what the history system's last record
   // of it is. At worst, we'll end up re-downloading a small portion of the file
   // when resuming a download (assuming the server supports byte ranges).
   virtual void Cancel(bool user_cancel) = 0;
 
   // Deletes the file from disk and removes the download from the views and
-  // history.
-  virtual void Delete(DeleteReason reason) = 0;
+  // history. If |callback| is not empty, then the downloaded file will not be
+  // deleted. Instead, the path of the file will be passed into |callback|. If
+  // the intermediate file is not available, then the returned path will be
+  // empty.
+  virtual void DiscardDangerousDownload(
+      DeleteReason reason,
+      const AcquireFileCallback& callback) = 0;
 
   // Removes the download from the views and history.
   virtual void Remove() = 0;
 
   // Open the file associated with this download.  If the download is
   // still in progress, marks the download to be opened when it is complete.
   virtual void OpenDownload() = 0;
 
   // Show the download via the OS shell.
   virtual void ShowDownloadInShell() = 0;
@@ skipping 91 matching lines @@
   virtual const std::string& GetHash() const = 0;
 
   // Intermediate hash state, for persisting partial downloads.
   virtual const std::string& GetHashState() const = 0;
 
   // True if the file associated with the download has been removed by
   // external action.
   virtual bool GetFileExternallyRemoved() const = 0;
 
   // True if the file that will be written by the download is dangerous
-  // and we will require a call to DangerousDownloadValidated() to complete.
+  // and we will require a call to ValidateDangerousDownload() to complete.
   // False if the download is safe or that function has been called.
   virtual bool IsDangerous() const = 0;
 
   // Why |safety_state_| is not SAFE.
   virtual DownloadDangerType GetDangerType() const = 0;
 
   //    Progress State accessors -----------------------------------------------
 
   // Simple calculation of the amount of time remaining to completion. Fills
   // |*remaining| with the amount of time remaining if successful. Fails and
@@ skipping 65 matching lines @@
   // return |name|. Has no effect on the final target filename.
   virtual void SetDisplayName(const base::FilePath& name) = 0;
 
   // Debug/testing -------------------------------------------------------------
   virtual std::string DebugString(bool verbose) const = 0;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_DOWNLOAD_ITEM_H_