Use user specific NSSDatabase in CertLoader.

chromeos/tpm_token_loader.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 "chromeos/tpm_token_loader.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 37 matching lines @@
   crypto::EnableTPMTokenForNSS();
 }
 
 }  // namespace
 
 static TPMTokenLoader* g_tpm_token_loader = NULL;
 
 // static
 void TPMTokenLoader::Initialize() {
   CHECK(!g_tpm_token_loader);
-  g_tpm_token_loader = new TPMTokenLoader();
+  g_tpm_token_loader = new TPMTokenLoader(false /*for_test*/);
 }
 
 // static
+void TPMTokenLoader::InitializeForTest() {
+  CHECK(!g_tpm_token_loader);
+  g_tpm_token_loader = new TPMTokenLoader(true /*for_test*/);
+}
+
+// static
 void TPMTokenLoader::Shutdown() {
   CHECK(g_tpm_token_loader);
   delete g_tpm_token_loader;
   g_tpm_token_loader = NULL;
 }
 
 // static
 TPMTokenLoader* TPMTokenLoader::Get() {
   CHECK(g_tpm_token_loader)
       << "TPMTokenLoader::Get() called before Initialize()";
   return g_tpm_token_loader;
 }
 
 // static
 bool TPMTokenLoader::IsInitialized() {
   return g_tpm_token_loader;
 }
 
-TPMTokenLoader::TPMTokenLoader()
-    : initialize_tpm_for_test_(false),
+TPMTokenLoader::TPMTokenLoader(bool for_test)
+    : initialized_for_test_(for_test),
       tpm_token_state_(TPM_STATE_UNKNOWN),
       tpm_request_delay_(
           base::TimeDelta::FromMilliseconds(kInitialRequestDelayMs)),
       tpm_token_slot_id_(-1),
       weak_factory_(this) {
-  if (LoginState::IsInitialized())
+  if (!initialized_for_test_ && LoginState::IsInitialized())
     LoginState::Get()->AddObserver(this);
-}
 
-void TPMTokenLoader::InitializeTPMForTest() {
-  initialize_tpm_for_test_ = true;
+  if (initialized_for_test_) {
+    tpm_token_state_ = TPM_TOKEN_INITIALIZED;
+    tpm_user_pin_ = "111111";
+  }
 }
 
 void TPMTokenLoader::SetCryptoTaskRunner(
     const scoped_refptr<base::SequencedTaskRunner>& crypto_task_runner) {
   crypto_task_runner_ = crypto_task_runner;
   MaybeStartTokenInitialization();
 }
 
 TPMTokenLoader::~TPMTokenLoader() {
-  if (LoginState::IsInitialized())
+  if (!initialized_for_test_ && LoginState::IsInitialized())
     LoginState::Get()->RemoveObserver(this);
 }
 
 void TPMTokenLoader::AddObserver(TPMTokenLoader::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void TPMTokenLoader::RemoveObserver(TPMTokenLoader::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool TPMTokenLoader::IsTPMTokenReady() const {
   return tpm_token_state_ == TPM_DISABLED ||
          tpm_token_state_ == TPM_TOKEN_INITIALIZED;
 }
 
 void TPMTokenLoader::MaybeStartTokenInitialization() {
   CHECK(thread_checker_.CalledOnValidThread());
 
   // This is the entry point to the TPM token initialization process,
   // which we should do at most once.
   if (tpm_token_state_ != TPM_STATE_UNKNOWN || !crypto_task_runner_.get())
     return;
 
   if (!LoginState::IsInitialized())
     return;
 
-  bool request_certificates = LoginState::Get()->IsUserLoggedIn() ||
+  bool start_initialization = LoginState::Get()->IsUserLoggedIn() ||
       LoginState::Get()->IsInSafeMode();
 
-  VLOG(1) << "RequestCertificates: " << request_certificates;
-  if (!request_certificates)
+  VLOG(1) << "StartTokenInitialization: " << start_initialization;
+  if (!start_initialization)
     return;
 
-  if (!initialize_tpm_for_test_ && !base::SysInfo::IsRunningOnChromeOS())
+  if (!base::SysInfo::IsRunningOnChromeOS())
     tpm_token_state_ = TPM_DISABLED;
 
   // Treat TPM as disabled for guest users since they do not store certs.
   if (LoginState::Get()->IsGuestUser())
     tpm_token_state_ = TPM_DISABLED;
 
   ContinueTokenInitialization();
 
   DCHECK_NE(tpm_token_state_, TPM_STATE_UNKNOWN);
 }
@@ skipping 122 matching lines @@
   VLOG(1) << "OnTPMTokenInitialized: " << success;
   if (!success) {
     RetryTokenInitializationLater();
     return;
   }
   tpm_token_state_ = TPM_TOKEN_INITIALIZED;
   ContinueTokenInitialization();
 }
 
 void TPMTokenLoader::NotifyTPMTokenReady() {
-  FOR_EACH_OBSERVER(Observer, observers_,
-      OnTPMTokenReady(tpm_user_pin_, tpm_token_name_, tpm_token_slot_id_));
+  FOR_EACH_OBSERVER(Observer, observers_, OnTPMTokenReady());
 }
 
 void TPMTokenLoader::LoggedInStateChanged() {
   VLOG(1) << "LoggedInStateChanged";
   MaybeStartTokenInitialization();
 }
 
 }  // namespace chromeos