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

chrome/browser/sync/sync_prefs.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/sync/sync_prefs.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
@@ skipping 69 matching lines @@
   // KeepEverythingSynced.
   for (syncer::ModelTypeSet::Iterator it = user_types.First();
        it.Good(); it.Inc()) {
     RegisterDataTypePreferredPref(registry, it.Get(), false);
   }
 
   registry->RegisterBooleanPref(prefs::kSyncManaged,
                                 false,
                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
-                               "",
+                               std::string(),
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(prefs::kSyncKeystoreEncryptionBootstrapToken,
-                               "",
+                               std::string(),
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 #if defined(OS_CHROMEOS)
   registry->RegisterStringPref(prefs::kSyncSpareBootstrapToken,
                                "",
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
 
   registry->RegisterStringPref(prefs::kSyncSessionsGUID,
-                               "",
+                               std::string(),
                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 
   // We will start prompting people about new data types after the launch of
   // SESSIONS - all previously launched data types are treated as if they are
   // already acknowledged.
   syncer::ModelTypeSet model_set;
   model_set.Put(syncer::BOOKMARKS);
   model_set.Put(syncer::PREFERENCES);
   model_set.Put(syncer::PASSWORDS);
   model_set.Put(syncer::AUTOFILL_PROFILE);
@@ skipping 61 matching lines @@
 }
 
 void SyncPrefs::SetStartSuppressed(bool is_suppressed) {
   DCHECK(CalledOnValidThread());
   CHECK(pref_service_);
   pref_service_->SetBoolean(prefs::kSyncSuppressStart, is_suppressed);
 }
 
 std::string SyncPrefs::GetGoogleServicesUsername() const {
   DCHECK(CalledOnValidThread());
-  return
-      pref_service_ ?
-      pref_service_->GetString(prefs::kGoogleServicesUsername) : "";
+  return pref_service_
+             ? pref_service_->GetString(prefs::kGoogleServicesUsername)
+             : std::string();
 }
 
 base::Time SyncPrefs::GetLastSyncedTime() const {
   DCHECK(CalledOnValidThread());
   return
       base::Time::FromInternalValue(
           pref_service_ ?
           pref_service_->GetInt64(prefs::kSyncLastSyncedTime) : 0);
 }
 
@@ skipping 62 matching lines @@
   }
 }
 
 bool SyncPrefs::IsManaged() const {
   DCHECK(CalledOnValidThread());
   return pref_service_ && pref_service_->GetBoolean(prefs::kSyncManaged);
 }
 
 std::string SyncPrefs::GetEncryptionBootstrapToken() const {
   DCHECK(CalledOnValidThread());
-  return
-      pref_service_ ?
-      pref_service_->GetString(prefs::kSyncEncryptionBootstrapToken) : "";
+  return pref_service_
+             ? pref_service_->GetString(prefs::kSyncEncryptionBootstrapToken)
+             : std::string();
 }
 
 void SyncPrefs::SetEncryptionBootstrapToken(const std::string& token) {
   DCHECK(CalledOnValidThread());
   pref_service_->SetString(prefs::kSyncEncryptionBootstrapToken, token);
 }
 
 std::string SyncPrefs::GetKeystoreEncryptionBootstrapToken() const {
   DCHECK(CalledOnValidThread());
-  return
-      pref_service_ ?
-      pref_service_->GetString(prefs::kSyncKeystoreEncryptionBootstrapToken) :
-      "";
+  return pref_service_ ? pref_service_->GetString(
+                             prefs::kSyncKeystoreEncryptionBootstrapToken)
+                       : std::string();
 }
 
 void SyncPrefs::SetKeystoreEncryptionBootstrapToken(const std::string& token) {
   DCHECK(CalledOnValidThread());
   pref_service_->SetString(prefs::kSyncKeystoreEncryptionBootstrapToken, token);
 }
 
 std::string SyncPrefs::GetSyncSessionsGUID() const {
   DCHECK(CalledOnValidThread());
-  return
-      pref_service_ ?
-      pref_service_->GetString(prefs::kSyncSessionsGUID) : "";
+  return pref_service_ ? pref_service_->GetString(prefs::kSyncSessionsGUID)
+                       : std::string();
 }
 
 void SyncPrefs::SetSyncSessionsGUID(const std::string& guid) {
   DCHECK(CalledOnValidThread());
   pref_service_->SetString(prefs::kSyncSessionsGUID, guid);
 }
 
 // static
 const char* SyncPrefs::GetPrefNameForDataType(syncer::ModelType data_type) {
   switch (data_type) {
@@ skipping 177 matching lines @@
   for (PrefGroupsMap::const_iterator i = pref_groups_.begin();
       i != pref_groups_.end(); ++i) {
     if (types.Has(i->first))
       types_with_groups.PutAll(i->second);
   }
   types_with_groups.RetainAll(registered_types);
   return types_with_groups;
 }
 
 }  // namespace browser_sync