This CL replaces user_manager::UserID with AccountId.

chrome/browser/chromeos/login/auth/cryptohome_authenticator_unittest.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/auth/chrome_cryptohome_authenticator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 113 matching lines @@
                                kOwnerPrivateKey + arraysize(kOwnerPrivateKey));
   return crypto::ImportNSSKeyFromPrivateKeyInfo(slot, key,
                                                 true /* permanent */);
 }
 
 }  // namespace
 
 class CryptohomeAuthenticatorTest : public testing::Test {
  public:
   CryptohomeAuthenticatorTest()
-      : user_context_("me@nowhere.org"),
+      : user_context_(AccountId::FromUserEmail("me@nowhere.org")),
         user_manager_(new user_manager::FakeUserManager()),
         user_manager_enabler_(user_manager_),
         mock_caller_(NULL),
         mock_homedir_methods_(NULL),
         owner_key_util_(new ownership::MockOwnerKeyUtil()) {
     OwnerSettingsServiceChromeOSFactory::GetInstance()
         ->SetOwnerKeyUtilForTesting(owner_key_util_);
     user_context_.SetKey(Key("fakepass"));
     user_context_.SetUserIDHash("me_nowhere_com_hash");
     const user_manager::User* user =
-        user_manager_->AddUser(user_context_.GetUserID());
-    profile_.set_profile_name(user_context_.GetUserID());
+        user_manager_->AddUser(user_context_.GetAccountId());
+    profile_.set_profile_name(user_context_.GetAccountId().GetUserEmail());
 
     ProfileHelper::Get()->SetUserToProfileMappingForTesting(user, &profile_);
 
     CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256_TOP_HALF,
                          SystemSaltGetter::ConvertRawSaltToHexString(
                              FakeCryptohomeClient::GetStubSystemSalt()));
   }
 
   ~CryptohomeAuthenticatorTest() override {}
 
@@ skipping 100 matching lines @@
     if (key_type) {
       key_definition.provider_data.push_back(
           cryptohome::KeyDefinition::ProviderData("type"));
       key_definition.provider_data.back().number = key_type.Pass();
     }
     if (salt) {
       key_definition.provider_data.push_back(
           cryptohome::KeyDefinition::ProviderData("salt"));
       key_definition.provider_data.back().bytes = salt.Pass();
     }
-    EXPECT_CALL(*mock_homedir_methods_, GetKeyDataEx(
-        cryptohome::Identification(user_context_.GetUserID()),
-        kCryptohomeGAIAKeyLabel,
-        _))
+    EXPECT_CALL(*mock_homedir_methods_,
+                GetKeyDataEx(cryptohome::Identification(
+                                 user_context_.GetAccountId().GetUserEmail()),
+                             kCryptohomeGAIAKeyLabel, _))
         .WillOnce(WithArg<2>(Invoke(
-            this,
-            &CryptohomeAuthenticatorTest::InvokeGetDataExCallback)));
+            this, &CryptohomeAuthenticatorTest::InvokeGetDataExCallback)));
   }
 
   void ExpectMountExCall(bool expect_create_attempt) {
     const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
                                              std::string(),
                                              cryptohome::PRIV_DEFAULT);
     cryptohome::MountParameters mount(false /* ephemeral */);
     if (expect_create_attempt) {
       mount.create_keys.push_back(cryptohome::KeyDefinition(
           transformed_key_.GetSecret(),
           kCryptohomeGAIAKeyLabel,
           cryptohome::PRIV_DEFAULT));
     }
     EXPECT_CALL(*mock_homedir_methods_,
-                MountEx(cryptohome::Identification(user_context_.GetUserID()),
-                        cryptohome::Authorization(auth_key),
-                        mount,
-                        _))
+                MountEx(cryptohome::Identification(
+                            user_context_.GetAccountId().GetUserEmail()),
+                        cryptohome::Authorization(auth_key), mount, _))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   void RunResolve(CryptohomeAuthenticator* auth) {
     auth->Resolve();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void SetAttemptState(CryptohomeAuthenticator* auth, TestAttemptState* state) {
@@ skipping 253 matching lines @@
 TEST_F(CryptohomeAuthenticatorTest, DriveDataResync) {
   UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a cryptohome
   // remove attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
-  EXPECT_CALL(*mock_caller_, AsyncRemove(user_context_.GetUserID(), _))
+  EXPECT_CALL(*mock_caller_,
+              AsyncRemove(user_context_.GetAccountId().GetUserEmail(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
   ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
   ExpectMountExCall(true /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveResyncFail) {
   FailOnLoginSuccess();
   ExpectLoginFailure(AuthFailure(AuthFailure::DATA_REMOVAL_FAILED));
 
   // Set up mock async method caller to fail a cryptohome remove attempt.
   mock_caller_->SetUp(false, cryptohome::MOUNT_ERROR_NONE);
-  EXPECT_CALL(*mock_caller_, AsyncRemove(user_context_.GetUserID(), _))
+  EXPECT_CALL(*mock_caller_,
+              AsyncRemove(user_context_.GetAccountId().GetUserEmail(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveRequestOldPassword) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
   state_->PresetCryptohomeStatus(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecover) {
   UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a key migration.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
-  EXPECT_CALL(
-      *mock_caller_,
-      AsyncMigrateKey(
-          user_context_.GetUserID(), _, transformed_key_.GetSecret(), _))
+  EXPECT_CALL(*mock_caller_,
+              AsyncMigrateKey(user_context_.GetAccountId().GetUserEmail(), _,
+                              transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome mount
   // attempt.
   ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
   ExpectMountExCall(false /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecoverButFail) {
   FailOnLoginSuccess();
   ExpectPasswordChange();
 
   // Set up mock async method caller to fail a key migration attempt,
   // asserting that the wrong password was used.
   mock_caller_->SetUp(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
-  EXPECT_CALL(
-      *mock_caller_,
-      AsyncMigrateKey(
-          user_context_.GetUserID(), _, transformed_key_.GetSecret(), _))
+  EXPECT_CALL(*mock_caller_,
+              AsyncMigrateKey(user_context_.GetAccountId().GetUserEmail(), _,
+                              transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, ResolveNoMountToFailedMount) {
@@ skipping 68 matching lines @@
   RunResolve(auth_.get());
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveUnlock) {
   ExpectLoginSuccess(user_context_);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a cryptohome
   // key-check attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
-  EXPECT_CALL(*mock_caller_, AsyncCheckKey(user_context_.GetUserID(), _, _))
+  EXPECT_CALL(*mock_caller_,
+              AsyncCheckKey(user_context_.GetAccountId().GetUserEmail(), _, _))
       .Times(1)
       .RetiresOnSaturation();
 
   auth_->AuthenticateToUnlock(user_context_);
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveLoginWithPreHashedPassword) {
   CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256, kSalt);
 
@@ skipping 27 matching lines @@
   // salt.
   ExpectGetKeyDataExCall(
       make_scoped_ptr(new int64(Key::KEY_TYPE_SALTED_SHA256)),
       scoped_ptr<std::string>());
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 }  // namespace chromeos