[NoStatePrefetch] Implement FINAL_STATUS_SAFEBROWSING

chrome/browser/loader/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/loader/safe_browsing_resource_throttle.h"
 
 #include <iterator>
 #include <utility>
 
 #include "base/debug/alias.h"
@@ skipping 52 matching lines @@
 std::unique_ptr<base::Value> NetLogStringCallback(const char* name,
                                                   const char* value,
                                                   net::NetLogCaptureMode) {
   std::unique_ptr<base::DictionaryValue> event_params(
       new base::DictionaryValue());
   if (name && value)
     event_params->SetString(name, value);
   return std::move(event_params);
 }
 
+// Destroys the prerender contents associated with the web_contents, if any.
+void DestroyPrerenderContents(
+    const content::ResourceRequestInfo::WebContentsGetter&
+        web_contents_getter) {
+  content::WebContents* web_contents = web_contents_getter.Run();
+  if (web_contents) {
+    prerender::PrerenderContents* prerender_contents =
+        prerender::PrerenderContents::FromWebContents(web_contents);
+    if (prerender_contents)
+      prerender_contents->Destroy(prerender::FINAL_STATUS_SAFE_BROWSING);
+  }
+}
+
 }  // namespace
 
 // TODO(eroman): Downgrade these CHECK()s to DCHECKs once there is more
 //               unit test coverage.
 
 // static
 SafeBrowsingResourceThrottle* SafeBrowsingResourceThrottle::MaybeCreate(
     net::URLRequest* request,
     content::ResourceType resource_type,
     safe_browsing::SafeBrowsingService* sb_service) {
@@ skipping 177 matching lines @@
     if (defer_state_ != DEFERRED_NONE) {
       // Log how much time the safe browsing check cost us.
       ui_manager_->LogPauseDelay(base::TimeTicks::Now() - defer_start_time_);
       ResumeRequest();
     } else {
       ui_manager_->LogPauseDelay(base::TimeDelta());
     }
     return;
   }
 
+  const content::ResourceRequestInfo* info =
+      content::ResourceRequestInfo::ForRequest(request_);
+
   if (request_->load_flags() & net::LOAD_PREFETCH) {
     // Don't prefetch resources that fail safe browsing, disallow them.
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&DestroyPrerenderContents,
+                   info->GetWebContentsGetterForRequest()));
     Cancel();
     UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes2.UnsafePrefetchCanceled",
                               resource_type_, content::RESOURCE_TYPE_LAST_TYPE);
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes2.Unsafe", resource_type_,
                             content::RESOURCE_TYPE_LAST_TYPE);
 
-  const content::ResourceRequestInfo* info =
-      content::ResourceRequestInfo::ForRequest(request_);
-
   security_interstitials::UnsafeResource resource;
   resource.url = url;
   resource.original_url = request_->original_url();
   resource.redirect_urls = redirect_urls_;
   resource.is_subresource = resource_type_ != content::RESOURCE_TYPE_MAIN_FRAME;
   resource.is_subframe = resource_type_ == content::RESOURCE_TYPE_SUB_FRAME;
   resource.threat_type = threat_type;
   resource.threat_metadata = metadata;
   resource.callback = base::Bind(
       &SafeBrowsingResourceThrottle::OnBlockingPageComplete, AsWeakPtr());
@@ skipping 139 matching lines @@
                        unchecked_redirect_url_, "defer_reason",
                        "resumed_redirect");
     }
   }
 
   if (resume) {
     defer_state_ = DEFERRED_NONE;
     Resume();
   }
 }