DownloadManagerDelegate::ShouldCompleteDownload(callback)

chrome/browser/download/chrome_download_manager_delegate.cc

 // 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.
 
 #include "chrome/browser/download/chrome_download_manager_delegate.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 51 matching lines @@
 using content::WebContents;
 using safe_browsing::DownloadProtectionService;
 
 namespace {
 
 // String pointer used for identifying safebrowing data associated with
 // a download item.
 static const char safe_browsing_id[] = "Safe Browsing ID";
 
 // The state of a safebrowsing check.
-struct SafeBrowsingState : public DownloadItem::ExternalData {
+class SafeBrowsingState : public DownloadItem::ExternalData {
+ public:
+  explicit SafeBrowsingState(const base::Closure& complete_cb)
+    : pending_(true),
+      verdict_(DownloadProtectionService::SAFE),
+      complete_cb_(complete_cb) {
+  }
+
+  virtual ~SafeBrowsingState();
+
   // If true the SafeBrowsing check is not done yet.
-  bool pending;
+  bool pending() const { return pending_; }
+
   // The verdict that we got from calling CheckClientDownload.
-  safe_browsing::DownloadProtectionService::DownloadCheckResult verdict;
+  DownloadProtectionService::DownloadCheckResult verdict() const {
+    return verdict_;
+  }
+
+  // |cb| will be run when CompleteDownload() is called.
+  void set_complete_callback(const base::Closure& cb) {
+    // Be very careful to avoid calling cb twice, or more than one cb!
+    if (pending())
+      complete_cb_ = cb;
+  }
+
+  void CompleteDownload(DownloadProtectionService::DownloadCheckResult result) {
+    pending_ = false;
+    verdict_ = result;
+    if (!complete_cb_.is_null()) {
+      complete_cb_.Run();
+      complete_cb_.Reset();
+    }
+  }
+
+ private:
+  bool pending_;
+  DownloadProtectionService::DownloadCheckResult verdict_;
+  base::Closure complete_cb_;
+
+  DISALLOW_COPY_AND_ASSIGN(SafeBrowsingState);
 };
 
+SafeBrowsingState::~SafeBrowsingState() {}
+
 }  // namespace
 
 ChromeDownloadManagerDelegate::ChromeDownloadManagerDelegate(Profile* profile)
     : profile_(profile),
       next_download_id_(0),
       download_prefs_(new DownloadPrefs(profile->GetPrefs())) {
 }
 
 ChromeDownloadManagerDelegate::~ChromeDownloadManagerDelegate() {
 }
@@ skipping 58 matching lines @@
   CheckDownloadUrlDone(download_id, DownloadProtectionService::SAFE);
   return false;
 }
 
 void ChromeDownloadManagerDelegate::ChooseDownloadPath(
     WebContents* web_contents,
     const FilePath& suggested_path,
     int32 download_id) {
   // Deletes itself.
 #if defined(OS_CHROMEOS)
-  new DownloadFilePickerChromeOS(
+  new DownloadFilePickerChromeOS
 #else
-  new DownloadFilePicker(
+  new DownloadFilePicker
 #endif
-      download_manager_, web_contents, suggested_path, download_id);
+      (download_manager_, web_contents, suggested_path, download_id);
 }
 
 FilePath ChromeDownloadManagerDelegate::GetIntermediatePath(
     const FilePath& suggested_path) {
   return download_util::GetCrDownloadPath(suggested_path);
 }
 
 WebContents* ChromeDownloadManagerDelegate::
     GetAlternativeWebContentsToNotifyForDownload() {
 #if defined(OS_ANDROID)
@@ skipping 14 matching lines @@
   FilePath::StringType extension = path.Extension();
   if (extension.empty())
     return false;
   if (Extension::IsExtension(path))
     return false;
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   return download_prefs_->IsAutoOpenEnabledForExtension(extension);
 }
 
-bool ChromeDownloadManagerDelegate::ShouldCompleteDownload(DownloadItem* item) {
+bool ChromeDownloadManagerDelegate::ShouldCompleteDownload(
+    DownloadItem* item,
+    const base::Closure& complete_cb) {
 #if defined(ENABLE_SAFE_BROWSING)
   // See if there is already a pending SafeBrowsing check for that download.
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetExternalData(&safe_browsing_id));
-  if (state)
+  if (state) {
+    // Allow calling ShouldCompleteDownload() first with a null callback, then
+    // with a non-null callback.
+    if (!complete_cb.is_null())

[Randy Smith (Not in Mondays), 2012/05/01 18:21:49]

Same comment as for gdata; why not pass along a null callback?  It feels like
you're violating your interface (that last complete_cb wins) if you don't.

[benjhayden, 2012/05/01 19:00:30]

"You can't unset it once you set it" was supposed to clarify the interface. See
my response to the other version of this comment.

+      state->set_complete_callback(complete_cb);
+
     // Don't complete the download until we have an answer.
-    return !state->pending;
+    return !state->pending();

[Randy Smith (Not in Mondays), 2012/05/01 18:21:49]

nit, suggestion: Naively, I'd expect this code not to set complete_cb if it
returns true.  I don't think it matters in terms of behavior, but it seems a
little weird to do.

[benjhayden, 2012/05/01 19:00:30]

Done.

+  }
 
   // Begin the safe browsing download protection check.
   DownloadProtectionService* service = GetDownloadProtectionService();
   if (service) {
     VLOG(2) << __FUNCTION__ << "() Start SB download check for download = "
             << item->DebugString(false);
-    state = new SafeBrowsingState();
-    state->pending = true;
-    state->verdict = DownloadProtectionService::SAFE;
+    state = new SafeBrowsingState(complete_cb);
     item->SetExternalData(&safe_browsing_id, state);
     service->CheckClientDownload(
         DownloadProtectionService::DownloadInfo::FromDownloadItem(*item),
         base::Bind(
             &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
             this,
             item->GetId()));
     return false;
   }
 #endif
 #if defined(OS_CHROMEOS)
   // If there's a GData upload associated with this download, we wait until that
   // is complete before allowing the download item to complete.
-  if (!gdata::GDataDownloadObserver::IsReadyToComplete(item))
+  if (!gdata::GDataDownloadObserver::IsReadyToComplete(
+        item, complete_cb))
     return false;
 #endif
   return true;
 }
 
 bool ChromeDownloadManagerDelegate::ShouldOpenDownload(DownloadItem* item) {
   if (IsExtensionDownload(item)) {
     scoped_refptr<CrxInstaller> crx_installer =
         download_crx_util::OpenChromeExtension(profile_, *item);
 
@@ skipping 203 matching lines @@
         item->SetDangerType(content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT);
         break;
       case DownloadProtectionService::UNCOMMON:
         item->SetDangerType(content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT);
         break;
     }
   }
 
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetExternalData(&safe_browsing_id));
-  DCHECK(state);
-  if (state) {
-    state->pending = false;
-    state->verdict = result;
-  }
-  item->MaybeCompleteDownload();
+  state->CompleteDownload(result);
 }
 
 // content::NotificationObserver implementation.
 void ChromeDownloadManagerDelegate::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_CRX_INSTALLER_DONE);
 
   registrar_.Remove(this,
@@ skipping 234 matching lines @@
     int32 download_id, int64 db_handle) {
   // It's not immediately obvious, but HistoryBackend::CreateDownload() can
   // call this function with an invalid |db_handle|. For instance, this can
   // happen when the history database is offline. We cannot have multiple
   // DownloadItems with the same invalid db_handle, so we need to assign a
   // unique |db_handle| here.
   if (db_handle == DownloadItem::kUninitializedHandle)
     db_handle = download_history_->GetNextFakeDbHandle();
   download_manager_->OnItemAddedToPersistentStore(download_id, db_handle);
 }