Add Windows desktop shortcut for multiple profiles.

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/browser_process.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/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"
 
@@ skipping 54 matching lines @@
   IDS_DEFAULT_AVATAR_NAME_18,
   IDS_DEFAULT_AVATAR_NAME_19,
   IDS_DEFAULT_AVATAR_NAME_20,
   IDS_DEFAULT_AVATAR_NAME_21,
   IDS_DEFAULT_AVATAR_NAME_22,
   IDS_DEFAULT_AVATAR_NAME_23,
   IDS_DEFAULT_AVATAR_NAME_24,
   IDS_DEFAULT_AVATAR_NAME_25
 };
 
-} // namespace
+}  // namespace
 
 ProfileInfoCache::ProfileInfoCache(PrefService* prefs,
                                    const FilePath& user_data_dir)
     : prefs_(prefs),
       user_data_dir_(user_data_dir) {
   // Populate the cache
   const DictionaryValue* cache =
       prefs_->GetDictionary(prefs::kProfileInfoCache);
   for (DictionaryValue::key_iterator it = cache->begin_keys();
        it != cache->end_keys(); ++it) {
@@ skipping 20 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);
 
+  FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
+                    observer_list_,
+                    OnProfileAdded(name, UTF8ToUTF16(key)));
+
   content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
     content::NotificationService::AllSources(),
     content::NotificationService::NoDetails());
 }
 
+void ProfileInfoCache::AddObserver(ProfileInfoCacheObserver* obs) {
+  observer_list_.AddObserver(obs);
+}
+
+void ProfileInfoCache::RemoveObserver(ProfileInfoCacheObserver* obs) {
+  observer_list_.RemoveObserver(obs);
+}
+
 void ProfileInfoCache::DeleteProfileFromCache(const FilePath& profile_path) {
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   DictionaryValue* cache = update.Get();
+  DCHECK(cache);
+  std::string key = CacheKeyFromProfilePath(profile_path);
+  DictionaryValue* info = NULL;
+  cache->GetDictionary(key, &info);
+  DCHECK(info);
+  string16 name;
+  info->GetString(kNameKey, &name);
 
-  std::string key = CacheKeyFromProfilePath(profile_path);
+  FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
+                    observer_list_,
+                    OnProfileRemoved(name));
+
   cache->Remove(key, NULL);
   sorted_keys_.erase(std::find(sorted_keys_.begin(), sorted_keys_.end(), key));
 
   content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
     content::NotificationService::AllSources(),
     content::NotificationService::NoDetails());
 }
 
 size_t ProfileInfoCache::GetNumberOfProfiles() const {
@@ skipping 57 matching lines @@
   if (IsDefaultAvatarIconUrl(icon_url, &icon_index))
     return icon_index;
 
   DLOG(WARNING) << "Unknown avatar icon: " << icon_url;
   return GetDefaultAvatarIconResourceIDAtIndex(0);
 }
 
 void ProfileInfoCache::SetNameOfProfileAtIndex(size_t index,
                                                const string16& name) {
   scoped_ptr<DictionaryValue> info(GetInfoForProfileAtIndex(index)->DeepCopy());
+  string16 old_name;
+  info->GetString(kNameKey, &old_name);
   info->SetString(kNameKey, name);
   // This takes ownership of |info|.
   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);
 
+  FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
+                    observer_list_,
+                    OnProfileNameChanged(old_name, name));
+
   content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
     content::NotificationService::AllSources(),
     content::NotificationService::NoDetails());
 }
 
 void ProfileInfoCache::SetUserNameOfProfileAtIndex(size_t index,
                                                    const string16& user_name) {
   string16 old_user_name;
   const base::DictionaryValue* old_info = GetInfoForProfileAtIndex(index);
@@ skipping 138 matching lines @@
   return false;
 }
 
 const DictionaryValue* ProfileInfoCache::GetInfoForProfileAtIndex(
     size_t index) const {
   DCHECK_LT(index, GetNumberOfProfiles());
   const DictionaryValue* cache =
       prefs_->GetDictionary(prefs::kProfileInfoCache);
   DictionaryValue* info = NULL;
   cache->GetDictionary(sorted_keys_[index], &info);
+  DCHECK(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);
 
   content::NotificationService::current()->Notify(
@@ skipping 18 matching lines @@
       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();
 }
 
+// static
+std::vector<string16> ProfileInfoCache::GetProfileNames() {
+  std::vector<string16> names;
+  PrefService* local_state = g_browser_process->local_state();
+  const DictionaryValue* cache = local_state->GetDictionary(
+      prefs::kProfileInfoCache);
+  string16 name;
+  for (base::DictionaryValue::key_iterator it = cache->begin_keys();
+       it != cache->end_keys();
+     ++it) {

[grt (UTC plus 2), 2011/11/18 20:02:54]

indent

[Miranda Callahan, 2011/11/18 22:41:33]

Done.

+    base::DictionaryValue* info = NULL;
+    cache->GetDictionary(*it, &info);
+    info->GetString(kNameKey, &name);
+    names.push_back(name);
+  }
+  return names;
+}
+
+// static
 void ProfileInfoCache::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kProfileInfoCache);
 }