We should use UserID object to identify users instead of username.

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/files/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_avatar_downloader.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/signin/core/common/profile_management_switches.h"
+#include "components/user_manager/user_id.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_util.h"
 
 #if defined(ENABLE_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_constants.h"
 #endif
 
@@ skipping 155 matching lines @@
       avatar_images_downloads_in_progress_.begin(),
       avatar_images_downloads_in_progress_.end());
 }
 
 void ProfileInfoCache::AddProfileToCache(
     const base::FilePath& profile_path,
     const base::string16& name,
     const std::string& gaia_id,
     const base::string16& user_name,
     size_t icon_index,
-    const std::string& supervised_user_id) {
+    const user_manager::UserID& supervised_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(kGAIAIdKey, gaia_id);
   info->SetString(kUserNameKey, user_name);
   info->SetString(kAvatarIconKey,
       profiles::GetDefaultAvatarIconUrl(icon_index));
   // Default value for whether background apps are running is false.
   info->SetBoolean(kBackgroundAppsKey, false);
-  info->SetString(kSupervisedUserId, supervised_user_id);
+  info->SetString(kSupervisedUserId, supervised_user_id.GetUserEmail());
   info->SetBoolean(kIsOmittedFromProfileListKey, !supervised_user_id.empty());
   info->SetBoolean(kProfileIsEphemeral, false);
   info->SetBoolean(kIsUsingDefaultNameKey, IsDefaultProfileName(name));
   // Assume newly created profiles use a default avatar.
   info->SetBoolean(kIsUsingDefaultAvatarKey, true);
   cache->SetWithoutPathExpansion(key, info.release());
 
   sorted_keys_.insert(FindPositionForProfile(key, name), key);
 
   if (switches::IsNewAvatarMenu() && !disable_avatar_download_for_testing_)
@@ skipping 179 matching lines @@
   return value;
 }
 
 bool ProfileInfoCache::ProfileIsSupervisedAtIndex(size_t index) const {
   return !GetSupervisedUserIdOfProfileAtIndex(index).empty();
 }
 
 bool ProfileInfoCache::ProfileIsChildAtIndex(size_t index) const {
 #if defined(ENABLE_SUPERVISED_USERS)
   return GetSupervisedUserIdOfProfileAtIndex(index) ==
-      supervised_users::kChildAccountSUID;
+      supervised_users::GetChildAccountSUID();
 #else
   return false;
 #endif
 }
 
 bool ProfileInfoCache::ProfileIsLegacySupervisedAtIndex(size_t index) const {
   return ProfileIsSupervisedAtIndex(index) && !ProfileIsChildAtIndex(index);
 }
 
 bool ProfileInfoCache::IsOmittedProfileAtIndex(size_t index) const {
   bool value = false;
   GetInfoForProfileAtIndex(index)->GetBoolean(kIsOmittedFromProfileListKey,
                                               &value);
   return value;
 }
 
 bool ProfileInfoCache::ProfileIsSigninRequiredAtIndex(size_t index) const {
   bool value = false;
   GetInfoForProfileAtIndex(index)->GetBoolean(kSigninRequiredKey, &value);
   return value;
 }
 
-std::string ProfileInfoCache::GetSupervisedUserIdOfProfileAtIndex(
+user_manager::UserID ProfileInfoCache::GetSupervisedUserIdOfProfileAtIndex(
     size_t index) const {
-  std::string supervised_user_id;
+  std::string supervised_user_email;
   GetInfoForProfileAtIndex(index)->GetString(kSupervisedUserId,
-                                             &supervised_user_id);
-  return supervised_user_id;
+                                             &supervised_user_email);
+  return user_manager::UserID::FromUserEmail(supervised_user_email);
 }
 
 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;
@@ skipping 139 matching lines @@
   SetInfoForProfileAtIndex(index, info.release());
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                     observer_list_,
                     OnProfileIsOmittedChanged(profile_path));
 }
 
 void ProfileInfoCache::SetSupervisedUserIdOfProfileAtIndex(
     size_t index,
-    const std::string& id) {
+    const user_manager::UserID& id) {
   if (GetSupervisedUserIdOfProfileAtIndex(index) == id)
     return;
   scoped_ptr<base::DictionaryValue> info(
       GetInfoForProfileAtIndex(index)->DeepCopy());
-  info->SetString(kSupervisedUserId, id);
+  info->SetString(kSupervisedUserId, id.GetUserEmail());
   // This takes ownership of |info|.
   SetInfoForProfileAtIndex(index, info.release());
 
   base::FilePath profile_path = GetPathOfProfileAtIndex(index);
   FOR_EACH_OBSERVER(ProfileInfoCacheObserver,
                     observer_list_,
                     OnProfileSupervisedUserIdChanged(profile_path));
 }
 
 void ProfileInfoCache::SetLocalAuthCredentialsOfProfileAtIndex(
@@ skipping 592 matching lines @@
   std::vector<base::FilePath>::const_iterator it;
   for (it = profiles_to_rename.begin(); it != profiles_to_rename.end(); ++it) {
     size_t profile_index = GetIndexOfProfileWithPath(*it);
     SetProfileIsUsingDefaultNameAtIndex(profile_index, true);
     // This will assign a new "Person %d" type name and re-sort the cache.
     SetNameOfProfileAtIndex(profile_index, ChooseNameForNewProfile(
         GetAvatarIconIndexOfProfileAtIndex(profile_index)));
   }
 #endif
 }