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

chrome/browser/profiles/profile_manager.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_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 375 matching lines @@
 
 size_t ProfileManager::GetNumberOfProfiles() {
   return GetProfileInfoCache().GetNumberOfProfiles();
 }
 
 void ProfileManager::CreateProfileAsync(
     const base::FilePath& profile_path,
     const CreateCallback& callback,
     const base::string16& name,
     const base::string16& icon_url,
-    const std::string& supervised_user_id) {
+    const user_manager::UserID& supervised_user_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT1("browser,startup",
                "ProfileManager::CreateProfileAsync",
                "profile_path",
                profile_path.AsUTF8Unsafe());
 
   // Make sure that this profile is not pending deletion.
   if (IsProfileMarkedForDeletion(profile_path)) {
     if (!callback.is_null())
       callback.Run(NULL, Profile::CREATE_STATUS_LOCAL_FAIL);
@@ skipping 160 matching lines @@
   ProfileInfo* profile_info = GetProfileInfoByPath(path);
   return (profile_info && profile_info->created) ? profile_info->profile.get()
                                                  : nullptr;
 }
 
 // static
 base::FilePath ProfileManager::CreateMultiProfileAsync(
     const base::string16& name,
     const base::string16& icon_url,
     const CreateCallback& callback,
-    const std::string& supervised_user_id) {
+    const user_manager::UserID& supervised_user_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
   base::FilePath new_path = profile_manager->GenerateNextProfileDirectoryPath();
 
   profile_manager->CreateProfileAsync(new_path,
                                       callback,
                                       name,
                                       icon_url,
@@ skipping 100 matching lines @@
 
     new_path = GenerateNextProfileDirectoryPath();
     CreateProfileAsync(new_path,
                        base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
                                   base::Unretained(this),
                                   profile_dir,
                                   new_path,
                                   callback),
                        new_profile_name,
                        new_avatar_url,
-                       std::string());
+                       user_manager::UserID(std::string(), std::string()));

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:45]

EmptyUserID

 
     ProfileMetrics::LogProfileAddNewUser(
         ProfileMetrics::ADD_NEW_USER_LAST_DELETED);
     return;
   }
 
 #if defined(OS_MACOSX)
   // On the Mac, the browser process is not killed when all browser windows are
   // closed, so just in case we are deleting the active profile, and no other
   // profile has been loaded, we must pre-load a next one.
   const base::FilePath last_used_profile =
       GetLastUsedProfileDir(user_data_dir_);
   if (last_used_profile == profile_dir ||
       last_used_profile == GetGuestProfilePath()) {
     CreateProfileAsync(last_non_supervised_profile_path,
                        base::Bind(&ProfileManager::OnNewActiveProfileLoaded,
                                   base::Unretained(this),
                                   profile_dir,
                                   last_non_supervised_profile_path,
                                   callback),
                        base::string16(),
                        base::string16(),
-                       std::string());
+                       user_manager::UserID(std::string(), std::string()));

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:44]

EmtpyUserID

     return;
   }
 #endif  // defined(OS_MACOSX)
 
   FinishDeletingProfile(profile_dir, last_non_supervised_profile_path);
 }
 
 void ProfileManager::AutoloadProfiles() {
   // If running in the background is disabled for the browser, do not autoload
   // any profiles.
@@ skipping 57 matching lines @@
 
 void ProfileManager::InitProfileUserPrefs(Profile* profile) {
   TRACE_EVENT0("browser", "ProfileManager::InitProfileUserPrefs");
   ProfileInfoCache& cache = GetProfileInfoCache();
 
   if (profile->GetPath().DirName() != cache.GetUserDataDir())
     return;
 
   size_t avatar_index;
   std::string profile_name;
-  std::string supervised_user_id;
+  user_manager::UserID supervised_user_id = user_manager::UserID(std::string(), std::string());

[Denis Kuznetsov (DE-MUC), 2015/06/10 16:50:45]

EmptyUserID

   if (profile->IsGuestSession()) {
     profile_name = l10n_util::GetStringUTF8(IDS_PROFILES_GUEST_PROFILE_NAME);
     avatar_index = 0;
   } else {
     size_t profile_cache_index =
         cache.GetIndexOfProfileWithPath(profile->GetPath());
     // If the cache has an entry for this profile, use the cache data.
     if (profile_cache_index != std::string::npos) {
       avatar_index =
           cache.GetAvatarIconIndexOfProfileAtIndex(profile_cache_index);
@@ skipping 24 matching lines @@
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   bool force_supervised_user_id =
 #if defined(OS_CHROMEOS)
       g_browser_process->platform_part()
               ->profile_helper()
               ->GetSigninProfileDir() != profile->GetPath() &&
 #endif
       command_line->HasSwitch(switches::kSupervisedUserId);
   if (force_supervised_user_id) {
-    supervised_user_id =
-        command_line->GetSwitchValueASCII(switches::kSupervisedUserId);
+    supervised_user_id = user_manager::UserID::FromUserEmail(
+        command_line->GetSwitchValueASCII(switches::kSupervisedUserId));
   }
   if (force_supervised_user_id ||
       !profile->GetPrefs()->HasPrefPath(prefs::kSupervisedUserId)) {
     profile->GetPrefs()->SetString(prefs::kSupervisedUserId,
-                                   supervised_user_id);
+                                   supervised_user_id.GetUserEmail());
   }
 }
 
 void ProfileManager::RegisterTestingProfile(Profile* profile,
                                             bool add_to_cache,
                                             bool start_deferred_task_runners) {
   RegisterProfile(profile, true);
   if (add_to_cache) {
     InitProfileUserPrefs(profile);
     AddProfileToCache(profile);
@@ skipping 442 matching lines @@
   }
 
   // Profile name and avatar are set by InitProfileUserPrefs and stored in the
   // profile. Use those values to setup the cache entry.
   base::string16 profile_name =
       base::UTF8ToUTF16(profile->GetPrefs()->GetString(prefs::kProfileName));
 
   size_t icon_index = profile->GetPrefs()->GetInteger(
       prefs::kProfileAvatarIndex);
 
-  std::string supervised_user_id =
-      profile->GetPrefs()->GetString(prefs::kSupervisedUserId);
+  const user_manager::UserID& supervised_user_id =
+      user_manager::UserID::FromUserEmail(profile->GetPrefs()->GetString(prefs::kSupervisedUserId));
 
   cache.AddProfileToCache(profile->GetPath(),
                           profile_name,
                           account_info.gaia,
                           username,
                           icon_index,
                           supervised_user_id);
 
   if (profile->GetPrefs()->GetBoolean(prefs::kForceEphemeralProfiles)) {
     cache.SetProfileIsEphemeralAtIndex(
@@ skipping 142 matching lines @@
   }
 
   FinishDeletingProfile(profile_to_delete_path, new_active_profile_path);
   if (!original_callback.is_null())
     original_callback.Run(loaded_profile, status);
 }
 
 ProfileManagerWithoutInit::ProfileManagerWithoutInit(
     const base::FilePath& user_data_dir) : ProfileManager(user_data_dir) {
 }