Change preference APIs to take std::string instead of const char*.

base/prefs/pref_value_store.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 "base/prefs/pref_value_store.h"
 
 #include "base/logging.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/prefs/pref_observer.h"
 
@@ skipping 91 matching lines @@
 void PrefValueStore::set_callback(const PrefChangedCallback& callback) {
   pref_changed_callback_ = callback;
 }
 
 bool PrefValueStore::GetValue(const std::string& name,
                               base::Value::Type type,
                               const base::Value** out_value) const {
   // Check the |PrefStore|s in order of their priority from highest to lowest,
   // looking for the first preference value with the given |name| and |type|.
   for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
-    if (GetValueFromStoreWithType(name.c_str(), type,
-                                  static_cast<PrefStoreType>(i), out_value))
+    if (GetValueFromStoreWithType(name, type, static_cast<PrefStoreType>(i),
+                                  out_value))
       return true;
   }
   return false;
 }
 
 bool PrefValueStore::GetRecommendedValue(const std::string& name,
                                          base::Value::Type type,
                                          const base::Value** out_value) const {
-  return GetValueFromStoreWithType(name.c_str(), type, RECOMMENDED_STORE,
-                                   out_value);
+  return GetValueFromStoreWithType(name, type, RECOMMENDED_STORE, out_value);
 }
 
 void PrefValueStore::NotifyPrefChanged(
-    const char* path,
+    const std::string& path,
     PrefValueStore::PrefStoreType new_store) {
   DCHECK(new_store != INVALID_STORE);
   // A notification is sent when the pref value in any store changes. If this
   // store is currently being overridden by a higher-priority store, the
   // effective value of the pref will not have changed.
   pref_notifier_->OnPreferenceChanged(path);
   if (!pref_changed_callback_.is_null())
     pref_changed_callback_.Run(path);
 }
 
