Move SecurityInterstitialPage into component

chrome/browser/safe_browsing/safe_browsing_blocking_page.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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/interstitials/chrome_controller_client.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/safe_browsing/threat_details.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/url_constants.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
+#include "components/security_interstitials/content/security_interstitial_controller_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 
 using base::UserMetricsAction;
 using content::BrowserThread;
 using content::InterstitialPage;
 using content::WebContents;
 using security_interstitials::SafeBrowsingErrorUI;
+using security_interstitials::SecurityInterstitialControllerClient;
 
 namespace safe_browsing {
 
 namespace {
 
 // After a safe browsing interstitial where the user opted-in to the report
 // but clicked "proceed anyway", we delay the call to
 // ThreatDetails::FinishCollection() by this much time (in
 // milliseconds).
 const int64_t kThreatDetailsProceedDelayMilliSeconds = 3000;
@@ skipping 45 matching lines @@
         &SafeBrowsingBlockingPage::kTypeForTesting;
 
 SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
     SafeBrowsingUIManager* ui_manager,
     WebContents* web_contents,
     const GURL& main_frame_url,
     const UnsafeResourceList& unsafe_resources)
     : SecurityInterstitialPage(
           web_contents,
           unsafe_resources[0].url,
-          CreateMetricsHelper(web_contents, unsafe_resources)),
+          CreateControllerClient(web_contents, unsafe_resources)),
       threat_details_proceed_delay_ms_(kThreatDetailsProceedDelayMilliSeconds),
       ui_manager_(ui_manager),
       main_frame_url_(main_frame_url),
       unsafe_resources_(unsafe_resources),
       proceeded_(false) {
   // Computes display options based on user profile and blocked resource.
   bool is_main_frame_load_blocked = IsMainPageLoadBlocked(unsafe_resources);
-  bool can_show_extended_reporting_option = CanShowExtendedReportingOption();
   SafeBrowsingErrorUI::SBErrorDisplayOptions display_options(
-      is_main_frame_load_blocked, can_show_extended_reporting_option,
-      IsExtendedReportingEnabled(*profile()->GetPrefs()),
-      IsScout(*profile()->GetPrefs()),
+      is_main_frame_load_blocked,
+      IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingOptInAllowed),
+      web_contents->GetBrowserContext()->IsOffTheRecord(),
+      IsExtendedReportingEnabled(*controller()->GetPrefService()),
+      IsScout(*controller()->GetPrefService()),
       IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled));
   sb_error_ui_ = base::MakeUnique<SafeBrowsingErrorUI>(
       unsafe_resources[0].url, main_frame_url_,
       GetInterstitialReason(unsafe_resources), display_options,
       g_browser_process->GetApplicationLocale(),
       base::Time::NowFromSystemTime(), controller());
 
   if (!is_main_frame_load_blocked) {
     navigation_entry_index_to_remove_ =
         web_contents->GetController().GetLastCommittedEntryIndex();
   } else {
     navigation_entry_index_to_remove_ = -1;
   }
 
   // Start computing threat details. They will be sent only
   // if the user opts-in on the blocking page later.
   // If there's more than one malicious resources, it means the user
   // clicked through the first warning, so we don't prepare additional
   // reports.
   if (unsafe_resources.size() == 1 &&
       ShouldReportThreatDetails(unsafe_resources[0].threat_type) &&
-      threat_details_.get() == NULL && can_show_extended_reporting_option) {
+      threat_details_.get() == NULL &&
+      sb_error_ui_->CanShowExtendedReportingOption()) {
     threat_details_ = ThreatDetails::NewThreatDetails(ui_manager_, web_contents,
                                                       unsafe_resources[0]);
   }
 }
 
 bool SafeBrowsingBlockingPage::ShouldReportThreatDetails(
     SBThreatType threat_type) {
   return threat_type == SB_THREAT_TYPE_URL_PHISHING ||
          threat_type == SB_THREAT_TYPE_URL_MALWARE ||
          threat_type == SB_THREAT_TYPE_URL_UNWANTED ||
          threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL ||
          threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL;
 }
 
