Download filename determination refactor (3/3)

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_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/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 DownloadId;
-class DownloadItem;
 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 FilePath&,
                             content::SavePageType,
                             const SavePackageDownloadCreatedCallback&)>
     SavePackagePathPickedCallback;
 
+typedef base::Callback<void(
+    const FilePath& target_path,
+    content::DownloadItem::TargetDisposition disposition,
+    content::DownloadDangerType danger_type,
+    const FilePath& intermediate_path)> DownloadTargetCallback;
+
 // 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() {}
 
   // Returns a new DownloadId.
   virtual DownloadId GetNextId();
 
-  // Notifies the delegate that a download is starting. The delegate can return
-  // false to delay the start of the download, in which case it should call
-  // DownloadManager::RestartDownload when it's ready.
-  virtual bool ShouldStartDownload(int32 download_id);
-
-  // Asks the user for the path for a download. The delegate calls
-  // DownloadManager::FileSelected or DownloadManager::FileSelectionCanceled to
-  // give the answer.
-  virtual void ChooseDownloadPath(DownloadItem* item) {}
-
-  // Allows the embedder to set an intermediate name for the download until it's
-  // complete. The return value is the intermediate path to use. If the embedder
-  // doesn't want to set an intermediate path, it should return
-  // item.GetTargetFilePath(). If there's already a file at the returned path,
-  // it will not be overwritten. Instead the path will be uniquified by adding a
-  // suffix to the filename.
-  virtual FilePath GetIntermediatePath(const DownloadItem& item);
+  // 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,
+  // possibly empty, target path.

[Randy Smith (Not in Mondays), 2012/07/12 17:01:22]

I'd like to say something about the state changes that are possible on the
DownloadItem when calling this function.  I'd *like* the answer to be "none"
(i.e. only used for external data/observers), but that doesn't allow the user to
cancel if prompted.  So I'll settle for documenting what can and can't happen. 
(Though if it appealed to you to update DownloadTargetCallback to allow
propagating a cancel that way instead, I wouldn't object :-}.)

[asanka, 2012/07/18 21:50:56]

I made a note that the state of |item| shouldn't be changed save for external
data and changed the callback logic so that an empty target_path causes the
download to be canceled. This also means that unless a target path is specified,
the download would be implicitly canceled.

+  virtual bool DetermineDownloadTarget(DownloadItem* item,
+                                       const DownloadTargetCallback& callback);
 
   // Called when the download system wants to alert a WebContents that a
   // download has started, but the TabConetnts has gone away. This lets an
   // delegate return an alternative WebContents. The delegate can return NULL.
   virtual WebContents* GetAlternativeWebContentsToNotifyForDownload();
 
   // Tests if a file type should be opened automatically.
   virtual bool ShouldOpenFileBasedOnExtension(const FilePath& path);
 
   // Allows the delegate to delay completion of the download.  This function
@@ skipping 60 matching lines @@
                               const SavePackagePathPickedCallback& callback) {
   }
 
  protected:
   virtual ~DownloadManagerDelegate();
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_