Add SecurityStateModelClient interface and implementation

chrome/browser/ssl/security_state_model.cc

 // Copyright 2015 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/security_state_model.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ssl/chrome_security_state_model_client.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/cert_store.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/origin_util.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
@@ skipping 35 matching lines @@
     level = SecurityStateModel::SECURITY_ERROR;
   } else {
     status = NEUTRAL;
     level = SecurityStateModel::NONE;
   }
 
   UMA_HISTOGRAM_ENUMERATION(kEnumeration, status, LAST_STATUS);
   return level;
 }
 
-scoped_refptr<net::X509Certificate> GetCertForSSLStatus(
-    const content::SSLStatus& ssl) {
-  scoped_refptr<net::X509Certificate> cert;
-  return content::CertStore::GetInstance()->RetrieveCert(ssl.cert_id, &cert)
-             ? cert
-             : nullptr;
-}
-
 SecurityStateModel::SHA1DeprecationStatus GetSHA1DeprecationStatus(
     scoped_refptr<net::X509Certificate> cert,
     const content::SSLStatus& ssl) {
   if (!cert || !(ssl.cert_status & net::CERT_STATUS_SHA1_SIGNATURE_PRESENT))
     return SecurityStateModel::NO_DEPRECATED_SHA1;
 
   // The internal representation of the dates for UI treatment of SHA-1.
   // See http://crbug.com/401365 for details.
   static const int64_t kJanuary2017 = INT64_C(13127702400000000);
   if (cert->valid_expiry() >= base::Time::FromInternalValue(kJanuary2017))
@@ skipping 23 matching lines @@
 
   return SecurityStateModel::NO_MIXED_CONTENT;
 }
 
 SecurityStateModel::SecurityLevel GetSecurityLevelForRequest(
     const GURL& url,
     const content::SSLStatus& ssl,
     Profile* profile,
     scoped_refptr<net::X509Certificate> cert,
     SecurityStateModel::SHA1DeprecationStatus sha1_status,
-    SecurityStateModel::MixedContentStatus mixed_content_status) {
+    SecurityStateModel::MixedContentStatus mixed_content_status,
+    bool used_policy_installed_certificate) {
   switch (ssl.security_style) {
     case content::SECURITY_STYLE_UNKNOWN:
       return SecurityStateModel::NONE;
 
     case content::SECURITY_STYLE_UNAUTHENTICATED: {
       if (!content::IsOriginSecure(url) && url.IsStandard())
         return GetSecurityLevelForNonSecureFieldTrial();
       return SecurityStateModel::NONE;
     }
 
     case content::SECURITY_STYLE_AUTHENTICATION_BROKEN:
       return SecurityStateModel::SECURITY_ERROR;
 
     case content::SECURITY_STYLE_WARNING:
       NOTREACHED();
       return SecurityStateModel::SECURITY_WARNING;
 
     case content::SECURITY_STYLE_AUTHENTICATED: {
-#if defined(OS_CHROMEOS)
       // Report if there is a policy cert first, before reporting any other
       // authenticated-but-with-errors cases. A policy cert is a strong
       // indicator of a MITM being present (the enterprise), while the
       // other authenticated-but-with-errors indicate something may
       // be wrong, or may be wrong in the future, but is unclear now.
-      policy::PolicyCertService* service =
-          policy::PolicyCertServiceFactory::GetForProfile(profile);
-      if (service && service->UsedPolicyCertificates())
+      if (used_policy_installed_certificate)
         return SecurityStateModel::SECURITY_POLICY_WARNING;
-#endif
 
       if (sha1_status == SecurityStateModel::DEPRECATED_SHA1_MAJOR)
         return SecurityStateModel::SECURITY_ERROR;
       if (sha1_status == SecurityStateModel::DEPRECATED_SHA1_MINOR)
         return SecurityStateModel::NONE;
 
       // Active mixed content is downgraded to the BROKEN style and
       // handled above.
       DCHECK_NE(SecurityStateModel::RAN_MIXED_CONTENT, mixed_content_status);
       DCHECK_NE(SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT,
@@ skipping 52 matching lines @@
     const {
   content::NavigationEntry* entry =
       web_contents_->GetController().GetVisibleEntry();
   if (!entry) {
     security_info_ = SecurityInfo();
     visible_url_ = GURL();
     visible_ssl_status_ = content::SSLStatus();
     return security_info_;
   }
 
+  scoped_refptr<net::X509Certificate> cert = nullptr;
+  client_->RetrieveCert(&cert);
+
   if (entry->GetURL() == visible_url_ &&
       entry->GetSSL().Equals(visible_ssl_status_)) {
     // A cert must be present in the CertStore in order for the site to
     // be considered EV_SECURE, and the cert might have been removed
     // since the security level was last computed.
-    if (security_info_.security_level == EV_SECURE &&
-        !GetCertForSSLStatus(visible_ssl_status_)) {
+    if (security_info_.security_level == EV_SECURE && !cert) {
       security_info_.security_level = SECURE;
     }
     return security_info_;
   }
 
   SecurityInfoForRequest(
       entry->GetURL(), entry->GetSSL(),
-      Profile::FromBrowserContext(web_contents_->GetBrowserContext()),
-      &security_info_);
+      Profile::FromBrowserContext(web_contents_->GetBrowserContext()), cert,
+      client_->UsedPolicyInstalledCertificate(), &security_info_);
   visible_url_ = entry->GetURL();
   visible_ssl_status_ = entry->GetSSL();
   return security_info_;
 }
 
 // static
-void SecurityStateModel::SecurityInfoForRequest(const GURL& url,
-                                                const content::SSLStatus& ssl,
-                                                Profile* profile,
-                                                SecurityInfo* security_info) {
-  scoped_refptr<net::X509Certificate> cert = GetCertForSSLStatus(ssl);
+void SecurityStateModel::SecurityInfoForRequest(
+    const GURL& url,
+    const content::SSLStatus& ssl,
+    Profile* profile,
+    const scoped_refptr<net::X509Certificate>& cert,
+    bool used_policy_installed_certificate,
+    SecurityInfo* security_info) {
   security_info->cert_id = ssl.cert_id;
   security_info->sha1_deprecation_status = GetSHA1DeprecationStatus(cert, ssl);
   security_info->mixed_content_status = GetMixedContentStatus(ssl);
   security_info->security_bits = ssl.security_bits;
   security_info->connection_status = ssl.connection_status;
   security_info->cert_status = ssl.cert_status;
   security_info->scheme_is_cryptographic = url.SchemeIsCryptographic();
   security_info->is_secure_protocol_and_ciphersuite =
       (net::SSLConnectionStatusToVersion(ssl.connection_status) >=
            net::SSL_CONNECTION_VERSION_TLS1_2 &&
        net::IsSecureTLSCipherSuite(
            net::SSLConnectionStatusToCipherSuite(ssl.connection_status)));
 
   security_info->sct_verify_statuses.clear();
   for (const auto& sct : ssl.signed_certificate_timestamp_ids) {
     security_info->sct_verify_statuses.push_back(sct.status);
   }
 
   security_info->security_level = GetSecurityLevelForRequest(
       url, ssl, profile, cert, security_info->sha1_deprecation_status,
-      security_info->mixed_content_status);
+      security_info->mixed_content_status, used_policy_installed_certificate);
 }
 
 SecurityStateModel::SecurityStateModel(content::WebContents* web_contents)
-    : web_contents_(web_contents) {}
+    : web_contents_(web_contents),
+      client_(new ChromeSecurityStateModelClient(web_contents)) {}