Make NotificationService an interface in the content namespace, and switch callers to use it. Mov...

chrome/browser/profiles/profile_info_cache.cc

 // Copyright (c) 2011 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_info_cache.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
-#include "content/common/notification_service.h"
+#include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace {
 
 const char kNameKey[] = "name";
 const char kUserNameKey[] = "user_name";
 const char kAvatarIconKey[] = "avatar_icon";
@@ skipping 90 matching lines @@
   scoped_ptr<DictionaryValue> info(new DictionaryValue);
   info->SetString(kNameKey, name);
   info->SetString(kUserNameKey, username);
   info->SetString(kAvatarIconKey, GetDefaultAvatarIconUrl(icon_index));
   // Default value for whether background apps are running is false.
   info->SetBoolean(kBackgroundAppsKey, false);
   cache->Set(key, info.release());
 
   sorted_keys_.insert(FindPositionForProfile(key, name), key);
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
-    NotificationService::AllSources(),
-    NotificationService::NoDetails());
+    content::NotificationService::AllSources(),
+    content::NotificationService::NoDetails());
 }
 
 void ProfileInfoCache::DeleteProfileFromCache(const FilePath& profile_path) {
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   DictionaryValue* cache = update.Get();
 
   std::string key = CacheKeyFromProfilePath(profile_path);
   cache->Remove(key, NULL);
   sorted_keys_.erase(std::find(sorted_keys_.begin(), sorted_keys_.end(), key));
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
-    NotificationService::AllSources(),
-    NotificationService::NoDetails());
+    content::NotificationService::AllSources(),
+    content::NotificationService::NoDetails());
 }
 
 size_t ProfileInfoCache::GetNumberOfProfiles() const {
   return sorted_keys_.size();
 }
 
 size_t ProfileInfoCache::GetIndexOfProfileWithPath(
     const FilePath& profile_path) const {
   if (profile_path.DirName() != user_data_dir_)
     return std::string::npos;
@@ skipping 62 matching lines @@
   SetInfoForProfileAtIndex(index, info.release());
 
   // Remove and reinsert key in |sorted_keys_| to alphasort.
   std::string key = CacheKeyFromProfilePath(GetPathOfProfileAtIndex(index));
   std::vector<std::string>::iterator key_it =
       std::find(sorted_keys_.begin(), sorted_keys_.end(), key);
   DCHECK(key_it != sorted_keys_.end());
   sorted_keys_.erase(key_it);
   sorted_keys_.insert(FindPositionForProfile(key, name), key);
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
-    NotificationService::AllSources(),
-    NotificationService::NoDetails());
+    content::NotificationService::AllSources(),
+    content::NotificationService::NoDetails());
 }
 
 void ProfileInfoCache::SetUserNameOfProfileAtIndex(size_t index,
                                                    const string16& user_name) {
   scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetString(kUserNameKey, user_name);
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
 }
 
@@ skipping 137 matching lines @@
   cache->GetDictionary(sorted_keys_[index], &info);
   return info;
 }
 
 void ProfileInfoCache::SetInfoForProfileAtIndex(size_t index,
                                                 DictionaryValue* info) {
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   DictionaryValue* cache = update.Get();
   cache->Set(sorted_keys_[index], info);
 
-  NotificationService::current()->Notify(
+  content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
-    NotificationService::AllSources(),
-    NotificationService::NoDetails());
+    content::NotificationService::AllSources(),
+    content::NotificationService::NoDetails());
 }
 
 std::string ProfileInfoCache::CacheKeyFromProfilePath(
     const FilePath& profile_path) const {
   DCHECK(user_data_dir_ == profile_path.DirName());
   FilePath base_name = profile_path.BaseName();
   return base_name.MaybeAsASCII();
 }
 
 std::vector<std::string>::iterator ProfileInfoCache::FindPositionForProfile(
     std::string search_key,
     const string16& search_name) {
   for (size_t i = 0; i < GetNumberOfProfiles(); ++i) {
     int name_compare = search_name.compare(GetNameOfProfileAtIndex(i));
     if (name_compare < 0)
       return sorted_keys_.begin() + i;
     if (name_compare == 0) {
       int key_compare = search_key.compare(sorted_keys_[i]);
       if (key_compare < 0)
         return sorted_keys_.begin() + i;
     }
   }
   return sorted_keys_.end();
 }
 
 void ProfileInfoCache::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kProfileInfoCache);
 }