Rename SecurityStateModel::MIXED_CONTENT_STATUS enum values

components/security_state/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 "components/security_state/security_state_model.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 54 matching lines @@
   static const int64_t kJanuary2017 = INT64_C(13127702400000000);
   if (cert->valid_expiry() >= base::Time::FromInternalValue(kJanuary2017))
     return SecurityStateModel::DEPRECATED_SHA1_MAJOR;
   static const int64_t kJanuary2016 = INT64_C(13096080000000000);
   if (cert->valid_expiry() >= base::Time::FromInternalValue(kJanuary2016))
     return SecurityStateModel::DEPRECATED_SHA1_MINOR;
 
   return SecurityStateModel::NO_DEPRECATED_SHA1;
 }
 
-SecurityStateModel::MixedContentStatus GetMixedContentStatus(
+SecurityStateModel::ContentStatus GetMixedContentStatus(
     const SecurityStateModel::VisibleSecurityState& visible_security_state) {
   bool ran_insecure_content = visible_security_state.ran_mixed_content;
   bool displayed_insecure_content =
       visible_security_state.displayed_mixed_content;
   if (ran_insecure_content && displayed_insecure_content)
-    return SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT;
+    return SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN;
   if (ran_insecure_content)
-    return SecurityStateModel::RAN_MIXED_CONTENT;
+    return SecurityStateModel::CONTENT_STATUS_RAN;
   if (displayed_insecure_content)
-    return SecurityStateModel::DISPLAYED_MIXED_CONTENT;
+    return SecurityStateModel::CONTENT_STATUS_DISPLAYED;
 
-  return SecurityStateModel::NO_MIXED_CONTENT;
+  return SecurityStateModel::CONTENT_STATUS_NONE;
 }
 
 SecurityStateModel::SecurityLevel GetSecurityLevelForRequest(
     const SecurityStateModel::VisibleSecurityState& visible_security_state,
     SecurityStateModelClient* client,
     const scoped_refptr<net::X509Certificate>& cert,
     SecurityStateModel::SHA1DeprecationStatus sha1_status,
-    SecurityStateModel::MixedContentStatus mixed_content_status) {
+    SecurityStateModel::ContentStatus mixed_content_status) {
   DCHECK(visible_security_state.connection_info_initialized ||
          visible_security_state.fails_malware_check);
 
   // Override the connection security information if the website failed the
   // browser's malware checks.
   if (visible_security_state.fails_malware_check)
     return SecurityStateModel::SECURITY_ERROR;
 
   GURL url = visible_security_state.url;
   switch (visible_security_state.initial_security_level) {
@@ skipping 13 matching lines @@
     case SecurityStateModel::SECURE:
     case SecurityStateModel::EV_SECURE: {
       // Major cert errors and active mixed content will generally be
       // downgraded by the embedder to SECURITY_ERROR and handled above,
       // but downgrade here just in case.
       net::CertStatus cert_status = visible_security_state.cert_status;
       if (net::IsCertStatusError(cert_status) &&
           !net::IsCertStatusMinorError(cert_status)) {
         return SecurityStateModel::SECURITY_ERROR;
       }
-      if (mixed_content_status == SecurityStateModel::RAN_MIXED_CONTENT ||
+      if (mixed_content_status == SecurityStateModel::CONTENT_STATUS_RAN ||
           mixed_content_status ==
-              SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT) {
+              SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN) {
         return SecurityStateModel::kRanInsecureContentLevel;
       }
 
       // 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.
       if (client->UsedPolicyInstalledCertificate())
         return SecurityStateModel::SECURITY_POLICY_WARNING;
 
       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 handled above.
-      DCHECK_NE(SecurityStateModel::RAN_MIXED_CONTENT, mixed_content_status);
-      DCHECK_NE(SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT,
+      DCHECK_NE(SecurityStateModel::CONTENT_STATUS_RAN, mixed_content_status);
+      DCHECK_NE(SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN,
                 mixed_content_status);
-      if (mixed_content_status == SecurityStateModel::DISPLAYED_MIXED_CONTENT)
+      if (mixed_content_status == SecurityStateModel::CONTENT_STATUS_DISPLAYED)
         return SecurityStateModel::kDisplayedInsecureContentLevel;
 
       if (net::IsCertStatusError(cert_status)) {
         // Major cert errors are handled above.
         DCHECK(net::IsCertStatusMinorError(cert_status));
         return SecurityStateModel::NONE;
       }
       if (net::SSLConnectionStatusToVersion(
               visible_security_state.connection_status) ==
           net::SSL_CONNECTION_VERSION_SSL3) {
@@ skipping 12 matching lines @@
 void SecurityInfoForRequest(
     SecurityStateModelClient* client,
     const SecurityStateModel::VisibleSecurityState& visible_security_state,
     const scoped_refptr<net::X509Certificate>& cert,
     SecurityStateModel::SecurityInfo* security_info) {
   if (!visible_security_state.connection_info_initialized) {
     *security_info = SecurityStateModel::SecurityInfo();
     security_info->fails_malware_check =
         visible_security_state.fails_malware_check;
     if (security_info->fails_malware_check) {
-      security_info->security_level =
-          GetSecurityLevelForRequest(visible_security_state, client, cert,
-                                     SecurityStateModel::UNKNOWN_SHA1,
-                                     SecurityStateModel::UNKNOWN_MIXED_CONTENT);
+      security_info->security_level = GetSecurityLevelForRequest(
+          visible_security_state, client, cert,
+          SecurityStateModel::UNKNOWN_SHA1,
+          SecurityStateModel::CONTENT_STATUS_UNKNOWN);
     }
     return;
   }
   security_info->cert_id = visible_security_state.cert_id;
   security_info->sha1_deprecation_status =
       GetSHA1DeprecationStatus(cert, visible_security_state);
   security_info->mixed_content_status =
       GetMixedContentStatus(visible_security_state);
   security_info->security_bits = visible_security_state.security_bits;
   security_info->connection_status = visible_security_state.connection_status;
@@ skipping 25 matching lines @@
     SecurityStateModel::kDisplayedInsecureContentLevel =
         SecurityStateModel::NONE;
 const SecurityStateModel::SecurityLevel
     SecurityStateModel::kRanInsecureContentLevel =
         SecurityStateModel::SECURITY_ERROR;
 
 SecurityStateModel::SecurityInfo::SecurityInfo()
     : security_level(SecurityStateModel::NONE),
       fails_malware_check(false),
       sha1_deprecation_status(SecurityStateModel::NO_DEPRECATED_SHA1),
-      mixed_content_status(SecurityStateModel::NO_MIXED_CONTENT),
+      mixed_content_status(SecurityStateModel::CONTENT_STATUS_NONE),
       scheme_is_cryptographic(false),
       cert_status(0),
       cert_id(0),
       security_bits(-1),
       connection_status(0),
       is_secure_protocol_and_ciphersuite(false),
       pkp_bypassed(false) {}
 
 SecurityStateModel::SecurityInfo::~SecurityInfo() {}
 
@@ skipping 53 matching lines @@
           cert_id == other.cert_id && cert_status == other.cert_status &&
           connection_status == other.connection_status &&
           security_bits == other.security_bits &&
           sct_verify_statuses == other.sct_verify_statuses &&
           displayed_mixed_content == other.displayed_mixed_content &&
           ran_mixed_content == other.ran_mixed_content &&
           pkp_bypassed == other.pkp_bypassed);
 }
 
 }  // namespace security_state