Rewrite std::string("") to std::string(), Linux edition.

chrome/common/net/x509_certificate_model_nss.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/common/net/x509_certificate_model.h"
 
 #include <cert.h>
 #include <cms.h>
 #include <hasht.h>
 #include <keyhi.h>  // SECKEY_DestroyPrivateKey
@@ skipping 82 matching lines @@
     ScopedNSSCMSSignedData;
 
 }  // namespace
 
 namespace x509_certificate_model {
 
 using net::X509Certificate;
 using std::string;
 
 string GetCertNameOrNickname(X509Certificate::OSCertHandle cert_handle) {
-  string name = ProcessIDN(Stringize(CERT_GetCommonName(&cert_handle->subject),
-                                     ""));
+  string name = ProcessIDN(
+      Stringize(CERT_GetCommonName(&cert_handle->subject), std::string()));
   if (!name.empty())
     return name;
   return GetNickname(cert_handle);
 }
 
 string GetNickname(X509Certificate::OSCertHandle cert_handle) {
   string name;
   if (cert_handle->nickname) {
     name = cert_handle->nickname;
     // Hack copied from mozilla: Cut off text before first :, which seems to
@@ skipping 10 matching lines @@
 }
 
 string GetVersion(X509Certificate::OSCertHandle cert_handle) {
   // If the version field is omitted from the certificate, the default
   // value is v1(0).
   unsigned long version = 0;
   if (cert_handle->version.len == 0 ||
       SEC_ASN1DecodeInteger(&cert_handle->version, &version) == SECSuccess) {
     return base::UintToString(version + 1);
   }
-  return "";
+  return std::string();
 }
 
 net::CertType GetType(X509Certificate::OSCertHandle cert_handle) {
     return psm::GetCertType(cert_handle);
 }
 
 string GetEmailAddress(X509Certificate::OSCertHandle cert_handle) {
   if (cert_handle->emailAddr)
     return cert_handle->emailAddr;
-  return "";
+  return std::string();
 }
 
 void GetUsageStrings(X509Certificate::OSCertHandle cert_handle,
                      std::vector<string>* usages) {
   psm::GetCertUsageStrings(cert_handle, usages);
 }
 
 string GetKeyUsageString(X509Certificate::OSCertHandle cert_handle) {
   SECItem key_usage;
   key_usage.data = NULL;
@@ skipping 183 matching lines @@
   DCHECK(arena.get());
 
   ScopedNSSCMSMessage message(NSS_CMSMessage_Create(arena.get()));
   DCHECK(message.get());
 
   // First, create SignedData with the certificate only (no chain).
   ScopedNSSCMSSignedData signed_data(NSS_CMSSignedData_CreateCertsOnly(
       message.get(), cert_chain[start], PR_FALSE));
   if (!signed_data.get()) {
     DLOG(ERROR) << "NSS_CMSSignedData_Create failed";
-    return "";
+    return std::string();
   }
   // Add the rest of the chain (if any).
   for (size_t i = start + 1; i < end; ++i) {
     if (NSS_CMSSignedData_AddCertificate(signed_data.get(), cert_chain[i]) !=
         SECSuccess) {
       DLOG(ERROR) << "NSS_CMSSignedData_AddCertificate failed on " << i;
-      return "";
+      return std::string();
     }
   }
 
   NSSCMSContentInfo *cinfo = NSS_CMSMessage_GetContentInfo(message.get());
   if (NSS_CMSContentInfo_SetContent_SignedData(
       message.get(), cinfo, signed_data.get()) == SECSuccess) {
     ignore_result(signed_data.release());
   } else {
     DLOG(ERROR) << "NSS_CMSMessage_GetContentInfo failed";
-    return "";
+    return std::string();
   }
 
   SECItem cert_p7 = { siBuffer, NULL, 0 };
   NSSCMSEncoderContext *ecx = NSS_CMSEncoder_Start(message.get(), NULL, NULL,
                                                    &cert_p7, arena.get(), NULL,
                                                    NULL, NULL, NULL, NULL,
                                                    NULL);
   if (!ecx) {
     DLOG(ERROR) << "NSS_CMSEncoder_Start failed";
-    return "";
+    return std::string();
   }
 
   if (NSS_CMSEncoder_Finish(ecx) != SECSuccess) {
     DLOG(ERROR) << "NSS_CMSEncoder_Finish failed";
-    return "";
+    return std::string();
   }
 
   return string(reinterpret_cast<const char*>(cert_p7.data), cert_p7.len);
 }
 
 string ProcessSecAlgorithmSignature(X509Certificate::OSCertHandle cert_handle) {
   return ProcessSecAlgorithmInternal(&cert_handle->signature);
 }
 
 string ProcessSecAlgorithmSubjectPublicKey(
@@ skipping 15 matching lines @@
 string ProcessRawBitsSignatureWrap(X509Certificate::OSCertHandle cert_handle) {
   return ProcessRawBits(cert_handle->signatureWrap.signature.data,
                         cert_handle->signatureWrap.signature.len);
 }
 
 void RegisterDynamicOids() {
   psm::RegisterDynamicOids();
 }
 
 }  // namespace x509_certificate_model