Delay creating easy signin TPM keys until TPM is initialized

chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_unittest.cc

Index: chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_unittest.cc
diff --git a/chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_unittest.cc b/chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_unittest.cc
index 286a85ed0ae81d7c0f2a0ee1095319816c39c3c9..ee93c65355e2c788898330b8b364dd7240d850da 100644
--- a/chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_unittest.cc
+++ b/chrome/browser/chromeos/login/easy_unlock/easy_unlock_tpm_key_manager_unittest.cc
@@ -23,7 +23,9 @@
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "crypto/scoped_test_nss_chromeos_user.h"
 #include "crypto/scoped_test_system_nss_key_slot.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -200,7 +202,8 @@ class EasyUnlockTpmKeyManagerTest : public testing::Test {
 
   void SetUp() override {
     ASSERT_TRUE(profile_manager_.SetUp());
-    user_manager_->AddUser(kTestUserId);
+    const user_manager::User* user = user_manager_->AddUser(kTestUserId);
+    username_hash_ = user->username_hash();
 
     signin_profile_ = profile_manager_.CreateTestingProfile(
         chrome::kInitialProfile,
@@ -220,10 +223,53 @@ class EasyUnlockTpmKeyManagerTest : public testing::Test {
   }
 
   void TearDown() override {
+    if (test_nss_user_)
+      ResetTestNssUser();
     profile_manager_.DeleteTestingProfile(kTestUserId);
     profile_manager_.DeleteTestingProfile(chrome::kInitialProfile);
   }
 
+  bool InitTestNssUser() {
+    bool success = false;
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&EasyUnlockTpmKeyManagerTest::InitTestNssUserOnIOThread,
+                   base::Unretained(this), base::Unretained(&success)),
+        run_loop.QuitClosure());
+    run_loop.Run();
+    return success;
+  }
+
+  void InitTestNssUserOnIOThread(bool* success) {
+    test_nss_user_.reset(new crypto::ScopedTestNSSChromeOSUser(username_hash_));
+    *success = test_nss_user_->constructed_successfully();
+  }
+
+  void FinalizeTestNssUser() {
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&EasyUnlockTpmKeyManagerTest::FinalizeTestNssUserOnIOThread,
+                   base::Unretained(this)),
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void FinalizeTestNssUserOnIOThread() { test_nss_user_->FinishInit(); }
+
+  void ResetTestNssUser() {
+    base::RunLoop run_loop;
+    content::BrowserThread::PostTaskAndReply(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&EasyUnlockTpmKeyManagerTest::ResetTestNssUserOnIOThread,
+                   base::Unretained(this)),
+        run_loop.QuitClosure());
+    run_loop.Run();
+  }
+
+  void ResetTestNssUserOnIOThread() { test_nss_user_.reset(); }
+
   // Creates and sets test system NSS key slot.
   bool SetUpTestSystemSlot() {
     test_system_slot_.reset(new crypto::ScopedTestSystemNSSKeySlot());
@@ -283,6 +329,7 @@ class EasyUnlockTpmKeyManagerTest : public testing::Test {
 
   // The NSS system slot used by EasyUnlockTPMKeyManagers in tests.
   scoped_ptr<crypto::ScopedTestSystemNSSKeySlot> test_system_slot_;
+  scoped_ptr<crypto::ScopedTestNSSChromeOSUser> test_nss_user_;
 
   // Needed to properly set up signin and user profiles for test.
   user_manager::FakeUserManager* user_manager_;
@@ -294,10 +341,15 @@ class EasyUnlockTpmKeyManagerTest : public testing::Test {
   TestingProfile* user_profile_;
   TestingProfile* signin_profile_;
 
+  // The test user's username hash.
+  std::string username_hash_;
+
   DISALLOW_COPY_AND_ASSIGN(EasyUnlockTpmKeyManagerTest);
 };
 
 TEST_F(EasyUnlockTpmKeyManagerTest, CreateKeyPair) {
+  ASSERT_TRUE(InitTestNssUser());
+
   base::RunLoop run_loop;
   EXPECT_TRUE(user_key_manager()->GetPublicTpmKey(kTestUserId).empty());
   EXPECT_TRUE(signin_key_manager()->GetPublicTpmKey(kTestUserId).empty());
@@ -307,6 +359,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, CreateKeyPair) {
   EXPECT_TRUE(user_key_manager()->GetPublicTpmKey(kTestUserId).empty());
 
   ASSERT_TRUE(SetUpTestSystemSlot());
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();
   run_loop.Run();
 
   EXPECT_FALSE(user_key_manager()->GetPublicTpmKey(kTestUserId).empty());
@@ -319,6 +373,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, CreateKeyPair) {
 }
 
 TEST_F(EasyUnlockTpmKeyManagerTest, CreateKeyPairMultipleCallbacks) {
+  ASSERT_TRUE(InitTestNssUser());
+
   int callback_count = 0;
   base::RunLoop run_loop;
 
@@ -336,6 +392,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, CreateKeyPairMultipleCallbacks) {
       false /* check_private_key */, base::Closure()));
 
   ASSERT_TRUE(SetUpTestSystemSlot());
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();
   EXPECT_EQ(0, callback_count);
 
   run_loop.Run();
@@ -350,7 +408,7 @@ TEST_F(EasyUnlockTpmKeyManagerTest, CreateKeyPairMultipleCallbacks) {
       base::Bind(&ExpectNotCalledCallback)));
 }
 
-TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefs) {
+TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInPrefs) {
   SetLocalStatePublicKey(
       kTestUserId, std::string(kTestPublicKey, arraysize(kTestPublicKey)));
 
@@ -365,7 +423,9 @@ TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefs) {
             signin_key_manager()->GetPublicTpmKey(kTestUserId));
 }
 
-TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefsCheckPrivateKey) {
+TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInPrefsCheckPrivateKey) {
+  ASSERT_TRUE(InitTestNssUser());
+
   SetLocalStatePublicKey(
       kTestUserId, std::string(kTestPublicKey, arraysize(kTestPublicKey)));
 
@@ -375,6 +435,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefsCheckPrivateKey) {
       run_loop.QuitClosure()));
 
   ASSERT_TRUE(SetUpTestSystemSlot());
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();
   run_loop.Run();
 
   EXPECT_FALSE(user_key_manager()->GetPublicTpmKey(kTestUserId).empty());
@@ -384,8 +446,11 @@ TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefsCheckPrivateKey) {
             signin_key_manager()->GetPublicTpmKey(kTestUserId));
 }
 
-TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefsCheckPrivateKey_OK) {
+TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInPrefsCheckPrivateKey_OK) {
+  ASSERT_TRUE(InitTestNssUser());
   ASSERT_TRUE(SetUpTestSystemSlot());
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();

[pneubeck (no reviews), 2015/05/12 12:21:44]

why not the EXPECT_FALSE into the FinalizeTestNssUser and calling it
CheckKeyGenerationAndFinalizeTestNssUser or similar?

at least that would move all the distributed assertions to a single place and
allow you to add a comment describing the rational behind that.

[tbarzic, 2015/05/12 17:10:47]

Done.

   ASSERT_TRUE(ImportPrivateKey(kTestPrivateKey,  arraysize(kTestPrivateKey)));
   SetLocalStatePublicKey(
       kTestUserId, std::string(kTestPublicKey, arraysize(kTestPublicKey)));
@@ -415,6 +480,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, PublicKeySetInUserPrefsCheckPrivateKey_OK) {
 }
 
 TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotTimeoutTriggers) {
+  ASSERT_TRUE(InitTestNssUser());
+
   base::RunLoop run_loop;
   ASSERT_FALSE(user_key_manager()->PrepareTpmKey(
       false /* check_private_key */,
@@ -425,6 +492,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotTimeoutTriggers) {
   run_loop_get_slot_timeout.RunUntilIdle();
 
   ASSERT_TRUE(SetUpTestSystemSlot());
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();
 
   run_loop.Run();
 
@@ -432,12 +501,15 @@ TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotTimeoutTriggers) {
 }
 
 TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotTimeoutAfterSlotFetched) {
+  ASSERT_TRUE(InitTestNssUser());
   base::RunLoop run_loop;
   ASSERT_FALSE(user_key_manager()->PrepareTpmKey(
       false /* check_private_key */,
       run_loop.QuitClosure()));
 
   base::RunLoop run_loop_slot;
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();
   ASSERT_TRUE(SetUpTestSystemSlot());
   run_loop_slot.RunUntilIdle();
 
@@ -449,6 +521,7 @@ TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotTimeoutAfterSlotFetched) {
 }
 
 TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotRetryAfterFailure) {
+  ASSERT_TRUE(InitTestNssUser());
   base::RunLoop run_loop;
   ASSERT_FALSE(user_key_manager()->PrepareTpmKey(
       false /* check_private_key */,
@@ -469,6 +542,8 @@ TEST_F(EasyUnlockTpmKeyManagerTest, GetSystemSlotRetryAfterFailure) {
       run_loop_retry.QuitClosure()));
 
   ASSERT_TRUE(SetUpTestSystemSlot());
+  EXPECT_FALSE(user_key_manager()->StartedCreatingTpmKeys());
+  FinalizeTestNssUser();
 
   run_loop_retry.Run();