Use custom profile names (if available) for signed in profiles

chrome/browser/profiles/profile_info_cache.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_info_cache.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 26 matching lines @@
 using content::BrowserThread;
 
 namespace {
 
 const char kNameKey[] = "name";
 const char kShortcutNameKey[] = "shortcut_name";
 const char kGAIANameKey[] = "gaia_name";
 const char kGAIAGivenNameKey[] = "gaia_given_name";
 const char kUseGAIANameKey[] = "use_gaia_name";
 const char kUserNameKey[] = "user_name";
+const char kIsUsingDefaultName[] = "is_using_default_name";
 const char kAvatarIconKey[] = "avatar_icon";
 const char kAuthCredentialsKey[] = "local_auth_credentials";
 const char kUseGAIAPictureKey[] = "use_gaia_picture";
 const char kBackgroundAppsKey[] = "background_apps";
 const char kHasMigratedToGAIAInfoKey[] = "has_migrated_to_gaia_info";
 const char kGAIAPictureFileNameKey[] = "gaia_picture_file_name";
 const char kIsManagedKey[] = "is_managed";
 const char kIsOmittedFromProfileListKey[] = "is_omitted_from_profile_list";
 const char kSigninRequiredKey[] = "signin_required";
 const char kManagedUserId[] = "managed_user_id";
@@ skipping 109 matching lines @@
   }
 
   *out_image = new gfx::Image(image);
 }
 
 void DeleteBitmap(const base::FilePath& image_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   base::DeleteFile(image_path, false);
 }
 
