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

chrome/browser/chromeos/login/supervised/supervised_user_creation_screen.cc

 // Copyright 2014 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/chromeos/login/supervised/supervised_user_creation_screen.h"
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "base/rand_util.h"
 #include "base/values.h"
@@ skipping 198 matching lines @@
       ->GetSessionManagerClient()
       ->NotifySupervisedUserCreationFinished();
   controller_->FinishCreation();
 }
 
 void SupervisedUserCreationScreen::HideFlow() {
   Hide();
 }
 
 void SupervisedUserCreationScreen::AuthenticateManager(
-    const std::string& manager_id,
+    const user_manager::UserID& manager_id,
     const std::string& manager_password) {
   if (manager_signin_in_progress_)
     return;
   manager_signin_in_progress_ = true;
 
   UserFlow* flow = new SupervisedUserCreationFlow(manager_id);
   ChromeUserManager::Get()->SetUserFlow(manager_id, flow);
 
   // Make sure no two controllers exist at the same time.
   controller_.reset();
@@ skipping 13 matching lines @@
   int image;
   if (selected_image_ == user_manager::User::USER_IMAGE_EXTERNAL)
     // TODO(dzhioev): crbug/249660
     image = SupervisedUserCreationController::kDummyAvatarIndex;
   else
     image = selected_image_;
   controller_->StartCreation(display_name, supervised_user_password, image);
 }
 
 void SupervisedUserCreationScreen::ImportSupervisedUser(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   DCHECK(controller_.get());
   DCHECK(existing_users_.get());
-  VLOG(1) << "Importing user " << user_id;
+  VLOG(1) << "Importing user " << user_id.GetUserEmail();
   base::DictionaryValue* user_info;
-  if (!existing_users_->GetDictionary(user_id, &user_info)) {
-    LOG(ERROR) << "Can not import non-existing user " << user_id;
+  if (!existing_users_->GetDictionary(user_id.GetUserEmail(), &user_info)) {
+    LOG(ERROR) << "Can not import non-existing user " << user_id.GetUserEmail();
     return;
   }
   base::string16 display_name;
   std::string master_key;
   std::string signature_key;
   std::string encryption_key;
   std::string avatar;
   bool exists;
   int avatar_index = SupervisedUserCreationController::kDummyAvatarIndex;
   user_info->GetString(SupervisedUserSyncService::kName, &display_name);
@@ skipping 17 matching lines @@
     return;
   }
 
   SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   const base::DictionaryValue* password_data = NULL;
   SupervisedUserSharedSettingsService* shared_settings_service =
       SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
           controller_->GetManagerProfile());
   const base::Value* value = shared_settings_service->GetValue(
-      user_id, supervised_users::kChromeOSPasswordData);
+      user_id.GetUserEmail(), supervised_users::kChromeOSPasswordData);
 
   bool password_right_here = value && value->GetAsDictionary(&password_data) &&
                              !password_data->empty();
 
   if (password_right_here) {
     controller_->StartImport(display_name,
                              avatar_index,
-                             user_id,
+                             user_id.GetUserEmail(),
                              master_key,
                              password_data,
                              encryption_key,
                              signature_key);
   } else {
     NOTREACHED() << " Oops, no password";
   }
 }
 
 // TODO(antrim): Code duplication with previous method will be removed once
 // password sync is implemented.
 void SupervisedUserCreationScreen::ImportSupervisedUserWithPassword(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& password) {
   DCHECK(controller_.get());
   DCHECK(existing_users_.get());
-  VLOG(1) << "Importing user " << user_id;
+  VLOG(1) << "Importing user " << user_id.GetUserEmail();
   base::DictionaryValue* user_info;
-  if (!existing_users_->GetDictionary(user_id, &user_info)) {
-    LOG(ERROR) << "Can not import non-existing user " << user_id;
+  if (!existing_users_->GetDictionary(user_id.GetUserEmail(), &user_info)) {
+    LOG(ERROR) << "Can not import non-existing user " << user_id.GetUserEmail();
     return;
   }
   base::string16 display_name;
   std::string master_key;
   std::string avatar;
   bool exists;
   int avatar_index = SupervisedUserCreationController::kDummyAvatarIndex;
   user_info->GetString(SupervisedUserSyncService::kName, &display_name);
   user_info->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   user_info->GetString(SupervisedUserSyncService::kChromeOsAvatar, &avatar);
   user_info->GetBoolean(kUserExists, &exists);
 
   // We should not get here with existing user selected, so just display error.
   if (exists) {
     actor_->ShowErrorPage(
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_TITLE),
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR),
         l10n_util::GetStringUTF16(
             IDS_CREATE_SUPERVISED_USER_GENERIC_ERROR_BUTTON));
     return;
   }
 
   SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   controller_->StartImport(display_name,
                            password,
                            avatar_index,
-                           user_id,
+                           user_id.GetUserEmail(),
                            master_key);
 }
 
 void SupervisedUserCreationScreen::OnManagerLoginFailure() {
   manager_signin_in_progress_ = false;
   if (actor_)
     actor_->ShowManagerPasswordError();
 }
 
 void SupervisedUserCreationScreen::OnManagerFullyAuthenticated(
@@ skipping 85 matching lines @@
 
 void SupervisedUserCreationScreen::OnLongCreationWarning() {
   if (actor_) {
     actor_->ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
         IDS_PROFILES_CREATE_SUPERVISED_JUST_SIGNED_IN));
   }
 }
 
 bool SupervisedUserCreationScreen::FindUserByDisplayName(
     const base::string16& display_name,
-    std::string *out_id) const {
+    std::string *out_email) const {
   if (!existing_users_.get())
     return false;
   for (base::DictionaryValue::Iterator it(*existing_users_.get());
        !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* user_info =
         static_cast<const base::DictionaryValue*>(&it.value());
     base::string16 user_display_name;
     if (user_info->GetString(SupervisedUserSyncService::kName,
                              &user_display_name)) {
       if (display_name == user_display_name) {
-        if (out_id)
-          *out_id = it.key();
+        if (out_email)
+          *out_email = it.key();
         return true;
       }
     }
   }
   return false;
 }
 
 // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 // It should be removed by issue 251179.
 
 void SupervisedUserCreationScreen::ApplyPicture() {
-  std::string user_id = controller_->GetSupervisedUserId();
+  user_manager::UserID user_id = controller_->GetSupervisedUserId();
   UserImageManager* image_manager =
       ChromeUserManager::Get()->GetUserImageManager(user_id);
   switch (selected_image_) {
     case user_manager::User::USER_IMAGE_EXTERNAL:
       // Photo decoding may not have been finished yet.
       if (user_photo_.isNull()) {
         apply_photo_after_decoding_ = true;
         return;
       }
       image_manager->SaveUserImage(
@@ skipping 126 matching lines @@
     selected_image_ = user_manager::User::USER_IMAGE_EXTERNAL;
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 }
 
 void SupervisedUserCreationScreen::OnImageAccepted() {
 }
 
 }  // namespace chromeos