xref: /external/chromium_org/content/public/browser/download_manager_delegate.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.

#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_