This CL replaces e-mail with AccountId in easy signin code.

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 AccountId& account_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(account_id.GetUserEmail(), NULL);
 }
 
 EasyUnlockTpmKeyManager::EasyUnlockTpmKeyManager(
-    const std::string& user_id,
+    const AccountId& account_id,
     const std::string& username_hash,
     PrefService* local_state)
-    : user_id_(user_id),
+    : account_id_(account_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) {
-}
+      weak_ptr_factory_(this) {}
 
 EasyUnlockTpmKeyManager::~EasyUnlockTpmKeyManager() {
 }
 
 bool EasyUnlockTpmKeyManager::PrepareTpmKey(
     bool check_private_key,
     const base::Closure& callback) {
-  CHECK(!user_id_.empty());
+  CHECK(account_id_.is_valid());
   CHECK(!username_hash_.empty());
 
   if (create_tpm_key_state_ == CREATE_TPM_KEY_DONE)
     return true;
 
-  std::string key = GetPublicTpmKey(user_id_);
+  std::string key = GetPublicTpmKey(account_id_);
   if (!check_private_key && !key.empty() &&
       create_tpm_key_state_ == CREATE_TPM_KEY_NOT_STARTED) {
     return true;
   }
 
   prepare_tpm_key_callbacks_.push_back(callback);
 
   if (create_tpm_key_state_ == CREATE_TPM_KEY_NOT_STARTED) {
     create_tpm_key_state_ = CREATE_TPM_KEY_WAITING_FOR_USER_SLOT;
 
@@ skipping 17 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 AccountId& account_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(account_id.GetUserEmail(), &key);
   std::string decoded;
   base::Base64Decode(key, &decoded);
   return decoded;
 }
 
 void EasyUnlockTpmKeyManager::SignUsingTpmKey(
-    const std::string& user_id,
+    const AccountId& account_id,
     const std::string& data,
     const base::Callback<void(const std::string& data)> callback) {
-  std::string key = GetPublicTpmKey(user_id);
+  const std::string key = GetPublicTpmKey(account_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 AccountId& account_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(account_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 50 matching lines @@
   // |OnTpmKeyCreated| is called by a timeout task posted by
   // |StartGetSystemSlotTimeoutMs|. Invalidating the factory will have
   // an effect of canceling any pending |GetSystemSlotOnIOThread| callbacks,
   // as well as other pending timeouts.
   // Note that in the case |OnTpmKeyCreated| was called as a result of
   // |CreateKeyInSystemSlot|, this should have no effect as no weak ptrs from
   // this factory should be in use in this case.
   get_tpm_slot_weak_ptr_factory_.InvalidateWeakPtrs();
 
   if (!public_key.empty())
-    SetKeyInLocalState(user_id_, public_key);
+    SetKeyInLocalState(account_id_, public_key);
 
   for (size_t i = 0; i < prepare_tpm_key_callbacks_.size(); ++i) {
     if (!prepare_tpm_key_callbacks_[i].is_null())
       prepare_tpm_key_callbacks_[i].Run();
   }
 
   prepare_tpm_key_callbacks_.clear();
 
   // 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);
 }