| // 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. |
| |
| #ifndef CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_ |
| #define CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_ |
| |
| #include "base/basictypes.h" |
| #include "base/callback.h" |
| #include "base/files/file_path.h" |
| #include "base/logging.h" |
| #include "base/time/time.h" |
| #include "content/common/content_export.h" |
| #include "content/public/browser/download_danger_type.h" |
| #include "content/public/browser/download_item.h" |
| #include "content/public/browser/save_page_type.h" |
| |
| namespace content { |
| |
| class BrowserContext; |
| class WebContents; |
| |
| // Called by SavePackage when it creates a DownloadItem. |
| typedef base::Callback<void(DownloadItem*)> |
| SavePackageDownloadCreatedCallback; |
| |
| // Will be called asynchronously with the results of the ChooseSavePath |
| // operation. If the delegate wants notification of the download item created |
| // in response to this operation, the SavePackageDownloadCreatedCallback will be |
| // non-null. |
| typedef base::Callback<void(const base::FilePath&, |
| SavePageType, |
| const SavePackageDownloadCreatedCallback&)> |
| SavePackagePathPickedCallback; |
| |
| // Called with the results of DetermineDownloadTarget(). If the delegate decides |
| // to cancel the download, then |target_path| should be set to an empty path. If |
| // |target_path| is non-empty, then |intermediate_path| is required to be |
| // non-empty and specify the path to the intermediate file (which could be the |
| // same as |target_path|). Both |target_path| and |intermediate_path| are |
| // expected to in the same directory. |
| typedef base::Callback<void( |
| const base::FilePath& target_path, |
| DownloadItem::TargetDisposition disposition, |
| DownloadDangerType danger_type, |
| const base::FilePath& intermediate_path)> DownloadTargetCallback; |
| |
| // Called when a download delayed by the delegate has completed. |
| typedef base::Callback<void(bool)> DownloadOpenDelayedCallback; |
| |
| // Called with the result of CheckForFileExistence(). |
| typedef base::Callback<void(bool result)> CheckForFileExistenceCallback; |
| |
| typedef base::Callback<void(uint32)> DownloadIdCallback; |
| |
| // Browser's download manager: manages all downloads and destination view. |
| class CONTENT_EXPORT DownloadManagerDelegate { |
| public: |
| // Lets the delegate know that the download manager is shutting down. |
| virtual void Shutdown() {} |
| |
| // Runs |callback| with a new download id when possible, perhaps |
| // synchronously. |
| virtual void GetNextId(const DownloadIdCallback& callback); |
| |
| // Called to notify the delegate that a new download |item| requires a |
| // download target to be determined. The delegate should return |true| if it |
| // will determine the target information and will invoke |callback|. The |
| // callback may be invoked directly (synchronously). If this function returns |
| // |false|, the download manager will continue the download using a default |
| // target path. |
| // |
| // The state of the |item| shouldn't be modified during the process of |
| // filename determination save for external data (GetExternalData() / |
| // SetExternalData()). |
| // |
| // If the download should be canceled, |callback| should be invoked with an |
| // empty |target_path| argument. |
| virtual bool DetermineDownloadTarget(DownloadItem* item, |
| const DownloadTargetCallback& callback); |
| |
| // Tests if a file type should be opened automatically. |
| virtual bool ShouldOpenFileBasedOnExtension(const base::FilePath& path); |
| |
| // Allows the delegate to delay completion of the download. This function |
| // will either return true (in which case the download may complete) |
| // or will call the callback passed when the download is ready for |
| // completion. This routine may be called multiple times; once the callback |
| // has been called or the function has returned true for a particular |
| // download it should continue to return true for that download. |
| virtual bool ShouldCompleteDownload( |
| DownloadItem* item, |
| const base::Closure& complete_callback); |
| |
| // Allows the delegate to override opening the download. If this function |
| // returns false, the delegate needs to call callback when it's done |
| // with the item, and is responsible for opening it. This function is called |
| // after the final rename, but before the download state is set to COMPLETED. |
| virtual bool ShouldOpenDownload(DownloadItem* item, |
| const DownloadOpenDelayedCallback& callback); |
| |
| // Returns true if we need to generate a binary hash for downloads. |
| virtual bool GenerateFileHash(); |
| |
| // Retrieve the directories to save html pages and downloads to. |
| virtual void GetSaveDir(BrowserContext* browser_context, |
| base::FilePath* website_save_dir, |
| base::FilePath* download_save_dir, |
| bool* skip_dir_check) {} |
| |
| // Asks the user for the path to save a page. The delegate calls the callback |
| // to give the answer. |
| virtual void ChooseSavePath( |
| WebContents* web_contents, |
| const base::FilePath& suggested_path, |
| const base::FilePath::StringType& default_extension, |
| bool can_save_as_complete, |
| const SavePackagePathPickedCallback& callback) { |
| } |
| |
| // Opens the file associated with this download. |
| virtual void OpenDownload(DownloadItem* download) {} |
| |
| // Shows the download via the OS shell. |
| virtual void ShowDownloadInShell(DownloadItem* download) {} |
| |
| // Checks whether a downloaded file still exists. |
| virtual void CheckForFileExistence( |
| DownloadItem* download, |
| const CheckForFileExistenceCallback& callback) {} |
| |
| // Return a GUID string used for identifying the application to the |
| // system AV function for scanning downloaded files. If an empty |
| // or invalid GUID string is returned, no client identification |
| // will be given to the AV function. |
| virtual std::string ApplicationClientIdForFileScanning() const; |
| |
| protected: |
| virtual ~DownloadManagerDelegate(); |
| }; |
| |
| } // namespace content |
| |
| #endif // CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_ |