Various optimizations to reduce the number of temporary allocations.

chrome/browser/extensions/api/font_settings/font_settings_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.
 
 // Font Settings Extension API implementation.
 
 #include "chrome/browser/extensions/api/font_settings/font_settings_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 43 matching lines @@
 
 // Gets the font name preference path for |generic_family| and |script|. If
 // |script| is NULL, uses prefs::kWebKitCommonScript.
 std::string GetFontNamePrefPath(fonts::GenericFamily generic_family_enum,
                                 fonts::ScriptCode script_enum) {
   std::string script = fonts::ToString(script_enum);
   if (script.empty())
     script = prefs::kWebKitCommonScript;
   std::string generic_family = fonts::ToString(generic_family_enum);
   return base::StringPrintf(kWebKitFontPrefFormat,
-                            generic_family.c_str(),
-                            script.c_str());
+                            generic_family,
+                            script);
 }
 
 // Returns the localized name of a font so that it can be matched within the
 // list of system fonts. On Windows, the list of system fonts has names only
 // for the system locale, but the pref value may be in the English name.
 std::string MaybeGetLocalizedFontName(const std::string& font_name) {
 #if defined(OS_WIN)
   if (!font_name.empty()) {
     gfx::Font font(font_name, 12);  // dummy font size
     return static_cast<gfx::PlatformFontWin*>(font.platform_font())->
         GetLocalizedFontName();
   }
 #endif
   return font_name;
 }
 
 // Registers |obs| to observe per-script font prefs under the path |map_name|.
 void RegisterFontFamilyMapObserver(
     PrefChangeRegistrar* registrar,
     const char* map_name,
     const PrefChangeRegistrar::NamedChangeCallback& callback) {
+  std::string pref_name;
+  pref_name.reserve(512);  // Reduces number of grows.
   for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
     const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
-    std::string pref_name = base::StringPrintf("%s.%s", map_name, script);

[Nico, 2014/12/03 20:34:34]

doesn't look restored?

-    registrar->Add(pref_name.c_str(), callback);
+    pref_name.assign(map_name);
+    pref_name.append(1, '.');
+    pref_name.append(script);
+    registrar->Add(pref_name, callback);
   }
 }
 
 }  // namespace
 
 FontSettingsEventRouter::FontSettingsEventRouter(
     Profile* profile) : profile_(profile) {
   registrar_.Init(profile_->GetPrefs());
 
   AddPrefToObserve(prefs::kWebKitDefaultFixedFontSize,
@@ skipping 48 matching lines @@
   }
 
   NOTREACHED();
 }
 
 void FontSettingsEventRouter::OnFontNamePrefChanged(
     const std::string& pref_name,
     const std::string& generic_family,
     const std::string& script) {
   const PrefService::Preference* pref = registrar_.prefs()->FindPreference(
-      pref_name.c_str());
+      pref_name);
   CHECK(pref);
 
   std::string font_name;
   if (!pref->GetValue()->GetAsString(&font_name)) {
     NOTREACHED();
     return;
   }
   font_name = MaybeGetLocalizedFontName(font_name);
 
   base::ListValue args;
@@ skipping 10 matching lines @@
       APIPermission::kFontSettings,
       false,
       pref_name);
 }
 
 void FontSettingsEventRouter::OnFontPrefChanged(
     const std::string& event_name,
     const std::string& key,
     const std::string& pref_name) {
   const PrefService::Preference* pref = registrar_.prefs()->FindPreference(
-      pref_name.c_str());
+      pref_name);
   CHECK(pref);
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   args.Append(dict);
   dict->Set(key, pref->GetValue()->DeepCopy());
 
   extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
       event_name,
@@ skipping 27 matching lines @@
 
   scoped_ptr<fonts::ClearFont::Params> params(
       fonts::ClearFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script);
 
   // Ensure |pref_path| really is for a registered per-script font pref.
   EXTENSION_FUNCTION_VALIDATE(
-      GetProfile()->GetPrefs()->FindPreference(pref_path.c_str()));
+      GetProfile()->GetPrefs()->FindPreference(pref_path));
 
   PreferenceAPI::Get(GetProfile())->RemoveExtensionControlledPref(
-      extension_id(), pref_path.c_str(), kExtensionPrefsScopeRegular);
+      extension_id(), pref_path, kExtensionPrefsScopeRegular);
   return true;
 }
 
 bool FontSettingsGetFontFunction::RunSync() {
   scoped_ptr<fonts::GetFont::Params> params(
       fonts::GetFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script);
 
   PrefService* prefs = GetProfile()->GetPrefs();
   const PrefService::Preference* pref =
-      prefs->FindPreference(pref_path.c_str());
+      prefs->FindPreference(pref_path);
 
   std::string font_name;
   EXTENSION_FUNCTION_VALIDATE(
       pref && pref->GetValue()->GetAsString(&font_name));
   font_name = MaybeGetLocalizedFontName(font_name);
 
   // We don't support incognito-specific font prefs, so don't consider them when
   // getting level of control.
   const bool kIncognito = false;
   std::string level_of_control =
@@ skipping 15 matching lines @@
 
   scoped_ptr<fonts::SetFont::Params> params(
       fonts::SetFont::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string pref_path = GetFontNamePrefPath(params->details.generic_family,
                                               params->details.script);
 
   // Ensure |pref_path| really is for a registered font pref.
   EXTENSION_FUNCTION_VALIDATE(
-      GetProfile()->GetPrefs()->FindPreference(pref_path.c_str()));
+      GetProfile()->GetPrefs()->FindPreference(pref_path));
 
   PreferenceAPI::Get(GetProfile())->SetExtensionControlledPref(
       extension_id(),
-      pref_path.c_str(),
+      pref_path,
       kExtensionPrefsScopeRegular,
       new base::StringValue(params->details.font_id));
   return true;
 }
 
 bool FontSettingsGetFontListFunction::RunAsync() {
   content::GetFontListAsync(
       Bind(&FontSettingsGetFontListFunction::FontListHasLoaded, this));
   return true;
 }
@@ skipping 142 matching lines @@
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions