Add SafeBrowsingNavigationThrottle

chrome/browser/renderer_host/safe_browsing_navigation_throttle.cc

Index: chrome/browser/renderer_host/safe_browsing_navigation_throttle.cc
diff --git a/chrome/browser/renderer_host/safe_browsing_navigation_throttle.cc b/chrome/browser/renderer_host/safe_browsing_navigation_throttle.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b1fde07b82bcd2f9d9058e35fae4b1fe55084b20
--- /dev/null
+++ b/chrome/browser/renderer_host/safe_browsing_navigation_throttle.cc
@@ -0,0 +1,136 @@
+// Copyright 2016 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_navigation_throttle.h"
+
+#include "chrome/browser/prerender/prerender_contents.h"
+#include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/navigation_handle.h"
+#include "content/public/browser/resource_request_info.h"
+
+// static
+std::unique_ptr<content::NavigationThrottle>
+SafeBrowsingNavigationThrottle::MaybeCreate(
+    content::NavigationHandle* handle,
+    safe_browsing::SafeBrowsingService* sb_service) {
+  if (sb_service->database_manager()->IsSupported()) {
+    return std::unique_ptr<content::NavigationThrottle>(
+        new SafeBrowsingNavigationThrottle(handle, sb_service));
+  }
+  return nullptr;
+}
+
+SafeBrowsingNavigationThrottle::~SafeBrowsingNavigationThrottle() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+}
+
+SafeBrowsingNavigationThrottle::SafeBrowsingNavigationThrottle(
+    content::NavigationHandle* handle,
+    safe_browsing::SafeBrowsingService* sb_service)
+    : NavigationThrottle(handle),
+      database_manager_(sb_service->database_manager()),
+      ui_manager_(sb_service->ui_manager()) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+}
+
+content::NavigationThrottle::ThrottleCheckResult
+SafeBrowsingNavigationThrottle::WillStartRequest() {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &SafeBrowsingNavigationThrottle::CheckUrlOnIO,
+          base::Unretained(
+              this) /* TODO(scottmg) not sure about this; can't be weak */,
+          navigation_handle()->GetURL()));
+  return ThrottleCheckResult::DEFER;
+}
+
+content::NavigationThrottle::ThrottleCheckResult
+SafeBrowsingNavigationThrottle::WillRedirectRequest() {
+  return content::NavigationThrottle::ThrottleCheckResult::PROCEED;
+}
+
+void SafeBrowsingNavigationThrottle::OnCheckBrowseUrlResult(
+    const GURL& url,
+    safe_browsing::SBThreatType result,
+    const safe_browsing::ThreatMetadata& metadata) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&SafeBrowsingNavigationThrottle::OnCheckUrlResultOnUI,
+                 AsWeakPtr(), url, result, metadata));
+}
+
+void SafeBrowsingNavigationThrottle::CheckUrlOnIO(const GURL& url) {
+  bool succeeded_synchronously = database_manager_->CheckBrowseUrl(url, this);
+  if (succeeded_synchronously) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&SafeBrowsingNavigationThrottle::OnCheckUrlResultOnUI,
+                   AsWeakPtr(), url, safe_browsing::SB_THREAT_TYPE_SAFE,
+                   safe_browsing::ThreatMetadata()));
+  }
+  // TODO(scottmg): Timeout == let it go.
+}
+
+content::WebContents*
+SafeBrowsingNavigationThrottle::GetNavigationHandlesWebContents() {
+  return navigation_handle()->GetWebContents();
+}
+
+void SafeBrowsingNavigationThrottle::OnCheckUrlResultOnUI(
+    const GURL& url,
+    safe_browsing::SBThreatType result,
+    const safe_browsing::ThreatMetadata& metadata) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (result == safe_browsing::SB_THREAT_TYPE_SAFE) {
+    navigation_handle()->Resume();
+    return;
+  }
+
+  subresource_filter::ContentSubresourceFilterDriverFactory* driver_factory =
+      subresource_filter::ContentSubresourceFilterDriverFactory::
+          FromWebContents(navigation_handle()->GetWebContents());
+  DCHECK(driver_factory);
+  driver_factory->OnMainResourceMatchedSafeBrowsingBlacklist(
+      url, std::vector<GURL>(), metadata.threat_pattern_type);
+
+  prerender::PrerenderContents* prerender_contents =
+      prerender::PrerenderContents::FromWebContents(
+          navigation_handle()->GetWebContents());
+  if (prerender_contents) {
+    prerender_contents->Destroy(prerender::FINAL_STATUS_SAFE_BROWSING);
+    navigation_handle()->CancelDeferredNavigation(CANCEL);
+    return;
+  }
+
+  safe_browsing::SafeBrowsingUIManager::UnsafeResource resource;
+  resource.url = url;
+  resource.original_url = navigation_handle()->GetURL();  // TODO(scottmg)
+  resource.redirect_urls = std::vector<GURL>();           // TODO(scottmg)
+  resource.is_subresource = false;
+  resource.is_subframe =
+      !navigation_handle()->IsInMainFrame();  // TODO(scottmg): Correct?
+  resource.threat_type = result;
+  resource.threat_metadata = metadata;
+  resource.callback = base::Bind(
+      &SafeBrowsingNavigationThrottle::OnBlockingPageComplete, AsWeakPtr());
+  resource.callback_thread = content::BrowserThread::GetTaskRunnerForThread(
+      content::BrowserThread::UI);
+  // This stays on the UI thread, so we can just return the WebContents*.
+  resource.web_contents_getter = base::Bind(
+      &SafeBrowsingNavigationThrottle::GetNavigationHandlesWebContents,
+      base::Unretained(this));
+  resource.threat_source = database_manager_->GetThreatSource();
+  ui_manager_->DisplayBlockingPage(resource);
+}
+
+void SafeBrowsingNavigationThrottle::OnBlockingPageComplete(bool proceed) {
+  if (proceed) {
+    navigation_handle()->Resume();
+  } else {
+    navigation_handle()->CancelDeferredNavigation(CANCEL);
+  }
+}