[Downloads] Gracefully handle SafeBrowsing check failures.

chrome/browser/download/download_target_determiner.cc

 // Copyright 2013 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/download_target_determiner.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
@@ skipping 71 matching lines @@
     const base::FilePath& initial_virtual_path,
     DownloadPrefs* download_prefs,
     DownloadTargetDeterminerDelegate* delegate,
     const CompletionCallback& callback)
     : next_state_(STATE_GENERATE_TARGET_PATH),
       should_prompt_(false),
       should_notify_extensions_(false),
       create_target_directory_(false),
       conflict_action_(DownloadPathReservationTracker::OVERWRITE),
       danger_type_(download->GetDangerType()),
+      is_dangerous_file_(false),
       virtual_path_(initial_virtual_path),
       is_filetype_handled_safely_(false),
       download_(download),
       is_resumption_(download_->GetLastReason() !=
                          content::DOWNLOAD_INTERRUPT_REASON_NONE &&
                      !initial_virtual_path.empty()),
       download_prefs_(download_prefs),
       delegate_(delegate),
       completion_callback_(callback),
       weak_ptr_factory_(this) {
@@ skipping 467 matching lines @@
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoCheckVisitedReferrerBefore() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   next_state_ = STATE_DETERMINE_INTERMEDIATE_PATH;
 
   // Checking if there are prior visits to the referrer is only necessary if the
-  // danger level of the download depends on the file type. This excludes cases
-  // where the download has already been deemed dangerous, or where the user is
-  // going to be prompted or where this is a programmatic download.
-  if (danger_type_ != content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
+  // danger level of the download depends on the file type.
+  if (danger_type_ != content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS &&
+      danger_type_ != content::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT)
     return CONTINUE;
 
   // Assume that:
   // IsDangerousFile(VISITED_REFERRER) => IsDangerousFile(NO_VISITS_...)
   // I.e. having visited a referrer only lowers a file's danger level.
   if (IsDangerousFile(NO_VISITS_TO_REFERRER)) {
     // Only need to ping the history DB if the download would be considered safe
     // if there are prior visits and is considered dangerous otherwise.
     if (!IsDangerousFile(VISITED_REFERRER)) {
       // HistoryServiceFactory redirects incognito profiles to on-record
@@ skipping 10 matching lines @@
                     &DownloadTargetDeterminer::CheckVisitedReferrerBeforeDone,
                     weak_ptr_factory_.GetWeakPtr())),
             &history_tracker_);
         return QUIT_DOLOOP;
       }
     }
 
     // If the danger level doesn't depend on having visited the refererrer URL
     // or if original profile doesn't have a HistoryService or the referrer url
     // is invalid, then assume the referrer has not been visited before.
-    danger_type_ = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
+    is_dangerous_file_ = true;
   }
   return CONTINUE;
 }
 
 void DownloadTargetDeterminer::CheckVisitedReferrerBeforeDone(
     bool visited_referrer_before) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(STATE_DETERMINE_INTERMEDIATE_PATH, next_state_);
   if (IsDangerousFile(
           visited_referrer_before ? VISITED_REFERRER : NO_VISITS_TO_REFERRER))
-    danger_type_ = content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE;
+    is_dangerous_file_ = true;
   DoLoop();
 }
 
 DownloadTargetDeterminer::Result
     DownloadTargetDeterminer::DoDetermineIntermediatePath() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!virtual_path_.empty());
   DCHECK(!local_path_.empty());
   DCHECK(intermediate_path_.empty());
   DCHECK(!virtual_path_.MatchesExtension(kCrdownloadSuffix));
@@ skipping 73 matching lines @@
             << " Intermediate:" << intermediate_path_.AsUTF8Unsafe()
             << " Should prompt:" << should_prompt_
             << " Danger type:" << danger_type_;
   scoped_ptr<DownloadTargetInfo> target_info(new DownloadTargetInfo);
 
   target_info->target_path = local_path_;
   target_info->target_disposition =
       (HasPromptedForPath() || should_prompt_
            ? DownloadItem::TARGET_DISPOSITION_PROMPT
            : DownloadItem::TARGET_DISPOSITION_OVERWRITE);
-  target_info->danger_type = danger_type_;
+  target_info->danger_type =
+      (is_dangerous_file_ &&
+       danger_type_ == content::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS)
+          ? content::DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE
+          : danger_type_;
+  target_info->is_dangerous_file = is_dangerous_file_;
   target_info->intermediate_path = intermediate_path_;
   target_info->mime_type = mime_type_;
   target_info->is_filetype_handled_safely = is_filetype_handled_safely_;
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(completion_callback_, base::Passed(&target_info)));
   completion_callback_.Reset();
   delete this;
 }
 
@@ skipping 150 matching lines @@
     const base::FilePath& suggested_path) {
   return base::FilePath(suggested_path.value() + kCrdownloadSuffix);
 }
 
 #if defined(OS_WIN)
 // static
 bool DownloadTargetDeterminer::IsAdobeReaderUpToDate() {
   return g_is_adobe_reader_up_to_date_;
 }
 #endif