Componentize SafeBrowsingBlockingPage for WebView use

components/safe_browsing/base_resource_throttle.cc

 // Copyright (c) 2017 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 "components/safe_browsing/base_safe_browsing_resource_throttle.h"
+#include "components/safe_browsing/base_resource_throttle.h"
 
 #include <iterator>
 #include <utility>
 
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "components/safe_browsing/base_ui_manager.h"
 #include "components/safe_browsing_db/util.h"
 #include "components/security_interstitials/content/unsafe_resource.h"
 #include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/load_flags.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/log/net_log_source.h"
 #include "net/log/net_log_source_type.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request.h"
 
 using net::NetLogEventType;
 using net::NetLogSourceType;
-using safe_browsing::BaseSafeBrowsingUIManager;
+
+namespace safe_browsing {
 
 namespace {
 
 // 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.
 const int kCheckUrlTimeoutMs = 5000;
 
 // Return a dictionary with "url"=|url-spec| and optionally
 // |name|=|value| (if not null), for netlogging.
@@ skipping 22 matching lines @@
   if (name && value)
     event_params->SetString(name, value);
   return std::move(event_params);
 }
 
 }  // namespace
 
 // TODO(eroman): Downgrade these CHECK()s to DCHECKs once there is more
 //               unit test coverage.
 
-BaseSafeBrowsingResourceThrottle::BaseSafeBrowsingResourceThrottle(
+BaseResourceThrottle::BaseResourceThrottle(
     const net::URLRequest* request,
     content::ResourceType resource_type,
-    scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager,
-    scoped_refptr<safe_browsing::BaseSafeBrowsingUIManager> ui_manager)
+    scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
+    scoped_refptr<BaseUIManager> ui_manager)
     : ui_manager_(ui_manager),
-      threat_type_(safe_browsing::SB_THREAT_TYPE_SAFE),
+      threat_type_(SB_THREAT_TYPE_SAFE),
       database_manager_(database_manager),
       request_(request),
       state_(STATE_NONE),
       defer_state_(DEFERRED_NONE),
       resource_type_(resource_type),
       net_log_with_source_(
           net::NetLogWithSource::Make(request->net_log().net_log(),
                                       NetLogSourceType::SAFE_BROWSING)) {}
 
 // static
