Rename SafeBrowsingErrorUI to SafeBrowsingLoudErrorUI

components/safe_browsing/base_blocking_page.cc

 // Copyright 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_blocking_page.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
 #include "components/security_interstitials/content/security_interstitial_controller_client.h"
 #include "components/security_interstitials/core/metrics_helper.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 
 using content::InterstitialPage;
 using content::WebContents;
-using security_interstitials::SafeBrowsingErrorUI;
+using security_interstitials::SafeBrowsingLoudErrorUI;
 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;
 
 base::LazyInstance<BaseBlockingPage::UnsafeResourceMap>::Leaky
     g_unsafe_resource_map = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BaseBlockingPage::BaseBlockingPage(
     BaseUIManager* ui_manager,
     WebContents* web_contents,
     const GURL& main_frame_url,
     const UnsafeResourceList& unsafe_resources,
     std::unique_ptr<SecurityInterstitialControllerClient> controller_client,
-    const SafeBrowsingErrorUI::SBErrorDisplayOptions& display_options)
+    const BaseSafeBrowsingErrorUI::SBErrorDisplayOptions& display_options)
     : SecurityInterstitialPage(web_contents,
                                unsafe_resources[0].url,
                                std::move(controller_client)),
       ui_manager_(ui_manager),
       main_frame_url_(main_frame_url),
       navigation_entry_index_to_remove_(
           IsMainPageLoadBlocked(unsafe_resources)
               ? -1
               : web_contents->GetController().GetLastCommittedEntryIndex()),
       unsafe_resources_(unsafe_resources),
