Remove usage of singleton software_slot_ in nss on ChromeOS

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 20 matching lines @@
   base::TimeDelta next_delay = last_delay * 2;
 
   // Cap the delay to prevent an overflow. This threshold is arbitrarily chosen.
   const base::TimeDelta max_delay =
       base::TimeDelta::FromMilliseconds(kMaxRequestDelayMs);
   if (next_delay > max_delay)
     next_delay = max_delay;
   return next_delay;
 }
 
-void CallOpenPersistentNSSDB() {
-  // Called from crypto_task_runner_.
-  VLOG(1) << "CallOpenPersistentNSSDB";
-
-  // Ensure we've opened the user's key/certificate database.
-  if (base::SysInfo::IsRunningOnChromeOS())
-    crypto::OpenPersistentNSSDB();
-  crypto::EnableTPMTokenForNSS();
-}
-
 void PostResultToTaskRunner(scoped_refptr<base::SequencedTaskRunner> runner,
                             const base::Callback<void(bool)>& callback,
                             bool success) {
   runner->PostTask(FROM_HERE, base::Bind(callback, success));
 }
 
 }  // namespace
 
 static TPMTokenLoader* g_tpm_token_loader = NULL;
 
@@ skipping 72 matching lines @@
   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 start_initialization = LoginState::Get()->IsUserLoggedIn() ||
-      LoginState::Get()->IsInSafeMode();
+  bool start_initialization = LoginState::Get()->IsUserLoggedIn();
 
   VLOG(1) << "StartTokenInitialization: " << start_initialization;
   if (!start_initialization)
     return;
 
   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);
 }
 
 void TPMTokenLoader::ContinueTokenInitialization() {
   CHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "ContinueTokenInitialization: " << tpm_token_state_;
 
   switch (tpm_token_state_) {
     case TPM_STATE_UNKNOWN: {
       crypto_task_runner_->PostTaskAndReply(
           FROM_HERE,
-          base::Bind(&CallOpenPersistentNSSDB),
-          base::Bind(&TPMTokenLoader::OnPersistentNSSDBOpened,
+          base::Bind(&crypto::EnableTPMTokenForNSS),
+          base::Bind(&TPMTokenLoader::OnTPMTokenEnabledForNSS,
                      weak_factory_.GetWeakPtr()));
       tpm_token_state_ = TPM_INITIALIZATION_STARTED;
       return;
     }
     case TPM_INITIALIZATION_STARTED: {
       NOTREACHED();
       return;
     }
-    case TPM_DB_OPENED: {
+    case TPM_TOKEN_ENABLED_FOR_NSS: {
       DBusThreadManager::Get()->GetCryptohomeClient()->TpmIsEnabled(
           base::Bind(&TPMTokenLoader::OnTpmIsEnabled,
                      weak_factory_.GetWeakPtr()));
       return;
     }
     case TPM_DISABLED: {
       // TPM is disabled, so proceed with empty tpm token name.
       NotifyTPMTokenReady();
       return;
     }
@@ skipping 34 matching lines @@
   CHECK(thread_checker_.CalledOnValidThread());
   LOG(WARNING) << "Retry token initialization later.";
   base::MessageLoopProxy::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&TPMTokenLoader::ContinueTokenInitialization,
                  weak_factory_.GetWeakPtr()),
       tpm_request_delay_);
   tpm_request_delay_ = GetNextRequestDelayMs(tpm_request_delay_);
 }
 
-void TPMTokenLoader::OnPersistentNSSDBOpened() {
-  VLOG(1) << "PersistentNSSDBOpened";
-  tpm_token_state_ = TPM_DB_OPENED;
+void TPMTokenLoader::OnTPMTokenEnabledForNSS() {
+  VLOG(1) << "TPMTokenEnabledForNSS";
+  tpm_token_state_ = TPM_TOKEN_ENABLED_FOR_NSS;
   ContinueTokenInitialization();
 }
 
 void TPMTokenLoader::OnTpmIsEnabled(DBusMethodCallStatus call_status,
                                     bool tpm_is_enabled) {
   VLOG(1) << "OnTpmIsEnabled: " << tpm_is_enabled;
 
   if (call_status == DBUS_METHOD_CALL_SUCCESS && tpm_is_enabled)
     tpm_token_state_ = TPM_ENABLED;
   else
@@ skipping 47 matching lines @@
 void TPMTokenLoader::NotifyTPMTokenReady() {
   FOR_EACH_OBSERVER(Observer, observers_, OnTPMTokenReady());
 }
 
 void TPMTokenLoader::LoggedInStateChanged() {
   VLOG(1) << "LoggedInStateChanged";
   MaybeStartTokenInitialization();
 }
 
 }  // namespace chromeos