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

chrome/browser/chromeos/login/users/avatar/user_image_manager_browsertest.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 <map>
 #include <string>
 #include <vector>
 
@@ skipping 87 matching lines @@
     return NULL;
   }
   return policy_manager->core()->store();
 }
 
 }  // namespace
 
 class UserImageManagerTest : public LoginManagerTest,
                              public user_manager::UserManager::Observer {
  protected:
-  UserImageManagerTest()
-      : LoginManagerTest(true),
-        enterprise_account_id_(AccountId::FromUserEmail(kEnterpriseUser1)) {}
+  UserImageManagerTest() : LoginManagerTest(true) {}
 
   // LoginManagerTest overrides:
   void SetUpInProcessBrowserTestFixture() override {
     LoginManagerTest::SetUpInProcessBrowserTestFixture();
 
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_));
     ASSERT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir_));
   }
 
   void SetUpOnMainThread() override {
@@ skipping 187 matching lines @@
   base::FilePath user_data_dir_;
 
   PrefService* local_state_;
 
   scoped_ptr<gfx::ImageSkia> decoded_image_;
 
   scoped_ptr<base::RunLoop> run_loop_;
 
   const AccountId test_account_id1_ = AccountId::FromUserEmail(kTestUser1);
   const AccountId test_account_id2_ = AccountId::FromUserEmail(kTestUser2);
-  const AccountId enterprise_account_id_;
+  const AccountId enterprise_account_id_ =
+      AccountId::FromUserEmail(kEnterpriseUser1);
+  const cryptohome::Identification cryptohome_id_ =
+      cryptohome::Identification(enterprise_account_id_);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UserImageManagerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(UserImageManagerTest, PRE_DefaultUserImagePreserved) {
   // Setup an old default (stock) user image.
   ScopedUserManagerEnabler(new MockUserManager);
   SetOldUserImageInfo(test_account_id1_,
                       default_user_image::kFirstDefaultImageIndex,
@@ skipping 318 matching lines @@
     UserImageManagerTest::SetUpInProcessBrowserTestFixture();
   }
 
   void SetUpOnMainThread() override {
     UserImageManagerTest::SetUpOnMainThread();
 
     base::FilePath user_keys_dir;
     ASSERT_TRUE(PathService::Get(chromeos::DIR_USER_POLICY_KEYS,
                                  &user_keys_dir));
     const std::string sanitized_username =
-        chromeos::CryptohomeClient::GetStubSanitizedUsername(
-            enterprise_account_id_.GetUserEmail());
+        chromeos::CryptohomeClient::GetStubSanitizedUsername(cryptohome_id_);
     const base::FilePath user_key_file =
         user_keys_dir.AppendASCII(sanitized_username)
                      .AppendASCII("policy.pub");
     std::vector<uint8_t> user_key_bits;
     ASSERT_TRUE(user_policy_.GetSigningKey()->ExportPublicKey(&user_key_bits));
     ASSERT_TRUE(base::CreateDirectory(user_key_file.DirName()));
     ASSERT_EQ(base::WriteFile(
                   user_key_file,
                   reinterpret_cast<const char*>(user_key_bits.data()),
                   user_key_bits.size()),
@@ skipping 60 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   policy::CloudPolicyStore* store = GetStoreForUser(user);
   ASSERT_TRUE(store);
 
   // Set policy. Verify that the policy-provided user image is downloaded, set
   // and persisted.
   user_policy_.payload().mutable_useravatarimage()->set_value(
       ConstructPolicy(test::kUserAvatarImage2RelativePath));
   user_policy_.Build();
-  fake_session_manager_client_->set_user_policy(
-      enterprise_account_id_.GetUserEmail(), user_policy_.GetBlob());
+  fake_session_manager_client_->set_user_policy(cryptohome_id_,
+                                                user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(enterprise_account_id_,
                          user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(enterprise_account_id_, "jpg"));
 
   scoped_ptr<gfx::ImageSkia> saved_image =
       test::ImageLoader(GetUserImagePath(enterprise_account_id_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 
   // Clear policy. Verify that the user image switches to a random default
   // image.
   user_policy_.payload().Clear();
   user_policy_.Build();
-  fake_session_manager_client_->set_user_policy(
-      enterprise_account_id_.GetUserEmail(), user_policy_.GetBlob());
+  fake_session_manager_client_->set_user_policy(cryptohome_id_,
+                                                user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->AddObserver(this);
   store->Load();
   run_loop_->Run();
   store->RemoveObserver(this);
   base::RunLoop().RunUntilIdle();
 
   const int default_image_index = user->image_index();
   EXPECT_TRUE(user->HasDefaultImage());
   ASSERT_LE(default_user_image::kFirstDefaultImageIndex, default_image_index);
@@ skipping 60 matching lines @@
   EXPECT_TRUE(test::AreImagesEqual(default_image, user->GetImage()));
   ExpectNewUserImageInfo(enterprise_account_id_,
                          default_user_image::kFirstDefaultImageIndex,
                          base::FilePath());
 
   // Set policy. Verify that the policy-provided user image is downloaded, set
   // and persisted, overriding the previously set image.
   user_policy_.payload().mutable_useravatarimage()->set_value(
       ConstructPolicy(test::kUserAvatarImage2RelativePath));
   user_policy_.Build();
-  fake_session_manager_client_->set_user_policy(
-      enterprise_account_id_.GetUserEmail(), user_policy_.GetBlob());
+  fake_session_manager_client_->set_user_policy(cryptohome_id_,
+                                                user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(enterprise_account_id_,
                          user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(enterprise_account_id_, "jpg"));
@@ skipping 25 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   policy::CloudPolicyStore* store = GetStoreForUser(user);
   ASSERT_TRUE(store);
 
   // Set policy. Verify that the policy-provided user image is downloaded, set
   // and persisted.
   user_policy_.payload().mutable_useravatarimage()->set_value(
       ConstructPolicy(test::kUserAvatarImage2RelativePath));
   user_policy_.Build();
-  fake_session_manager_client_->set_user_policy(
-      enterprise_account_id_.GetUserEmail(), user_policy_.GetBlob());
+  fake_session_manager_client_->set_user_policy(cryptohome_id_,
+                                                user_policy_.GetBlob());
   run_loop_.reset(new base::RunLoop);
   store->Load();
   run_loop_->Run();
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(test::AreImagesEqual(*policy_image_, user->GetImage()));
   ExpectNewUserImageInfo(enterprise_account_id_,
                          user_manager::User::USER_IMAGE_EXTERNAL,
                          GetUserImagePath(enterprise_account_id_, "jpg"));
@@ skipping 23 matching lines @@
   saved_image =
       test::ImageLoader(GetUserImagePath(enterprise_account_id_, "jpg")).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image_->width(), saved_image->width());
   EXPECT_EQ(policy_image_->height(), saved_image->height());
 }
 
 }  // namespace chromeos