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

chrome/browser/supervised_user/legacy/supervised_user_registration_utility.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/supervised_user/legacy/supervised_user_registration_utility.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_refresh_token_fetcher.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service_factory.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_shared_settings_update.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_sync_service.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_sync_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_manager.h"
+#include "components/user_manager/user_id.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "sync/util/get_session_name.h"
 
 using base::DictionaryValue;
 
 namespace {
 
 SupervisedUserRegistrationUtility* g_instance_for_tests = NULL;
@@ skipping 12 matching lines @@
   ~SupervisedUserRegistrationUtilityImpl() override;
 
   // Registers a new supervised user with the server. |supervised_user_id| is a
   // new unique ID for the new supervised user. If its value is the same as that
   // of one of the existing supervised users, then the same user will be created
   // on this machine (and if he has no avatar in sync, his avatar will be
   // updated). |info| contains necessary information like the display name of
   // the user and his avatar. |callback| is called with the result of the
   // registration. We use the info here and not the profile, because on Chrome
   // OS the profile of the supervised user does not yet exist.
-  void Register(const std::string& supervised_user_id,
+  void Register(const user_manager::UserID& supervised_user_id,
                 const SupervisedUserRegistrationInfo& info,
                 const RegistrationCallback& callback) override;
 
   // SupervisedUserSyncServiceObserver:
   void OnSupervisedUserAcknowledged(
-      const std::string& supervised_user_id) override;
+      const user_manager::UserID& supervised_user_id) override;
   void OnSupervisedUsersSyncingStopped() override;
   void OnSupervisedUsersChanged() override;
 
  private:
   // Fetches the supervised user token when we have the device name.
   void FetchToken(const std::string& client_name);
 
   // Called when we have received a token for the supervised user.
   void OnReceivedToken(const GoogleServiceAuthError& error,
                        const std::string& token);
@@ skipping 22 matching lines @@
 
   PrefService* prefs_;
   scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher_;
 
   // A |KeyedService| owned by the custodian profile.
   SupervisedUserSyncService* supervised_user_sync_service_;
 
   // A |KeyedService| owned by the custodian profile.
   SupervisedUserSharedSettingsService* supervised_user_shared_settings_service_;
 
-  std::string pending_supervised_user_id_;
+  user_manager::UserID pending_supervised_user_id_;
   std::string pending_supervised_user_token_;
   bool pending_supervised_user_acknowledged_;
   bool is_existing_supervised_user_;
   bool avatar_updated_;
   RegistrationCallback callback_;
   scoped_ptr<SupervisedUserSharedSettingsUpdate> password_update_;
 
   base::WeakPtrFactory<SupervisedUserRegistrationUtilityImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SupervisedUserRegistrationUtilityImpl);
@@ skipping 49 matching lines @@
   SupervisedUserSharedSettingsService* supervised_user_shared_settings_service =
       SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(profile);
   return make_scoped_ptr(SupervisedUserRegistrationUtility::CreateImpl(
       profile->GetPrefs(),
       token_fetcher.Pass(),
       supervised_user_sync_service,
       supervised_user_shared_settings_service));
 }
 
 // static