-bool SafeBrowsingBlockingPage::CanShowExtendedReportingOption() {
-  return (!web_contents()->GetBrowserContext()->IsOffTheRecord() &&
-          IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingOptInAllowed));
-}
-
 SafeBrowsingBlockingPage::~SafeBrowsingBlockingPage() {
 }
 
 void SafeBrowsingBlockingPage::CommandReceived(const std::string& page_cmd) {
   if (page_cmd == "\"pageLoadComplete\"") {
     // content::WaitForRenderFrameReady sends this message when the page
     // load completes. Ignore it.
     return;
   }
 
@@ skipping 54 matching lines @@
 bool SafeBrowsingBlockingPage::ShouldCreateNewNavigation() const {
   return sb_error_ui_->is_main_frame_load_blocked();
 }
 
 void SafeBrowsingBlockingPage::OnDontProceed() {
   // We could have already called Proceed(), in which case we must not notify
   // the SafeBrowsingUIManager again, as the client has been deleted.
   if (proceeded_)
     return;
 
-  if (!IsPrefEnabled(prefs::kSafeBrowsingProceedAnywayDisabled)) {
+  if (!sb_error_ui_->is_proceed_anyway_disabled()) {
     controller()->metrics_helper()->RecordUserDecision(
         security_interstitials::MetricsHelper::DONT_PROCEED);
   }
 
   // Send the malware details, if we opted to.
   FinishThreatDetails(0, false /* did_proceed */,
                       controller()->metrics_helper()->NumVisits());  // No delay
 
   ui_manager_->OnBlockingPageDone(unsafe_resources_, false, web_contents(),
                                   main_frame_url_);
@@ skipping 24 matching lines @@
   }
 }
 
 void SafeBrowsingBlockingPage::FinishThreatDetails(int64_t delay_ms,
                                                    bool did_proceed,
                                                    int num_visits) {
   if (threat_details_.get() == NULL)
     return;  // Not all interstitials have threat details (eg., incognito mode).
 
   const bool enabled =
-      IsExtendedReportingEnabled(*profile()->GetPrefs()) &&
-      IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingOptInAllowed);
+      sb_error_ui_->is_extended_reporting_enabled() &&
+      sb_error_ui_->is_extended_reporting_opt_in_allowed();
   if (!enabled)
     return;
 
   controller()->metrics_helper()->RecordUserInteraction(
       security_interstitials::MetricsHelper::EXTENDED_REPORTING_IS_ENABLED);
   // Finish the malware details collection, send it over.
   BrowserThread::PostDelayedTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ThreatDetails::FinishCollection, threat_details_,
                  did_proceed, num_visits),
@@ skipping 147 matching lines @@
   }
   DCHECK(phishing || malware || harmful);
   if (malware)
     return SafeBrowsingErrorUI::SB_REASON_MALWARE;
   else if (harmful)
     return SafeBrowsingErrorUI::SB_REASON_HARMFUL;
   return SafeBrowsingErrorUI::SB_REASON_PHISHING;
 }
 
 // static
-std::unique_ptr<ChromeMetricsHelper>
-SafeBrowsingBlockingPage::CreateMetricsHelper(
+std::unique_ptr<security_interstitials::SecurityInterstitialControllerClient>
+SafeBrowsingBlockingPage::CreateControllerClient(
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources) {
   SafeBrowsingErrorUI::SBInterstitialReason interstitial_reason =
       GetInterstitialReason(unsafe_resources);
   GURL request_url(unsafe_resources[0].url);
   security_interstitials::MetricsHelper::ReportDetails reporting_info;
   reporting_info.metric_prefix =
       GetMetricPrefix(unsafe_resources, interstitial_reason);
   reporting_info.extra_suffix = GetExtraMetricsSuffix(unsafe_resources);
-  return std::unique_ptr<ChromeMetricsHelper>(
-      new ChromeMetricsHelper(web_contents, request_url, reporting_info,
-                              GetSamplingEventName(interstitial_reason)));
+
+  std::unique_ptr<ChromeMetricsHelper> metrics_helper =
+      base::MakeUnique<ChromeMetricsHelper>(
+          web_contents, request_url, reporting_info,
+          GetSamplingEventName(interstitial_reason));
+
+  Profile* profile = Profile::FromBrowserContext(
+      web_contents->GetBrowserContext());
+  DCHECK(profile);
+
+  return base::MakeUnique<
+      security_interstitials::SecurityInterstitialControllerClient>(
+          web_contents,
+          std::move(metrics_helper),
+          profile->GetPrefs(),
+          g_browser_process->GetApplicationLocale(),
+          GURL(chrome::kChromeUINewTabURL));
 }
 
 void SafeBrowsingBlockingPage::PopulateInterstitialStrings(
     base::DictionaryValue* load_time_data) {
   sb_error_ui_->PopulateStringsForHTML(load_time_data);
 }
 
 }  // namespace safe_browsing