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

chrome/browser/chromeos/login/supervised/supervised_user_authentication.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_authentication.h"
 
 #include "base/base64.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
@@ skipping 103 matching lines @@
     std::string salt;
     owner_->GetPasswordInformation(context.GetUserID(), &holder);
     holder.GetStringWithoutPathExpansion(kSalt, &salt);
     DCHECK(!salt.empty());
     Key* const key = result.GetKey();
     key->Transform(Key::KEY_TYPE_SALTED_PBKDF2_AES256_1234, salt);
     key->SetLabel(kCryptohomeSupervisedUserKeyLabel);
     result.SetIsUsingOAuth(false);
     return result;
   }
-  NOTREACHED() << "Unknown password schema for " << context.GetUserID();
+  NOTREACHED() << "Unknown password schema for " << context.GetUserID().GetUserEmail();
   return context;
 }
 
 bool SupervisedUserAuthentication::FillDataForNewUser(
-    const std::string& user_id,
+    const user_manager::UserID& /* user_id */,
     const std::string& password,
     base::DictionaryValue* password_data,
     base::DictionaryValue* extra_data) {
   Schema schema = stable_schema_;
   if (schema == SCHEMA_PLAIN)
     return false;
 
   if (schema == SCHEMA_SALT_HASHED) {
     password_data->SetIntegerWithoutPathExpansion(kSchemaVersion, schema);
     std::string salt = CreateSalt();
@@ skipping 23 matching lines @@
 
 std::string SupervisedUserAuthentication::GenerateMasterKey() {
   char master_key_bytes[kMasterKeySize];
   crypto::RandBytes(&master_key_bytes, sizeof(master_key_bytes));
   return base::StringToLowerASCII(
       base::HexEncode(reinterpret_cast<const void*>(master_key_bytes),
                       sizeof(master_key_bytes)));
 }
 
 void SupervisedUserAuthentication::StorePasswordData(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const base::DictionaryValue& password_data) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
   const base::Value* value;
   if (password_data.GetWithoutPathExpansion(kSchemaVersion, &value))
       holder.SetWithoutPathExpansion(kSchemaVersion, value->DeepCopy());
   if (password_data.GetWithoutPathExpansion(kSalt, &value))
       holder.SetWithoutPathExpansion(kSalt, value->DeepCopy());
   if (password_data.GetWithoutPathExpansion(kPasswordRevision, &value))
       holder.SetWithoutPathExpansion(kPasswordRevision, value->DeepCopy());
   owner_->SetPasswordInformation(user_id, &holder);
 }
 
 SupervisedUserAuthentication::Schema
 SupervisedUserAuthentication::GetPasswordSchema(
-  const std::string& user_id) {
+  const user_manager::UserID& user_id) {
   base::DictionaryValue holder;
 
   owner_->GetPasswordInformation(user_id, &holder);
   // Default version.
   int schema_version_index;
   Schema schema_version = SCHEMA_PLAIN;
   if (holder.GetIntegerWithoutPathExpansion(kSchemaVersion,
                                             &schema_version_index)) {
     schema_version = static_cast<Schema>(schema_version_index);
   }
   return schema_version;
 }
 
 bool SupervisedUserAuthentication::NeedPasswordChange(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const base::DictionaryValue* password_data) {
   base::DictionaryValue local;
   owner_->GetPasswordInformation(user_id, &local);
   int local_schema = SCHEMA_PLAIN;
   int local_revision = kMinPasswordRevision;
   int updated_schema = SCHEMA_PLAIN;
   int updated_revision = kMinPasswordRevision;
   local.GetIntegerWithoutPathExpansion(kSchemaVersion, &local_schema);
   local.GetIntegerWithoutPathExpansion(kPasswordRevision, &local_revision);
   password_data->GetIntegerWithoutPathExpansion(kSchemaVersion,
                                                 &updated_schema);
   password_data->GetIntegerWithoutPathExpansion(kPasswordRevision,
                                                 &updated_revision);
   if (updated_schema > local_schema)
     return true;
   DCHECK_EQ(updated_schema, local_schema);
   return updated_revision > local_revision;
 }
 
 void SupervisedUserAuthentication::ScheduleSupervisedPasswordChange(
-    const std::string& supervised_user_id,
+    const user_manager::UserID& supervised_user_id,
     const base::DictionaryValue* password_data) {
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(supervised_user_id);
   base::FilePath profile_path = ProfileHelper::GetProfilePathByUserIdHash(
       user->username_hash());
   JSONFileValueSerializer serializer(profile_path.Append(kPasswordUpdateFile));
   if (!serializer.Serialize(*password_data)) {
     LOG(ERROR) << "Failed to schedule password update for supervised user "
-               << supervised_user_id;
+               << supervised_user_id.GetUserEmail();
     UMA_HISTOGRAM_ENUMERATION(
         "ManagedUsers.ChromeOS.PasswordChange",
         SupervisedUserAuthentication::PASSWORD_CHANGE_FAILED_STORE_DATA,
         SupervisedUserAuthentication::PASSWORD_CHANGE_RESULT_MAX_VALUE);
     return;
   }
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(supervised_user_id, &holder);
   holder.SetBoolean(kRequirePasswordUpdate, true);
   owner_->SetPasswordInformation(supervised_user_id, &holder);
 }
 
 bool SupervisedUserAuthentication::HasScheduledPasswordUpdate(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
   bool require_update = false;
   holder.GetBoolean(kRequirePasswordUpdate, &require_update);
   return require_update;
 }
 
 void SupervisedUserAuthentication::ClearScheduledPasswordUpdate(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
   holder.SetBoolean(kRequirePasswordUpdate, false);
   owner_->SetPasswordInformation(user_id, &holder);
 }
 
 bool SupervisedUserAuthentication::HasIncompleteKey(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
   bool incomplete_key = false;
   holder.GetBoolean(kHasIncompleteKey, &incomplete_key);
   return incomplete_key;
 }
 
-void SupervisedUserAuthentication::MarkKeyIncomplete(const std::string& user_id,
+void SupervisedUserAuthentication::MarkKeyIncomplete(const user_manager::UserID& user_id,
                                                      bool incomplete) {
   base::DictionaryValue holder;
   owner_->GetPasswordInformation(user_id, &holder);
   holder.SetBoolean(kHasIncompleteKey, incomplete);
   owner_->SetPasswordInformation(user_id, &holder);
 }
 
 void SupervisedUserAuthentication::LoadPasswordUpdateData(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const PasswordDataCallback& success_callback,
     const base::Closure& failure_callback) {
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(user_id);
   base::FilePath profile_path =
       ProfileHelper::GetProfilePathByUserIdHash(user->username_hash());
   PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
@@ skipping 24 matching lines @@
     LOG(FATAL) << "HMAC::Sign failed";
 
   std::string raw_result(out_bytes, out_bytes + sizeof(out_bytes));
 
   std::string result;
   base::Base64Encode(raw_result, &result);
   return result;
 }
 
 }  // namespace chromeos