Replace c/b/nss_context by a KeyedService.

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 32 matching lines @@
                             bool success) {
   runner->PostTask(FROM_HERE, base::Bind(callback, success));
 }
 
 }  // namespace
 
 static TPMTokenLoader* g_tpm_token_loader = NULL;
 
 // static
 void TPMTokenLoader::Initialize() {
+  if (g_tpm_token_loader && g_tpm_token_loader->initialized_for_test_)
+    return;
   CHECK(!g_tpm_token_loader);
   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*/);
 }
 
@@ skipping 36 matching lines @@
     const scoped_refptr<base::SequencedTaskRunner>& crypto_task_runner) {
   crypto_task_runner_ = crypto_task_runner;
   MaybeStartTokenInitialization();
 }
 
 TPMTokenLoader::~TPMTokenLoader() {
   if (!initialized_for_test_ && LoginState::IsInitialized())
     LoginState::Get()->RemoveObserver(this);
 }
 
-void TPMTokenLoader::AddObserver(TPMTokenLoader::Observer* observer) {
-  observers_.AddObserver(observer);
+TPMTokenLoader::TPMTokenStatus TPMTokenLoader::IsTPMTokenEnabled(
+    const TPMReadyCallback& callback) {
+  if (tpm_token_state_ == TPM_TOKEN_INITIALIZED)
+    return TPM_TOKEN_STATUS_ENABLED;
+  if (!IsTPMLoadingEnabled() || tpm_token_state_ == TPM_DISABLED)
+    return TPM_TOKEN_STATUS_DISABLED;
+  // Status is not known yet.
+  if (!callback.is_null())
+    tpm_ready_callback_list_.push_back(callback);
+  return TPM_TOKEN_STATUS_UNDETERMINED;
 }
 
-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;
+bool TPMTokenLoader::IsTPMLoadingEnabled() const {
+  // TPM loading is enabled on non-ChromeOS environments, e.g. when running
+  // tests on Linux.
+  // Treat TPM as disabled for guest users since they do not store certs.
+  return initialized_for_test_ || (base::SysInfo::IsRunningOnChromeOS() &&
+                                   LoginState::Get()->IsGuestSessionUser());
 }
 
 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 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()->IsGuestSessionUser())
+  if (!IsTPMLoadingEnabled())
     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_;
@@ skipping 79 matching lines @@
 
   if (call_status == DBUS_METHOD_CALL_SUCCESS && tpm_is_enabled)
     tpm_token_state_ = TPM_ENABLED;
   else
     tpm_token_state_ = TPM_DISABLED;
 
   ContinueTokenInitialization();
 }
 
 void TPMTokenLoader::OnPkcs11IsTpmTokenReady(DBusMethodCallStatus call_status,
-                                         bool is_tpm_token_ready) {
+                                             bool is_tpm_token_ready) {
   VLOG(1) << "OnPkcs11IsTpmTokenReady: " << is_tpm_token_ready;
 
   if (call_status == DBUS_METHOD_CALL_FAILURE || !is_tpm_token_ready) {
     RetryTokenInitializationLater();
     return;
   }
 
   tpm_token_state_ = TPM_TOKEN_READY;
   ContinueTokenInitialization();
 }
@@ skipping 20 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());
+  DCHECK(tpm_token_state_ == TPM_DISABLED ||
+         tpm_token_state_ == TPM_TOKEN_INITIALIZED);
+  bool tpm_status = tpm_token_state_ == TPM_TOKEN_INITIALIZED;
+  for (TPMReadyCallbackList::iterator i = tpm_ready_callback_list_.begin();
+       i != tpm_ready_callback_list_.end();
+       ++i) {
+    i->Run(tpm_status);
+  }
+  tpm_ready_callback_list_.clear();
 }
 
 void TPMTokenLoader::LoggedInStateChanged() {
   VLOG(1) << "LoggedInStateChanged";
   MaybeStartTokenInitialization();
 }
 
 }  // namespace chromeos