Safebrowsing: Honor the metadata from malware fullhash results in SB API 3.0.

chrome/browser/renderer_host/safe_browsing_resource_throttle.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/renderer_host/safe_browsing_resource_throttle.h"
 
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request.h"
 
 // Maximum time in milliseconds to wait for the safe browsing service to
 // verify a URL. After this amount of time the outstanding check will be
 // aborted, and the URL will be treated as if it were safe.
 static const int kCheckUrlTimeoutMs = 5000;
 
 // TODO(eroman): Downgrade these CHECK()s to DCHECKs once there is more
 //               unit test coverage.
 
 SafeBrowsingResourceThrottle::SafeBrowsingResourceThrottle(
     const net::URLRequest* request,
-    bool is_subresource,
+    content::ResourceType resource_type,
     SafeBrowsingService* safe_browsing)
     : state_(STATE_NONE),
       defer_state_(DEFERRED_NONE),
       threat_type_(SB_THREAT_TYPE_SAFE),
       database_manager_(safe_browsing->database_manager()),
       ui_manager_(safe_browsing->ui_manager()),
       request_(request),
-      is_subresource_(is_subresource) {
+      is_subresource_(resource_type != content::RESOURCE_TYPE_MAIN_FRAME),
+      is_subframe_(resource_type == content::RESOURCE_TYPE_SUB_FRAME) {
 }
 
 SafeBrowsingResourceThrottle::~SafeBrowsingResourceThrottle() {
   if (state_ == STATE_CHECKING_URL)
     database_manager_->CancelCheck(this);
 }
 
 void SafeBrowsingResourceThrottle::WillStartRequest(bool* defer) {
   // We need to check the new URL before starting the request.
   if (CheckUrl(request_->url()))
@@ skipping 25 matching lines @@
   *defer = true;
 }
 
 const char* SafeBrowsingResourceThrottle::GetNameForLogging() const {
   return "SafeBrowsingResourceThrottle";
 }
 
 // SafeBrowsingService::Client implementation, called on the IO thread once
 // the URL has been classified.
 void SafeBrowsingResourceThrottle::OnCheckBrowseUrlResult(
-    const GURL& url, SBThreatType threat_type) {
+    const GURL& url,
+    SBThreatType threat_type,
+    const std::string& metadata) {
   CHECK(state_ == STATE_CHECKING_URL);
   CHECK(defer_state_ != DEFERRED_NONE);
   CHECK(url == url_being_checked_) << "Was expecting: " << url_being_checked_
                                    << " but got: " << url;
 
 #if defined(OS_ANDROID)
   // Temporarily disable SB interstitial during Finch experiment.
   // The database check is still exercised, but the interstitial never shown.
   threat_type = SB_THREAT_TYPE_SAFE;
 #endif
@@ skipping 19 matching lines @@
   }
 
   const content::ResourceRequestInfo* info =
       content::ResourceRequestInfo::ForRequest(request_);
 
   SafeBrowsingUIManager::UnsafeResource resource;
   resource.url = url;
   resource.original_url = request_->original_url();
   resource.redirect_urls = redirect_urls_;
   resource.is_subresource = is_subresource_;
+  resource.is_subframe = is_subframe_;
   resource.threat_type = threat_type;
+  resource.threat_metadata = metadata;
   resource.callback = base::Bind(
       &SafeBrowsingResourceThrottle::OnBlockingPageComplete, AsWeakPtr());
   resource.render_process_host_id = info->GetChildID();
   resource.render_view_id =  info->GetRouteID();
 
   state_ = STATE_DISPLAYING_BLOCKING_PAGE;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
@@ skipping 72 matching lines @@
                this, &SafeBrowsingResourceThrottle::OnCheckUrlTimeout);
 
   return false;
 }
 
 void SafeBrowsingResourceThrottle::OnCheckUrlTimeout() {
   CHECK(state_ == STATE_CHECKING_URL);
   CHECK(defer_state_ != DEFERRED_NONE);
 
   database_manager_->CancelCheck(this);
-  OnCheckBrowseUrlResult(url_being_checked_, SB_THREAT_TYPE_SAFE);
+  OnCheckBrowseUrlResult(
+      url_being_checked_, SB_THREAT_TYPE_SAFE, std::string());
 }
 
 void SafeBrowsingResourceThrottle::ResumeRequest() {
   CHECK(state_ == STATE_NONE);
   CHECK(defer_state_ != DEFERRED_NONE);
 
   defer_state_ = DEFERRED_NONE;
   controller()->Resume();
 }