Run `git cl format` on all desktop page_info code.

chrome/browser/ui/page_info/website_settings.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 "chrome/browser/ui/page_info/website_settings.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 126 matching lines @@
     case security_state::CONTENT_STATUS_DISPLAYED_AND_RAN:
       *displayed = true;
       *ran = true;
       break;
     case security_state::CONTENT_STATUS_UNKNOWN:
     case security_state::CONTENT_STATUS_NONE:
       break;
   }
 }
 
-void CheckForInsecureContent(
-    const security_state::SecurityInfo& security_info,
-    bool* displayed,
-    bool* ran) {
+void CheckForInsecureContent(const security_state::SecurityInfo& security_info,
+                             bool* displayed,
+                             bool* ran) {
   CheckContentStatus(security_info.mixed_content_status, displayed, ran);
   // Only consider subresources with certificate errors if the main
   // resource was loaded over HTTPS without major certificate errors. If
   // the main resource had a certificate error, then it would not be
   // that useful (and would potentially be confusing) to warn about
   // subesources that had certificate errors too.
   if (net::IsCertStatusError(security_info.cert_status) &&
       !net::IsCertStatusMinorError(security_info.cert_status)) {
     return;
   }
   CheckContentStatus(security_info.content_with_cert_errors_status, displayed,
                      ran);
 }
 
 void GetSiteIdentityByMaliciousContentStatus(
     security_state::MaliciousContentStatus malicious_content_status,
     WebsiteSettings::SiteIdentityStatus* status,
     base::string16* details) {
   switch (malicious_content_status) {
     case security_state::MALICIOUS_CONTENT_STATUS_NONE:
       NOTREACHED();
       break;
     case security_state::MALICIOUS_CONTENT_STATUS_MALWARE:
       *status = WebsiteSettings::SITE_IDENTITY_STATUS_MALWARE;
-      *details =
-          l10n_util::GetStringUTF16(IDS_PAGEINFO_MALWARE_DETAILS);
+      *details = l10n_util::GetStringUTF16(IDS_PAGEINFO_MALWARE_DETAILS);
       break;
     case security_state::MALICIOUS_CONTENT_STATUS_SOCIAL_ENGINEERING:
       *status = WebsiteSettings::SITE_IDENTITY_STATUS_SOCIAL_ENGINEERING;
-      *details = l10n_util::GetStringUTF16(
-          IDS_PAGEINFO_SOCIAL_ENGINEERING_DETAILS);
+      *details =
+          l10n_util::GetStringUTF16(IDS_PAGEINFO_SOCIAL_ENGINEERING_DETAILS);
       break;
     case security_state::MALICIOUS_CONTENT_STATUS_UNWANTED_SOFTWARE:
       *status = WebsiteSettings::SITE_IDENTITY_STATUS_UNWANTED_SOFTWARE;
-      *details = l10n_util::GetStringUTF16(
-          IDS_PAGEINFO_UNWANTED_SOFTWARE_DETAILS);
+      *details =
+          l10n_util::GetStringUTF16(IDS_PAGEINFO_UNWANTED_SOFTWARE_DETAILS);
       break;
   }
 }
 
 base::string16 GetSimpleSiteName(const GURL& url) {
   return url_formatter::FormatUrlForSecurityDisplay(
       url, url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS);
 }
 
 ChooserContextBase* GetUsbChooserContext(Profile* profile) {
@@ skipping 37 matching lines @@
 
   PresentSitePermissions();
   PresentSiteData();
   PresentSiteIdentity();
 
   // Every time the Website Settings UI is opened a |WebsiteSettings| object is
   // created. So this counts how ofter the Website Settings UI is opened.
   RecordWebsiteSettingsAction(WEBSITE_SETTINGS_OPENED);
 }
 
-WebsiteSettings::~WebsiteSettings() {
-}
+WebsiteSettings::~WebsiteSettings() {}
 
 void WebsiteSettings::RecordWebsiteSettingsAction(
     WebsiteSettingsAction action) {
-  UMA_HISTOGRAM_ENUMERATION("WebsiteSettings.Action",
-                            action,
+  UMA_HISTOGRAM_ENUMERATION("WebsiteSettings.Action", action,
                             WEBSITE_SETTINGS_COUNT);
 
   std::string histogram_name;
 
   if (site_url_.SchemeIsCryptographic()) {
     if (security_level_ == security_state::SECURE ||
         security_level_ == security_state::EV_SECURE) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Valid",
                                 action, WEBSITE_SETTINGS_COUNT);
     } else if (security_level_ == security_state::NONE) {
@@ skipping 253 matching lines @@
     std::vector<ssl_errors::ErrorInfo> errors;
     ssl_errors::ErrorInfo::GetErrorsForCertStatus(
         certificate_, security_info.cert_status, url, &errors);
     for (size_t i = 0; i < errors.size(); ++i) {
       site_identity_details_ += bullet;
       site_identity_details_ += errors[i].short_description();
     }
 
     if (security_info.cert_status & net::CERT_STATUS_NON_UNIQUE_NAME) {
       site_identity_details_ += ASCIIToUTF16("\n\n");
-      site_identity_details_ += l10n_util::GetStringUTF16(
-          IDS_PAGE_INFO_SECURITY_TAB_NON_UNIQUE_NAME);
+      site_identity_details_ +=
+          l10n_util::GetStringUTF16(IDS_PAGE_INFO_SECURITY_TAB_NON_UNIQUE_NAME);
     }
   }
 
   // Site Connection
   // We consider anything less than 80 bits encryption to be weak encryption.
   // TODO(wtc): Bug 1198735: report mixed/unsafe content for unencrypted and
   // weakly encrypted connections.
   site_connection_status_ = SITE_CONNECTION_STATUS_UNKNOWN;
 
   base::string16 subject_name(GetSimpleSiteName(url));
@@ skipping 17 matching lines @@
     DCHECK_NE(security_info.security_level, security_state::NONE);
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
     site_connection_details_.assign(l10n_util::GetStringFUTF16(
         IDS_PAGE_INFO_SECURITY_TAB_NOT_ENCRYPTED_CONNECTION_TEXT,
         subject_name));
   } else {
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED;
 
     if (security_info.obsolete_ssl_status == net::OBSOLETE_SSL_NONE) {
       site_connection_details_.assign(l10n_util::GetStringFUTF16(
-          IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_CONNECTION_TEXT,
-          subject_name));
+          IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_CONNECTION_TEXT, subject_name));
     } else {
       site_connection_details_.assign(l10n_util::GetStringFUTF16(
           IDS_PAGE_INFO_SECURITY_TAB_WEAK_ENCRYPTION_CONNECTION_TEXT,
           subject_name));
     }
 
     bool ran_insecure_content = false;
     bool displayed_insecure_content = false;
     CheckForInsecureContent(security_info, &displayed_insecure_content,
                             &ran_insecure_content);
