Replace UTF16 string with UTF8 string in the |WebsiteSettings| class.

chrome/browser/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/website_settings.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_number_conversions.h"
@@ skipping 57 matching lines @@
 
   // TODO(markusheintz): Add the strings below to the grd file once a decision
   // has been made about the exact wording.
   std::string site_info;
   switch (site_identity_status_) {
     case WebsiteSettings::SITE_IDENTITY_STATUS_CERT:
     case WebsiteSettings::SITE_IDENTITY_STATUS_DNSSEC_CERT:
       site_info = "Identity verified";
       break;
     case WebsiteSettings::SITE_IDENTITY_STATUS_EV_CERT:
-      site_info = UTF16ToUTF8(organization_name());
+      site_info = organization_name();
       site_info += " - Identity verified";
       break;
     default:
       site_info = "Identity not verified";
       break;
   }
   ui_->SetSiteInfo(site_info);
 
   PresentSitePermissions();
 }
@@ skipping 31 matching lines @@
 
   ui_->SetPermissionInfo(permission_info_list);
 }
 
 void WebsiteSettings::Init(Profile* profile,
                            const GURL& url,
                            const content::SSLStatus& ssl) {
   if (url.SchemeIs(chrome::kChromeUIScheme)) {
     site_identity_status_ = SITE_IDENTITY_STATUS_INTERNAL_PAGE;
     site_identity_details_ =
-        l10n_util::GetStringUTF16(IDS_PAGE_INFO_INTERNAL_PAGE);
+        l10n_util::GetStringUTF8(IDS_PAGE_INFO_INTERNAL_PAGE);
     site_connection_status_ = SITE_CONNECTION_STATUS_INTERNAL_PAGE;
     return;
   }
 
   scoped_refptr<net::X509Certificate> cert;
 
   // Identity section.
-  string16 subject_name(UTF8ToUTF16(url.host()));
+  std::string subject_name(url.host());
   if (subject_name.empty()) {
     subject_name.assign(
-        l10n_util::GetStringUTF16(IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY));
+        l10n_util::GetStringUTF8(IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY));
   }
 
   if (ssl.cert_id &&
       cert_store_->RetrieveCert(ssl.cert_id, &cert) &&
       (!net::IsCertStatusError(ssl.cert_status) ||
        net::IsCertStatusMinorError(ssl.cert_status))) {
     // There are no major errors. Check for minor errors.
     if (net::IsCertStatusMinorError(ssl.cert_status)) {
       site_identity_status_ = SITE_IDENTITY_STATUS_CERT_REVOCATION_UNKNOWN;
-      string16 issuer_name(UTF8ToUTF16(cert->issuer().GetDisplayName()));
+      std::string issuer_name(cert->issuer().GetDisplayName());
       if (issuer_name.empty()) {
-        issuer_name.assign(l10n_util::GetStringUTF16(
+        issuer_name.assign(l10n_util::GetStringUTF8(
             IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY));
       }
-      site_identity_details_.assign(l10n_util::GetStringFUTF16(
-          IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY, issuer_name));
+      site_identity_details_.assign(l10n_util::GetStringFUTF8(
+          IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY,
+          UTF8ToUTF16(issuer_name)));
 
-      site_identity_details_ += ASCIIToUTF16("\n\n");
+      site_identity_details_ += "\n\n";
       if (ssl.cert_status & net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION) {
-        site_identity_details_ += l10n_util::GetStringUTF16(
+        site_identity_details_ += l10n_util::GetStringUTF8(
             IDS_PAGE_INFO_SECURITY_TAB_UNABLE_TO_CHECK_REVOCATION);
       } else if (ssl.cert_status & net::CERT_STATUS_NO_REVOCATION_MECHANISM) {
-        site_identity_details_ += l10n_util::GetStringUTF16(
+        site_identity_details_ += l10n_util::GetStringUTF8(
             IDS_PAGE_INFO_SECURITY_TAB_NO_REVOCATION_MECHANISM);
       } else {
         NOTREACHED() << "Need to specify string for this warning";
       }
     } else if (ssl.cert_status & net::CERT_STATUS_IS_EV) {
       // EV HTTPS page.
       site_identity_status_ = SITE_IDENTITY_STATUS_EV_CERT;
       DCHECK(!cert->subject().organization_names.empty());
-      organization_name_ = UTF8ToUTF16(cert->subject().organization_names[0]);
+      organization_name_ = cert->subject().organization_names[0];
       // An EV Cert is required to have a city (localityName) and country but
       // state is "if any".
       DCHECK(!cert->subject().locality_name.empty());
       DCHECK(!cert->subject().country_name.empty());
-      string16 locality;
+      std::string locality;
       if (!cert->subject().state_or_province_name.empty()) {
-        locality = l10n_util::GetStringFUTF16(
+        locality = l10n_util::GetStringFUTF8(
             IDS_PAGEINFO_ADDRESS,
             UTF8ToUTF16(cert->subject().locality_name),
             UTF8ToUTF16(cert->subject().state_or_province_name),
             UTF8ToUTF16(cert->subject().country_name));
       } else {
-        locality = l10n_util::GetStringFUTF16(
+        locality = l10n_util::GetStringFUTF8(
             IDS_PAGEINFO_PARTIAL_ADDRESS,
             UTF8ToUTF16(cert->subject().locality_name),
             UTF8ToUTF16(cert->subject().country_name));
       }
       DCHECK(!cert->subject().organization_names.empty());
-      site_identity_details_.assign(l10n_util::GetStringFUTF16(
+      site_identity_details_.assign(l10n_util::GetStringFUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY_EV,
           UTF8ToUTF16(cert->subject().organization_names[0]),
-          locality,
+          UTF8ToUTF16(locality),
           UTF8ToUTF16(cert->issuer().GetDisplayName())));
     } else if (ssl.cert_status & net::CERT_STATUS_IS_DNSSEC) {
       // DNSSEC authenticated page.
       site_identity_status_ = SITE_IDENTITY_STATUS_DNSSEC_CERT;
-      site_identity_details_.assign(l10n_util::GetStringFUTF16(
+      site_identity_details_.assign(l10n_util::GetStringFUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY, UTF8ToUTF16("DNSSEC")));
     } else {
       // Non-EV OK HTTPS page.
       site_identity_status_ = SITE_IDENTITY_STATUS_CERT;
-      string16 issuer_name(UTF8ToUTF16(cert->issuer().GetDisplayName()));
+      std::string issuer_name(cert->issuer().GetDisplayName());
       if (issuer_name.empty()) {
-        issuer_name.assign(l10n_util::GetStringUTF16(
+        issuer_name.assign(l10n_util::GetStringUTF8(
             IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY));
       }
-      site_identity_details_.assign(l10n_util::GetStringFUTF16(
-          IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY, issuer_name));
+      site_identity_details_.assign(l10n_util::GetStringFUTF8(
+          IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY,
+          UTF8ToUTF16(issuer_name)));
     }
   } else {
     // HTTP or HTTPS with errors (not warnings).
-    site_identity_details_.assign(l10n_util::GetStringUTF16(
+    site_identity_details_.assign(l10n_util::GetStringUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_INSECURE_IDENTITY));
     if (ssl.security_style == content::SECURITY_STYLE_UNAUTHENTICATED)
       site_identity_status_ = SITE_IDENTITY_STATUS_NO_CERT;
     else
       site_identity_status_ = SITE_IDENTITY_STATUS_ERROR;
 
-    const string16 bullet = UTF8ToUTF16("\n • ");
+    const std::string bullet = "\n • ";
     std::vector<SSLErrorInfo> errors;
     SSLErrorInfo::GetErrorsForCertStatus(ssl.cert_id, ssl.cert_status,
                                          url, &errors);
     for (size_t i = 0; i < errors.size(); ++i) {
       site_identity_details_ += bullet;
-      site_identity_details_ += errors[i].short_description();
+      site_identity_details_ += UTF16ToUTF8(errors[i].short_description());
     }
 
     if (ssl.cert_status & net::CERT_STATUS_NON_UNIQUE_NAME) {
-      site_identity_details_ += ASCIIToUTF16("\n\n");
-      site_identity_details_ += l10n_util::GetStringUTF16(
+      site_identity_details_ += "\n\n";
+      site_identity_details_ += l10n_util::GetStringUTF8(
           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;
 
   if (!ssl.cert_id) {
     // Not HTTPS.
     DCHECK_EQ(ssl.security_style, content::SECURITY_STYLE_UNAUTHENTICATED);
     if (ssl.security_style == content::SECURITY_STYLE_UNAUTHENTICATED)
       site_connection_status_ = SITE_CONNECTION_STATUS_UNENCRYPTED;
     else
       site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
 
-    site_connection_details_.assign(l10n_util::GetStringFUTF16(
+    site_connection_details_.assign(l10n_util::GetStringFUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_NOT_ENCRYPTED_CONNECTION_TEXT,
-        subject_name));
+        UTF8ToUTF16(subject_name)));
   } else if (ssl.security_bits < 0) {
     // Security strength is unknown.  Say nothing.
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
   } else if (ssl.security_bits == 0) {
     DCHECK_NE(ssl.security_style, content::SECURITY_STYLE_UNAUTHENTICATED);
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
-    site_connection_details_.assign(l10n_util::GetStringFUTF16(
+    site_connection_details_.assign(l10n_util::GetStringFUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_NOT_ENCRYPTED_CONNECTION_TEXT,
-        subject_name));
+        UTF8ToUTF16(subject_name)));
   } else if (ssl.security_bits < 80) {
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
-    site_connection_details_.assign(l10n_util::GetStringFUTF16(
+    site_connection_details_.assign(l10n_util::GetStringFUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_WEAK_ENCRYPTION_CONNECTION_TEXT,
-        subject_name));
+        UTF8ToUTF16(subject_name)));
   } else {
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED;
-    site_connection_details_.assign(l10n_util::GetStringFUTF16(
+    site_connection_details_.assign(l10n_util::GetStringFUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_CONNECTION_TEXT,
-        subject_name,
+        UTF8ToUTF16(subject_name),
         base::IntToString16(ssl.security_bits)));
     if (ssl.content_status) {
       bool ran_insecure_content =
           !!(ssl.content_status & content::SSLStatus::RAN_INSECURE_CONTENT);
       site_connection_status_ = ran_insecure_content ?
           SITE_CONNECTION_STATUS_ENCRYPTED_ERROR
           : SITE_CONNECTION_STATUS_MIXED_CONTENT;
-      site_connection_details_.assign(l10n_util::GetStringFUTF16(
+      site_connection_details_.assign(l10n_util::GetStringFUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_SENTENCE_LINK,
-          site_connection_details_,
+          UTF8ToUTF16(site_connection_details_),
           l10n_util::GetStringUTF16(ran_insecure_content ?
               IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_INSECURE_CONTENT_ERROR :
               IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_INSECURE_CONTENT_WARNING)));
     }
   }
 
   uint16 cipher_suite =
       net::SSLConnectionStatusToCipherSuite(ssl.connection_status);
   if (ssl.security_bits > 0 && cipher_suite) {
     int ssl_version =
         net::SSLConnectionStatusToVersion(ssl.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(
+    site_connection_details_ += "\n\n";
+    site_connection_details_ += l10n_util::GetStringFUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_SSL_VERSION,
         ASCIIToUTF16(ssl_version_str));
 
     bool did_fallback = (ssl.connection_status &
                          net::SSL_CONNECTION_SSL3_FALLBACK) != 0;
     bool no_renegotiation =
         (ssl.connection_status &
         net::SSL_CONNECTION_NO_RENEGOTIATION_EXTENSION) != 0;
     const char *key_exchange, *cipher, *mac;
     net::SSLCipherSuiteToStrings(&key_exchange, &cipher, &mac, cipher_suite);
 
-    site_connection_details_ += ASCIIToUTF16("\n\n");
-    site_connection_details_ += l10n_util::GetStringFUTF16(
+    site_connection_details_ += "\n\n";
+    site_connection_details_ += l10n_util::GetStringFUTF8(
         IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTION_DETAILS,
         ASCIIToUTF16(cipher), ASCIIToUTF16(mac), ASCIIToUTF16(key_exchange));
 
-    site_connection_details_ += ASCIIToUTF16("\n\n");
+    site_connection_details_ += "\n\n";
     uint8 compression_id =
         net::SSLConnectionStatusToCompression(ssl.connection_status);
     if (compression_id) {
       const char* compression;
       net::SSLCompressionToString(&compression, compression_id);
-      site_connection_details_ += l10n_util::GetStringFUTF16(
+      site_connection_details_ += l10n_util::GetStringFUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_COMPRESSION_DETAILS,
-          ASCIIToUTF16(compression));
+          UTF8ToUTF16(compression));
     } else {
-      site_connection_details_ += l10n_util::GetStringUTF16(
+      site_connection_details_ += l10n_util::GetStringUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_NO_COMPRESSION);
     }
 
     if (did_fallback) {
       // For now, only SSLv3 fallback will trigger a warning icon.
       if (site_connection_status_ < SITE_CONNECTION_STATUS_MIXED_CONTENT)
         site_connection_status_ = SITE_CONNECTION_STATUS_MIXED_CONTENT;
-      site_connection_details_ += ASCIIToUTF16("\n\n");
-      site_connection_details_ += l10n_util::GetStringUTF16(
+      site_connection_details_ += "\n\n";
+      site_connection_details_ += l10n_util::GetStringUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_FALLBACK_MESSAGE);
     }
     if (no_renegotiation) {
-      site_connection_details_ += ASCIIToUTF16("\n\n");
-      site_connection_details_ += l10n_util::GetStringUTF16(
+      site_connection_details_ += "\n\n";
+      site_connection_details_ += l10n_util::GetStringUTF8(
           IDS_PAGE_INFO_SECURITY_TAB_RENEGOTIATION_MESSAGE);
     }
   }
 }
 
 void WebsiteSettings::OnUIClosing() {
   ui_->SetPresenter(NULL);
   delete this;
 }
 
@@ skipping 57 matching lines @@
 // static
 void WebsiteSettings::Show(gfx::NativeWindow parent,
                            Profile* profile,
                            TabContentsWrapper* tab_contents_wrapper,
                            const GURL& url,
                            const content::SSLStatus& ssl) {
 #if defined(TOOLKIT_GTK)
   // The WebsiteSettingsModel will delete itself after the UI is closed.
   new WebsiteSettings(new WebsiteSettingsPopupGtk(parent,
                                                   profile,
-                                                 tab_contents_wrapper),
+                                                  tab_contents_wrapper),
                       profile,
                       url,
                       ssl,
                       content::CertStore::GetInstance());
 #endif
 }