ChromeOS cryptohome should be able to use gaia id as user identifier.

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 <stdint.h>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 248 matching lines @@
     if (key_type) {
       key_definition.provider_data.push_back(
           cryptohome::KeyDefinition::ProviderData("type"));
       key_definition.provider_data.back().number = std::move(key_type);
     }
     if (salt) {
       key_definition.provider_data.push_back(
           cryptohome::KeyDefinition::ProviderData("salt"));
       key_definition.provider_data.back().bytes = std::move(salt);
     }
-    EXPECT_CALL(*mock_homedir_methods_,
-                GetKeyDataEx(cryptohome::Identification(
-                                 user_context_.GetAccountId().GetUserEmail()),
-                             kCryptohomeGAIAKeyLabel, _))
+    EXPECT_CALL(
+        *mock_homedir_methods_,
+        GetKeyDataEx(cryptohome::Identification(user_context_.GetAccountId()),
+                     kCryptohomeGAIAKeyLabel, _))
         .WillOnce(WithArg<2>(Invoke(
             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_.GetAccountId().GetUserEmail()),
-                        cryptohome::Authorization(auth_key), mount, _))
+    EXPECT_CALL(
+        *mock_homedir_methods_,
+        MountEx(cryptohome::Identification(user_context_.GetAccountId()),
+                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_.GetAccountId().GetUserEmail(), _))
+  EXPECT_CALL(
+      *mock_caller_,
+      AsyncRemove(cryptohome::Identification(user_context_.GetAccountId()), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
   ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), 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_.GetAccountId().GetUserEmail(), _))
+  EXPECT_CALL(
+      *mock_caller_,
+      AsyncRemove(cryptohome::Identification(user_context_.GetAccountId()), _))
       .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_.GetAccountId().GetUserEmail(), _,
-                              transformed_key_.GetSecret(), _))
+  EXPECT_CALL(
+      *mock_caller_,
+      AsyncMigrateKey(cryptohome::Identification(user_context_.GetAccountId()),
+                      _, transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome mount
   // attempt.
   ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), 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_.GetAccountId().GetUserEmail(), _,
-                              transformed_key_.GetSecret(), _))
+  EXPECT_CALL(
+      *mock_caller_,
+      AsyncMigrateKey(cryptohome::Identification(user_context_.GetAccountId()),
+                      _, 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_.GetAccountId().GetUserEmail(), _, _))
+  EXPECT_CALL(
+      *mock_caller_,
+      AsyncCheckKey(cryptohome::Identification(user_context_.GetAccountId()), _,
+                    _))
       .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_t(Key::KEY_TYPE_SALTED_SHA256)),
       scoped_ptr<std::string>());
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 }  // namespace chromeos