Rename SecurityStyleExplanations and WebSecurityStyle fields

components/security_state/content/content_utils.cc

 // Copyright 2016 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/content/content_utils.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ skipping 19 matching lines @@
 
 namespace {
 
 // Note: This is a lossy operation. Not all of the policies that can be
 // expressed by a SecurityLevel can be expressed by a blink::WebSecurityStyle.
 blink::WebSecurityStyle SecurityLevelToSecurityStyle(
     security_state::SecurityLevel security_level) {
   switch (security_level) {
     case security_state::NONE:
     case security_state::HTTP_SHOW_WARNING:
-      return blink::WebSecurityStyleUnauthenticated;
+      return blink::WebSecurityStyleNeutral;
     case security_state::SECURITY_WARNING:
     case security_state::SECURE_WITH_POLICY_INSTALLED_CERT:
       return blink::WebSecurityStyleWarning;
     case security_state::EV_SECURE:
     case security_state::SECURE:
-      return blink::WebSecurityStyleAuthenticated;
+      return blink::WebSecurityStyleSecure;
     case security_state::DANGEROUS:
-      return blink::WebSecurityStyleAuthenticationBroken;
+      return blink::WebSecurityStyleInsecure;
   }
 
   NOTREACHED();
   return blink::WebSecurityStyleUnknown;
 }
 
 void AddConnectionExplanation(
     const security_state::SecurityInfo& security_info,
     content::SecurityStyleExplanations* security_style_explanations) {
   // Avoid showing TLS details when we couldn't even establish a TLS connection
@@ skipping 122 matching lines @@
     const security_state::SecurityInfo& security_info,
     content::SecurityStyleExplanations* security_style_explanations) {
   const blink::WebSecurityStyle security_style =
       SecurityLevelToSecurityStyle(security_info.security_level);
 
   // The HTTP_SHOW_WARNING state may occur if the page is served as a data: URI
   // or if it is served non-securely AND contains a sensitive form field.
   if (security_info.security_level == security_state::HTTP_SHOW_WARNING &&
       (security_info.displayed_password_field_on_http ||
        security_info.displayed_credit_card_field_on_http)) {
-    security_style_explanations->unauthenticated_explanations.push_back(
+    security_style_explanations->neutral_explanations.push_back(
         content::SecurityStyleExplanation(
             l10n_util::GetStringUTF8(IDS_PRIVATE_USER_DATA_INPUT),
             l10n_util::GetStringUTF8(IDS_PRIVATE_USER_DATA_INPUT_DESCRIPTION)));
   }
   security_style_explanations->ran_insecure_content_style =
       SecurityLevelToSecurityStyle(security_state::kRanInsecureContentLevel);
   security_style_explanations->displayed_insecure_content_style =
       SecurityLevelToSecurityStyle(
           security_state::kDisplayedInsecureContentLevel);
 
@@ skipping 10 matching lines @@
   // the page, and the embedder can choose to display HTTPS page as HTTP
   // if it wants to (for example, displaying deprecated crypto
   // algorithms with the same UI treatment as HTTP pages).
   security_style_explanations->scheme_is_cryptographic =
       security_info.scheme_is_cryptographic;
   if (!security_info.scheme_is_cryptographic) {
     return security_style;
   }
 
   if (security_info.sha1_in_chain) {
-    security_style_explanations->unauthenticated_explanations.push_back(
+    security_style_explanations->neutral_explanations.push_back(
         content::SecurityStyleExplanation(
             l10n_util::GetStringUTF8(IDS_SHA1),
             l10n_util::GetStringUTF8(IDS_SHA1_DESCRIPTION),
             !!security_info.certificate));
   }
 
   if (security_info.cert_missing_subject_alt_name) {
-    security_style_explanations->broken_explanations.push_back(
+    security_style_explanations->insecure_explanations.push_back(
         content::SecurityStyleExplanation(
             l10n_util::GetStringUTF8(IDS_SUBJECT_ALT_NAME_MISSING),
             l10n_util::GetStringUTF8(IDS_SUBJECT_ALT_NAME_MISSING_DESCRIPTION),
             !!security_info.certificate));
   }
 
   // Record the presence of mixed content (HTTP subresources on an HTTPS
   // page).
   security_style_explanations->ran_mixed_content =
       security_info.mixed_content_status ==
@@ skipping 33 matching lines @@
     base::string16 error_string = base::UTF8ToUTF16(net::ErrorToString(
         net::MapCertStatusToNetError(security_info.cert_status)));
 
     content::SecurityStyleExplanation explanation(
         l10n_util::GetStringUTF8(IDS_CERTIFICATE_CHAIN_ERROR),
         l10n_util::GetStringFUTF8(
             IDS_CERTIFICATE_CHAIN_ERROR_DESCRIPTION_FORMAT, error_string),
         !!security_info.certificate);
 
     if (is_cert_status_minor_error) {
-      security_style_explanations->unauthenticated_explanations.push_back(
-          explanation);
+      security_style_explanations->neutral_explanations.push_back(explanation);
     } else {
-      security_style_explanations->broken_explanations.push_back(explanation);
+      security_style_explanations->insecure_explanations.push_back(explanation);
     }
   } else {
     // If the certificate does not have errors and is not using SHA1, then add
     // an explanation that the certificate is valid.
     if (!security_info.sha1_in_chain) {
       security_style_explanations->secure_explanations.push_back(
           content::SecurityStyleExplanation(
               l10n_util::GetStringUTF8(IDS_VALID_SERVER_CERTIFICATE),
               l10n_util::GetStringUTF8(
                   IDS_VALID_SERVER_CERTIFICATE_DESCRIPTION),
               !!security_info.certificate));
     }
   }
 
   AddConnectionExplanation(security_info, security_style_explanations);
 
   security_style_explanations->pkp_bypassed = security_info.pkp_bypassed;
   if (security_info.pkp_bypassed) {
     security_style_explanations->info_explanations.push_back(
         content::SecurityStyleExplanation(
             "Public-Key Pinning Bypassed",
             "Public-key pinning was bypassed by a local root certificate."));
   }
 
   return security_style;
 }
 
 }  // namespace security_state