[Downloads] Gracefully handle SafeBrowsing check failures.

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/basictypes.h"
 #include "base/bind.h"
@@ skipping 60 matching lines @@
 
 #if defined(FULL_SAFE_BROWSING)
 
 // String pointer used for identifying safebrowing data associated with
 // a download item.
 const char kSafeBrowsingUserDataKey[] = "Safe Browsing ID";
 
 // The state of a safebrowsing check.
 class SafeBrowsingState : public DownloadCompletionBlocker {
  public:
-  SafeBrowsingState()
-    : verdict_(DownloadProtectionService::SAFE) {
-  }
-
+  SafeBrowsingState() {}
   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() {}
 
 #endif  // FULL_SAFE_BROWSING
 
 // Used with GetPlatformDownloadPath() to indicate which platform path to
 // return.
 enum PlatformDownloadPathType {
@@ skipping 41 matching lines @@
 // Danger type is (in order of preference):
 //   * DANGEROUS_URL, if the URL is a known malware site.
 //   * MAYBE_DANGEROUS_CONTENT, if the content will be scanned for
 //         malware. I.e. |is_content_check_supported| is true.
 //   * NOT_DANGEROUS.
 void CheckDownloadUrlDone(
     const DownloadTargetDeterminerDelegate::CheckDownloadUrlCallback& callback,
     bool is_content_check_supported,
     DownloadProtectionService::DownloadCheckResult result) {
   content::DownloadDangerType danger_type;
-  if (result == DownloadProtectionService::SAFE) {
+  if (result == DownloadProtectionService::SAFE ||
+      result == DownloadProtectionService::UNKNOWN) {
     // If this type of files is handled by the enhanced SafeBrowsing download
     // protection, mark it as potentially dangerous content until we are done
     // with scanning it.
     if (is_content_check_supported)
       danger_type = content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT;
     else
       danger_type = content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS;
   } else {
     // If the URL is malicious, we'll use that as the danger type. The results
     // of the content check, if one is performed, will be ignored.
@@ skipping 113 matching lines @@
 // static
 void ChromeDownloadManagerDelegate::DisableSafeBrowsing(DownloadItem* item) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #if defined(FULL_SAFE_BROWSING)
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetUserData(&kSafeBrowsingUserDataKey));
   if (!state) {
     state = new SafeBrowsingState();
     item->SetUserData(&kSafeBrowsingUserDataKey, state);
   }
-  state->SetVerdict(DownloadProtectionService::SAFE);
+  state->CompleteDownload();
 #endif
 }
 
 bool ChromeDownloadManagerDelegate::IsDownloadReadyForCompletion(
     DownloadItem* item,
     const base::Closure& internal_complete_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 #if defined(FULL_SAFE_BROWSING)
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetUserData(&kSafeBrowsingUserDataKey));
   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->set_callback(internal_complete_callback);
       item->SetUserData(&kSafeBrowsingUserDataKey, state);
       service->CheckClientDownload(
           item,
-          base::Bind(
-              &ChromeDownloadManagerDelegate::CheckClientDownloadDone,
-              weak_ptr_factory_.GetWeakPtr(),
-              item->GetId()));
+          base::Bind(&ChromeDownloadManagerDelegate::CheckClientDownloadDone,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     item->GetId()));
+      return false;
+    }
+
+    // In case the service was disabled between the download starting and now,
+    // we need to restore the danger state.
+    content::DownloadDangerType danger_type = item->GetDangerType();
+    if (DownloadItemModel(item).IsDangerousFileBasedOnType() &&
+        (danger_type == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS ||
+         danger_type ==
+             content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)) {
+      DVLOG(2) << __FUNCTION__
+               << "() SB service disabled. Marking download as DANGEROUS FILE";
+      item->OnContentCheckCompleted(
+          content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE);
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI, FROM_HERE, internal_complete_callback);
       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
   return true;
 }
 
 void ChromeDownloadManagerDelegate::ShouldCompleteDownloadInternal(
     uint32 download_id,
     const base::Closure& user_complete_callback) {
   DownloadItem* item = download_manager_->GetDownload(download_id);
   if (!item)
     return;
@@ skipping 290 matching lines @@
   VLOG(2) << __FUNCTION__ << "() download = " << item->DebugString(false)
           << " verdict = " << result;
   // We only mark the content as being dangerous if the download's safety state
   // has not been set to DANGEROUS yet.  We don't want to show two warnings.
   if (item->GetDangerType() == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS ||
       item->GetDangerType() ==
       content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT) {
     content::DownloadDangerType danger_type =
         content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS;
     switch (result) {
+      case DownloadProtectionService::UNKNOWN:
+        // The check failed or was inconclusive.
+        if (DownloadItemModel(item).IsDangerousFileBasedOnType())
+          danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
+        break;
       case DownloadProtectionService::SAFE:
         // Do nothing.
         break;
       case DownloadProtectionService::DANGEROUS:
         danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT;
         break;
       case DownloadProtectionService::UNCOMMON:
         danger_type = content::DOWNLOAD_DANGER_TYPE_UNCOMMON_CONTENT;
         break;
       case DownloadProtectionService::DANGEROUS_HOST:
         danger_type = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST;
         break;
       case DownloadProtectionService::POTENTIALLY_UNWANTED:
         danger_type = content::DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED;
         break;
     }
 
     if (danger_type != content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
       item->OnContentCheckCompleted(danger_type);
   }
 
   SafeBrowsingState* state = static_cast<SafeBrowsingState*>(
       item->GetUserData(&kSafeBrowsingUserDataKey));
-  state->SetVerdict(result);
+  state->CompleteDownload();
 }
 #endif  // FULL_SAFE_BROWSING
 
 // content::NotificationObserver implementation.
 void ChromeDownloadManagerDelegate::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
 #if defined(ENABLE_EXTENSIONS)
   DCHECK(type == extensions::NOTIFICATION_CRX_INSTALLER_DONE);
 
   registrar_.Remove(this, extensions::NOTIFICATION_CRX_INSTALLER_DONE, source);
 
   scoped_refptr<extensions::CrxInstaller> installer =
       content::Source<extensions::CrxInstaller>(source).ptr();
   content::DownloadOpenDelayedCallback callback =
       crx_installers_[installer.get()];
   crx_installers_.erase(installer.get());
   callback.Run(installer->did_handle_successfully());
 #endif
 }
 
 void ChromeDownloadManagerDelegate::OnDownloadTargetDetermined(
     int32 download_id,
     const content::DownloadTargetCallback& callback,
     scoped_ptr<DownloadTargetInfo> target_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* item = download_manager_->GetDownload(download_id);
-  if (!target_info->target_path.empty() && item &&
-      IsOpenInBrowserPreferreredForFile(target_info->target_path) &&
-      target_info->is_filetype_handled_safely)
-    DownloadItemModel(item).SetShouldPreferOpeningInBrowser(true);
+  if (item) {
+    if (!target_info->target_path.empty() &&
+        IsOpenInBrowserPreferreredForFile(target_info->target_path) &&
+        target_info->is_filetype_handled_safely)
+      DownloadItemModel(item).SetShouldPreferOpeningInBrowser(true);
+
+    if (target_info->is_dangerous_file)
+      DownloadItemModel(item).SetIsDangerousFileBasedOnType(true);
+  }
   callback.Run(target_info->target_path,
                target_info->target_disposition,
                target_info->danger_type,
                target_info->intermediate_path);
 }
 
 bool ChromeDownloadManagerDelegate::IsOpenInBrowserPreferreredForFile(
     const base::FilePath& path) {
   // On Windows, PDFs should open in Acrobat Reader if the user chooses.
 #if defined(OS_WIN)
@@ skipping 17 matching lines @@
       path.MatchesExtension(FILE_PATH_LITERAL(".xht")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xhtm")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xhtml")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xsl")) ||
       path.MatchesExtension(FILE_PATH_LITERAL(".xslt"))) {
     return true;
   }
 #endif
   return false;
 }