Remove content::NotificationObserver dependency from most Prefs code.

chrome/browser/profiles/profile_impl.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/profiles/profile_impl.h"
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
@@ skipping 296 matching lines @@
   policy_service_.reset(new policy::PolicyServiceStub());
 #endif
 
   if (create_mode == CREATE_MODE_ASYNCHRONOUS) {
     prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         policy_service_.get(),
         new ExtensionPrefStore(
             ExtensionPrefValueMapFactory::GetForProfile(this), false),
         true));
-    // Wait for the notification that prefs has been loaded (successfully or
-    // not).
-    registrar_.Add(this, chrome::NOTIFICATION_PREF_INITIALIZATION_COMPLETED,
-                   content::Source<PrefService>(prefs_.get()));
+    // Wait for the notification that prefs has been loaded
+    // (successfully or not).  Note that we can use base::Unretained
+    // because the prefs service is owned by this class and lives on
+    // the same thread.
+    prefs_->AddPrefInitObserver(base::Bind(&ProfileImpl::OnPrefsLoaded,
+                                           base::Unretained(this)));
   } else if (create_mode == CREATE_MODE_SYNCHRONOUS) {
     // Load prefs synchronously.
     prefs_.reset(PrefService::CreatePrefService(
         GetPrefFilePath(),
         policy_service_.get(),
         new ExtensionPrefStore(
             ExtensionPrefValueMapFactory::GetForProfile(this), false),
         false));
     OnPrefsLoaded(true);
   } else {
@@ skipping 546 matching lines @@
 }
 
 history::TopSites* ProfileImpl::GetTopSitesWithoutCreating() {
   return top_sites_;
 }
 
 void ProfileImpl::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_PREF_INITIALIZATION_COMPLETED: {
-      bool* succeeded = content::Details<bool>(details).ptr();
-      PrefService *prefs = content::Source<PrefService>(source).ptr();
-      DCHECK(prefs == prefs_.get());
-      registrar_.Remove(this,
-                        chrome::NOTIFICATION_PREF_INITIALIZATION_COMPLETED,
-                        content::Source<PrefService>(prefs));
-      OnPrefsLoaded(*succeeded);
-      break;
-    }
-    case chrome::NOTIFICATION_PREF_CHANGED: {
-      std::string* pref_name_in = content::Details<std::string>(details).ptr();
-      PrefService* prefs = content::Source<PrefService>(source).ptr();
-      DCHECK(pref_name_in && prefs);
-      if (*pref_name_in == prefs::kGoogleServicesUsername) {
-        UpdateProfileUserNameCache();
-      } else if (*pref_name_in == prefs::kProfileAvatarIndex) {
-        UpdateProfileAvatarCache();
-      } else if (*pref_name_in == prefs::kProfileName) {
-        UpdateProfileNameCache();
-      } else if (*pref_name_in == prefs::kDefaultZoomLevel) {
-          HostZoomMap::GetForBrowserContext(this)->SetDefaultZoomLevel(
-              prefs->GetDouble(prefs::kDefaultZoomLevel));
-      }
-      break;
-    }
     case chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED:
       // Causes lazy-load if sync is enabled.
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(this);
       registrar_.Remove(this, chrome::NOTIFICATION_BOOKMARK_MODEL_LOADED,
                         content::Source<Profile>(this));
       break;
     case content::NOTIFICATION_ZOOM_LEVEL_CHANGED: {
       const std::string& host =
           *(content::Details<const std::string>(details).ptr());
       if (!host.empty()) {
         HostZoomMap* host_zoom_map = HostZoomMap::GetForBrowserContext(this);
         double level = host_zoom_map->GetZoomLevel(host);
         DictionaryPrefUpdate update(prefs_.get(), prefs::kPerHostZoomLevels);
         DictionaryValue* host_zoom_dictionary = update.Get();
         if (level == host_zoom_map->GetDefaultZoomLevel()) {
           host_zoom_dictionary->RemoveWithoutPathExpansion(host, NULL);
         } else {
           host_zoom_dictionary->SetWithoutPathExpansion(
               host, Value::CreateDoubleValue(level));
         }
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+void ProfileImpl::OnPreferenceChanged(PrefServiceBase* prefs,
+                                      const std::string& pref_name_in) {
+  DCHECK(prefs);
+  if (pref_name_in == prefs::kGoogleServicesUsername) {
+    UpdateProfileUserNameCache();
+  } else if (pref_name_in == prefs::kProfileAvatarIndex) {
+    UpdateProfileAvatarCache();
+  } else if (pref_name_in == prefs::kProfileName) {
+    UpdateProfileNameCache();
+  } else if (pref_name_in == prefs::kDefaultZoomLevel) {
+    HostZoomMap::GetForBrowserContext(this)->SetDefaultZoomLevel(
+        prefs->GetDouble(prefs::kDefaultZoomLevel));
+  }
+}
+
 #if defined(ENABLE_SESSION_SERVICE)
 void ProfileImpl::StopCreateSessionServiceTimer() {
   create_session_service_timer_.Stop();
 }
 
 void ProfileImpl::EnsureSessionServiceCreated() {
   SessionServiceFactory::GetForProfile(this);
 }
 #endif
 
@@ skipping 181 matching lines @@
   if (!path.empty())
     *cache_path = path;
   *max_size = is_media_context ? prefs_->GetInteger(prefs::kMediaCacheSize) :
                                  prefs_->GetInteger(prefs::kDiskCacheSize);
 }
 
 base::Callback<ChromeURLDataManagerBackend*(void)>
     ProfileImpl::GetChromeURLDataManagerBackendGetter() const {
   return io_data_.GetChromeURLDataManagerBackendGetter();
 }