-BaseSafeBrowsingResourceThrottle* BaseSafeBrowsingResourceThrottle::MaybeCreate(
+BaseResourceThrottle* BaseResourceThrottle::MaybeCreate(
     net::URLRequest* request,
     content::ResourceType resource_type,
-    scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager,
-    scoped_refptr<safe_browsing::BaseSafeBrowsingUIManager> ui_manager) {
+    scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
+    scoped_refptr<BaseUIManager> ui_manager) {
   if (database_manager->IsSupported()) {
-    return new BaseSafeBrowsingResourceThrottle(request, resource_type,
-                                                database_manager, ui_manager);
+    return new BaseResourceThrottle(request, resource_type,
+                                    database_manager, ui_manager);
   }
   return nullptr;
 }
 
-BaseSafeBrowsingResourceThrottle::~BaseSafeBrowsingResourceThrottle() {
+BaseResourceThrottle::~BaseResourceThrottle() {
   if (defer_state_ != DEFERRED_NONE) {
     EndNetLogEvent(NetLogEventType::SAFE_BROWSING_DEFERRED, nullptr, nullptr);
   }
 
   if (state_ == STATE_CHECKING_URL) {
     database_manager_->CancelCheck(this);
     EndNetLogEvent(NetLogEventType::SAFE_BROWSING_CHECKING_URL, "result",
                    "request_canceled");
   }
 }
 
 // Note on net_log calls: SAFE_BROWSING_DEFERRED events must be wholly
 // nested within SAFE_BROWSING_CHECKING_URL events.  Synchronous checks
 // are not logged at all.
-void BaseSafeBrowsingResourceThrottle::BeginNetLogEvent(NetLogEventType type,
-                                                        const GURL& url,
-                                                        const char* name,
-                                                        const char* value) {
+void BaseResourceThrottle::BeginNetLogEvent(NetLogEventType type,
+                                            const GURL& url,
+                                            const char* name,
+                                            const char* value) {
   net_log_with_source_.BeginEvent(
       type, base::Bind(&NetLogUrlCallback, request_, url, name, value));
   request_->net_log().AddEvent(
       type, net_log_with_source_.source().ToEventParametersCallback());
 }
 
-void BaseSafeBrowsingResourceThrottle::EndNetLogEvent(NetLogEventType type,
-                                                      const char* name,
-                                                      const char* value) {
+void BaseResourceThrottle::EndNetLogEvent(NetLogEventType type,
+                                          const char* name,
+                                          const char* value) {
   net_log_with_source_.EndEvent(type,
                                 base::Bind(&NetLogStringCallback, name, value));
   request_->net_log().AddEvent(
       type, net_log_with_source_.source().ToEventParametersCallback());
 }
 
-void BaseSafeBrowsingResourceThrottle::WillStartRequest(bool* defer) {
+void BaseResourceThrottle::WillStartRequest(bool* defer) {
   // We need to check the new URL before starting the request.
   if (CheckUrl(request_->url()))
     return;
 
   // We let the check run in parallel with resource load only if this
   // db_manager only supports asynchronous checks, like on mobile.
   // Otherwise, we defer now.
   if (database_manager_->ChecksAreAlwaysAsync())
     return;
 
   // If the URL couldn't be verified synchronously, defer starting the
   // request until the check has completed.
   defer_state_ = DEFERRED_START;
   defer_start_time_ = base::TimeTicks::Now();
   *defer = true;
   BeginNetLogEvent(NetLogEventType::SAFE_BROWSING_DEFERRED, request_->url(),
                    "defer_reason", "at_start");
 }
 
-void BaseSafeBrowsingResourceThrottle::WillProcessResponse(bool* defer) {
+void BaseResourceThrottle::WillProcessResponse(bool* defer) {
   CHECK_EQ(defer_state_, DEFERRED_NONE);
   // TODO(nparker): Maybe remove this check, since it should have no effect.
   if (!database_manager_->ChecksAreAlwaysAsync())
     return;
 
   if (state_ == STATE_CHECKING_URL ||
       state_ == STATE_DISPLAYING_BLOCKING_PAGE) {
     defer_state_ = DEFERRED_PROCESSING;
     defer_start_time_ = base::TimeTicks::Now();
     *defer = true;
     BeginNetLogEvent(NetLogEventType::SAFE_BROWSING_DEFERRED, request_->url(),
                      "defer_reason", "at_response");
   }
 }
 
-bool BaseSafeBrowsingResourceThrottle::MustProcessResponseBeforeReadingBody() {
+bool BaseResourceThrottle::MustProcessResponseBeforeReadingBody() {
   // On Android, SafeBrowsing may only decide to cancel the request when the
   // response has been received. Therefore, no part of it should be cached
   // until this ResourceThrottle has been able to check the response. This
   // prevents the following scenario:
   //   1) A request is made for foo.com which has been hacked.
   //   2) The request is only canceled at WillProcessResponse stage, but part of
   //   it has been cached.
   //   3) foo.com is no longer hacked and removed from the SafeBrowsing list.
   //   4) The user requests foo.com, which is not on the SafeBrowsing list. This
   //   is deemed safe. However, the resource is actually served from cache,
   //   using the version that was previously stored.
   //   5) This results in the  user accessing an unsafe resource without being
   //   notified that it's dangerous.
   // TODO(clamy): Add a browser test that checks this specific scenario.
   return true;
 }
 
-void BaseSafeBrowsingResourceThrottle::WillRedirectRequest(
+void BaseResourceThrottle::WillRedirectRequest(
     const net::RedirectInfo& redirect_info,
     bool* defer) {
   CHECK_EQ(defer_state_, DEFERRED_NONE);
 
   // Prev check completed and was safe.
   if (state_ == STATE_NONE) {
     // Save the redirect urls for possible malware detail reporting later.
     redirect_urls_.push_back(redirect_info.new_url);
 
     // We need to check the new URL before following the redirect.
@@ skipping 10 matching lines @@
   }
 
   defer_start_time_ = base::TimeTicks::Now();
   *defer = true;
   BeginNetLogEvent(
       NetLogEventType::SAFE_BROWSING_DEFERRED, redirect_info.new_url,
       "defer_reason",
       defer_state_ == DEFERRED_REDIRECT ? "redirect" : "unchecked_redirect");
 }
 
-const char* BaseSafeBrowsingResourceThrottle::GetNameForLogging() const {
-  return "BaseSafeBrowsingResourceThrottle";
+const char* BaseResourceThrottle::GetNameForLogging() const {
+  return "BaseResourceThrottle";
 }
 
-void BaseSafeBrowsingResourceThrottle::MaybeDestroyPrerenderContents(
+void BaseResourceThrottle::MaybeDestroyPrerenderContents(
     const content::ResourceRequestInfo* info) {}
 
 // SafeBrowsingService::Client implementation, called on the IO thread once
 // the URL has been classified.
-void BaseSafeBrowsingResourceThrottle::OnCheckBrowseUrlResult(
+void BaseResourceThrottle::OnCheckBrowseUrlResult(
     const GURL& url,
-    safe_browsing::SBThreatType threat_type,
-    const safe_browsing::ThreatMetadata& metadata) {
+    SBThreatType threat_type,
+    const ThreatMetadata& metadata) {
   CHECK_EQ(state_, STATE_CHECKING_URL);
   // TODO(vakh): The following base::debug::Alias() and CHECK calls should be
   // removed after http://crbug.com/660293 is fixed.
   CHECK(url.is_valid());
   CHECK(url_being_checked_.is_valid());
   if (url != url_being_checked_) {
     bool url_had_timed_out = timed_out_urls_.count(url) > 0;
     char buf[1000];
     snprintf(buf, sizeof(buf), "sbtr::ocbur:%d:%s -- %s\n", url_had_timed_out,
              url.spec().c_str(), url_being_checked_.spec().c_str());
     base::debug::Alias(buf);
     CHECK(false) << "buf: " << buf;
   }
 
   timer_.Stop();  // Cancel the timeout timer.
   threat_type_ = threat_type;
   state_ = STATE_NONE;
 
   if (defer_state_ != DEFERRED_NONE) {
     EndNetLogEvent(NetLogEventType::SAFE_BROWSING_DEFERRED, nullptr, nullptr);
   }
   EndNetLogEvent(
       NetLogEventType::SAFE_BROWSING_CHECKING_URL, "result",
-      threat_type_ == safe_browsing::SB_THREAT_TYPE_SAFE ? "safe" : "unsafe");
+      threat_type_ == SB_THREAT_TYPE_SAFE ? "safe" : "unsafe");
 
-  if (threat_type == safe_browsing::SB_THREAT_TYPE_SAFE) {
+  if (threat_type == SB_THREAT_TYPE_SAFE) {
     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;
   }
 
@@ skipping 17 matching lines @@
 
   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(
-      &BaseSafeBrowsingResourceThrottle::OnBlockingPageComplete, AsWeakPtr());
+      &BaseResourceThrottle::OnBlockingPageComplete, AsWeakPtr());
   resource.callback_thread = content::BrowserThread::GetTaskRunnerForThread(
       content::BrowserThread::IO);
   resource.web_contents_getter = info->GetWebContentsGetterForRequest();
   resource.threat_source = database_manager_->GetThreatSource();
 
   state_ = STATE_DISPLAYING_BLOCKING_PAGE;
 
   StartDisplayingBlockingPageHelper(resource);
 }
 
-void BaseSafeBrowsingResourceThrottle::StartDisplayingBlockingPageHelper(
+void BaseResourceThrottle::StartDisplayingBlockingPageHelper(
     security_interstitials::UnsafeResource resource) {
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&BaseSafeBrowsingResourceThrottle::StartDisplayingBlockingPage,
+      base::Bind(&BaseResourceThrottle::StartDisplayingBlockingPage,
                  AsWeakPtr(), ui_manager_, resource));
 }
 
 // Static
-void BaseSafeBrowsingResourceThrottle::StartDisplayingBlockingPage(
-    const base::WeakPtr<BaseSafeBrowsingResourceThrottle>& throttle,
-    scoped_refptr<BaseSafeBrowsingUIManager> ui_manager,
+void BaseResourceThrottle::StartDisplayingBlockingPage(
+    const base::WeakPtr<BaseResourceThrottle>& throttle,
+    scoped_refptr<BaseUIManager> ui_manager,
     const security_interstitials::UnsafeResource& resource) {
   content::WebContents* web_contents = resource.web_contents_getter.Run();
   if (web_contents) {
     // Once activated, the subresource filter will filter subresources, but is
     // triggered when the main frame document matches Safe Browsing blacklists.
     if (!resource.is_subresource) {
       using subresource_filter::ContentSubresourceFilterDriverFactory;
       ContentSubresourceFilterDriverFactory* driver_factory =
           ContentSubresourceFilterDriverFactory::FromWebContents(web_contents);
       DCHECK(driver_factory);
@@ skipping 13 matching lines @@
           resource.threat_metadata.threat_pattern_type);
     }
 
     ui_manager->DisplayBlockingPage(resource);
     return;
   }
 
   // Tab is gone or it's being prerendered.
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&BaseSafeBrowsingResourceThrottle::Cancel, throttle));
+      base::Bind(&BaseResourceThrottle::Cancel, throttle));
 }
 
-void BaseSafeBrowsingResourceThrottle::OnBlockingPageComplete(bool proceed) {
+void BaseResourceThrottle::OnBlockingPageComplete(bool proceed) {
   CHECK_EQ(state_, STATE_DISPLAYING_BLOCKING_PAGE);
   state_ = STATE_NONE;
 
   if (proceed) {
-    threat_type_ = safe_browsing::SB_THREAT_TYPE_SAFE;
+    threat_type_ = SB_THREAT_TYPE_SAFE;
     if (defer_state_ != DEFERRED_NONE) {
       ResumeRequest();
     }
   } else {
     Cancel();
   }
 }
 
-bool BaseSafeBrowsingResourceThrottle::CheckUrl(const GURL& url) {
-  TRACE_EVENT1("loader", "BaseSafeBrowsingResourceThrottle::CheckUrl", "url",
+bool BaseResourceThrottle::CheckUrl(const GURL& url) {
+  TRACE_EVENT1("loader", "BaseResourceThrottle::CheckUrl", "url",
                url.spec());
   CHECK_EQ(state_, STATE_NONE);
   // To reduce aggregate latency on mobile, check only the most dangerous
   // resource types.
   if (!database_manager_->CanCheckResourceType(resource_type_)) {
     // TODO(vakh): Consider changing this metric to SafeBrowsing.V4ResourceType
     // to be consistent with the other PVer4 metrics.
     UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes2.Skipped", resource_type_,
                               content::RESOURCE_TYPE_LAST_TYPE);
     return true;
   }
 
   // TODO(vakh): Consider changing this metric to SafeBrowsing.V4ResourceType to
   // be consistent with the other PVer4 metrics.
   UMA_HISTOGRAM_ENUMERATION("SB2.ResourceTypes2.Checked", resource_type_,
                             content::RESOURCE_TYPE_LAST_TYPE);
 
   if (database_manager_->CheckBrowseUrl(url, this)) {
-    threat_type_ = safe_browsing::SB_THREAT_TYPE_SAFE;
+    threat_type_ = SB_THREAT_TYPE_SAFE;
     ui_manager_->LogPauseDelay(base::TimeDelta());  // No delay.
     return true;
   }
 
   state_ = STATE_CHECKING_URL;
   url_being_checked_ = url;
   BeginNetLogEvent(NetLogEventType::SAFE_BROWSING_CHECKING_URL, url, nullptr,
                    nullptr);
 
   // Start a timer to abort the check if it takes too long.
   // TODO(nparker): Set this only when we defer, based on remaining time,
   // so we don't cancel earlier than necessary.
   timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(kCheckUrlTimeoutMs),
-               this, &BaseSafeBrowsingResourceThrottle::OnCheckUrlTimeout);
+               this, &BaseResourceThrottle::OnCheckUrlTimeout);
 
   return false;
 }
 
-void BaseSafeBrowsingResourceThrottle::OnCheckUrlTimeout() {
+void BaseResourceThrottle::OnCheckUrlTimeout() {
   CHECK_EQ(state_, STATE_CHECKING_URL);
 
   database_manager_->CancelCheck(this);
 
   OnCheckBrowseUrlResult(url_being_checked_, safe_browsing::SB_THREAT_TYPE_SAFE,
-                         safe_browsing::ThreatMetadata());
+                         ThreatMetadata());
 
   timed_out_urls_.insert(url_being_checked_);
 }
 
-void BaseSafeBrowsingResourceThrottle::ResumeRequest() {
+void BaseResourceThrottle::ResumeRequest() {
   CHECK_EQ(state_, STATE_NONE);
   CHECK_NE(defer_state_, DEFERRED_NONE);
 
   bool resume = true;
   if (defer_state_ == DEFERRED_UNCHECKED_REDIRECT) {
     // Save the redirect urls for possible malware detail reporting later.
     redirect_urls_.push_back(unchecked_redirect_url_);
     if (!CheckUrl(unchecked_redirect_url_)) {
       // We're now waiting for the unchecked_redirect_url_.
       defer_state_ = DEFERRED_REDIRECT;
       resume = false;
       BeginNetLogEvent(NetLogEventType::SAFE_BROWSING_DEFERRED,
                        unchecked_redirect_url_, "defer_reason",
                        "resumed_redirect");
     }
   }
 
   if (resume) {
     defer_state_ = DEFERRED_NONE;
     Resume();
   }
 }
+
+}  // namespace safe_browsing