Various optimizations to reduce the number of temporary allocations.

chrome/browser/ui/prefs/prefs_tab_helper.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/ui/prefs/prefs_tab_helper.h"
 
 #include <string>
 
 #include "base/prefs/overlay_user_pref_store.h"
 #include "base/prefs/pref_service.h"
@@ skipping 111 matching lines @@
 }
 #endif  // !defined(OS_ANDROID)
 
 // Registers |obs| to observe per-script font prefs under the path |map_name|.
 // On android, there's no exposed way to change these prefs, so we can save
 // ~715KB of heap and some startup cycles by avoiding observing these prefs
 // since they will never change.
 void RegisterFontFamilyMapObserver(
     PrefChangeRegistrar* registrar,
     const char* map_name,
-    const PrefChangeRegistrar::NamedChangeCallback& obs) {
+    const PrefChangeRegistrar::NamedChangeCallback& obs,
+    std::string* pref_name) {
   DCHECK(StartsWithASCII(map_name, "webkit.webprefs.", true));
+  DCHECK(pref_name);
   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);
-    registrar->Add(pref_name.c_str(), obs);
+    pref_name->assign(map_name);
+    pref_name->append(1, '.');
+    pref_name->append(script);
+    registrar->Add(*pref_name, obs);
   }
 }
 
 #if defined(OS_WIN)
 // On Windows with antialising we want to use an alternate fixed font like
 // Consolas, which looks much better than Courier New.
 bool ShouldUseAlternateDefaultFixedFont(const std::string& script) {
   if (!StartsWithASCII(script, "courier", false))
     return false;
   UINT smooth_type = 0;
@@ skipping 194 matching lines @@
     pref_change_registrar_.Add(prefs::kFullscreenAllowed, renderer_callback);
 #endif
 
     PrefChangeRegistrar::NamedChangeCallback webkit_callback = base::Bind(
         &PrefsTabHelper::OnWebPrefChanged, base::Unretained(this));
     for (int i = 0; i < kPrefsToObserveLength; ++i) {
       const char* pref_name = kPrefsToObserve[i];
       pref_change_registrar_.Add(pref_name, webkit_callback);
     }
 
+    std::string pref_name;
+    pref_name.reserve(500);
+
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitStandardFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitFixedFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitSerifFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitSansSerifFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitCursiveFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitFantasyFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitPictographFontFamilyMap,
-                                  webkit_callback);
+                                  webkit_callback,
+                                  &pref_name);
   }
 
   content::RendererPreferences* render_prefs =
       web_contents_->GetMutableRendererPrefs();
   renderer_preferences_util::UpdateFromSystemSettings(render_prefs,
                                                       GetProfile(),
                                                       web_contents_);
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
   registrar_.Add(this,
@@ skipping 224 matching lines @@
   // is normally okay since WebKit does the desired fallback behavior regardless
   // of whether the empty string is passed or the pref is not passed at all. But
   // if the pref has changed from non-empty to the empty string, we must let
   // WebKit know.
   std::string generic_family;
   std::string script;
   if (pref_names_util::ParseFontNamePrefPath(pref_name,
                                              &generic_family,
                                              &script)) {
     PrefService* prefs = GetProfile()->GetPrefs();
-    std::string pref_value = prefs->GetString(pref_name.c_str());
+    std::string pref_value = prefs->GetString(pref_name);
     if (pref_value.empty()) {
       WebPreferences web_prefs =
           web_contents_->GetRenderViewHost()->GetWebkitPreferences();
       OverrideFontFamily(&web_prefs, generic_family, script, std::string());
       web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(web_prefs);
       return;
     }
   }
 }
 
 void PrefsTabHelper::OnWebPrefChanged(const std::string& pref_name) {
 #if !defined(OS_ANDROID)
   OnFontFamilyPrefChanged(pref_name);
 #endif
 
   web_contents_->GetRenderViewHost()->OnWebkitPreferencesChanged();
 }