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

chromeos/tpm/tpm_token_info_getter_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 <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
+#include "chromeos/login/auth/utils.h"
 #include "chromeos/tpm/tpm_token_info_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // The struct holding information returned by TPMTokenInfoGetter::Start
 // callback.
 struct TestTPMTokenInfo {
   TestTPMTokenInfo() : enabled(false), slot_id(-2) {}
 
@@ skipping 48 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeTaskRunner);
 };
 
 // Implementation of CryptohomeClient used in these tests. Note that
 // TestCryptohomeClient implements FakeCryptohomeClient purely for convenience
 // of not having to implement whole CryptohomeClient interface.
 // TestCryptohomeClient overrides all CryptohomeClient methods used in
 // TPMTokenInfoGetter tests.
 class TestCryptohomeClient : public chromeos::FakeCryptohomeClient {
  public:
-  // |user_id|: The user associated with the TPMTokenInfoGetter that will be
+  // |account_id|: The user associated with the TPMTokenInfoGetter that will be
   // using the TestCryptohomeClient. Should be empty for system token.
-  explicit TestCryptohomeClient(const std::string& user_id)
-      : user_id_(user_id),
+  explicit TestCryptohomeClient(const AccountId& account_id)
+      : account_id_(account_id),
         tpm_is_enabled_(true),
         tpm_is_enabled_failure_count_(0),
         tpm_is_enabled_succeeded_(false),
         get_tpm_token_info_failure_count_(0),
         get_tpm_token_info_not_set_count_(0),
-        get_tpm_token_info_succeeded_(false) {
-  }
+        get_tpm_token_info_succeeded_(false) {}
 
   ~TestCryptohomeClient() override {}
 
   void set_tpm_is_enabled(bool value) {
     tpm_is_enabled_ = value;
   }
 
   void set_tpm_is_enabled_failure_count(int value) {
     ASSERT_GT(value, 0);
     tpm_is_enabled_failure_count_ = value;
@@ skipping 37 matching lines @@
       tpm_is_enabled_succeeded_ = true;
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(callback,
                      chromeos::DBUS_METHOD_CALL_SUCCESS, tpm_is_enabled_));
     }
   }
 
   void Pkcs11GetTpmTokenInfo(
       const Pkcs11GetTpmTokenInfoCallback& callback) override {
-    ASSERT_TRUE(user_id_.empty());
+    ASSERT_TRUE(account_id_.empty());
 
     HandleGetTpmTokenInfo(callback);
   }
 
   void Pkcs11GetTpmTokenInfoForUser(
       const std::string& user_id,
       const Pkcs11GetTpmTokenInfoCallback& callback) override {
-    ASSERT_FALSE(user_id_.empty());
-    ASSERT_EQ(user_id_, user_id);
+    ASSERT_FALSE(user_id.empty());
+    ASSERT_EQ(account_id_,
+              cryptohome::GetAccountId(
+                  cryptohome::Identification::FromString(user_id)));
 
     HandleGetTpmTokenInfo(callback);
   }
 
   // Handles Pkcs11GetTpmTokenInfo calls (both for system and user token). The
-  // CryptohomeClient method overrides should make sure that |user_id_| is
+  // CryptohomeClient method overrides should make sure that |account_id_| is
   // properly set before calling this.
   void HandleGetTpmTokenInfo(const Pkcs11GetTpmTokenInfoCallback& callback) {
     ASSERT_TRUE(tpm_is_enabled_succeeded_);
     ASSERT_FALSE(get_tpm_token_info_succeeded_);
     ASSERT_TRUE(pending_get_tpm_token_info_callback_.is_null());
 
     if (get_tpm_token_info_failure_count_ > 0) {
       --get_tpm_token_info_failure_count_;
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
@@ skipping 30 matching lines @@
     // Called synchronously for convenience (to avoid using extra RunLoop in
     // tests). Unlike with other Cryptohome callbacks, TPMTokenInfoGetter does
     // not rely on this callback being called asynchronously.
     pending_get_tpm_token_info_callback_.Run(
         chromeos::DBUS_METHOD_CALL_SUCCESS,
         tpm_token_info_.name,
         tpm_token_info_.pin,
         tpm_token_info_.slot_id);
   }
 
-  std::string user_id_;
+  AccountId account_id_;
   bool tpm_is_enabled_;
   int tpm_is_enabled_failure_count_;
   bool tpm_is_enabled_succeeded_;
   int get_tpm_token_info_failure_count_;
   int get_tpm_token_info_not_set_count_;
   bool get_tpm_token_info_succeeded_;
   Pkcs11GetTpmTokenInfoCallback pending_get_tpm_token_info_callback_;
   TestTPMTokenInfo tpm_token_info_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCryptohomeClient);
 };
 
 class SystemTPMTokenInfoGetterTest : public testing::Test {
  public:
   SystemTPMTokenInfoGetterTest() {}
   ~SystemTPMTokenInfoGetterTest() override {}
 
   void SetUp() override {
-    cryptohome_client_.reset(new TestCryptohomeClient(std::string()));
+    cryptohome_client_.reset(new TestCryptohomeClient(EmptyAccountId()));
     tpm_token_info_getter_ =
         chromeos::TPMTokenInfoGetter::CreateForSystemToken(
             cryptohome_client_.get(),
             scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
   }
 
  protected:
   scoped_ptr<TestCryptohomeClient> cryptohome_client_;
   scoped_ptr<chromeos::TPMTokenInfoGetter> tpm_token_info_getter_;
 
   std::vector<int64_t> delays_;
 
  private:
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTPMTokenInfoGetterTest);
 };
 
 class UserTPMTokenInfoGetterTest : public testing::Test {
  public:
-  UserTPMTokenInfoGetterTest() : user_id_("user") {}
+  UserTPMTokenInfoGetterTest()
+      : account_id_(AccountId::FromUserEmail("user")) {}
   ~UserTPMTokenInfoGetterTest() override {}
 
   void SetUp() override {
-    cryptohome_client_.reset(new TestCryptohomeClient(user_id_));
-    tpm_token_info_getter_ =
-        chromeos::TPMTokenInfoGetter::CreateForUserToken(
-            user_id_,
-            cryptohome_client_.get(),
-            scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
+    cryptohome_client_.reset(new TestCryptohomeClient(account_id_));
+    tpm_token_info_getter_ = chromeos::TPMTokenInfoGetter::CreateForUserToken(
+        account_id_, cryptohome_client_.get(),
+        scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
   }
 
  protected:
   scoped_ptr<TestCryptohomeClient> cryptohome_client_;
   scoped_ptr<chromeos::TPMTokenInfoGetter> tpm_token_info_getter_;
 
-  std::string user_id_;
+  const AccountId account_id_;
   std::vector<int64_t> delays_;
 
  private:
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(UserTPMTokenInfoGetterTest);
 };
 
 TEST_F(SystemTPMTokenInfoGetterTest, BasicFlow) {
   TestTPMTokenInfo reported_info;
@@ skipping 226 matching lines @@
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
   const int64_t kExpectedDelays[] = {100};
   EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
                                  kExpectedDelays + arraysize(kExpectedDelays)),
             delays_);
 }
 
 }  // namespace