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

sync/internal_api/sync_encryption_handler_impl.cc

 // Copyright 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 "sync/internal_api/sync_encryption_handler_impl.h"
 
 #include <queue>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 118 matching lines @@
 }
 
 // Keystore Bootstrap Token helper methods.
 // The bootstrap is a base64 encoded, encrypted, ListValue of keystore key
 // strings, with the current keystore key as the last value in the list.
 std::string PackKeystoreBootstrapToken(
     const std::vector<std::string>& old_keystore_keys,
     const std::string& current_keystore_key,
     Encryptor* encryptor) {
   if (current_keystore_key.empty())
-    return "";
+    return std::string();
 
   base::ListValue keystore_key_values;
   for (size_t i = 0; i < old_keystore_keys.size(); ++i)
     keystore_key_values.AppendString(old_keystore_keys[i]);
   keystore_key_values.AppendString(current_keystore_key);
 
   // Update the bootstrap token.
   // The bootstrap is a base64 encoded, encrypted, ListValue of keystore key
   // strings, with the current keystore key as the last value in the list.
   std::string serialized_keystores;
@@ skipping 955 matching lines @@
     const std::string& passphrase,
     WriteTransaction* trans,
     WriteNode* nigori_node) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsNigoriMigratedToKeystore(nigori_node->GetNigoriSpecifics()));
   KeyParams key_params = {"localhost", "dummy", passphrase};
 
   if (passphrase_type_ != KEYSTORE_PASSPHRASE) {
     DVLOG(1) << "Failing to set a custom passphrase because one has already "
              << "been set.";
-    FinishSetPassphrase(false, "", trans, nigori_node);
+    FinishSetPassphrase(false, std::string(), trans, nigori_node);
     return;
   }
 
   Cryptographer* cryptographer =
       &UnlockVaultMutable(trans->GetWrappedTrans())->cryptographer;
   if (cryptographer->has_pending_keys()) {
     // This theoretically shouldn't happen, because the only way to have pending
     // keys after migrating to keystore support is if a custom passphrase was
     // set, which should update passpshrase_state_ and should be caught by the
     // if statement above. For the sake of safety though, we check for it in
     // case a client is misbehaving.
     LOG(ERROR) << "Failing to set custom passphrase because of pending keys.";
-    FinishSetPassphrase(false, "", trans, nigori_node);
+    FinishSetPassphrase(false, std::string(), trans, nigori_node);
     return;
   }
 
   std::string bootstrap_token;
   if (cryptographer->AddKey(key_params)) {
     DVLOG(1) << "Setting custom passphrase.";
     cryptographer->GetBootstrapToken(&bootstrap_token);
     passphrase_type_ = CUSTOM_PASSPHRASE;
     custom_passphrase_time_ = base::Time::Now();
     FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
@@ skipping 506 matching lines @@
 
 base::Time SyncEncryptionHandlerImpl::GetExplicitPassphraseTime() const {
   if (passphrase_type_ == FROZEN_IMPLICIT_PASSPHRASE)
     return migration_time();
   else if (passphrase_type_ == CUSTOM_PASSPHRASE)
     return custom_passphrase_time();
   return base::Time();
 }
 
 }  // namespace browser_sync