@@ skipping 14 matching lines @@
 
   uint16_t cipher_suite =
       net::SSLConnectionStatusToCipherSuite(security_info.connection_status);
   if (security_info.security_bits > 0 && cipher_suite) {
     int ssl_version =
         net::SSLConnectionStatusToVersion(security_info.connection_status);
     const char* ssl_version_str;
     net::SSLVersionToString(&ssl_version_str, ssl_version);
     site_connection_details_ += ASCIIToUTF16("\n\n");
     site_connection_details_ += l10n_util::GetStringFUTF16(
-        IDS_PAGE_INFO_SECURITY_TAB_SSL_VERSION,
-        ASCIIToUTF16(ssl_version_str));
+        IDS_PAGE_INFO_SECURITY_TAB_SSL_VERSION, ASCIIToUTF16(ssl_version_str));
 
     const char *key_exchange, *cipher, *mac;
     bool is_aead, is_tls13;
     net::SSLCipherSuiteToStrings(&key_exchange, &cipher, &mac, &is_aead,
                                  &is_tls13, cipher_suite);
 
     site_connection_details_ += ASCIIToUTF16("\n\n");
     if (is_aead) {
       if (is_tls13) {
         // For TLS 1.3 ciphers, report the group (historically, curve) as the
         // key exchange.
         key_exchange = SSL_get_curve_name(security_info.key_exchange_group);
         if (!key_exchange) {
           NOTREACHED();
           key_exchange = "";
         }
       }
       site_connection_details_ += l10n_util::GetStringFUTF16(
           IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTION_DETAILS_AEAD,
           ASCIIToUTF16(cipher), ASCIIToUTF16(key_exchange));
     } else {
       site_connection_details_ += l10n_util::GetStringFUTF16(
-          IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTION_DETAILS,
-          ASCIIToUTF16(cipher), ASCIIToUTF16(mac), ASCIIToUTF16(key_exchange));
+          IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTION_DETAILS, ASCIIToUTF16(cipher),
+          ASCIIToUTF16(mac), ASCIIToUTF16(key_exchange));
     }
 
     if (ssl_version == net::SSL_CONNECTION_VERSION_SSL3 &&
         site_connection_status_ <
             SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE) {
       site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
     }
   }
 
   // Check if a user decision has been made to allow or deny certificates with
@@ skipping 109 matching lines @@
   // identity must be available.
   DCHECK_NE(site_identity_status_, SITE_IDENTITY_STATUS_UNKNOWN);
   DCHECK_NE(site_connection_status_, SITE_CONNECTION_STATUS_UNKNOWN);
   WebsiteSettingsUI::IdentityInfo info;
   if (site_identity_status_ == SITE_IDENTITY_STATUS_EV_CERT)
     info.site_identity = UTF16ToUTF8(organization_name());
   else
     info.site_identity = UTF16ToUTF8(GetSimpleSiteName(site_url_));
 
   info.connection_status = site_connection_status_;
-  info.connection_status_description =
-      UTF16ToUTF8(site_connection_details_);
+  info.connection_status_description = UTF16ToUTF8(site_connection_details_);
   info.identity_status = site_identity_status_;
-  info.identity_status_description =
-      UTF16ToUTF8(site_identity_details_);
+  info.identity_status_description = UTF16ToUTF8(site_identity_details_);
   info.certificate = certificate_;
   info.show_ssl_decision_revoke_button = show_ssl_decision_revoke_button_;
   ui_->SetIdentityInfo(info);
 }