Remove PrefObserver usages, batch 6.

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/string_util.h"
@@ skipping 79 matching lines @@
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalCursiveFontFamily,
                                      IDS_CURSIVE_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalFantasyFontFamily,
                                      IDS_FANTASY_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
 }
 
 // The list of prefs we want to observe.
 const char* kPrefsToObserve[] = {
-  prefs::kDefaultZoomLevel,
   prefs::kDefaultCharset,
-  prefs::kEnableReferrers,
-  prefs::kEnableDoNotTrack,
   prefs::kWebKitAllowDisplayingInsecureContent,
   prefs::kWebKitAllowRunningInsecureContent,
   prefs::kWebKitDefaultFixedFontSize,
   prefs::kWebKitDefaultFontSize,
 #if defined(OS_ANDROID)
   prefs::kWebKitFontScaleFactor,
   prefs::kWebKitForceEnableZoom,
 #endif
   prefs::kWebKitJavascriptEnabled,
   prefs::kWebKitJavaEnabled,
@@ skipping 19 matching lines @@
     const char* pref_name = pref_name_str.c_str();
     if (fonts_with_defaults.find(pref_name) == fonts_with_defaults.end()) {
       // We haven't already set a default value for this font preference, so set
       // an empty string as the default.
       prefs->RegisterStringPref(pref_name, "", PrefService::UNSYNCABLE_PREF);
     }
   }
 }
 
 // Registers |obs| to observe per-script font prefs under the path |map_name|.
-void RegisterFontFamilyMapObserver(PrefChangeRegistrar* registrar,
-                                   const char* map_name,
-                                   PrefObserver* obs) {
+void RegisterFontFamilyMapObserver(
+    PrefChangeRegistrar* registrar,
+    const char* map_name,
+    const PrefChangeRegistrar::NamedChangeCallback& obs) {
   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);
   }
 }
 
 struct FontDefault {
   const char* pref_name;
   int resource_id;
@@ skipping 222 matching lines @@
   (*map)[script] = UTF8ToUTF16(pref_value);
 }
 
 }  // namespace
 
 PrefsTabHelper::PrefsTabHelper(WebContents* contents)
     : web_contents_(contents) {
   PrefService* prefs = GetProfile()->GetPrefs();
   pref_change_registrar_.Init(prefs);
   if (prefs) {
+    base::Closure renderer_callback = base::Bind(
+        &PrefsTabHelper::UpdateRendererPreferences, base::Unretained(this));
+    pref_change_registrar_.Add(prefs::kDefaultZoomLevel, renderer_callback);
+    pref_change_registrar_.Add(prefs::kEnableDoNotTrack, renderer_callback);
+    pref_change_registrar_.Add(prefs::kEnableReferrers, renderer_callback);
+
+    PrefChangeRegistrar::NamedChangeCallback webkit_callback = base::Bind(
+        &PrefsTabHelper::OnWebKitPreferenceChanged, base::Unretained(this));
     for (int i = 0; i < kPrefsToObserveLength; ++i)
-      pref_change_registrar_.Add(kPrefsToObserve[i], this);
+      pref_change_registrar_.Add(kPrefsToObserve[i], webkit_callback);
 
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitStandardFontFamilyMap, this);
+                                  prefs::kWebKitStandardFontFamilyMap,
+                                  webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitFixedFontFamilyMap, this);
+                                  prefs::kWebKitFixedFontFamilyMap,
+                                  webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitSerifFontFamilyMap, this);
+                                  prefs::kWebKitSerifFontFamilyMap,
+                                  webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitSansSerifFontFamilyMap, this);
+                                  prefs::kWebKitSansSerifFontFamilyMap,
+                                  webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitCursiveFontFamilyMap, this);
+                                  prefs::kWebKitCursiveFontFamilyMap,
+                                  webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitFantasyFontFamilyMap, this);
+                                  prefs::kWebKitFantasyFontFamilyMap,
+                                  webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
-                                  prefs::kWebKitPictographFontFamilyMap, this);
+                                  prefs::kWebKitPictographFontFamilyMap,
+                                  webkit_callback);
   }
 
   renderer_preferences_util::UpdateFromSystemSettings(
       web_contents_->GetMutableRendererPrefs(), GetProfile());
 
   registrar_.Add(this, chrome::NOTIFICATION_USER_STYLE_SHEET_UPDATED,
                  content::NotificationService::AllSources());
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  content::Source<ThemeService>(
@@ skipping 163 matching lines @@
     case chrome::NOTIFICATION_BROWSER_THEME_CHANGED: {
       UpdateRendererPreferences();
       break;
     }
 #endif
     default:
       NOTREACHED();
   }
 }
 
-void PrefsTabHelper::OnPreferenceChanged(PrefServiceBase* service,
-                                         const std::string& pref_name_in) {
-  DCHECK_EQ(GetProfile()->GetPrefs(), service);
+void PrefsTabHelper::OnWebKitPreferenceChanged(
+    const std::string& pref_name_in) {
   if (pref_name_in == prefs::kDefaultCharset ||
       StartsWithASCII(pref_name_in, "webkit.webprefs.", true)) {

[Mattias Nissler (ping if slow), 2012/11/15 14:56:22]

I would even go as far as dropping this check and binding to OnWebPrefChanged()
directly, the test in the old code is just the pref-name-switch pattern
boilerplate I guess. Even if the check is considered useful, how about putting
the DCHECK(StartsWithASCII()) at the registration in line 395?

Maybe we should check with an OWNER :)

     OnWebPrefChanged(pref_name_in);
-  } else if (pref_name_in == prefs::kDefaultZoomLevel ||
-             pref_name_in == prefs::kEnableReferrers ||
-             pref_name_in == prefs::kEnableDoNotTrack) {
-    UpdateRendererPreferences();
   } else {
     NOTREACHED() << "unexpected pref change notification" << pref_name_in;
   }
 }
 
 void PrefsTabHelper::UpdateWebPreferences() {
   web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(
       web_contents_->GetRenderViewHost()->GetWebkitPreferences());
 }
 
@@ skipping 31 matching lines @@
       WebPreferences web_prefs =
           web_contents_->GetRenderViewHost()->GetWebkitPreferences();
       OverrideFontFamily(&web_prefs, generic_family, script, "");
       web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(web_prefs);
       return;
     }
   }
 
   UpdateWebPreferences();
 }