Remove TPMTokenInfoDelegate

crypto/nss_util.h

 // Copyright (c) 2012 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.
 
 #ifndef CRYPTO_NSS_UTIL_H_
 #define CRYPTO_NSS_UTIL_H_
 #pragma once
 
 #include <string>
 #include "base/basictypes.h"
-#include "base/callback.h"
 #include "crypto/crypto_export.h"
 
 #if defined(USE_NSS)
 class FilePath;
 #endif  // defined(USE_NSS)
 
 namespace base {
 class Lock;
 class Time;
 }  // namespace base
 
 // This file specifically doesn't depend on any NSS or NSPR headers because it
 // is included by various (non-crypto) parts of chrome to call the
 // initialization functions.
 namespace crypto {
 
 class SymmetricKey;
 
-// A callback to handle the result of InitializeTPMToken.
-typedef base::Callback<void(bool result)> InitializeTPMTokenCallback;
-
 #if defined(USE_NSS)
 // EarlySetupForNSSInit performs lightweight setup which must occur before the
 // process goes multithreaded. This does not initialise NSS. For test, see
 // EnsureNSSInit.
 CRYPTO_EXPORT void EarlySetupForNSSInit();
 #endif
 
 // Initialize NRPR if it isn't already initialized.  This function is
 // thread-safe, and NSPR will only ever be initialized once.
 CRYPTO_EXPORT void EnsureNSPRInit();
@@ skipping 43 matching lines @@
 // Check if the current NSS version is greater than or equals to |version|.
 // A sample version string is "3.12.3".
 bool CheckNSSVersion(const char* version);
 
 #if defined(OS_CHROMEOS)
 // Open the r/w nssdb that's stored inside the user's encrypted home
 // directory.  This is the default slot returned by
 // GetPublicNSSKeySlot().
 CRYPTO_EXPORT void OpenPersistentNSSDB();
 
-// A delegate class that we can use to access the cros API for
-// communication with cryptohomed and the TPM.
-class CRYPTO_EXPORT TPMTokenInfoDelegate {
- public:
-  // A callback to handle the result of RequestIsTokenReady.
-  typedef base::Callback<void(bool result)> RequestIsTokenReadyCallback;
-
-  TPMTokenInfoDelegate();
-  virtual ~TPMTokenInfoDelegate();
-
-  // Runs |callback| with true if the TPM and PKCS#11 token slot is ready to be
-  // used.
-  // If IsTokenAvailable() is false this should run |callback| with false.
-  // If IsTokenAvailable() is true, this should eventually run |callback| with
-  // true.
-  virtual void RequestIsTokenReady(RequestIsTokenReadyCallback callback) const
-      = 0;
-
-  // Fetches token properties. TODO(stevenjb): make this interface asynchronous
-  // so that the implementation does not have to be blocking.
-  virtual void GetTokenInfo(std::string* token_name,
-                            std::string* user_pin) const = 0;
-};
-
 // Indicates that NSS should load the Chaps library so that we
 // can access the TPM through NSS.  Once this is called,
 // GetPrivateNSSKeySlot() will return the TPM slot if one was found.
-// Takes ownership of the passed-in delegate object so it can access
-// the cros library to talk to cryptohomed.
-CRYPTO_EXPORT void EnableTPMTokenForNSS(TPMTokenInfoDelegate* delegate);
+CRYPTO_EXPORT void EnableTPMTokenForNSS();
 
 // Get name and user PIN for the built-in TPM token on ChromeOS.
 // Either one can safely be NULL.  Should only be called after
 // EnableTPMTokenForNSS has been called with a non-null delegate.
 CRYPTO_EXPORT void GetTPMTokenInfo(std::string* token_name,
                                    std::string* user_pin);
 
 // Returns true if the TPM is owned and PKCS#11 initialized with the
 // user and security officer PINs, and has been enabled in NSS by
 // calling EnableTPMForNSS, and Chaps has been successfully
 // loaded into NSS.
 CRYPTO_EXPORT bool IsTPMTokenReady();
 
 // Initialize the TPM token.  Does nothing if it is already initialized.
-CRYPTO_EXPORT void InitializeTPMToken(InitializeTPMTokenCallback callback);
+CRYPTO_EXPORT bool InitializeTPMToken(const std::string& token_name,
+                                      const std::string& user_pin);
 
 // Gets supplemental user key. Creates one in NSS database if it does not exist.
 // The supplemental user key is used for AES encryption of user data that is
 // stored and protected by cryptohome. This additional layer of encryption of
 // provided to ensure that sensitive data wouldn't be exposed in plain text in
 // case when an attacker would somehow gain access to all content within
 // cryptohome.
 CRYPTO_EXPORT SymmetricKey* GetSupplementalUserKey();
 #endif
 
@@ skipping 32 matching lines @@
  private:
   base::Lock *lock_;
   DISALLOW_COPY_AND_ASSIGN(AutoNSSWriteLock);
 };
 
 #endif  // defined(USE_NSS)
 
 }  // namespace crypto
 
 #endif  // CRYPTO_NSS_UTIL_H_