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"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/download/download_completion_blocker.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_extensions.h"
 #include "chrome/browser/download/download_file_picker.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/download/download_status_updater.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/browser/download/save_package_file_picker.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 34 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 {
-  // If true the SafeBrowsing check is not done yet.
-  bool pending;
-  // The verdict that we got from calling CheckClientDownload.
-  safe_browsing::DownloadProtectionService::DownloadCheckResult verdict;
+class SafeBrowsingState : public DownloadCompletionBlocker {
+ public:
+  SafeBrowsingState()
+    : verdict_(DownloadProtectionService::SAFE) {
+  }
+
+  virtual ~SafeBrowsingState();
+
+  // The verdict that we got from calling CheckClientDownload. Only valid to
+  // call if |is_complete()|.
+  DownloadProtectionService::DownloadCheckResult verdict() const {
+    return verdict_;
+  }
+
+  void SetVerdict(DownloadProtectionService::DownloadCheckResult result) {
+    verdict_ = result;
+    CompleteDownload();
+  }
+
+ private:
+  DownloadProtectionService::DownloadCheckResult verdict_;
+
+  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 106 matching lines @@
   DCHECK(extension[0] == FilePath::kExtensionSeparator);
   extension.erase(0, 1);
   return download_prefs_->IsAutoOpenEnabledForExtension(extension);
 }
 
 // static
 void ChromeDownloadManagerDelegate::DisableSafeBrowsing(DownloadItem* item) {
 #if defined(ENABLE_SAFE_BROWSING)
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetExternalData(&safe_browsing_id));
-  DCHECK(state == NULL);
-  if (state == NULL) {
+  DCHECK(!state);
+  if (!state)
     state = new SafeBrowsingState();
-    item->SetExternalData(&safe_browsing_id, state);
-  }
-  state->pending = false;
-  state->verdict = DownloadProtectionService::SAFE;
+  state->SetVerdict(DownloadProtectionService::SAFE);
+  item->SetExternalData(&safe_browsing_id, state);
 #endif
 }
 
-bool ChromeDownloadManagerDelegate::ShouldCompleteDownload(DownloadItem* item) {
+bool ChromeDownloadManagerDelegate::IsDownloadReadyForCompletion(
+    DownloadItem* item,
+    const base::Closure& internal_complete_callback) {
 #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));
-  // Don't complete the download until we have an answer.
-  if (state && state->pending)
-    return false;
-
-  if (state == NULL) {
+  if (!state) {
     // 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->set_callback(internal_complete_callback);
       item->SetExternalData(&safe_browsing_id, state);
       service->CheckClientDownload(
           DownloadProtectionService::DownloadInfo::FromDownloadItem(*item),
           base::Bind(
               &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
               this,
               item->GetId()));
       return false;
     }
+  } else if (!state->is_complete()) {
+    // Don't complete the download until we have an answer.
+    state->set_callback(internal_complete_callback);
+    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, internal_complete_callback))
     return false;
 #endif
   return true;
 }
 
+// ShouldCompleteDownloadInternal() will never be called directly by a user, it
+// will only be called asynchronously, so it should run
+// |user_complete_callback|. ShouldCompleteDownload() will only be called
+// directly by a user, so it does not need to run |user_complete_callback|
+// because it can return true synchronously. The two methods look very similar,
+// but their semantics are very different.
+
+void ChromeDownloadManagerDelegate::ShouldCompleteDownloadInternal(
+    int download_id,
+    const base::Closure& user_complete_callback) {
+  DownloadItem* item = download_manager_->GetActiveDownloadItem(download_id);
+  if (!item)
+    return;
+  if (IsDownloadReadyForCompletion(item, base::Bind(
+        &ChromeDownloadManagerDelegate::ShouldCompleteDownloadInternal, this,
+        download_id, user_complete_callback)))
+    user_complete_callback.Run();
+}
+
+bool ChromeDownloadManagerDelegate::ShouldCompleteDownload(
+    DownloadItem* item,
+    const base::Closure& user_complete_callback) {
+  return IsDownloadReadyForCompletion(item, base::Bind(
+      &ChromeDownloadManagerDelegate::ShouldCompleteDownloadInternal, this,
+      item->GetId(), user_complete_callback));
+}
+
 bool ChromeDownloadManagerDelegate::ShouldOpenDownload(DownloadItem* item) {
   if (IsExtensionDownload(item)) {
     // We can open extensions if either they came from the store, or
     // off-store-install is enabled.
     if (extensions::switch_utils::IsOffStoreInstallEnabled() ||
         WebstoreInstaller::GetAssociatedApproval(*item)) {
       scoped_refptr<CrxInstaller> crx_installer =
           download_crx_util::OpenChromeExtension(profile_, *item);
 
       // CRX_INSTALLER_DONE will fire when the install completes.  Observe()
@@ skipping 201 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->SetVerdict(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 235 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);
 }