Remove unnecessary |result| argument from AllowCertificateError()

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 97 matching lines @@
 // 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,
-    const base::Callback<void(bool)>& callback)
+    const base::Callback<void(content::CertificateRequestResultType)>& callback)
     : SecurityInterstitialPage(web_contents, request_url),
       callback_(callback),
       ssl_info_(ssl_info),
       overridable_(IsOverridable(
           options_mask,
           Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
       expired_but_previously_allowed_(
           (options_mask & SSLErrorUI::EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0),
       controller_(new ChromeControllerClient(web_contents)) {
   // Override prefs for the SSLErrorUI.
@@ skipping 104 matching lines @@
 
 void SSLBlockingPage::OnProceed() {
   // Finish collecting metrics, if the user opted into it.
   cert_report_helper_->FinishCertCollection(
       certificate_reporting::ErrorReport::USER_PROCEEDED);
   RecordSSLExpirationPageEventState(
       expired_but_previously_allowed_, true, overridable_);
 
   // Accepting the certificate resumes the loading of the page.
   DCHECK(!callback_.is_null());
-  callback_.Run(true);
+  callback_.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE);
   callback_.Reset();
 }
 
 void SSLBlockingPage::OnDontProceed() {
   // Finish collecting metrics, if the user opted into it.
   cert_report_helper_->FinishCertCollection(
       certificate_reporting::ErrorReport::USER_DID_NOT_PROCEED);
   RecordSSLExpirationPageEventState(
       expired_but_previously_allowed_, false, overridable_);
 
   NotifyDenyCertificate();
 }
 
 void SSLBlockingPage::NotifyDenyCertificate() {
   // It's possible that callback_ may not exist if the user clicks "Proceed"
   // followed by pressing the back button before the interstitial is hidden.
   // In that case the certificate will still be treated as allowed.
   if (callback_.is_null())
     return;
 
-  callback_.Run(false);
+  callback_.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL);
   callback_.Reset();
 }
 
 // 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;
 }