-      sb_error_ui_(base::MakeUnique<SafeBrowsingErrorUI>(
+      sb_error_ui_(base::MakeUnique<SafeBrowsingLoudErrorUI>(
           unsafe_resources_[0].url,
           main_frame_url_,
           GetInterstitialReason(unsafe_resources_),
           display_options,
           ui_manager->app_locale(),
           base::Time::NowFromSystemTime(),
           controller())),
       proceeded_(false),
       threat_details_proceed_delay_ms_(kThreatDetailsProceedDelayMilliSeconds) {
 }
 
 BaseBlockingPage::~BaseBlockingPage() {}
 
 // static
-const SafeBrowsingErrorUI::SBErrorDisplayOptions
+const security_interstitials::BaseSafeBrowsingErrorUI::SBErrorDisplayOptions
 BaseBlockingPage::CreateDefaultDisplayOptions(
     const UnsafeResourceList& unsafe_resources) {
-  return SafeBrowsingErrorUI::SBErrorDisplayOptions(
+  return BaseSafeBrowsingErrorUI::SBErrorDisplayOptions(
       IsMainPageLoadBlocked(unsafe_resources),
       false,  // kSafeBrowsingExtendedReportingOptInAllowed
       false,  // is_off_the_record
       false,  // is_extended_reporting
       false,  // is_scout
       false,  // kSafeBrowsingProceedAnywayDisabled
       true);  // is_resource_cancellable
 }
 
 // static
@@ skipping 54 matching lines @@
   threat_details_proceed_delay_ms_ = delay;
 }
 
 void BaseBlockingPage::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;
 
   UpdateMetricsAfterSecurityInterstitial();
-  if (!sb_error_ui_->is_proceed_anyway_disabled()) {
+  if (!sb_error_ui_->base_safe_browsing_error_ui.is_proceed_anyway_disabled()) {
     controller()->metrics_helper()->RecordUserDecision(
         security_interstitials::MetricsHelper::DONT_PROCEED);
   }
 
   // Send the malware details, if we opted to.
   FinishThreatDetails(base::TimeDelta(), false /* did_proceed */,
                       controller()->metrics_helper()->NumVisits());  // No delay
 
   ui_manager_->OnBlockingPageDone(unsafe_resources_, false /* proceed */,
                                   web_contents(), main_frame_url_);
@@ skipping 34 matching lines @@
   int command = 0;
   bool retval = base::StringToInt(page_cmd, &command);
   DCHECK(retval) << page_cmd;
 
   sb_error_ui_->HandleCommand(
       static_cast<security_interstitials::SecurityInterstitialCommands>(
           command));
 }
 
 bool BaseBlockingPage::ShouldCreateNewNavigation() const {
-  return sb_error_ui_->is_main_frame_load_blocked();
+  return sb_error_ui_->base_safe_browsing_error_ui.is_main_frame_load_blocked();
 }
 
 void BaseBlockingPage::PopulateInterstitialStrings(
     base::DictionaryValue* load_time_data) {
   sb_error_ui_->PopulateStringsForHTML(load_time_data);
 }
 
 void BaseBlockingPage::FinishThreatDetails(const base::TimeDelta& delay,
                                            bool did_proceed,
                                            int num_visits) {}
 
 // static
 BaseBlockingPage::UnsafeResourceMap*
 BaseBlockingPage::GetUnsafeResourcesMap() {
   return g_unsafe_resource_map.Pointer();
 }
 
 // static
 std::string BaseBlockingPage::GetMetricPrefix(
     const UnsafeResourceList& unsafe_resources,
-    SafeBrowsingErrorUI::SBInterstitialReason interstitial_reason) {
+    BaseSafeBrowsingErrorUI::SBInterstitialReason interstitial_reason) {
   bool primary_subresource = unsafe_resources[0].is_subresource;
   switch (interstitial_reason) {
-    case SafeBrowsingErrorUI::SB_REASON_MALWARE:
+    case BaseSafeBrowsingErrorUI::SB_REASON_MALWARE:
       return primary_subresource ? "malware_subresource" : "malware";
-    case SafeBrowsingErrorUI::SB_REASON_HARMFUL:
+    case BaseSafeBrowsingErrorUI::SB_REASON_HARMFUL:
       return primary_subresource ? "harmful_subresource" : "harmful";
-    case SafeBrowsingErrorUI::SB_REASON_PHISHING:
+    case BaseSafeBrowsingErrorUI::SB_REASON_PHISHING:
       ThreatPatternType threat_pattern_type =
           unsafe_resources[0].threat_metadata.threat_pattern_type;
       if (threat_pattern_type == ThreatPatternType::PHISHING ||
           threat_pattern_type == ThreatPatternType::NONE)
         return primary_subresource ? "phishing_subresource" : "phishing";
       else if (threat_pattern_type == ThreatPatternType::SOCIAL_ENGINEERING_ADS)
         return primary_subresource ? "social_engineering_ads_subresource"
                                    : "social_engineering_ads";
       else if (threat_pattern_type ==
                ThreatPatternType::SOCIAL_ENGINEERING_LANDING)
@@ skipping 21 matching lines @@
     case safe_browsing::ThreatSource::CLIENT_SIDE_DETECTION:
       return "from_client_side_detection";
     case safe_browsing::ThreatSource::UNKNOWN:
       break;
   }
   NOTREACHED();
   return std::string();
 }
 
 // static
-SafeBrowsingErrorUI::SBInterstitialReason
+security_interstitials::BaseSafeBrowsingErrorUI::SBInterstitialReason
 BaseBlockingPage::GetInterstitialReason(
     const UnsafeResourceList& unsafe_resources) {
   bool harmful = false;
   for (UnsafeResourceList::const_iterator iter = unsafe_resources.begin();
        iter != unsafe_resources.end(); ++iter) {
     const BaseUIManager::UnsafeResource& resource = *iter;
     safe_browsing::SBThreatType threat_type = resource.threat_type;
     if (threat_type == SB_THREAT_TYPE_URL_MALWARE ||
         threat_type == SB_THREAT_TYPE_CLIENT_SIDE_MALWARE_URL) {
-      return SafeBrowsingErrorUI::SB_REASON_MALWARE;
+      return BaseSafeBrowsingErrorUI::SB_REASON_MALWARE;
     } else if (threat_type == SB_THREAT_TYPE_URL_UNWANTED) {
       harmful = true;
     } else {
       DCHECK(threat_type == SB_THREAT_TYPE_URL_PHISHING ||
              threat_type == SB_THREAT_TYPE_CLIENT_SIDE_PHISHING_URL);
     }
   }
 
   if (harmful)
-    return SafeBrowsingErrorUI::SB_REASON_HARMFUL;
-  return SafeBrowsingErrorUI::SB_REASON_PHISHING;
+    return BaseSafeBrowsingErrorUI::SB_REASON_HARMFUL;
+  return BaseSafeBrowsingErrorUI::SB_REASON_PHISHING;
 }
 
 BaseUIManager* BaseBlockingPage::ui_manager() const {
   return ui_manager_;
 }
 
 const GURL BaseBlockingPage::main_frame_url() const {
   return main_frame_url_;
 }
 
 BaseBlockingPage::UnsafeResourceList
 BaseBlockingPage::unsafe_resources() const {
   return unsafe_resources_;
 }
 
-SafeBrowsingErrorUI* BaseBlockingPage::sb_error_ui() const {
+SafeBrowsingLoudErrorUI* BaseBlockingPage::sb_error_ui() const {
   return sb_error_ui_.get();
 }
 
 void BaseBlockingPage::set_proceeded(bool proceeded) {
   proceeded_ = proceeded;
 }
 
 // static
 security_interstitials::MetricsHelper::ReportDetails
 BaseBlockingPage::GetReportingInfo(const UnsafeResourceList& unsafe_resources) {
-  SafeBrowsingErrorUI::SBInterstitialReason interstitial_reason =
+  BaseSafeBrowsingErrorUI::SBInterstitialReason interstitial_reason =
       GetInterstitialReason(unsafe_resources);
 
   security_interstitials::MetricsHelper::ReportDetails reporting_info;
   reporting_info.metric_prefix =
       GetMetricPrefix(unsafe_resources, interstitial_reason);
   reporting_info.extra_suffix = GetExtraMetricsSuffix(unsafe_resources);
   return reporting_info;
 }
 
 // static
 std::unique_ptr<SecurityInterstitialControllerClient>
 BaseBlockingPage::CreateControllerClient(
     content::WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources,
     BaseUIManager* ui_manager) {
   history::HistoryService* history_service =
       ui_manager->history_service(web_contents);
 
   std::unique_ptr<security_interstitials::MetricsHelper> metrics_helper =
       base::MakeUnique<security_interstitials::MetricsHelper>(
           unsafe_resources[0].url, GetReportingInfo(unsafe_resources),
           history_service);
 
   return base::MakeUnique<SecurityInterstitialControllerClient>(
       web_contents, std::move(metrics_helper), nullptr, /* prefs */
       ui_manager->app_locale(), ui_manager->default_safe_page());
 }
 
 }  // namespace safe_browsing