-bool PrefValueStore::PrefValueInManagedStore(const char* name) const {
+bool PrefValueStore::PrefValueInManagedStore(const std::string& name) const {
   return PrefValueInStore(name, MANAGED_STORE);
 }
 
-bool PrefValueStore::PrefValueInExtensionStore(const char* name) const {
+bool PrefValueStore::PrefValueInExtensionStore(const std::string& name) const {
   return PrefValueInStore(name, EXTENSION_STORE);
 }
 
-bool PrefValueStore::PrefValueInUserStore(const char* name) const {
+bool PrefValueStore::PrefValueInUserStore(const std::string& name) const {
   return PrefValueInStore(name, USER_STORE);
 }
 
-bool PrefValueStore::PrefValueFromExtensionStore(const char* name) const {
+bool PrefValueStore::PrefValueFromExtensionStore(
+    const std::string& name) const {
   return ControllingPrefStoreForPref(name) == EXTENSION_STORE;
 }
 
-bool PrefValueStore::PrefValueFromUserStore(const char* name) const {
+bool PrefValueStore::PrefValueFromUserStore(const std::string& name) const {
   return ControllingPrefStoreForPref(name) == USER_STORE;
 }
 
-bool PrefValueStore::PrefValueFromRecommendedStore(const char* name) const {
+bool PrefValueStore::PrefValueFromRecommendedStore(
+    const std::string& name) const {
   return ControllingPrefStoreForPref(name) == RECOMMENDED_STORE;
 }
 
-bool PrefValueStore::PrefValueFromDefaultStore(const char* name) const {
+bool PrefValueStore::PrefValueFromDefaultStore(const std::string& name) const {
   return ControllingPrefStoreForPref(name) == DEFAULT_STORE;
 }
 
-bool PrefValueStore::PrefValueUserModifiable(const char* name) const {
+bool PrefValueStore::PrefValueUserModifiable(const std::string& name) const {
   PrefStoreType effective_store = ControllingPrefStoreForPref(name);
   return effective_store >= USER_STORE ||
          effective_store == INVALID_STORE;
 }
 
-bool PrefValueStore::PrefValueExtensionModifiable(const char* name) const {
+bool PrefValueStore::PrefValueExtensionModifiable(
+    const std::string& name) const {
   PrefStoreType effective_store = ControllingPrefStoreForPref(name);
   return effective_store >= EXTENSION_STORE ||
          effective_store == INVALID_STORE;
 }
 
 void PrefValueStore::UpdateCommandLinePrefStore(PrefStore* command_line_prefs) {
   InitPrefStore(COMMAND_LINE_STORE, command_line_prefs);
 }
 
 bool PrefValueStore::PrefValueInStore(
-    const char* name,
+    const std::string& name,
     PrefValueStore::PrefStoreType store) const {
   // Declare a temp Value* and call GetValueFromStore,
   // ignoring the output value.
   const base::Value* tmp_value = NULL;
   return GetValueFromStore(name, store, &tmp_value);
 }
 
 bool PrefValueStore::PrefValueInStoreRange(
-    const char* name,
+    const std::string& name,
     PrefValueStore::PrefStoreType first_checked_store,
     PrefValueStore::PrefStoreType last_checked_store) const {
   if (first_checked_store > last_checked_store) {
     NOTREACHED();
     return false;
   }
 
   for (size_t i = first_checked_store;
        i <= static_cast<size_t>(last_checked_store); ++i) {
     if (PrefValueInStore(name, static_cast<PrefStoreType>(i)))
       return true;
   }
   return false;
 }
 
 PrefValueStore::PrefStoreType PrefValueStore::ControllingPrefStoreForPref(
-    const char* name) const {
+    const std::string& name) const {
   for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
     if (PrefValueInStore(name, static_cast<PrefStoreType>(i)))
       return static_cast<PrefStoreType>(i);
   }
   return INVALID_STORE;
 }
 
-bool PrefValueStore::GetValueFromStore(const char* name,
+bool PrefValueStore::GetValueFromStore(const std::string& name,
                                        PrefValueStore::PrefStoreType store_type,
                                        const base::Value** out_value) const {
   // Only return true if we find a value and it is the correct type, so stale
   // values with the incorrect type will be ignored.
   const PrefStore* store = GetPrefStore(static_cast<PrefStoreType>(store_type));
   if (store && store->GetValue(name, out_value))
     return true;
 
   // No valid value found for the given preference name: set the return value
   // to false.
   *out_value = NULL;
   return false;
 }
 
 bool PrefValueStore::GetValueFromStoreWithType(
-    const char* name,
+    const std::string& name,
     base::Value::Type type,
     PrefStoreType store,
     const base::Value** out_value) const {
   if (GetValueFromStore(name, store, out_value)) {
     if ((*out_value)->IsType(type))
       return true;
 
     LOG(WARNING) << "Expected type for " << name << " is " << type
                  << " but got " << (*out_value)->GetType()
                  << " in store " << store;
   }
 
   *out_value = NULL;
   return false;
 }
 
 void PrefValueStore::OnPrefValueChanged(PrefValueStore::PrefStoreType type,
                                         const std::string& key) {
-  NotifyPrefChanged(key.c_str(), type);
+  NotifyPrefChanged(key, type);
 }
 
 void PrefValueStore::OnInitializationCompleted(
     PrefValueStore::PrefStoreType type, bool succeeded) {
   if (initialization_failed_)
     return;
   if (!succeeded) {
     initialization_failed_ = true;
     pref_notifier_->OnInitializationCompleted(false);
     return;
@@ skipping 10 matching lines @@
   if (initialization_failed_)
     return;
   for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
     scoped_refptr<PrefStore> store =
         GetPrefStore(static_cast<PrefStoreType>(i));
     if (store.get() && !store->IsInitializationComplete())
       return;
   }
   pref_notifier_->OnInitializationCompleted(true);
 }