Componentize SafeBrowsingBlockingPage for WebView use

chrome/browser/safe_browsing/ui_manager.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/safe_browsing/ui_manager.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/ping_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/threat_details.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/url_constants.h"
 #include "components/prefs/pref_service.h"
-#include "components/safe_browsing_db/metadata.pb.h"
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "ipc/ipc_message.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/ssl/ssl_info.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::WebContents;
 using safe_browsing::HitReport;
 using safe_browsing::SBThreatType;
 
-namespace {
-
-// Returns the URL that should be used in a WhitelistUrlSet for the given
-// |resource|.
-GURL GetMainFrameWhitelistUrlForResource(
-    const security_interstitials::UnsafeResource& resource) {
-  if (resource.is_subresource) {
-    NavigationEntry* entry = resource.GetNavigationEntryForResource();
-    if (!entry)
-      return GURL();
-    return entry->GetURL().GetWithEmptyPath();
-  }
-  return resource.url.GetWithEmptyPath();
-}
-
-}  // namespace
-
 namespace safe_browsing {
 
 SafeBrowsingUIManager::SafeBrowsingUIManager(
     const scoped_refptr<SafeBrowsingService>& service)
     : sb_service_(service) {}
 
 SafeBrowsingUIManager::~SafeBrowsingUIManager() {}
 
 void SafeBrowsingUIManager::StopOnIOThread(bool shutdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (shutdown)
     sb_service_ = NULL;
 }
 
-void SafeBrowsingUIManager::LogPauseDelay(base::TimeDelta time) {
-  UMA_HISTOGRAM_LONG_TIMES("SB2.Delay", time);
-}
-
 void SafeBrowsingUIManager::DisplayBlockingPage(
     const UnsafeResource& resource) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (resource.is_subresource && !resource.is_subframe) {
     // Sites tagged as serving Unwanted Software should only show a warning for
     // main-frame or sub-frame resource. Similar warning restrictions should be
     // applied to malware sites tagged as "landing sites" (see "Types of
     // Malware sites" under
     // https://developers.google.com/safe-browsing/developers_guide_v3#UserWarnings).
-    MalwarePatternType proto;
     if (resource.threat_type == SB_THREAT_TYPE_URL_UNWANTED ||
         (resource.threat_type == SB_THREAT_TYPE_URL_MALWARE &&
          resource.threat_metadata.threat_pattern_type ==
              ThreatPatternType::MALWARE_LANDING)) {
       if (!resource.callback.is_null()) {
         DCHECK(resource.callback_thread);
         resource.callback_thread->PostTask(FROM_HERE,
                                            base::Bind(resource.callback, true));
       }
 
@@ skipping 111 matching lines @@
       base::Bind(&SafeBrowsingUIManager::ReportPermissionActionOnIOThread, this,
                  report_info));
 }
 
 // Static.
 void SafeBrowsingUIManager::CreateWhitelistForTesting(
     content::WebContents* web_contents) {
   EnsureWhitelistCreated(web_contents);
 }
 
+void SafeBrowsingUIManager::AddObserver(Observer* observer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  observer_list_.AddObserver(observer);
+}
+
+void SafeBrowsingUIManager::RemoveObserver(Observer* observer) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  observer_list_.RemoveObserver(observer);
+}
+
+const std::string SafeBrowsingUIManager::app_locale() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return g_browser_process->GetApplicationLocale();
+}
+
+history::HistoryService* SafeBrowsingUIManager::history_service(
+    content::WebContents* web_contents) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return HistoryServiceFactory::GetForProfile(
+      Profile::FromBrowserContext(web_contents->GetBrowserContext()),
+      ServiceAccessType::EXPLICIT_ACCESS);
+}
+
+const GURL SafeBrowsingUIManager::default_safe_page() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return GURL(chrome::kChromeUINewTabURL);
+}
+
 void SafeBrowsingUIManager::ReportPermissionActionOnIOThread(
     const PermissionReportInfo& report_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The service may delete the ping manager (i.e. when user disabling service,
   // etc). This happens on the IO thread.
   if (!sb_service_ || !sb_service_->ping_manager())
     return;
 
   sb_service_->ping_manager()->ReportPermissionAction(report_info);
@@ skipping 16 matching lines @@
   }
 }
 
 // Static.
 GURL SafeBrowsingUIManager::GetMainFrameWhitelistUrlForResourceForTesting(
     const security_interstitials::UnsafeResource& resource) {
   return GetMainFrameWhitelistUrlForResource(resource);
 }
 
 }  // namespace safe_browsing