Remove content::NotificationObserver dependency from most Prefs code.

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 85 matching lines @@
     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,
-                                   content::NotificationObserver* obs) {
+                                   PrefObserver* 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);
   }
 }
 
 }  // namespace
 
 FontSettingsEventRouter::FontSettingsEventRouter(
@@ skipping 24 matching lines @@
                                 prefs::kWebKitFixedFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitCursiveFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFantasyFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitPictographFontFamilyMap, this);
 }
 
 void FontSettingsEventRouter::AddPrefToObserve(const char* pref_name,
-                                                        const char* event_name,
-                                                        const char* key) {
+                                               const char* event_name,
+                                               const char* key) {
   registrar_.Add(pref_name, this);
   pref_event_map_[pref_name] = std::make_pair(event_name, key);
 }
 
-void FontSettingsEventRouter::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  if (type != chrome::NOTIFICATION_PREF_CHANGED) {
-    NOTREACHED();
-    return;
-  }
-
-  PrefService* pref_service = content::Source<PrefService>(source).ptr();
+void FontSettingsEventRouter::OnPreferenceChanged(
+    PrefServiceBase* pref_service,
+    const std::string& pref_name) {
   bool incognito = (pref_service != profile_->GetPrefs());
   // We're only observing pref changes on the regular profile.
   DCHECK(!incognito);
-  const std::string* pref_name =
-      content::Details<const std::string>(details).ptr();
 
-  PrefEventMap::iterator iter = pref_event_map_.find(*pref_name);
+  PrefEventMap::iterator iter = pref_event_map_.find(pref_name);
   if (iter != pref_event_map_.end()) {
     const std::string& event_name = iter->second.first;
     const std::string& key = iter->second.second;
-    OnFontPrefChanged(pref_service, *pref_name, event_name, key, incognito);
+    OnFontPrefChanged(pref_service, pref_name, event_name, key, incognito);
     return;
   }
 
   std::string generic_family;
   std::string script;
-  if (ParseFontNamePrefPath(*pref_name, &generic_family, &script)) {
-    OnFontNamePrefChanged(pref_service, *pref_name, generic_family, script,
-                          incognito);
+  if (ParseFontNamePrefPath(pref_name, &generic_family, &script)) {
+    OnFontNamePrefChanged(static_cast<PrefService*>(pref_service), pref_name,
+                          generic_family, script, incognito);
     return;
   }
 
   NOTREACHED();
 }
 
 void FontSettingsEventRouter::OnFontNamePrefChanged(
     PrefService* pref_service,
     const std::string& pref_name,
     const std::string& generic_family,
@@ skipping 20 matching lines @@
   extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       APIPermission::kFontSettings,
       incognito,
       pref_name);
 }
 
 void FontSettingsEventRouter::OnFontPrefChanged(
-    PrefService* pref_service,
+    PrefServiceBase* pref_service,
     const std::string& pref_name,
     const std::string& event_name,
     const std::string& key,
     bool incognito) {
-  const PrefService::Preference* pref = pref_service->FindPreference(
+  const PrefServiceBase::Preference* pref = pref_service->FindPreference(
       pref_name.c_str());
   CHECK(pref);
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
   dict->Set(key, pref->GetValue()->DeepCopy());
 
   extensions::preference_helpers::DispatchEventToExtensions(
       profile_,
@@ skipping 238 matching lines @@
 
 const char* SetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* SetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions