Add constructor to create SSLStatus from SSLInfo

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 158 matching lines @@
       backend_->DidHostRunInsecureContent(
           entry->GetURL().host(), site_instance->GetProcess()->GetID())) {
     entry->GetSSL().security_style =
         SECURITY_STYLE_AUTHENTICATION_BROKEN;
     entry->GetSSL().content_status |= SSLStatus::RAN_INSECURE_CONTENT;
     return;
   }
 }
 
 // Static
-SecurityStyle SSLPolicy::GetSecurityStyleForResource(const GURL& url,
-                                                     const SSLStatus& ssl) {
+SecurityStyle SSLPolicy::GetSecurityStyleForResource(
+    const GURL& url,
+    int cert_id,
+    net::CertStatus cert_status) {
   // An HTTPS response may not have a certificate for some reason.  When that
   // happens, use the unauthenticated (HTTP) rather than the authentication
   // broken security style so that we can detect this error condition.
-  if (!url.SchemeIsCryptographic() || !ssl.cert_id)
+  if (!url.SchemeIsCryptographic() || !cert_id)
     return SECURITY_STYLE_UNAUTHENTICATED;
 
   // Minor errors don't lower the security style to
   // SECURITY_STYLE_AUTHENTICATION_BROKEN.
-  if (net::IsCertStatusError(ssl.cert_status) &&
-      !net::IsCertStatusMinorError(ssl.cert_status)) {
+  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) {
   DCHECK(handler->ssl_info().is_valid());
   if (allow) {
@@ skipping 53 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 }
 
 void SSLPolicy::InitializeEntryIfNeeded(NavigationEntryImpl* entry) {
   if (entry->GetSSL().security_style != SECURITY_STYLE_UNKNOWN)
     return;
 
-  entry->GetSSL().security_style =
-      GetSecurityStyleForResource(entry->GetURL(), entry->GetSSL());
+  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