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"
@@ skipping 76 matching lines @@
         event,
         END_OF_SSL_EXPIRATION_AND_DECISION);
   } else {
     UMA_HISTOGRAM_ENUMERATION(
         "interstitial.ssl.expiration_and_decision.nonoverridable",
         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,
@@ skipping 16 matching lines @@
       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);
+  SSLBlockingPage* page =
+      new SSLBlockingPage(web_contents, ssl_info, request_url, options_mask,
+                          time_triggered, std::move(ssl_cert_reporter),
+                          overridable, std::move(metrics_helper), callback);
+  page->SetErrorUI(base::MakeUnique<SSLErrorUI>(
+      request_url, cert_error, ssl_info, options_mask, time_triggered,
+      page->controller()));
+  return page;
 }
 
 bool SSLBlockingPage::ShouldCreateNewNavigation() const {
   return true;
 }
 
 InterstitialPageDelegate::TypeID SSLBlockingPage::GetTypeForTesting() const {
   return SSLBlockingPage::kTypeForTesting;
 }
 
 SSLBlockingPage::~SSLBlockingPage() {
   if (!callback_.is_null()) {
     // The page is closed without the user having chosen what to do, default to
     // deny.
     RecordSSLExpirationPageEventState(expired_but_previously_allowed_, false,
                                       overridable_);
     NotifyDenyCertificate();
   }
 }
 
 void SSLBlockingPage::PopulateInterstitialStrings(
     base::DictionaryValue* load_time_data) {
   ssl_error_ui_->PopulateStringsForHTML(load_time_data);
   cert_report_helper_->PopulateExtendedReportingOption(load_time_data);
 }
 
+void SSLBlockingPage::SetErrorUI(std::unique_ptr<SSLErrorUI> error_ui) {
+  ssl_error_ui_ = std::move(error_ui);
+}
+
+// static
+std::unique_ptr<ChromeMetricsHelper> SSLBlockingPage::CreateMetricsHelper(
+    content::WebContents* web_contents,
+    int cert_error,
+    const GURL& request_url,
+    bool overridable) {
+  // Set up the metrics helper for the SSLErrorUI.

[meacer, 2017/06/22 19:06:18]

nit: Comment seems a bit redundant.

[estark, 2017/06/22 22:01:05]

Done.

+  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));
+}
+
 // Note that we always create a navigation entry with SSL errors.
 // No error happening loading a sub-resource triggers an interstitial so far.
 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,
     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,
           overridable_,
           time_triggered,
-          controller()->metrics_helper())),
-      ssl_error_ui_(new SSLErrorUI(request_url,
-                                   cert_error,
-                                   ssl_info,
-                                   options_mask,
-                                   time_triggered,
-                                   controller())) {
+          controller()->metrics_helper())) {
   // 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;
 }