Remove unnecessary |result| argument from AllowCertificateError()

content/browser/ssl/ssl_policy.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 "content/browser/ssl/ssl_policy.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/singleton.h"
@@ skipping 177 matching lines @@
   // SECURITY_STYLE_AUTHENTICATION_BROKEN.
   if (net::IsCertStatusError(cert_status) &&
       !net::IsCertStatusMinorError(cert_status)) {
     return SECURITY_STYLE_AUTHENTICATION_BROKEN;
   }
 
   return SECURITY_STYLE_AUTHENTICATED;
 }
 
 void SSLPolicy::OnAllowCertificate(scoped_refptr<SSLCertErrorHandler> handler,
-                                   bool allow) {
+                                   CertificateRequestResultType decision) {
   DCHECK(handler->ssl_info().is_valid());
-  if (allow) {
-    // Default behavior for accepting a certificate.
-    // Note that we should not call SetMaxSecurityStyle here, because the active
-    // NavigationEntry has just been deleted (in HideInterstitialPage) and the
-    // new NavigationEntry will not be set until DidNavigate.  This is ok,
-    // because the new NavigationEntry will have its max security style set
-    // within DidNavigate.
-    //
-    // While AllowCertForHost() executes synchronously on this thread,
-    // ContinueRequest() gets posted to a different thread. Calling
-    // AllowCertForHost() first ensures deterministic ordering.
-    backend_->AllowCertForHost(*handler->ssl_info().cert.get(),
-                               handler->request_url().host(),
-                               handler->cert_error());
-    handler->ContinueRequest();
-  } else {
-    // Default behavior for rejecting a certificate.
-    handler->CancelRequest();
+  switch (decision) {
+    case CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE:
+      // Note that we should not call SetMaxSecurityStyle here, because the
+      // active
+      // NavigationEntry has just been deleted (in HideInterstitialPage) and the
+      // new NavigationEntry will not be set until DidNavigate.  This is ok,
+      // because the new NavigationEntry will have its max security style set
+      // within DidNavigate.
+      //
+      // While AllowCertForHost() executes synchronously on this thread,
+      // ContinueRequest() gets posted to a different thread. Calling
+      // AllowCertForHost() first ensures deterministic ordering.
+      backend_->AllowCertForHost(*handler->ssl_info().cert.get(),
+                                 handler->request_url().host(),
+                                 handler->cert_error());
+      handler->ContinueRequest();
+      return;
+    case CERTIFICATE_REQUEST_RESULT_TYPE_DENY:
+      handler->DenyRequest();
+      return;
+    case CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL:
+      handler->CancelRequest();
+      return;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Certificate Error Routines
 
 void SSLPolicy::OnCertErrorInternal(SSLCertErrorHandler* handler,
                                     int options_mask) {
   bool overridable = (options_mask & OVERRIDABLE) != 0;
   bool strict_enforcement = (options_mask & STRICT_ENFORCEMENT) != 0;
   bool expired_previous_decision =
       (options_mask & EXPIRED_PREVIOUS_DECISION) != 0;
-  CertificateRequestResultType result =
-      CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE;
   GetContentClient()->browser()->AllowCertificateError(
       handler->GetManager()->controller()->GetWebContents(),
       handler->cert_error(), handler->ssl_info(), handler->request_url(),
       handler->resource_type(), overridable, strict_enforcement,
       expired_previous_decision,
       base::Bind(&SSLPolicy::OnAllowCertificate, base::Unretained(this),
-                 make_scoped_refptr(handler)),
-      &result);
-  switch (result) {
-    case CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE:
-      break;
-    case CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL:
-      handler->CancelRequest();
-      break;
-    case CERTIFICATE_REQUEST_RESULT_TYPE_DENY:
-      handler->DenyRequest();
-      break;
-    default:
-      NOTREACHED();
-  }
+                 make_scoped_refptr(handler)));
 }
 
 void SSLPolicy::InitializeEntryIfNeeded(NavigationEntryImpl* entry) {
   if (entry->GetSSL().security_style != SECURITY_STYLE_UNKNOWN)
     return;
 
   entry->GetSSL().security_style = GetSecurityStyleForResource(
       entry->GetURL(), entry->GetSSL().cert_id, entry->GetSSL().cert_status);
 }
 
 void SSLPolicy::OriginRanInsecureContent(const std::string& origin, int pid) {
   GURL parsed_origin(origin);
   if (parsed_origin.SchemeIsCryptographic())
     backend_->HostRanInsecureContent(parsed_origin.host(), pid);
 }
 
 }  // namespace content