Remove unnecessary calls to std::basic_string<>::c_str()

chrome/browser/extensions/api/preference/preference_api.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/extensions/api/preference/preference_api.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 363 matching lines @@
   bool incognito = (pref_service != profile_->GetPrefs());
 
   std::string event_name;
   APIPermission::ID permission = APIPermission::kInvalid;
   bool rv = PrefMapping::GetInstance()->FindEventForBrowserPref(
       browser_pref, &event_name, &permission);
   DCHECK(rv);
 
   base::ListValue args;
   const PrefService::Preference* pref =
-      pref_service->FindPreference(browser_pref.c_str());
+      pref_service->FindPreference(browser_pref);
   CHECK(pref);
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   base::Value* transformed_value =
       transformer->BrowserToExtensionPref(pref->GetValue());
   if (!transformed_value) {
     LOG(ERROR) << ErrorUtils::FormatErrorMessage(kConversionErrorMessage,
                                                  pref->name());
     return;
   }
@@ skipping 23 matching lines @@
                                      browser_pref);
 }
 
 void PreferenceAPIBase::SetExtensionControlledPref(
     const std::string& extension_id,
     const std::string& pref_key,
     ExtensionPrefsScope scope,
     base::Value* value) {
 #ifndef NDEBUG
   const PrefService::Preference* pref =
-      extension_prefs()->pref_service()->FindPreference(pref_key.c_str());
+      extension_prefs()->pref_service()->FindPreference(pref_key);
   DCHECK(pref) << "Extension controlled preference key " << pref_key
                << " not registered.";
   DCHECK_EQ(pref->GetType(), value->GetType())
       << "Extension controlled preference " << pref_key << " has wrong type.";
 #endif
 
   std::string scope_string;
   // ScopeToPrefName() returns false if the scope is not persisted.
   if (pref_names::ScopeToPrefName(scope, &scope_string)) {
     // Also store in persisted Preferences file to recover after a
     // browser restart.
     ExtensionPrefs::ScopedDictionaryUpdate update(extension_prefs(),
                                                   extension_id,
                                                   scope_string);
     base::DictionaryValue* preference = update.Get();
     if (!preference)
       preference = update.Create();
     preference->SetWithoutPathExpansion(pref_key, value->DeepCopy());
   }
   extension_pref_value_map()->SetExtensionPref(
       extension_id, pref_key, scope, value);
 }
 
 void PreferenceAPIBase::RemoveExtensionControlledPref(
     const std::string& extension_id,
     const std::string& pref_key,
     ExtensionPrefsScope scope) {
-  DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key.c_str()))
+  DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
 
   std::string scope_string;
   if (pref_names::ScopeToPrefName(scope, &scope_string)) {
     ExtensionPrefs::ScopedDictionaryUpdate update(extension_prefs(),
                                                   extension_id,
                                                   scope_string);
     base::DictionaryValue* preference = update.Get();
     if (preference)
       preference->RemoveWithoutPathExpansion(pref_key, NULL);
   }
   extension_pref_value_map()->RemoveExtensionPref(
       extension_id, pref_key, scope);
 }
 
 bool PreferenceAPIBase::CanExtensionControlPref(
      const std::string& extension_id,
      const std::string& pref_key,
      bool incognito) {
-  DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key.c_str()))
+  DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
 
   return extension_pref_value_map()->CanExtensionControlPref(
        extension_id, pref_key, incognito);
 }
 
 bool PreferenceAPIBase::DoesExtensionControlPref(
     const std::string& extension_id,
     const std::string& pref_key,
     bool* from_incognito) {
-  DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key.c_str()))
+  DCHECK(extension_prefs()->pref_service()->FindPreference(pref_key))
       << "Extension controlled preference key " << pref_key
       << " not registered.";
 
   return extension_pref_value_map()->DoesExtensionControlPref(
       extension_id, pref_key, from_incognito);
 }
 
 PreferenceAPI::PreferenceAPI(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)) {
   for (size_t i = 0; i < arraysize(kPrefMapping); ++i) {
@@ skipping 110 matching lines @@
   APIPermission::ID write_permission = APIPermission::kInvalid;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
       pref_key, &browser_pref, &read_permission, &write_permission));
   if (!extension()->permissions_data()->HasAPIPermission(read_permission))
     return RespondNow(Error(keys::kPermissionErrorMessage, pref_key));
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   PrefService* prefs =
       incognito ? profile->GetOffTheRecordPrefs() : profile->GetPrefs();
-  const PrefService::Preference* pref =
-      prefs->FindPreference(browser_pref.c_str());
+  const PrefService::Preference* pref = prefs->FindPreference(browser_pref);
   CHECK(pref);
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
 
   // Retrieve level of control.
   std::string level_of_control = helpers::GetLevelOfControl(
       profile, extension_id(), browser_pref, incognito);
   result->SetString(keys::kLevelOfControl, level_of_control);
 
   // Retrieve pref value.
@@ skipping 67 matching lines @@
   APIPermission::ID read_permission = APIPermission::kInvalid;
   APIPermission::ID write_permission = APIPermission::kInvalid;
   EXTENSION_FUNCTION_VALIDATE(
       PrefMapping::GetInstance()->FindBrowserPrefForExtensionPref(
       pref_key, &browser_pref, &read_permission, &write_permission));
   if (!extension()->permissions_data()->HasAPIPermission(write_permission))
     return RespondNow(Error(keys::kPermissionErrorMessage, pref_key));
 
   ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context());
   const PrefService::Preference* pref =
-      prefs->pref_service()->FindPreference(browser_pref.c_str());
+      prefs->pref_service()->FindPreference(browser_pref);
   CHECK(pref);
 
   // Validate new value.
   PrefTransformerInterface* transformer =
       PrefMapping::GetInstance()->FindTransformerForBrowserPref(browser_pref);
   std::string error;
   bool bad_message = false;
   std::unique_ptr<base::Value> browser_pref_value(
       transformer->ExtensionToBrowserPref(value, &error, &bad_message));
   if (!browser_pref_value) {
@@ skipping 53 matching lines @@
       pref_key, &browser_pref, &read_permission, &write_permission));
   if (!extension()->permissions_data()->HasAPIPermission(write_permission))
     return RespondNow(Error(keys::kPermissionErrorMessage, pref_key));
 
   PreferenceAPI::Get(browser_context())
       ->RemoveExtensionControlledPref(extension_id(), browser_pref, scope);
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions