crypto/nss_util: Get TPM slot id, do lookup by id instead of by name.

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/message_loop/message_loop_proxy.h"
 #include "base/observer_list.h"
@@ skipping 76 matching lines @@
 
 CertLoader::CertLoader()
     : initialize_tpm_for_test_(false),
       certificates_requested_(false),
       certificates_loaded_(false),
       certificates_update_required_(false),
       certificates_update_running_(false),
       tpm_token_state_(TPM_STATE_UNKNOWN),
       tpm_request_delay_(
           base::TimeDelta::FromMilliseconds(kInitialRequestDelayMs)),
+      tpm_token_slot_id_(-1),
       initialize_token_factory_(this),
       update_certificates_factory_(this) {
   if (LoginState::IsInitialized())
     LoginState::Get()->AddObserver(this);
 }
 
 void CertLoader::InitializeTPMForTest() {
   initialize_tpm_for_test_ = true;
 }
 
@@ skipping 97 matching lines @@
       // 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: {
       base::PostTaskAndReplyWithResult(
           crypto_task_runner_.get(),
           FROM_HERE,
-          base::Bind(
-              &crypto::InitializeTPMToken, tpm_token_name_, tpm_user_pin_),
+          base::Bind(&crypto::InitializeTPMToken,
+                     tpm_token_name_,
+                     tpm_token_slot_id_,
+                     tpm_user_pin_),
           base::Bind(&CertLoader::OnTPMTokenInitialized,
                      initialize_token_factory_.GetWeakPtr()));
       return;
     }
     case TPM_TOKEN_INITIALIZED: {
       StartLoadCertificates();
       return;
     }
   }
 }
@@ skipping 65 matching lines @@
     return;
   }
 
   tpm_token_state_ = TPM_TOKEN_READY;
   InitializeTokenAndLoadCertificates();
 }
 
 void CertLoader::OnPkcs11GetTpmTokenInfo(DBusMethodCallStatus call_status,
                                          const std::string& token_name,
                                          const std::string& user_pin,
-                                         int token_slot) {
+                                         int token_slot_id) {
   VLOG(1) << "OnPkcs11GetTpmTokenInfo: " << token_name;
 
   if (call_status == DBUS_METHOD_CALL_FAILURE) {
     RetryTokenInitializationLater();
     return;
   }
 
   tpm_token_name_ = token_name;
-  tpm_token_slot_ = base::IntToString(token_slot);
+  tpm_token_slot_id_ = token_slot_id;
   tpm_user_pin_ = user_pin;
   tpm_token_state_ = TPM_TOKEN_INFO_RECEIVED;
 
   InitializeTokenAndLoadCertificates();
 }
 
 void CertLoader::OnTPMTokenInitialized(bool success) {
   VLOG(1) << "OnTPMTokenInitialized: " << success;
   if (!success) {
     RetryTokenInitializationLater();
@@ skipping 67 matching lines @@
   VLOG(1) << "OnCertRemoved";
   LoadCertificates();
 }
 
 void CertLoader::LoggedInStateChanged() {
   VLOG(1) << "LoggedInStateChanged";
   MaybeRequestCertificates();
 }
 
 }  // namespace chromeos