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

chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager.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/easy_unlock/easy_unlock_tpm_key_manager.h"
 
 #include <cryptohi.h>
 #include <keyhi.h>
 
 #include "base/base64.h"
@@ skipping 166 matching lines @@
 }  // namespace
 
 // static
 void EasyUnlockTpmKeyManager::RegisterLocalStatePrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kEasyUnlockLocalStateTpmKeys);
 }
 
 // static
 void EasyUnlockTpmKeyManager::ResetLocalStateForUser(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   if (!g_browser_process)
     return;
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state)
     return;
 
   DictionaryPrefUpdate update(local_state, prefs::kEasyUnlockLocalStateTpmKeys);
-  update->RemoveWithoutPathExpansion(user_id, NULL);
+  update->RemoveWithoutPathExpansion(user_id.GetUserEmail(), NULL);
 }
 
 EasyUnlockTpmKeyManager::EasyUnlockTpmKeyManager(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& username_hash,
     PrefService* local_state)
     : user_id_(user_id),
       username_hash_(username_hash),
       local_state_(local_state),
       create_tpm_key_state_(CREATE_TPM_KEY_NOT_STARTED),
       get_tpm_slot_weak_ptr_factory_(this),
       weak_ptr_factory_(this) {
 }
 
@@ skipping 40 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&EasyUnlockTpmKeyManager::OnTpmKeyCreated,
                  get_tpm_slot_weak_ptr_factory_.GetWeakPtr(),
                  std::string()),
       base::TimeDelta::FromMilliseconds(timeout_ms));
   return true;
 }
 
 std::string EasyUnlockTpmKeyManager::GetPublicTpmKey(
-    const std::string& user_id) {
+    const user_manager::UserID& user_id) {
   if (!local_state_)
     return std::string();
   const base::DictionaryValue* dict =
       local_state_->GetDictionary(prefs::kEasyUnlockLocalStateTpmKeys);
   std::string key;
   if (dict)
-    dict->GetStringWithoutPathExpansion(user_id, &key);
+    dict->GetStringWithoutPathExpansion(user_id.GetUserEmail(), &key);
   std::string decoded;
   base::Base64Decode(key, &decoded);
   return decoded;
 }
 
 void EasyUnlockTpmKeyManager::SignUsingTpmKey(
-    const std::string& user_id,
+    const user_manager::UserID& user_id,
     const std::string& data,
     const base::Callback<void(const std::string& data)> callback) {
   std::string key = GetPublicTpmKey(user_id);
   if (key.empty()) {
     callback.Run(std::string());
     return;
   }
 
   base::Callback<void(crypto::ScopedPK11Slot)> sign_with_system_slot =
       base::Bind(&EasyUnlockTpmKeyManager::SignDataWithSystemSlot,
                  weak_ptr_factory_.GetWeakPtr(),
                  key, data, callback);
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO,
       FROM_HERE,
       base::Bind(&GetSystemSlotOnIOThread,
                  base::ThreadTaskRunnerHandle::Get(),
                  sign_with_system_slot));
 }
 
 bool EasyUnlockTpmKeyManager::StartedCreatingTpmKeys() const {
   return create_tpm_key_state_ == CREATE_TPM_KEY_GOT_SYSTEM_SLOT ||
          create_tpm_key_state_ == CREATE_TPM_KEY_DONE;
 }
 
-void EasyUnlockTpmKeyManager::SetKeyInLocalState(const std::string& user_id,
+void EasyUnlockTpmKeyManager::SetKeyInLocalState(const user_manager::UserID& user_id,
                                                  const std::string& value) {
   if (!local_state_)
     return;
 
   std::string encoded;
   base::Base64Encode(value, &encoded);
   DictionaryPrefUpdate update(local_state_,
                               prefs::kEasyUnlockLocalStateTpmKeys);
-  update->SetStringWithoutPathExpansion(user_id, encoded);
+  update->SetStringWithoutPathExpansion(user_id.GetUserEmail(), encoded);
 }
 
 void EasyUnlockTpmKeyManager::OnUserTPMInitialized(
     const std::string& public_key) {
   create_tpm_key_state_ = CREATE_TPM_KEY_WAITING_FOR_SYSTEM_SLOT;
 
   base::Callback<void(crypto::ScopedPK11Slot)> create_key_with_system_slot =
       base::Bind(&EasyUnlockTpmKeyManager::CreateKeyInSystemSlot,
                  get_tpm_slot_weak_ptr_factory_.GetWeakPtr(), public_key);
 
@@ skipping 69 matching lines @@
   // If key creation failed, reset the state machine.
   create_tpm_key_state_ =
       public_key.empty() ? CREATE_TPM_KEY_NOT_STARTED : CREATE_TPM_KEY_DONE;
 }
 
 void EasyUnlockTpmKeyManager::OnDataSigned(
     const base::Callback<void(const std::string&)>& callback,
     const std::string& signature) {
   callback.Run(signature);
 }