Fix CertLoader certificates_loaded() during notification.

chromeos/cert_loader.cc

 // Copyright (c) 2013 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/cert_loader.h"
 
 #include <algorithm>
 
 #include "base/chromeos/chromeos_version.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 26 matching lines @@
 
   // 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 LoadNSSCertificates(net::CertificateList* cert_list) {
-  if (base::chromeos::IsRunningOnChromeOS())
-    net::NSSCertDatabase::GetInstance()->ListCerts(cert_list);
+  net::NSSCertDatabase::GetInstance()->ListCerts(cert_list);
 }
 
 void CallOpenPersistentNSSDB() {
   // Called from crypto_task_runner_.
   VLOG(1) << "CallOpenPersistentNSSDB";
 
   // Ensure we've opened the user's key/certificate database.
   crypto::OpenPersistentNSSDB();
-  if (base::chromeos::IsRunningOnChromeOS())
-    crypto::EnableTPMTokenForNSS();
+  crypto::EnableTPMTokenForNSS();
 }
 
 }  // namespace
 
 static CertLoader* g_cert_loader = NULL;
 // static
 void CertLoader::Initialize() {
   CHECK(!g_cert_loader);
   g_cert_loader = new CertLoader();
   g_cert_loader->Init();
 }
 
 // static
 void CertLoader::Shutdown() {
   CHECK(g_cert_loader);
   delete g_cert_loader;
   g_cert_loader = NULL;
 }
 
 // static
 CertLoader* CertLoader::Get() {
-  CHECK(g_cert_loader)
-      << "CertLoader::Get() called before Initialize()";
+  CHECK(g_cert_loader) << "CertLoader::Get() called before Initialize()";
   return g_cert_loader;
 }
 
 // static
 bool CertLoader::IsInitialized() {
   return g_cert_loader;
 }
 
 CertLoader::CertLoader()
     : certificates_requested_(false),
@@ skipping 52 matching lines @@
   const bool logged_in = LoginState::IsInitialized() ?
       LoginState::Get()->IsUserLoggedIn() : false;
   VLOG(1) << "RequestCertificates: " << logged_in;
   if (!logged_in)
     return;
 
   certificates_requested_ = true;
 
   // Ensure we only initialize the TPM token once.
   DCHECK_EQ(tpm_token_state_, TPM_STATE_UNKNOWN);
+  if (!base::chromeos::IsRunningOnChromeOS())
+    tpm_token_state_ = TPM_DISABLED;
+
   InitializeTokenAndLoadCertificates();
 }
 
 void CertLoader::InitializeTokenAndLoadCertificates() {
   CHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "InitializeTokenAndLoadCertificates: " << tpm_token_state_;
 
   switch (tpm_token_state_) {
     case TPM_STATE_UNKNOWN: {
       crypto_task_runner_->PostTaskAndReply(
@@ skipping 22 matching lines @@
     }
     case TPM_TOKEN_READY: {
       // Retrieve token_name_ and user_pin_ here since they will never change
       // and CryptohomeClient calls are not thread safe.
       DBusThreadManager::Get()->GetCryptohomeClient()->Pkcs11GetTpmTokenInfo(
           base::Bind(&CertLoader::OnPkcs11GetTpmTokenInfo,
                      initialize_token_factory_.GetWeakPtr()));
       return;
     }
     case TPM_TOKEN_INFO_RECEIVED: {
-      if (base::chromeos::IsRunningOnChromeOS()) {
-        base::PostTaskAndReplyWithResult(
-            crypto_task_runner_.get(),
-            FROM_HERE,
-            base::Bind(&crypto::InitializeTPMToken,
-                       tpm_token_name_, tpm_user_pin_),
-            base::Bind(&CertLoader::OnTPMTokenInitialized,
-                       initialize_token_factory_.GetWeakPtr()));
-        return;
-      }
+      base::PostTaskAndReplyWithResult(
+          crypto_task_runner_.get(),
+          FROM_HERE,
+          base::Bind(
+              &crypto::InitializeTPMToken, tpm_token_name_, tpm_user_pin_),
+          base::Bind(&CertLoader::OnTPMTokenInitialized,
+                     initialize_token_factory_.GetWeakPtr()));
+      return;
       tpm_token_state_ = TPM_TOKEN_INITIALIZED;
       // FALL_THROUGH_INTENDED
     }
     case TPM_TOKEN_INITIALIZED: {
       StartLoadCertificates();
       return;
     }
   }
 }
 
@@ skipping 122 matching lines @@
 }
 
 void CertLoader::UpdateCertificates(net::CertificateList* cert_list) {
   CHECK(thread_checker_.CalledOnValidThread());
   DCHECK(certificates_update_running_);
   VLOG(1) << "UpdateCertificates: " << cert_list->size();
 
   // Ignore any existing certificates.
   cert_list_.swap(*cert_list);
 
-  NotifyCertificatesLoaded(!certificates_loaded_);
+  bool initial_load = !certificates_loaded_;
   certificates_loaded_ = true;
+  NotifyCertificatesLoaded(initial_load);
 
   certificates_update_running_ = false;
   if (certificates_update_required_)
     StartLoadCertificates();
 }
 
 void CertLoader::NotifyCertificatesLoaded(bool initial_load) {
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCertificatesLoaded(cert_list_, initial_load));
 }
@@ skipping 10 matching lines @@
   VLOG(1) << "OnCertRemoved";
   StartLoadCertificates();
 }
 
 void CertLoader::LoggedInStateChanged(LoginState::LoggedInState state) {
   VLOG(1) << "LoggedInStateChanged: " << state;
   MaybeRequestCertificates();
 }
 
 }  // namespace chromeos