-std::string SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId() {
-  std::string new_supervised_user_id;
-  base::Base64Encode(base::RandBytesAsString(8), &new_supervised_user_id);
-  return new_supervised_user_id;
+user_manager::UserID SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId() {
+  std::string new_supervised_user_id_str;
+  base::Base64Encode(base::RandBytesAsString(8), &new_supervised_user_id_str);
+  return user_manager::UserID::FromUserEmail(new_supervised_user_id_str);
 }
 
 // static
 void SupervisedUserRegistrationUtility::SetUtilityForTests(
     SupervisedUserRegistrationUtility* utility) {
   if (g_instance_for_tests)
     delete g_instance_for_tests;
   g_instance_for_tests = utility;
 }
 
@@ skipping 14 matching lines @@
 
 SupervisedUserRegistrationUtilityImpl::SupervisedUserRegistrationUtilityImpl(
     PrefService* prefs,
     scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
     SupervisedUserSyncService* service,
     SupervisedUserSharedSettingsService* shared_settings_service)
     : prefs_(prefs),
       token_fetcher_(token_fetcher.Pass()),
       supervised_user_sync_service_(service),
       supervised_user_shared_settings_service_(shared_settings_service),
+      pending_supervised_user_id_(std::string(), std::string()),
       pending_supervised_user_acknowledged_(false),
       is_existing_supervised_user_(false),
       avatar_updated_(false),
       weak_ptr_factory_(this) {
   supervised_user_sync_service_->AddObserver(this);
 }
 
 SupervisedUserRegistrationUtilityImpl::
 ~SupervisedUserRegistrationUtilityImpl() {
   supervised_user_sync_service_->RemoveObserver(this);
   CancelPendingRegistration();
 }
 
 void SupervisedUserRegistrationUtilityImpl::Register(
-    const std::string& supervised_user_id,
+    const user_manager::UserID& supervised_user_id,
     const SupervisedUserRegistrationInfo& info,
     const RegistrationCallback& callback) {
   DCHECK(pending_supervised_user_id_.empty());
   callback_ = callback;
   pending_supervised_user_id_ = supervised_user_id;
 
   bool need_password_update = !info.password_data.empty();
   const base::DictionaryValue* dict =
       prefs_->GetDictionary(prefs::kSupervisedUsers);
-  is_existing_supervised_user_ = dict->HasKey(supervised_user_id);
+  is_existing_supervised_user_ = dict->HasKey(supervised_user_id.GetUserEmail());
   if (!is_existing_supervised_user_) {
     supervised_user_sync_service_->AddSupervisedUser(
         pending_supervised_user_id_,
         base::UTF16ToUTF8(info.name),
         info.master_key,
         info.password_signature_key,
         info.password_encryption_key,
         info.avatar_index);
   } else {
     const base::DictionaryValue* value = NULL;
     bool success =
-        dict->GetDictionaryWithoutPathExpansion(supervised_user_id, &value);
+        dict->GetDictionaryWithoutPathExpansion(supervised_user_id.GetUserEmail(), &value);
     DCHECK(success);
     std::string key;
     bool need_keys = !info.password_signature_key.empty() ||
                      !info.password_encryption_key.empty();
     bool have_keys =
         value->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
                          &key) &&
         !key.empty() &&
         value->GetString(SupervisedUserSyncService::kPasswordEncryptionKey,
                          &key) &&
@@ skipping 18 matching lines @@
         supervised_user_sync_service_->UpdateSupervisedUserAvatarIfNeeded(
             supervised_user_id,
             info.avatar_index);
   }
 #if defined(OS_CHROMEOS)
   const char* kAvatarKey = supervised_users::kChromeOSAvatarIndex;
 #else
   const char* kAvatarKey = supervised_users::kChromeAvatarIndex;
 #endif
   supervised_user_shared_settings_service_->SetValue(
-      pending_supervised_user_id_, kAvatarKey,
+      pending_supervised_user_id_.GetUserEmail(), kAvatarKey,
       base::FundamentalValue(info.avatar_index));
   if (need_password_update) {
     password_update_.reset(new SupervisedUserSharedSettingsUpdate(
         supervised_user_shared_settings_service_,
-        pending_supervised_user_id_,
+        pending_supervised_user_id_.GetUserEmail(),
         supervised_users::kChromeOSPasswordData,
         scoped_ptr<base::Value>(info.password_data.DeepCopy()),
         base::Bind(
             &SupervisedUserRegistrationUtilityImpl::
                 OnPasswordChangeAcknowledged,
             weak_ptr_factory_.GetWeakPtr())));
   }
 
   syncer::GetSessionName(
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN).get(),
       base::Bind(&SupervisedUserRegistrationUtilityImpl::FetchToken,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void SupervisedUserRegistrationUtilityImpl::CancelPendingRegistration() {
   AbortPendingRegistration(
       false,  // Don't run the callback. The error will be ignored.
       GoogleServiceAuthError(GoogleServiceAuthError::NONE));
 }
 
 void SupervisedUserRegistrationUtilityImpl::OnSupervisedUserAcknowledged(
-    const std::string& supervised_user_id) {
-  DCHECK_EQ(pending_supervised_user_id_, supervised_user_id);
+    const user_manager::UserID& supervised_user_id) {
+  DCHECK(pending_supervised_user_id_ == supervised_user_id);
   DCHECK(!pending_supervised_user_acknowledged_);
   pending_supervised_user_acknowledged_ = true;
   CompleteRegistrationIfReady();
 }
 
 void SupervisedUserRegistrationUtilityImpl::OnPasswordChangeAcknowledged(
     bool success) {
   DCHECK(password_update_);
   DCHECK(success);
   password_update_.reset();
@@ skipping 75 matching lines @@
           pending_supervised_user_id_);
     }
   }
 
   if (run_callback)
     callback_.Run(error, pending_supervised_user_token_);
   callback_.Reset();
 }
 
 } // namespace