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

chrome/browser/chromeos/login/supervised/supervised_user_creation_controller_new.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_controller_new.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/login/auth/key.h"
 #include "chromeos/login/auth/user_context.h"
 #include "components/user_manager/user.h"
+#include "components/user_manager/user_id.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "crypto/random.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 
 namespace chromeos {
 
 namespace {
 
 const int kUserCreationTimeoutSeconds = 30;  // 30 seconds.
 
 bool StoreSupervisedUserFiles(const std::string& token,
                               const base::FilePath& base_path) {
   if (!base::SysInfo::IsRunningOnChromeOS()) {
     // If running on desktop, cryptohome stub does not create home directory.
     base::CreateDirectory(base_path);
   }
   base::FilePath token_file = base_path.Append(kSupervisedUserTokenFilename);
   int bytes = base::WriteFile(token_file, token.c_str(), token.length());
   return bytes >= 0;
 }
 
 }  // namespace
 
 SupervisedUserCreationControllerNew::SupervisedUserCreationControllerNew(
     SupervisedUserCreationControllerNew::StatusConsumer* consumer,
-    const std::string& manager_id)
+    const user_manager::UserID& manager_id)
     : SupervisedUserCreationController(consumer),
       stage_(STAGE_INITIAL),
       weak_factory_(this) {
   creation_context_.reset(
       new SupervisedUserCreationControllerNew::UserCreationContext());
   creation_context_->manager_id = manager_id;
 }
 
 SupervisedUserCreationControllerNew::~SupervisedUserCreationControllerNew() {}
 
 SupervisedUserCreationControllerNew::UserCreationContext::
-    UserCreationContext() {}
+    UserCreationContext() : manager_id(std::string(), std::string()), local_user_id(std::string(), std::string()) {}

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

EmptyGaiaID() ?

 
 SupervisedUserCreationControllerNew::UserCreationContext::
     ~UserCreationContext() {}
 
 void SupervisedUserCreationControllerNew::SetManagerProfile(
     Profile* manager_profile) {
   creation_context_->manager_profile = manager_profile;
 }
 
 Profile* SupervisedUserCreationControllerNew::GetManagerProfile() {
@@ skipping 67 matching lines @@
   VLOG(1) << "Starting supervised user creation";
   VLOG(1) << " Phase 1 : Prepare keys";
 
   SupervisedUserManager* manager =
       ChromeUserManager::Get()->GetSupervisedUserManager();
   manager->StartCreationTransaction(creation_context_->display_name);
 
   creation_context_->local_user_id = manager->GenerateUserId();
   if (creation_context_->creation_type == NEW_USER) {
     creation_context_->sync_user_id =
-        SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId();
+        SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId().GetUserEmail();
   }
 
   manager->SetCreationTransactionUserId(creation_context_->local_user_id);
 
   stage_ = TRANSACTION_STARTED;
 
   manager->CreateUserRecord(creation_context_->manager_id,
                             creation_context_->local_user_id,
                             creation_context_->sync_user_id,
                             creation_context_->display_name);
@@ skipping 153 matching lines @@
   SupervisedUserRegistrationInfo info(creation_context_->display_name,
                                       creation_context_->avatar_index);
   info.master_key = creation_context_->master_key;
   info.password_signature_key = creation_context_->signature_key;
   info.password_encryption_key = creation_context_->encryption_key;
 
   info.password_data.MergeDictionary(&creation_context_->password_data);
 
   // Registration utility will update user data if user already exist.
   creation_context_->registration_utility->Register(
-      creation_context_->sync_user_id,
+      user_manager::UserID::FromUserEmail(creation_context_->sync_user_id),
       info,
       base::Bind(&SupervisedUserCreationControllerNew::RegistrationCallback,
                  weak_factory_.GetWeakPtr()));
 }
 
 void SupervisedUserCreationControllerNew::RegistrationCallback(
     const GoogleServiceAuthError& error,
     const std::string& token) {
   DCHECK(creation_context_);
   DCHECK_EQ(CRYPTOHOME_CREATED, stage_);
@@ skipping 64 matching lines @@
 
 void SupervisedUserCreationControllerNew::FinishCreation() {
   chrome::AttemptUserExit();
 }
 
 void SupervisedUserCreationControllerNew::CancelCreation() {
   creation_context_->registration_utility.reset();
   chrome::AttemptUserExit();
 }
 
-std::string SupervisedUserCreationControllerNew::GetSupervisedUserId() {
+const user_manager::UserID& SupervisedUserCreationControllerNew::GetSupervisedUserId() const {
   DCHECK(creation_context_);
   return creation_context_->local_user_id;
 }
 
 }  // namespace chromeos