Continue to clean c_str() calls.

components/sync_preferences/pref_model_associator.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 "components/sync_preferences/pref_model_associator.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
@@ skipping 59 matching lines @@
   pref_service_ = NULL;
 
   synced_pref_observers_.clear();
 }
 
 void PrefModelAssociator::InitPrefAndAssociate(
     const syncer::SyncData& sync_pref,
     const std::string& pref_name,
     syncer::SyncChangeList* sync_changes) {
   const base::Value* user_pref_value =
-      pref_service_->GetUserPrefValue(pref_name.c_str());
+      pref_service_->GetUserPrefValue(pref_name);
   VLOG(1) << "Associating preference " << pref_name;
 
   if (sync_pref.IsValid()) {
     const sync_pb::PreferenceSpecifics& preference = GetSpecifics(sync_pref);
     DCHECK(pref_name == preference.name());
     base::JSONReader reader;
     std::unique_ptr<base::Value> sync_value(
         reader.ReadToValue(preference.value()));
     if (!sync_value.get()) {
       LOG(ERROR) << "Failed to deserialize preference value: "
                  << reader.GetErrorMessage();
       return;
     }
 
     if (user_pref_value) {
       DVLOG(1) << "Found user pref value for " << pref_name;
       // We have both server and local values. Merge them.
       std::unique_ptr<base::Value> new_value(
           MergePreference(pref_name, *user_pref_value, *sync_value));
 
       // Update the local preference based on what we got from the
       // sync server. Note: this only updates the user value store, which is
       // ignored if the preference is policy controlled.
       if (new_value->IsType(base::Value::Type::NONE)) {
         LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
-        pref_service_->ClearPref(pref_name.c_str());
+        pref_service_->ClearPref(pref_name);
       } else if (!new_value->IsType(user_pref_value->GetType())) {
         LOG(WARNING) << "Synced value for " << preference.name()
                      << " is of type " << new_value->GetType()
                      << " which doesn't match pref type "
                      << user_pref_value->GetType();
       } else if (!user_pref_value->Equals(new_value.get())) {
-        pref_service_->Set(pref_name.c_str(), *new_value);
+        pref_service_->Set(pref_name, *new_value);
       }
 
       // If the merge resulted in an updated value, inform the syncer.
       if (!sync_value->Equals(new_value.get())) {
         syncer::SyncData sync_data;
         if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) {
           LOG(ERROR) << "Failed to update preference.";
           return;
         }
 
         sync_changes->push_back(syncer::SyncChange(
             FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
       }
     } else if (!sync_value->IsType(base::Value::Type::NONE)) {
       // Only a server value exists. Just set the local user value.
-      pref_service_->Set(pref_name.c_str(), *sync_value);
+      pref_service_->Set(pref_name, *sync_value);
     } else {
       LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
     }
     synced_preferences_.insert(preference.name());
   } else if (user_pref_value) {
     // The server does not know about this preference and should be added
     // to the syncer's database.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(pref_name, *user_pref_value, &sync_data)) {
       LOG(ERROR) << "Failed to update preference.";
@@ skipping 196 matching lines @@
 // with user controlled data. We do not track any information for preferences
 // not registered locally as syncable and do not inform the syncer of
 // non-user controlled preferences.
 syncer::SyncDataList PrefModelAssociator::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(type_, type);
   syncer::SyncDataList current_data;
   for (PreferenceSet::const_iterator iter = synced_preferences_.begin();
        iter != synced_preferences_.end(); ++iter) {
     std::string name = *iter;
-    const PrefService::Preference* pref =
-        pref_service_->FindPreference(name.c_str());
+    const PrefService::Preference* pref = pref_service_->FindPreference(name);
     DCHECK(pref);
     if (!pref->IsUserControlled() || pref->IsDefaultValue())
       continue;  // This is not data we care about.
     // TODO(zea): plumb a way to read the user controlled value.
     syncer::SyncData sync_data;
     if (!CreatePrefSyncData(name, *pref->GetValue(), &sync_data))
       continue;
     current_data.push_back(sync_data);
   }
   return current_data;
@@ skipping 110 matching lines @@
 
 void PrefModelAssociator::ProcessPrefChange(const std::string& name) {
   if (processing_syncer_changes_)
     return;  // These are changes originating from us, ignore.
 
   // We only process changes if we've already associated models.
   if (!models_associated_)
     return;
 
   const PrefService::Preference* preference =
-      pref_service_->FindPreference(name.c_str());
+      pref_service_->FindPreference(name);
   if (!preference)
     return;
 
   if (!IsPrefRegistered(name.c_str()))
     return;  // We are not syncing this preference.
 
   syncer::SyncChangeList changes;
 
   if (!preference->IsUserModifiable()) {
     // If the preference is no longer user modifiable, it must now be controlled
@@ skipping 36 matching lines @@
                                                     bool from_sync) const {
   auto observer_iter = synced_pref_observers_.find(path);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second.get();
   for (auto& observer : *observers)
     observer.OnSyncedPrefChanged(path, from_sync);
 }
 
 }  // namespace sync_preferences