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

chrome/browser/supervised_user/legacy/supervised_user_sync_service.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_sync_service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/signin_manager.h"
+#include "components/user_manager/user_id.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
 
 #if defined(OS_CHROMEOS)
 #include "components/user_manager/user_image/default_user_images.h"
 #endif
@@ skipping 13 matching lines @@
 using sync_pb::ManagedUserSpecifics;
 
 namespace {
 
 #if defined(OS_CHROMEOS)
 const char kChromeOSAvatarPrefix[] = "chromeos-avatar-index:";
 #else
 const char kChromeAvatarPrefix[] = "chrome-avatar-index:";
 #endif
 
-SyncData CreateLocalSyncData(const std::string& id,
+SyncData CreateLocalSyncData(const user_manager::UserID& id,
                              const std::string& name,
                              bool acknowledged,
                              const std::string& master_key,
                              const std::string& chrome_avatar,
                              const std::string& chromeos_avatar,
                              const std::string& password_signature_key,
                              const std::string& password_encryption_key) {
   ::sync_pb::EntitySpecifics specifics;
-  specifics.mutable_managed_user()->set_id(id);
+  specifics.mutable_managed_user()->set_id(id.GetUserEmail());
   specifics.mutable_managed_user()->set_name(name);
   if (!chrome_avatar.empty())
     specifics.mutable_managed_user()->set_chrome_avatar(chrome_avatar);
   if (!chromeos_avatar.empty())
     specifics.mutable_managed_user()->set_chromeos_avatar(chromeos_avatar);
   if (!master_key.empty())
     specifics.mutable_managed_user()->set_master_key(master_key);
   if (acknowledged)
     specifics.mutable_managed_user()->set_acknowledged(true);
   if (!password_signature_key.empty()) {
     specifics.mutable_managed_user()->
         set_password_signature_key(password_signature_key);
   }
   if (!password_encryption_key.empty()) {
     specifics.mutable_managed_user()->
         set_password_encryption_key(password_encryption_key);
   }
-  return SyncData::CreateLocalData(id, name, specifics);
+  return SyncData::CreateLocalData(id.GetUserEmail(), name, specifics);
 }
 
-SyncData CreateSyncDataFromDictionaryEntry(const std::string& id,
+SyncData CreateSyncDataFromDictionaryEntry(const user_manager::UserID& id,
                                            const base::Value& value) {
   const base::DictionaryValue* dict = NULL;
   bool success = value.GetAsDictionary(&dict);
   DCHECK(success);
   bool acknowledged = false;
   dict->GetBoolean(SupervisedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
   dict->GetString(SupervisedUserSyncService::kName, &name);
   DCHECK(!name.empty());
   std::string master_key;
@@ skipping 127 matching lines @@
   chromeos_avatar = BuildAvatarString(avatar_index);
 #else
   chrome_avatar = BuildAvatarString(avatar_index);
 #endif
   result->SetString(kChromeAvatar, chrome_avatar);
   result->SetString(kChromeOsAvatar, chromeos_avatar);
   return result.Pass();
 }
 
 void SupervisedUserSyncService::AddSupervisedUser(
-    const std::string& id,
+    const user_manager::UserID& id,
     const std::string& name,
     const std::string& master_key,
     const std::string& signature_key,
     const std::string& encryption_key,
     int avatar_index) {
   UpdateSupervisedUserImpl(id,
                            name,
                            master_key,
                            signature_key,
                            encryption_key,
                            avatar_index,
                            true /* add */);
 }
 
 void SupervisedUserSyncService::UpdateSupervisedUser(
-    const std::string& id,
+    const user_manager::UserID& id,
     const std::string& name,
     const std::string& master_key,
     const std::string& signature_key,
     const std::string& encryption_key,
     int avatar_index) {
   UpdateSupervisedUserImpl(id,
                            name,
                            master_key,
                            signature_key,
                            encryption_key,
                            avatar_index,
                            false /* update */);
 }
 
 void SupervisedUserSyncService::UpdateSupervisedUserImpl(
-    const std::string& id,
+    const user_manager::UserID& id,
     const std::string& name,
     const std::string& master_key,
     const std::string& signature_key,
     const std::string& encryption_key,
     int avatar_index,
     bool add_user) {
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   scoped_ptr<base::DictionaryValue> value = CreateDictionary(
       name, master_key, signature_key, encryption_key, avatar_index);
 
-  DCHECK_EQ(add_user, !dict->HasKey(id));
+  DCHECK_EQ(add_user, !dict->HasKey(id.GetUserEmail()));
   base::DictionaryValue* entry = value.get();
-  dict->SetWithoutPathExpansion(id, value.release());
+  dict->SetWithoutPathExpansion(id.GetUserEmail(), value.release());
 
   if (!sync_processor_)
     return;
 
   // If we're already syncing, create a new change and upload it.
   SyncChangeList change_list;
   change_list.push_back(
       SyncChange(FROM_HERE,
                  add_user ? SyncChange::ACTION_ADD : SyncChange::ACTION_UPDATE,
                  CreateSyncDataFromDictionaryEntry(id, *entry)));
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!error.IsSet()) << error.ToString();
 }
 
-void SupervisedUserSyncService::DeleteSupervisedUser(const std::string& id) {
+void SupervisedUserSyncService::DeleteSupervisedUser(const user_manager::UserID& id) {
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
-  bool success = update->RemoveWithoutPathExpansion(id, NULL);
+  bool success = update->RemoveWithoutPathExpansion(id.GetUserEmail(), NULL);
   DCHECK(success);
 
   if (!sync_processor_)
     return;
 
   SyncChangeList change_list;
   change_list.push_back(SyncChange(
       FROM_HERE,
       SyncChange::ACTION_DELETE,
-      SyncData::CreateLocalDelete(id, SUPERVISED_USERS)));
+      SyncData::CreateLocalDelete(id.GetUserEmail(), SUPERVISED_USERS)));
   SyncError sync_error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!sync_error.IsSet());
 }
 
 const base::DictionaryValue* SupervisedUserSyncService::GetSupervisedUsers() {
   DCHECK(sync_processor_);
   return prefs_->GetDictionary(prefs::kSupervisedUsers);
 }
 
 bool SupervisedUserSyncService::UpdateSupervisedUserAvatarIfNeeded(
-    const std::string& id,
+    const user_manager::UserID& id,
     int avatar_index) {
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
-  DCHECK(dict->HasKey(id));
+  DCHECK(dict->HasKey(id.GetUserEmail()));
   base::DictionaryValue* value = NULL;
-  bool success = dict->GetDictionaryWithoutPathExpansion(id, &value);
+  bool success = dict->GetDictionaryWithoutPathExpansion(id.GetUserEmail(), &value);
   DCHECK(success);
 
   bool acknowledged = false;
   value->GetBoolean(SupervisedUserSyncService::kAcknowledged, &acknowledged);
   std::string name;
   value->GetString(SupervisedUserSyncService::kName, &name);
   std::string master_key;
   value->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   std::string signature;
   value->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
@@ skipping 36 matching lines @@
       CreateLocalSyncData(id, name, acknowledged, master_key,
                           chrome_avatar, chromeos_avatar,
                           signature, encryption)));
   SyncError error =
       sync_processor_->ProcessSyncChanges(FROM_HERE, change_list);
   DCHECK(!error.IsSet()) << error.ToString();
   return true;
 }
 
 void SupervisedUserSyncService::ClearSupervisedUserAvatar(
-    const std::string& id) {
+    const user_manager::UserID& id) {
   bool cleared = UpdateSupervisedUserAvatarIfNeeded(id, kNoAvatar);
   DCHECK(cleared);
 }
 
 void SupervisedUserSyncService::GetSupervisedUsersAsync(
     const SupervisedUsersCallback& callback) {
   // If we are already syncing, just run the callback.
   if (sync_processor_) {
     callback.Run(GetSupervisedUsers());
     return;
@@ skipping 48 matching lines @@
     seen_ids.insert(supervised_user.id());
   }
 
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
     if (seen_ids.find(it.key()) != seen_ids.end())
       continue;
 
     change_list.push_back(
         SyncChange(FROM_HERE,
                    SyncChange::ACTION_ADD,
-                   CreateSyncDataFromDictionaryEntry(it.key(), it.value())));
+                   CreateSyncDataFromDictionaryEntry(user_manager::UserID::FromUserEmail(it.key()), it.value())));
   }
   result.set_error(sync_processor_->ProcessSyncChanges(FROM_HERE, change_list));
 
   result.set_num_items_modified(num_items_modified);
   result.set_num_items_added(num_items_added);
   result.set_num_items_after_association(dict->size());
 
   DispatchCallbacks();
 
   return result;
 }
 
 void SupervisedUserSyncService::StopSyncing(ModelType type) {
   DCHECK_EQ(SUPERVISED_USERS, type);
   // The observers may want to change the Sync data, so notify them before
   // resetting the |sync_processor_|.
   NotifySupervisedUsersSyncingStopped();
   sync_processor_.reset();
   error_handler_.reset();
 }
 
 SyncDataList SupervisedUserSyncService::GetAllSyncData(
     ModelType type) const {
   SyncDataList data;
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
   for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance())
-    data.push_back(CreateSyncDataFromDictionaryEntry(it.key(), it.value()));
+    data.push_back(CreateSyncDataFromDictionaryEntry(user_manager::UserID::FromUserEmail(it.key()), it.value()));
 
   return data;
 }
 
 SyncError SupervisedUserSyncService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const SyncChangeList& change_list) {
   SyncError error;
   DictionaryPrefUpdate update(prefs_, prefs::kSupervisedUsers);
   base::DictionaryValue* dict = update.Get();
@@ skipping 13 matching lines @@
 
         // For an update action, the supervised user should already exist, for
         // an add action, it should not.
         DCHECK_EQ(
             old_value ? SyncChange::ACTION_UPDATE : SyncChange::ACTION_ADD,
             sync_change.change_type());
 
         // If the supervised user switched from unacknowledged to acknowledged,
         // we might need to continue with a registration.
         if (old_value && !old_value->HasKey(kAcknowledged))
-          NotifySupervisedUserAcknowledged(supervised_user.id());
+          NotifySupervisedUserAcknowledged(user_manager::UserID::FromUserEmail(supervised_user.id()));
 
         base::DictionaryValue* value = new base::DictionaryValue;
         value->SetString(kName, supervised_user.name());
         value->SetBoolean(kAcknowledged, supervised_user.acknowledged());
         value->SetString(kMasterKey, supervised_user.master_key());
         value->SetString(kChromeAvatar, supervised_user.chrome_avatar());
         value->SetString(kChromeOsAvatar, supervised_user.chromeos_avatar());
         value->SetString(kPasswordSignatureKey,
                          supervised_user.password_signature_key());
         value->SetString(kPasswordEncryptionKey,
@@ skipping 21 matching lines @@
     const std::string& account_id,
     const std::string& username) {
   DCHECK(!sync_processor_);
 
   // Clear all data on signout, to avoid supervised users from one custodian
   // appearing in another one's profile.
   prefs_->ClearPref(prefs::kSupervisedUsers);
 }
 
 void SupervisedUserSyncService::NotifySupervisedUserAcknowledged(
-    const std::string& supervised_user_id) {
+    const user_manager::UserID& supervised_user_id) {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver, observers_,
                     OnSupervisedUserAcknowledged(supervised_user_id));
 }
 
 void SupervisedUserSyncService::NotifySupervisedUsersSyncingStopped() {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver, observers_,
                     OnSupervisedUsersSyncingStopped());
 }
 
 void SupervisedUserSyncService::NotifySupervisedUsersChanged() {
   FOR_EACH_OBSERVER(SupervisedUserSyncServiceObserver,
                     observers_,
                     OnSupervisedUsersChanged());
 }
 
 void SupervisedUserSyncService::DispatchCallbacks() {
   const base::DictionaryValue* supervised_users =
       prefs_->GetDictionary(prefs::kSupervisedUsers);
   for (const auto& callback : callbacks_)
     callback.Run(supervised_users);
   callbacks_.clear();
 }