Remove unnecessary |result| argument from AllowCertificateError()

chrome/browser/ui/webui/interstitials/interstitial_ui.cc

 // Copyright 2014 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/ui/webui/interstitials/interstitial_ui.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
@@ skipping 76 matching lines @@
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
 // Provides fake connection information to the captive portal blocking page so
 // that both Wi-Fi and non Wi-Fi blocking pages can be displayed.
 class CaptivePortalBlockingPageWithNetInfo : public CaptivePortalBlockingPage {
  public:
   CaptivePortalBlockingPageWithNetInfo(
       content::WebContents* web_contents,
       const GURL& request_url,
       const GURL& login_url,
       const net::SSLInfo& ssl_info,
-      const base::Callback<void(bool)>& callback,
+      const base::Callback<void(content::CertificateRequestResultType)>&
+          callback,
       bool is_wifi,
       const std::string& wifi_ssid)
       : CaptivePortalBlockingPage(web_contents,
                                   request_url,
                                   login_url,
                                   nullptr,
                                   ssl_info,
                                   callback),
         is_wifi_(is_wifi),
         wifi_ssid_(wifi_ssid) {}
@@ skipping 37 matching lines @@
     strict_enforcement = strict_enforcement_param == "1";
   }
   net::SSLInfo ssl_info;
   ssl_info.cert = ssl_info.unverified_cert = CreateFakeCert();
   // This delegate doesn't create an interstitial.
   int options_mask = 0;
   if (overridable)
     options_mask |= security_interstitials::SSLErrorUI::SOFT_OVERRIDE_ENABLED;
   if (strict_enforcement)
     options_mask |= security_interstitials::SSLErrorUI::STRICT_ENFORCEMENT;
-  return new SSLBlockingPage(web_contents, cert_error, ssl_info, request_url,
-                             options_mask, time_triggered_, nullptr,
-                             base::Callback<void(bool)>());
+  return new SSLBlockingPage(
+      web_contents, cert_error, ssl_info, request_url, options_mask,
+      time_triggered_, nullptr,
+      base::Callback<void(content::CertificateRequestResultType)>());

[nasko, 2016/08/08 18:32:03]

Orthogonal for this CL and therefore just for my own education. Do we not pass a
meaningful callback here because we don't allow proceeding through the
interstitial?

[estark, 2016/08/08 20:00:13]

Yep, that's right. Clicking "Back to Safety" or "Proceed" on
chrome://interstitials is a no-op.

 }
 
 BadClockBlockingPage* CreateBadClockBlockingPage(
     content::WebContents* web_contents) {
   // Set up a fake clock error.
   int cert_error = net::ERR_CERT_DATE_INVALID;
   GURL request_url("https://example.com");
   bool overridable = false;
   bool strict_enforcement = false;
   std::string url_param;
@@ skipping 25 matching lines @@
   }
 
   net::SSLInfo ssl_info;
   ssl_info.cert = ssl_info.unverified_cert = CreateFakeCert();
   // This delegate doesn't create an interstitial.
   int options_mask = 0;
   if (overridable)
     options_mask |= security_interstitials::SSLErrorUI::SOFT_OVERRIDE_ENABLED;
   if (strict_enforcement)
     options_mask |= security_interstitials::SSLErrorUI::STRICT_ENFORCEMENT;
-  return new BadClockBlockingPage(web_contents, cert_error, ssl_info,
-                                  request_url, base::Time::Now(), clock_state,
-                                  nullptr, base::Callback<void(bool)>());
+  return new BadClockBlockingPage(
+      web_contents, cert_error, ssl_info, request_url, base::Time::Now(),
+      clock_state, nullptr,
+      base::Callback<void(content::CertificateRequestResultType)>());
 }
 
 safe_browsing::SafeBrowsingBlockingPage* CreateSafeBrowsingBlockingPage(
     content::WebContents* web_contents) {
   safe_browsing::SBThreatType threat_type =
       safe_browsing::SB_THREAT_TYPE_URL_MALWARE;
   GURL request_url("http://example.com");
   std::string url_param;
   if (net::GetValueForKeyInQuery(web_contents->GetURL(),
                                  "url",
@@ skipping 71 matching lines @@
   std::string wifi_ssid_param;
   if (net::GetValueForKeyInQuery(web_contents->GetURL(), "wifi_name",
                                  &wifi_ssid_param)) {
     wifi_ssid = wifi_ssid_param;
   }
   net::SSLInfo ssl_info;
   ssl_info.cert = ssl_info.unverified_cert = CreateFakeCert();
   CaptivePortalBlockingPage* blocking_page =
       new CaptivePortalBlockingPageWithNetInfo(
           web_contents, request_url, landing_url, ssl_info,
-          base::Callback<void(bool)>(), is_wifi_connection, wifi_ssid);
+          base::Callback<void(content::CertificateRequestResultType)>(),
+          is_wifi_connection, wifi_ssid);
   return blocking_page;
 }
 #endif
 
 } //  namespace
 
 InterstitialUI::InterstitialUI(content::WebUI* web_ui)
     : WebUIController(web_ui) {
   std::unique_ptr<InterstitialHTMLSource> html_source(
       new InterstitialHTMLSource(web_ui->GetWebContents()));
@@ skipping 62 matching lines @@
     html = interstitial_delegate.get()->GetHTMLContents();
   } else {
     html = ResourceBundle::GetSharedInstance()
                           .GetRawDataResource(IDR_SECURITY_INTERSTITIAL_UI_HTML)
                           .as_string();
   }
   scoped_refptr<base::RefCountedString> html_bytes = new base::RefCountedString;
   html_bytes->data().assign(html.begin(), html.end());
   callback.Run(html_bytes.get());
 }