Propagate the SafeBrowsing download protection verdict to the DownloadItem.

content/browser/download/download_item.cc

 // Copyright (c) 2011 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 "content/browser/download/download_item.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/basictypes.h"
@@ skipping 74 matching lines @@
       return "REMOVING";
     case DownloadItem::INTERRUPTED:
       return "INTERRUPTED";
     default:
       NOTREACHED() << "Unknown download state " << state;
       return "unknown";
   };
 }
 
 DownloadItem::SafetyState GetSafetyState(bool dangerous_file,
-                                         bool dangerous_url) {
+                                         bool dangerous_url,
+                                         bool dangerous_content) {
+  // TODO(noelutz): At this point we can't mark the download as dangerous
+  // if it's content is dangerous because the UI doesn't yet support it.
+  // Once the UI has been changed we should return DANGEROUS when
+  // |dangerous_content| is true.
   return (dangerous_url || dangerous_file) ?
       DownloadItem::DANGEROUS : DownloadItem::SAFE;
 }
 
-// Note: When a download has both |dangerous_file| and |dangerous_url| set,
-// danger type is set to DANGEROUS_URL since the risk of dangerous URL
-// overweights that of dangerous file type.
+// Note: |dangerous_url| takes precedence over both |dangerous_content| and

[benjhayden, 2011/11/16 15:57:22]

Thank you for fixing the incorrect use of the verb "overweight" (which means to
put too much weight on or to overload), but this looks both redundant and
repetitive, and I'm not just being cute: "du before both dc and dc, and du
before dc."
Is this Note even necessary? This method is not that complicated. If you want a
comment here, perhaps explain why we're more sure of url dangers than content
dangers, and content dangers than file dangers.

+// |dangerous_content| and |dangerous_url| takes precedence over
+// |dangerous_content|.
 DownloadItem::DangerType GetDangerType(bool dangerous_file,
-                                       bool dangerous_url) {
-  if (dangerous_url) {
-    // dangerous URL overweights dangerous file. We check dangerous URL first.
+                                       bool dangerous_url,
+                                       bool dangerous_content) {
+  if (dangerous_url)
     return DownloadItem::DANGEROUS_URL;
-  }
+  if (dangerous_content)
+    return DownloadItem::DANGEROUS_CONTENT;
   return dangerous_file ?
       DownloadItem::DANGEROUS_FILE : DownloadItem::NOT_DANGEROUS;
 }
 
 // Classes to null out request handle calls (for SavePage DownloadItems, which
 // may have, e.g., Cancel() called on them without it doing anything)
 // and to DCHECK on them (for history DownloadItems, which should never have
 // any operation that implies an off-thread component, since they don't
 // have any).
 class NullDownloadRequestHandle : public DownloadRequestHandleInterface {
@@ skipping 61 matching lines @@
 }
 
 // Constructing for a regular download:
 DownloadItem::DownloadItem(DownloadManager* download_manager,
                            const DownloadCreateInfo& info,
                            DownloadRequestHandleInterface* request_handle,
                            bool is_otr)
     : state_info_(info.original_name, info.save_info.file_path,
                   info.has_user_gesture, info.transition_type,
                   info.prompt_user_for_save_location, info.path_uniquifier,
-                  false, false),
+                  false, false, false, false),
       request_handle_(request_handle),
       download_id_(info.download_id),
       full_path_(info.path),
       url_chain_(info.url_chain),
       referrer_url_(info.referrer_url),
       suggested_filename_(UTF16ToUTF8(info.save_info.suggested_name)),
       content_disposition_(info.content_disposition),
       mime_type_(info.mime_type),
       original_mime_type_(info.original_mime_type),
       referrer_charset_(info.referrer_charset),
@@ skipping 256 matching lines @@
   if (state_ == new_state)
     return;
 
   state_ = new_state;
   UpdateObservers();
 }
 
 void DownloadItem::UpdateSafetyState() {
   SafetyState updated_value(
       GetSafetyState(state_info_.is_dangerous_file,
-                     state_info_.is_dangerous_url));
+                     state_info_.is_dangerous_url,
+                     state_info_.is_dangerous_content));
   if (updated_value != safety_state_) {
     safety_state_ = updated_value;
     UpdateObservers();
   }
 }
 
 void DownloadItem::UpdateTarget() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 188 matching lines @@
 
   VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true);
   state_info_ = state;
   VLOG(20) << " " << __FUNCTION__ << "()" << " this = " << DebugString(true);
 
   UpdateSafetyState();
 }
 
 DownloadItem::DangerType DownloadItem::GetDangerType() const {
   return ::GetDangerType(state_info_.is_dangerous_file,
-                         state_info_.is_dangerous_url);
+                         state_info_.is_dangerous_url,
+                         state_info_.is_dangerous_content);
 }
 
 bool DownloadItem::IsDangerous() const {
   return GetDangerType() != DownloadItem::NOT_DANGEROUS;
 }
 
 void DownloadItem::MarkFileDangerous() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   state_info_.is_dangerous_file = true;
   UpdateSafetyState();
 }
 
 void DownloadItem::MarkUrlDangerous() {
   // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   state_info_.is_dangerous_url = true;
   UpdateSafetyState();
 }
 
+void DownloadItem::MarkContentDangerous() {
+  // TODO(rdsmith): Change to DCHECK after http://crbug.com/85408 resolved.
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  state_info_.is_dangerous_content = true;
+  UpdateSafetyState();
+}
+
 DownloadPersistentStoreInfo DownloadItem::GetPersistentStoreInfo() const {
   return DownloadPersistentStoreInfo(full_path(),
                                      GetURL(),
                                      referrer_url(),
                                      start_time(),
                                      end_time(),
                                      received_bytes(),
                                      total_bytes(),
                                      state(),
                                      db_handle(),
@@ skipping 118 matching lines @@
         state_info_.target_name.value().c_str(),
         full_path().value().c_str());
   } else {
     description += base::StringPrintf(" url = \"%s\"", url_list.c_str());
   }
 
   description += " }";
 
   return description;
 }