+bool IsDefaultName(const base::string16& name) {
+  // Check if it's a "First user" old-style name.
+  if (name == l10n_util::GetStringUTF16(IDS_DEFAULT_PROFILE_NAME))
+    return true;
+
+  // Check if it's one of the old-style profile names.
+  for (size_t i = 0; i < arraysize(kDefaultNames); ++i) {
+    if (name == l10n_util::GetStringUTF16(kDefaultNames[i]))
+      return true;
+  }
+
+  // Check whether it's one of the "Person %d" style names.
+  std::string default_name_format = l10n_util::GetStringFUTF8(
+      IDS_NEW_NUMBERED_PROFILE_NAME, base::string16()) + "%d";
+
+  int generic_profile_number;  // Unused. Just a placeholder for sscanf.
+  int assignments = sscanf(base::UTF16ToUTF8(name).c_str(),
+                           default_name_format.c_str(),
+                           &generic_profile_number);
+  // Unless it matched the format, this is a custom name.
+  return assignments == 1;
+}
+
 }  // namespace
 
 ProfileInfoCache::ProfileInfoCache(PrefService* prefs,
                                    const base::FilePath& user_data_dir)
     : prefs_(prefs),
       user_data_dir_(user_data_dir) {
   // Populate the cache
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   base::DictionaryValue* cache = update.Get();
   for (base::DictionaryValue::Iterator it(*cache);
        !it.IsAtEnd(); it.Advance()) {
     base::DictionaryValue* info = NULL;
     cache->GetDictionaryWithoutPathExpansion(it.key(), &info);
     base::string16 name;
     info->GetString(kNameKey, &name);
     sorted_keys_.insert(FindPositionForProfile(it.key(), name), it.key());
     // TODO(ibraaaa): delete this when 97% of our users are using M31.
     // http://crbug.com/276163
     bool is_managed = false;
     if (info->GetBoolean(kIsManagedKey, &is_managed)) {
       info->Remove(kIsManagedKey, NULL);
       info->SetString(kManagedUserId, is_managed ? "DUMMY_ID" : std::string());
     }
+    info->SetBoolean(kIsUsingDefaultName, IsDefaultName(name));
   }
 }
 
 ProfileInfoCache::~ProfileInfoCache() {
   STLDeleteContainerPairSecondPointers(
       gaia_pictures_.begin(), gaia_pictures_.end());
 }
 
 void ProfileInfoCache::AddProfileToCache(const base::FilePath& profile_path,
                                          const base::string16& name,
                                          const base::string16& username,
                                          size_t icon_index,
                                          const std::string& managed_user_id) {
   std::string key = CacheKeyFromProfilePath(profile_path);
   DictionaryPrefUpdate update(prefs_, prefs::kProfileInfoCache);
   base::DictionaryValue* cache = update.Get();
 
   scoped_ptr<base::DictionaryValue> info(new base::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);
   info->SetString(kManagedUserId, managed_user_id);
   info->SetBoolean(kIsOmittedFromProfileListKey, !managed_user_id.empty());
   info->SetBoolean(kProfileIsEphemeral, false);
+  info->SetBoolean(kIsUsingDefaultName, IsDefaultName(name));
   cache->SetWithoutPathExpansion(key, info.release());
 
   sorted_keys_.insert(FindPositionForProfile(key, name), key);
 
   FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                     observer_list_,
                     OnProfileAdded(profile_path));
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
@@ skipping 49 matching lines @@
   std::string search_key = CacheKeyFromProfilePath(profile_path);
   for (size_t i = 0; i < sorted_keys_.size(); ++i) {
     if (sorted_keys_[i] == search_key)
       return i;
   }
   return std::string::npos;
 }
 
 base::string16 ProfileInfoCache::GetNameOfProfileAtIndex(size_t index) const {
   base::string16 name;
-  if (IsUsingGAIANameOfProfileAtIndex(index)) {
+  // Unless the user has customized the profile name, we should use the
+  // profile's Gaia given name, if it's available.
+  if (IsUsingGAIANameOfProfileAtIndex(index) &&
+      ProfileIsUsingDefaultNameAtIndex(index)) {
     base::string16 given_name = GetGAIAGivenNameOfProfileAtIndex(index);
     name = given_name.empty() ? GetGAIANameOfProfileAtIndex(index) : given_name;
   }
-
   if (name.empty())
     GetInfoForProfileAtIndex(index)->GetString(kNameKey, &name);
   return name;
 }
 
 base::string16 ProfileInfoCache::GetShortcutNameOfProfileAtIndex(size_t index)
     const {
   base::string16 shortcut_name;
   GetInfoForProfileAtIndex(index)->GetString(
       kShortcutNameKey, &shortcut_name);
@@ skipping 125 matching lines @@
   GetInfoForProfileAtIndex(index)->GetString(kManagedUserId, &managed_user_id);
   return managed_user_id;
 }
 
 bool ProfileInfoCache::ProfileIsEphemeralAtIndex(size_t index) const {
   bool value = false;
   GetInfoForProfileAtIndex(index)->GetBoolean(kProfileIsEphemeral, &value);
   return value;
 }
 
+bool ProfileInfoCache::ProfileIsUsingDefaultNameAtIndex(size_t index) const {
+  bool value = false;
+  GetInfoForProfileAtIndex(index)->GetBoolean(kIsUsingDefaultName, &value);
+  return value;
+}
+
 void ProfileInfoCache::OnGAIAPictureLoaded(const base::FilePath& path,
                                            gfx::Image** image) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string key = CacheKeyFromProfilePath(path);
   gaia_pictures_loading_[key] = false;
 
   if (*image) {
     delete gaia_pictures_[key];
     gaia_pictures_[key] = *image;
@@ skipping 52 matching lines @@
                                                const base::string16& name) {
   scoped_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   base::string16 current_name;
   info->GetString(kNameKey, &current_name);
   if (name == current_name)
     return;
 
   base::string16 old_display_name = GetNameOfProfileAtIndex(index);
   info->SetString(kNameKey, name);
+  info->SetBoolean(kIsUsingDefaultName, false);
+
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
   base::string16 new_display_name = GetNameOfProfileAtIndex(index);
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   UpdateSortForProfileIndex(index);
 
   if (old_display_name != new_display_name) {
     FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                       observer_list_,
                       OnProfileNameChanged(profile_path, old_display_name));
@@ skipping 229 matching lines @@
   if (value == ProfileIsEphemeralAtIndex(index))
     return;
 
   scoped_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
   info->SetBoolean(kProfileIsEphemeral, value);
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
 }
 
+void ProfileInfoCache::SetProfileIsUsingDefaultNameAtIndex(
+    size_t index, bool value) {
+  if (value == ProfileIsUsingDefaultNameAtIndex(index))
+    return;
+
+  scoped_ptr<base::DictionaryValue> info(
+      GetInfoForProfileAtIndex(index)->DeepCopy());
+  info->SetBoolean(kIsUsingDefaultName, value);
+  // This takes ownership of |info|.
+  SetInfoForProfileAtIndex(index, info.release());
+}
+
 base::string16 ProfileInfoCache::ChooseNameForNewProfile(
     size_t icon_index) const {
   base::string16 name;
   for (int name_index = 1; ; ++name_index) {
     if (switches::IsNewProfileManagement()) {
       name = l10n_util::GetStringFUTF16Int(IDS_NEW_NUMBERED_PROFILE_NAME,
                                            name_index);
     } else if (icon_index < kGenericIconCount) {
       name = l10n_util::GetStringFUTF16Int(IDS_NUMBERED_PROFILE_NAME,
                                            name_index);
@@ skipping 214 matching lines @@
     info->GetString(kNameKey, &name);
     names.push_back(name);
   }
   return names;
 }
 
 // static
 void ProfileInfoCache::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kProfileInfoCache);
 }