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

chrome/browser/chromeos/login/users/supervised_user_manager_impl.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/users/supervised_user_manager_impl.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/supervised/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/supervised/supervised_user_constants.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager_impl.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chromeos/login/user_names.h"
 #include "chromeos/settings/cros_settings_names.h"
+#include "components/user_manager/user_id.h"
 #include "components/user_manager/user_type.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Names for pref keys in Local State.
 // A map from supervised user local user id to sync user id.
@@ skipping 97 matching lines @@
     ChromeUserManagerImpl* owner)
     : owner_(owner), cros_settings_(CrosSettings::Get()) {
   // SupervisedUserManager instance should be used only on UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   authentication_.reset(new SupervisedUserAuthentication(this));
 }
 
 SupervisedUserManagerImpl::~SupervisedUserManagerImpl() {
 }
 
-std::string SupervisedUserManagerImpl::GenerateUserId() {
+user_manager::UserID SupervisedUserManagerImpl::GenerateUserId() {
   int counter = g_browser_process->local_state()->
       GetInteger(kSupervisedUsersNextId);
-  std::string id;
+  user_manager::UserID user_id = user_manager::UserID(std::string(), std::string());

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

EmptyGaiaID() ?

   bool user_exists;
   do {
-    id = base::StringPrintf(
+    const std::string email = base::StringPrintf(
         "%d@%s", counter, chromeos::login::kSupervisedUserDomain);
     counter++;
-    user_exists = (NULL != owner_->FindUser(id));
+    user_id = user_manager::UserID::FromUserEmail(email);
+    user_exists = (NULL != owner_->FindUser(user_id));
     DCHECK(!user_exists);
     if (user_exists) {
-      LOG(ERROR) << "Supervised user with id " << id << " already exists.";
+      LOG(ERROR) << "Supervised user with email " << email << " already exists.";
     }
   } while (user_exists);
 
   g_browser_process->local_state()->
       SetInteger(kSupervisedUsersNextId, counter);
 
   g_browser_process->local_state()->CommitPendingWrite();
-  return id;
+  return user_id;
 }
 
 bool SupervisedUserManagerImpl::HasSupervisedUsers(
-      const std::string& manager_id) const {
+      const user_manager::UserID& manager_id) const {
   const user_manager::UserList& users = owner_->GetUsers();
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
     if ((*it)->GetType() == user_manager::USER_TYPE_SUPERVISED) {
-      if (manager_id == GetManagerUserId((*it)->email()))
+      if (manager_id == GetManagerUserId((*it)->GetUserID()))
         return true;
     }
   }
   return false;
 }
 
 const user_manager::User* SupervisedUserManagerImpl::CreateUserRecord(
-    const std::string& manager_id,
-    const std::string& local_user_id,
+    const user_manager::UserID& manager_id,
+    const user_manager::UserID& local_user_id,
     const std::string& sync_user_id,
     const base::string16& display_name) {
   const user_manager::User* user = FindByDisplayName(display_name);
   DCHECK(!user);
   if (user)
     return user;
   const user_manager::User* manager = owner_->FindUser(manager_id);
   CHECK(manager);
 
   PrefService* local_state = g_browser_process->local_state();
 
   user_manager::User* new_user =
       user_manager::User::CreateSupervisedUser(local_user_id);
 
   owner_->AddUserRecord(new_user);
 
   ListPrefUpdate prefs_new_users_update(local_state,
                                         kSupervisedUsersFirstRun);
   DictionaryPrefUpdate sync_id_update(local_state, kSupervisedUserSyncId);
   DictionaryPrefUpdate manager_update(local_state, kSupervisedUserManagers);
   DictionaryPrefUpdate manager_name_update(local_state,
                                            kSupervisedUserManagerNames);
   DictionaryPrefUpdate manager_email_update(
       local_state,
       kSupervisedUserManagerDisplayEmails);
 
-  prefs_new_users_update->Insert(0, new base::StringValue(local_user_id));
+  prefs_new_users_update->Insert(0, new base::StringValue(local_user_id.GetUserEmail()));
 
-  sync_id_update->SetWithoutPathExpansion(local_user_id,
+  sync_id_update->SetWithoutPathExpansion(local_user_id.GetUserEmail(),
       new base::StringValue(sync_user_id));
-  manager_update->SetWithoutPathExpansion(local_user_id,
-      new base::StringValue(manager->email()));
-  manager_name_update->SetWithoutPathExpansion(local_user_id,
+  manager_update->SetWithoutPathExpansion(local_user_id.GetUserEmail(),
+      new base::StringValue(manager->GetUserID().GetUserEmail()));
+  manager_name_update->SetWithoutPathExpansion(local_user_id.GetUserEmail(),
       new base::StringValue(manager->GetDisplayName()));
-  manager_email_update->SetWithoutPathExpansion(local_user_id,
+  manager_email_update->SetWithoutPathExpansion(local_user_id.GetUserEmail(),
       new base::StringValue(manager->display_email()));
 
   owner_->SaveUserDisplayName(local_user_id, display_name);
 
   g_browser_process->local_state()->CommitPendingWrite();
   return new_user;
 }
 
-std::string SupervisedUserManagerImpl::GetUserSyncId(const std::string& user_id)
+std::string SupervisedUserManagerImpl::GetUserSyncId(const user_manager::UserID& user_id)
     const {
   std::string result;
   GetUserStringValue(user_id, kSupervisedUserSyncId, &result);
   return result;
 }
 
 base::string16 SupervisedUserManagerImpl::GetManagerDisplayName(
-    const std::string& user_id) const {
+    const user_manager::UserID& user_id) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* manager_names =
       local_state->GetDictionary(kSupervisedUserManagerNames);
   base::string16 result;
-  if (manager_names->GetStringWithoutPathExpansion(user_id, &result) &&
+  if (manager_names->GetStringWithoutPathExpansion(user_id.GetUserEmail(), &result) &&
       !result.empty())
     return result;
   return base::UTF8ToUTF16(GetManagerDisplayEmail(user_id));
 }
 
-std::string SupervisedUserManagerImpl::GetManagerUserId(
-      const std::string& user_id) const {
+user_manager::UserID SupervisedUserManagerImpl::GetManagerUserId(
+      const user_manager::UserID& user_id) const {
   std::string result;
   GetUserStringValue(user_id, kSupervisedUserManagers, &result);
-  return result;
+  return user_manager::UserID::FromUserEmail(result);
 }
 
 std::string SupervisedUserManagerImpl::GetManagerDisplayEmail(
-      const std::string& user_id) const {
+      const user_manager::UserID& user_id) const {
   std::string result;
   if (GetUserStringValue(user_id,
                          kSupervisedUserManagerDisplayEmails,
                          &result) &&
       !result.empty())
     return result;
-  return GetManagerUserId(user_id);
+  return GetManagerUserId(user_id).GetUserEmail();
 }
 
 void SupervisedUserManagerImpl::GetPasswordInformation(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     base::DictionaryValue* result) {
   int value;
   if (GetUserIntegerValue(user_id, kSupervisedUserPasswordSchema, &value))
     result->SetIntegerWithoutPathExpansion(kSchemaVersion, value);
   if (GetUserIntegerValue(user_id, kSupervisedUserPasswordRevision, &value))
     result->SetIntegerWithoutPathExpansion(kPasswordRevision, value);
 
   bool flag;
   if (GetUserBooleanValue(user_id, kSupervisedUserNeedPasswordUpdate, &flag))
     result->SetBooleanWithoutPathExpansion(kRequirePasswordUpdate, flag);
   if (GetUserBooleanValue(user_id, kSupervisedUserIncompleteKey, &flag))
     result->SetBooleanWithoutPathExpansion(kHasIncompleteKey, flag);
 
   std::string salt;
   if (GetUserStringValue(user_id, kSupervisedUserPasswordSalt, &salt))
     result->SetStringWithoutPathExpansion(kSalt, salt);
 }
 
 void SupervisedUserManagerImpl::SetPasswordInformation(
-      const std::string& user_id,
+      const user_manager::UserID& user_id,
       const base::DictionaryValue* password_info) {
   int value;
   if (password_info->GetIntegerWithoutPathExpansion(kSchemaVersion, &value))
     SetUserIntegerValue(user_id, kSupervisedUserPasswordSchema, value);
   if (password_info->GetIntegerWithoutPathExpansion(kPasswordRevision, &value))
     SetUserIntegerValue(user_id, kSupervisedUserPasswordRevision, value);
 
   bool flag;
   if (password_info->GetBooleanWithoutPathExpansion(kRequirePasswordUpdate,
                                                     &flag)) {
     SetUserBooleanValue(user_id, kSupervisedUserNeedPasswordUpdate, flag);
   }
   if (password_info->GetBooleanWithoutPathExpansion(kHasIncompleteKey, &flag))
     SetUserBooleanValue(user_id, kSupervisedUserIncompleteKey, flag);
 
   std::string salt;
   if (password_info->GetStringWithoutPathExpansion(kSalt, &salt))
     SetUserStringValue(user_id, kSupervisedUserPasswordSalt, salt);
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 bool SupervisedUserManagerImpl::GetUserStringValue(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const char* key,
     std::string* out_value) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dictionary = local_state->GetDictionary(key);
-  return dictionary->GetStringWithoutPathExpansion(user_id, out_value);
+  return dictionary->GetStringWithoutPathExpansion(user_id.GetUserEmail(), out_value);
 }
 
 bool SupervisedUserManagerImpl::GetUserIntegerValue(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const char* key,
     int* out_value) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dictionary = local_state->GetDictionary(key);
-  return dictionary->GetIntegerWithoutPathExpansion(user_id, out_value);
+  return dictionary->GetIntegerWithoutPathExpansion(user_id.GetUserEmail(), out_value);
 }
 
-bool SupervisedUserManagerImpl::GetUserBooleanValue(const std::string& user_id,
+bool SupervisedUserManagerImpl::GetUserBooleanValue(const user_manager::UserID& user_id,
                                                     const char* key,
                                                     bool* out_value) const {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* dictionary = local_state->GetDictionary(key);
-  return dictionary->GetBooleanWithoutPathExpansion(user_id, out_value);
+  return dictionary->GetBooleanWithoutPathExpansion(user_id.GetUserEmail(), out_value);
 }
 
 void SupervisedUserManagerImpl::SetUserStringValue(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const char* key,
     const std::string& value) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, key);
-  update->SetStringWithoutPathExpansion(user_id, value);
+  update->SetStringWithoutPathExpansion(user_id.GetUserEmail(), value);
 }
 
 void SupervisedUserManagerImpl::SetUserIntegerValue(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const char* key,
     const int value) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, key);
-  update->SetIntegerWithoutPathExpansion(user_id, value);
+  update->SetIntegerWithoutPathExpansion(user_id.GetUserEmail(), value);
 }
 
-void SupervisedUserManagerImpl::SetUserBooleanValue(const std::string& user_id,
+void SupervisedUserManagerImpl::SetUserBooleanValue(const user_manager::UserID& user_id,
                                                     const char* key,
                                                     const bool value) {
   PrefService* local_state = g_browser_process->local_state();
   DictionaryPrefUpdate update(local_state, key);
-  update->SetBooleanWithoutPathExpansion(user_id, value);
+  update->SetBooleanWithoutPathExpansion(user_id.GetUserEmail(), value);
 }
 
 const user_manager::User* SupervisedUserManagerImpl::FindByDisplayName(
     const base::string16& display_name) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const user_manager::UserList& users = owner_->GetUsers();
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
     if (((*it)->GetType() == user_manager::USER_TYPE_SUPERVISED) &&
         ((*it)->display_name() == display_name)) {
       return *it;
     }
   }
   return NULL;
 }
 
 const user_manager::User* SupervisedUserManagerImpl::FindBySyncId(
     const std::string& sync_id) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const user_manager::UserList& users = owner_->GetUsers();
   for (user_manager::UserList::const_iterator it = users.begin();
        it != users.end();
        ++it) {
     if (((*it)->GetType() == user_manager::USER_TYPE_SUPERVISED) &&
-        (GetUserSyncId((*it)->email()) == sync_id)) {
+        (GetUserSyncId((*it)->GetUserID()) == sync_id)) {
       return *it;
     }
   }
   return NULL;
 }
 
 void SupervisedUserManagerImpl::StartCreationTransaction(
       const base::string16& display_name) {
   g_browser_process->local_state()->
       SetString(kSupervisedUserCreationTransactionDisplayName,
                 base::UTF16ToASCII(display_name));
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 void SupervisedUserManagerImpl::SetCreationTransactionUserId(
-      const std::string& email) {
+      const user_manager::UserID& user_id) {
   g_browser_process->local_state()->
       SetString(kSupervisedUserCreationTransactionUserId,
-                email);
+                user_id.GetUserEmail());
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 void SupervisedUserManagerImpl::CommitCreationTransaction() {
   g_browser_process->local_state()->
       ClearPref(kSupervisedUserCreationTransactionDisplayName);
   g_browser_process->local_state()->
       ClearPref(kSupervisedUserCreationTransactionUserId);
   g_browser_process->local_state()->CommitPendingWrite();
 }
 
 bool SupervisedUserManagerImpl::HasFailedUserCreationTransaction() {
   return !(g_browser_process->local_state()->
                GetString(kSupervisedUserCreationTransactionDisplayName).
                    empty());
 }
 
 void SupervisedUserManagerImpl::RollbackUserCreationTransaction() {
   PrefService* prefs = g_browser_process->local_state();
 
   std::string display_name = prefs->
       GetString(kSupervisedUserCreationTransactionDisplayName);
-  std::string user_id = prefs->
-      GetString(kSupervisedUserCreationTransactionUserId);
+  user_manager::UserID user_id(user_manager::UserID::FromUserEmail(prefs->
+      GetString(kSupervisedUserCreationTransactionUserId)));
 
   LOG(WARNING) << "Cleaning up transaction for "
-               << display_name << "/" << user_id;
+               << display_name << "/" << user_id.GetUserEmail();
 
   if (user_id.empty()) {
     // Not much to do - just remove transaction.
     prefs->ClearPref(kSupervisedUserCreationTransactionDisplayName);
     prefs->CommitPendingWrite();
     return;
   }
 
-  if (gaia::ExtractDomainName(user_id) !=
+  if (gaia::ExtractDomainName(user_id.GetUserEmail()) !=
       chromeos::login::kSupervisedUserDomain) {
     LOG(WARNING) << "Clean up transaction for  non-supervised user found :"
-                 << user_id << ", will not remove data";
+                 << user_id.GetUserEmail() << ", will not remove data";
     prefs->ClearPref(kSupervisedUserCreationTransactionDisplayName);
     prefs->ClearPref(kSupervisedUserCreationTransactionUserId);
     prefs->CommitPendingWrite();
     return;
   }
   owner_->RemoveNonOwnerUserInternal(user_id, NULL);
 
   prefs->ClearPref(kSupervisedUserCreationTransactionDisplayName);
   prefs->ClearPref(kSupervisedUserCreationTransactionUserId);
   prefs->CommitPendingWrite();
 }
 
 void SupervisedUserManagerImpl::RemoveNonCryptohomeData(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   PrefService* prefs = g_browser_process->local_state();
   ListPrefUpdate prefs_new_users_update(prefs, kSupervisedUsersFirstRun);
-  prefs_new_users_update->Remove(base::StringValue(user_id), NULL);
+  prefs_new_users_update->Remove(base::StringValue(user_id.GetUserEmail()), NULL);
 
   CleanPref(user_id, kSupervisedUserSyncId);
   CleanPref(user_id, kSupervisedUserManagers);
   CleanPref(user_id, kSupervisedUserManagerNames);
   CleanPref(user_id, kSupervisedUserManagerDisplayEmails);
   CleanPref(user_id, kSupervisedUserPasswordSalt);
   CleanPref(user_id, kSupervisedUserPasswordSchema);
   CleanPref(user_id, kSupervisedUserPasswordRevision);
   CleanPref(user_id, kSupervisedUserNeedPasswordUpdate);
   CleanPref(user_id, kSupervisedUserIncompleteKey);
 }
 
-void SupervisedUserManagerImpl::CleanPref(const std::string& user_id,
+void SupervisedUserManagerImpl::CleanPref(const user_manager::UserID& user_id,
                                           const char* key) {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate dict_update(prefs, key);
-  dict_update->RemoveWithoutPathExpansion(user_id, NULL);
+  dict_update->RemoveWithoutPathExpansion(user_id.GetUserEmail(), NULL);
 }
 
-bool SupervisedUserManagerImpl::CheckForFirstRun(const std::string& user_id) {
+bool SupervisedUserManagerImpl::CheckForFirstRun(const user_manager::UserID& user_id) {
   ListPrefUpdate prefs_new_users_update(g_browser_process->local_state(),
                                         kSupervisedUsersFirstRun);
-  return prefs_new_users_update->Remove(base::StringValue(user_id), NULL);
+  return prefs_new_users_update->Remove(base::StringValue(user_id.GetUserEmail()), NULL);
 }
 
-void SupervisedUserManagerImpl::UpdateManagerName(const std::string& manager_id,
+void SupervisedUserManagerImpl::UpdateManagerName(const user_manager::UserID& manager_id,
     const base::string16& new_display_name) {
   PrefService* local_state = g_browser_process->local_state();
 
   const base::DictionaryValue* manager_ids =
       local_state->GetDictionary(kSupervisedUserManagers);
 
   DictionaryPrefUpdate manager_name_update(local_state,
                                            kSupervisedUserManagerNames);
   for (base::DictionaryValue::Iterator it(*manager_ids); !it.IsAtEnd();
       it.Advance()) {
-    std::string user_id;
-    bool has_manager_id = it.value().GetAsString(&user_id);
+    std::string user_email;
+    bool has_manager_id = it.value().GetAsString(&user_email);
     DCHECK(has_manager_id);
-    if (user_id == manager_id) {
+    if (user_manager::UserID::FromUserEmail(user_email) == manager_id) {
       manager_name_update->SetWithoutPathExpansion(
           it.key(),
           new base::StringValue(new_display_name));
     }
   }
 }
 
 SupervisedUserAuthentication* SupervisedUserManagerImpl::GetAuthentication() {
   return authentication_.get();
 }
@@ skipping 13 matching lines @@
 }
 
 void SupervisedUserManagerImpl::ConfigureSyncWithToken(
     Profile* profile,
     const std::string& token) {
   if (!token.empty())
     SupervisedUserServiceFactory::GetForProfile(profile)->InitSync(token);
 }
 
 }  // namespace chromeos