Implement a skeleton of the Superfish interstitial

chrome/browser/ssl/ssl_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.
 
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/interstitials/chrome_controller_client.h"
 #include "chrome/browser/interstitials/chrome_metrics_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ssl/cert_report_helper.h"
 #include "chrome/browser/ssl/ssl_cert_reporter.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing/common/safe_browsing_prefs.h"
 #include "components/security_interstitials/core/controller_client.h"
 #include "components/security_interstitials/core/metrics_helper.h"
 #include "components/security_interstitials/core/ssl_error_ui.h"
+#include "components/security_interstitials/core/superfish_error_ui.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/ssl_status.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/renderer_preferences.h"
 #include "net/base/net_errors.h"
 
 using base::TimeTicks;
@@ skipping 52 matching lines @@
         event,
         END_OF_SSL_EXPIRATION_AND_DECISION);
   }
 }
 
 std::unique_ptr<ChromeMetricsHelper> CreateMetricsHelper(
     content::WebContents* web_contents,
     int cert_error,
     const GURL& request_url,
     bool overridable) {
-  // Set up the metrics helper for the SSLErrorUI.
   security_interstitials::MetricsHelper::ReportDetails reporting_info;
   reporting_info.metric_prefix =
       overridable ? "ssl_overridable" : "ssl_nonoverridable";
   return base::MakeUnique<ChromeMetricsHelper>(
       web_contents, request_url, reporting_info,
       GetSamplingEventName(overridable, cert_error));
 }
 
 }  // namespace
 
 // static
 InterstitialPageDelegate::TypeID SSLBlockingPage::kTypeForTesting =
     &SSLBlockingPage::kTypeForTesting;
 
 // static
 SSLBlockingPage* SSLBlockingPage::Create(
     content::WebContents* web_contents,
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
     int options_mask,
     const base::Time& time_triggered,
     std::unique_ptr<SSLCertReporter> ssl_cert_reporter,
+    bool is_superfish,
     const base::Callback<void(content::CertificateRequestResultType)>&
         callback) {
   // Override prefs for the SSLErrorUI.
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   if (profile &&
       !profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed)) {
     options_mask |= SSLErrorUI::HARD_OVERRIDE_DISABLED;
   }
-  bool overridable = IsOverridable(
-      options_mask,
-      Profile::FromBrowserContext(web_contents->GetBrowserContext()));
+  const bool overridable =
+      is_superfish
+          ? false
+          : IsOverridable(options_mask, Profile::FromBrowserContext(
+                                            web_contents->GetBrowserContext()));
   if (overridable)
     options_mask |= SSLErrorUI::SOFT_OVERRIDE_ENABLED;
   else
     options_mask &= ~SSLErrorUI::SOFT_OVERRIDE_ENABLED;
 
   std::unique_ptr<ChromeMetricsHelper> metrics_helper(
       CreateMetricsHelper(web_contents, cert_error, request_url, overridable));
   metrics_helper.get()->StartRecordingCaptivePortalMetrics(overridable);
 
   return new SSLBlockingPage(web_contents, cert_error, ssl_info, request_url,
                              options_mask, time_triggered,
                              std::move(ssl_cert_reporter), overridable,
-                             std::move(metrics_helper), callback);
+                             std::move(metrics_helper), is_superfish, callback);
 }
 
 bool SSLBlockingPage::ShouldCreateNewNavigation() const {
   return true;
 }
 
 InterstitialPageDelegate::TypeID SSLBlockingPage::GetTypeForTesting() const {
   return SSLBlockingPage::kTypeForTesting;
 }
 
@@ skipping 18 matching lines @@
 SSLBlockingPage::SSLBlockingPage(
     content::WebContents* web_contents,
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
     int options_mask,
     const base::Time& time_triggered,
     std::unique_ptr<SSLCertReporter> ssl_cert_reporter,
     bool overridable,
     std::unique_ptr<ChromeMetricsHelper> metrics_helper,
+    bool is_superfish,
     const base::Callback<void(content::CertificateRequestResultType)>& callback)
     : SecurityInterstitialPage(
           web_contents,
           request_url,
-          base::MakeUnique<ChromeControllerClient>(
-              web_contents, std::move(metrics_helper))),
+          base::MakeUnique<ChromeControllerClient>(web_contents,
+                                                   std::move(metrics_helper))),
       callback_(callback),
       ssl_info_(ssl_info),
       overridable_(overridable),
       expired_but_previously_allowed_(
           (options_mask & SSLErrorUI::EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0),
       cert_report_helper_(new CertReportHelper(
           std::move(ssl_cert_reporter),
           web_contents,
           request_url,
           ssl_info,
-          certificate_reporting::ErrorReport::INTERSTITIAL_SSL,
+          is_superfish
+              ? certificate_reporting::ErrorReport::INTERSTITIAL_SUPERFISH
+              : certificate_reporting::ErrorReport::INTERSTITIAL_SSL,
           overridable_,
           time_triggered,
           controller()->metrics_helper())),
-      ssl_error_ui_(new SSLErrorUI(request_url,
-                                   cert_error,
-                                   ssl_info,
-                                   options_mask,
-                                   time_triggered,
-                                   controller())) {
+      ssl_error_ui_(
+          is_superfish
+              ? base::MakeUnique<security_interstitials::SuperfishErrorUI>(
+                    request_url,
+                    cert_error,
+                    ssl_info,
+                    options_mask,
+                    time_triggered,
+                    controller())
+              : base::MakeUnique<SSLErrorUI>(request_url,
+                                             cert_error,
+                                             ssl_info,
+                                             options_mask,
+                                             time_triggered,
+                                             controller())) {
   // Creating an interstitial without showing (e.g. from chrome://interstitials)
   // it leaks memory, so don't create it here.
 }
 
 void SSLBlockingPage::OverrideEntry(NavigationEntry* entry) {
   entry->GetSSL() = content::SSLStatus(ssl_info_);
 }
 
 void SSLBlockingPage::SetSSLCertReporterForTesting(
     std::unique_ptr<SSLCertReporter> ssl_cert_reporter) {
@@ skipping 81 matching lines @@
 
 // static
 bool SSLBlockingPage::IsOverridable(int options_mask,
                                     const Profile* const profile) {
   const bool is_overridable =
       (options_mask & SSLErrorUI::SOFT_OVERRIDE_ENABLED) &&
       !(options_mask & SSLErrorUI::STRICT_ENFORCEMENT) &&
       profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed);
   return is_overridable;
 }