Extract CryptohomeClientImplStub into its own files.

This only moves code without changing any functionality.
This allows to expose the CryptohomeClientImplStub type and extend the class about *ForTest functions in the next step.

BUG=NONE

Review URL: https://chromiumcodereview.appspot.com/22630012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@216835 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 550 insertions, 419 deletions

diff --git a/chromeos/chromeos.gyp b/chromeos/chromeos.gyp
index fa0335f..69d2a67 100644
--- a/chromeos/chromeos.gyp
+++ b/chromeos/chromeos.gyp
@@ -85,6 +85,8 @@
         'dbus/cros_disks_client.h',
         'dbus/cryptohome_client.cc',
         'dbus/cryptohome_client.h',
+        'dbus/cryptohome_client_stub.cc',
+        'dbus/cryptohome_client_stub.h',
         'dbus/dbus_client_implementation_type.h',
         'dbus/dbus_method_call_status.h',
         'dbus/dbus_thread_manager.cc',
diff --git a/chromeos/dbus/cryptohome_client.cc b/chromeos/dbus/cryptohome_client.cc
index 6ba9834..445ba0b 100644
--- a/chromeos/dbus/cryptohome_client.cc
+++ b/chromeos/dbus/cryptohome_client.cc
@@ -5,9 +5,12 @@
 #include "chromeos/dbus/cryptohome_client.h"
 
 #include "base/bind.h"
+#include "base/location.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "chromeos/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/blocking_method_caller.h"
+#include "chromeos/dbus/cryptohome_client_stub.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
@@ -838,425 +841,6 @@ class CryptohomeClientImpl : public CryptohomeClient {
   DISALLOW_COPY_AND_ASSIGN(CryptohomeClientImpl);
 };
 
-// A stub implementaion of CryptohomeClient.
-class CryptohomeClientStubImpl : public CryptohomeClient {
- public:
-  CryptohomeClientStubImpl()
-      : async_call_id_(1),
-        tpm_is_ready_counter_(0),
-        locked_(false),
-        weak_ptr_factory_(this) {
-  }
-
-  virtual ~CryptohomeClientStubImpl() {}
-
-  // CryptohomeClient override.
-  virtual void SetAsyncCallStatusHandlers(
-      const AsyncCallStatusHandler& handler,
-      const AsyncCallStatusWithDataHandler& data_handler) OVERRIDE {
-    async_call_status_handler_ = handler;
-    async_call_status_data_handler_ = data_handler;
-  }
-
-  // CryptohomeClient override.
-  virtual void ResetAsyncCallStatusHandlers() OVERRIDE {
-    async_call_status_handler_.Reset();
-    async_call_status_data_handler_.Reset();
-  }
-
-  // CryptohomeClient override.
-  virtual void IsMounted(const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual bool Unmount(bool* success) OVERRIDE {
-    *success = true;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncCheckKey(const std::string& username,
-                             const std::string& key,
-                             const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncMigrateKey(const std::string& username,
-                               const std::string& from_key,
-                               const std::string& to_key,
-                               const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncRemove(const std::string& username,
-                           const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual bool GetSystemSalt(std::vector<uint8>* salt) OVERRIDE {
-    const char kStubSystemSalt[] = "stub_system_salt";
-    salt->assign(kStubSystemSalt,
-                 kStubSystemSalt + arraysize(kStubSystemSalt) - 1);
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void GetSanitizedUsername(
-      const std::string& username,
-      const StringDBusMethodCallback& callback) OVERRIDE {
-    // Even for stub implementation we have to return different values
-    // so that multi-profiles would work.
-    std::string sanitized_username = GetStubSanitizedUsername(username);
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, sanitized_username));
-  }
-
-  // CryptohomeClient override.
-  virtual std::string BlockingGetSanitizedUsername(
-      const std::string& username) OVERRIDE {
-    return GetStubSanitizedUsername(username);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncMount(const std::string& username,
-                          const std::string& key,
-                          int flags,
-                          const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncAddKey(const std::string& username,
-                           const std::string& key,
-                           const std::string& new_key,
-                           const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncMountGuest(const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncMountPublic(const std::string& public_mount_id,
-                                int flags,
-                                const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmIsReady(const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmIsEnabled(const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual bool CallTpmIsEnabledAndBlock(bool* enabled) OVERRIDE {
-    *enabled = true;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmGetPassword(
-      const StringDBusMethodCallback& callback) OVERRIDE {
-    const char kStubTpmPassword[] = "Stub-TPM-password";
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, kStubTpmPassword));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmIsOwned(const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual bool CallTpmIsOwnedAndBlock(bool* owned) OVERRIDE {
-    *owned = true;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmIsBeingOwned(const BoolDBusMethodCallback& callback)
-      OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual bool CallTpmIsBeingOwnedAndBlock(bool* owning) OVERRIDE {
-    *owning = true;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmCanAttemptOwnership(
-      const VoidDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmClearStoredPassword(const VoidDBusMethodCallback& callback)
-      OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
-  }
-
-  // CryptohomeClient override.
-  virtual bool CallTpmClearStoredPasswordAndBlock() OVERRIDE { return true; }
-
-  // CryptohomeClient override.
-  virtual void Pkcs11IsTpmTokenReady(
-      const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual void Pkcs11GetTpmTokenInfo(
-      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
-    const char kStubLabel[] = "Stub TPM Token";
-    const char kStubUserPin[] = "012345";
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   DBUS_METHOD_CALL_SUCCESS,
-                   std::string(kStubLabel),
-                   std::string(kStubUserPin)));
-  }
-
-  // CryptohomeClient override.
-  virtual bool InstallAttributesGet(const std::string& name,
-                                    std::vector<uint8>* value,
-                                    bool* successful) OVERRIDE {
-    if (install_attrs_.find(name) != install_attrs_.end()) {
-      *value = install_attrs_[name];
-      *successful = true;
-    } else {
-      value->clear();
-      *successful = false;
-    }
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual bool InstallAttributesSet(const std::string& name,
-                                    const std::vector<uint8>& value,
-                                    bool* successful) OVERRIDE {
-    install_attrs_[name] = value;
-    *successful = true;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual bool InstallAttributesFinalize(bool* successful) OVERRIDE {
-    locked_ = true;
-    *successful = true;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void InstallAttributesIsReady(const BoolDBusMethodCallback& callback)
-      OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual bool InstallAttributesIsInvalid(bool* is_invalid) OVERRIDE {
-    *is_invalid = false;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual bool InstallAttributesIsFirstInstall(
-      bool* is_first_install) OVERRIDE {
-    *is_first_install = !locked_;
-    return true;
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationIsPrepared(
-        const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationIsEnrolled(
-        const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncTpmAttestationCreateEnrollRequest(
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, true);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncTpmAttestationEnroll(
-      const std::string& pca_response,
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, false);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncTpmAttestationCreateCertRequest(
-      int options,
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, true);
-  }
-
-  // CryptohomeClient override.
-  virtual void AsyncTpmAttestationFinishCertRequest(
-      const std::string& pca_response,
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, true);
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationDoesKeyExist(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationGetCertificate(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const DataMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationGetPublicKey(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const DataMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationRegisterKey(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, true);
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationSignEnterpriseChallenge(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const std::string& domain,
-      const std::string& device_id,
-      attestation::AttestationChallengeOptions options,
-      const std::string& challenge,
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, true);
-  }
-
-  // CryptohomeClient override.
-  virtual void TpmAttestationSignSimpleChallenge(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const std::string& challenge,
-      const AsyncMethodCallback& callback) OVERRIDE {
-    ReturnAsyncMethodResult(callback, true);
-  }
-
-  virtual void TpmAttestationGetKeyPayload(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const DataMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
-  }
-
-  virtual void TpmAttestationSetKeyPayload(
-      attestation::AttestationKeyType key_type,
-      const std::string& key_name,
-      const std::string& payload,
-      const BoolDBusMethodCallback& callback) OVERRIDE {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
-  }
-
-
- private:
-  // Posts tasks which return fake results to the UI thread.
-  void ReturnAsyncMethodResult(const AsyncMethodCallback& callback,
-                               bool returns_data) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&CryptohomeClientStubImpl::ReturnAsyncMethodResultInternal,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback,
-                   returns_data));
-  }
-
-  // This method is used to implement ReturnAsyncMethodResult.
-  void ReturnAsyncMethodResultInternal(const AsyncMethodCallback& callback,
-                                       bool returns_data) {
-    callback.Run(async_call_id_);
-    if (!returns_data && !async_call_status_handler_.is_null()) {
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(async_call_status_handler_,
-                     async_call_id_,
-                     true,
-                     cryptohome::MOUNT_ERROR_NONE));
-    } else if (returns_data && !async_call_status_data_handler_.is_null()) {
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(async_call_status_data_handler_,
-                     async_call_id_,
-                     true,
-                     std::string()));
-    }
-    ++async_call_id_;
-  }
-
-  int async_call_id_;
-  AsyncCallStatusHandler async_call_status_handler_;
-  AsyncCallStatusWithDataHandler async_call_status_data_handler_;
-  int tpm_is_ready_counter_;
-  std::map<std::string, std::vector<uint8> > install_attrs_;
-  bool locked_;
-  base::WeakPtrFactory<CryptohomeClientStubImpl> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(CryptohomeClientStubImpl);
-};
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/chromeos/dbus/cryptohome_client_stub.cc b/chromeos/dbus/cryptohome_client_stub.cc
new file mode 100644
index 0000000..e9faeec
--- /dev/null
+++ b/chromeos/dbus/cryptohome_client_stub.cc
@@ -0,0 +1,381 @@
+// Copyright 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/dbus/cryptohome_client_stub.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+CryptohomeClientStubImpl::CryptohomeClientStubImpl()
+    : async_call_id_(1),
+      tpm_is_ready_counter_(0),
+      locked_(false),
+      weak_ptr_factory_(this) {}
+
+CryptohomeClientStubImpl::~CryptohomeClientStubImpl() {}
+
+void CryptohomeClientStubImpl::SetAsyncCallStatusHandlers(
+    const AsyncCallStatusHandler& handler,
+    const AsyncCallStatusWithDataHandler& data_handler) {
+  async_call_status_handler_ = handler;
+  async_call_status_data_handler_ = data_handler;
+}
+
+void CryptohomeClientStubImpl::ResetAsyncCallStatusHandlers() {
+  async_call_status_handler_.Reset();
+  async_call_status_data_handler_.Reset();
+}
+
+void CryptohomeClientStubImpl::IsMounted(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+bool CryptohomeClientStubImpl::Unmount(bool* success) {
+  *success = true;
+  return true;
+}
+
+void CryptohomeClientStubImpl::AsyncCheckKey(
+    const std::string& username,
+    const std::string& key,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::AsyncMigrateKey(
+    const std::string& username,
+    const std::string& from_key,
+    const std::string& to_key,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::AsyncRemove(
+    const std::string& username,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+bool CryptohomeClientStubImpl::GetSystemSalt(std::vector<uint8>* salt) {
+  const char kStubSystemSalt[] = "stub_system_salt";
+  salt->assign(kStubSystemSalt,
+               kStubSystemSalt + arraysize(kStubSystemSalt) - 1);
+  return true;
+}
+
+void CryptohomeClientStubImpl::GetSanitizedUsername(
+    const std::string& username,
+    const StringDBusMethodCallback& callback) {
+  // Even for stub implementation we have to return different values so that
+  // multi-profiles would work.
+  std::string sanitized_username = GetStubSanitizedUsername(username);
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, sanitized_username));
+}
+
+std::string CryptohomeClientStubImpl::BlockingGetSanitizedUsername(
+    const std::string& username) {
+  return GetStubSanitizedUsername(username);
+}
+
+void CryptohomeClientStubImpl::AsyncMount(const std::string& username,
+                                          const std::string& key,
+                                          int flags,
+                                          const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::AsyncAddKey(
+    const std::string& username,
+    const std::string& key,
+    const std::string& new_key,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::AsyncMountGuest(
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::AsyncMountPublic(
+    const std::string& public_mount_id,
+    int flags,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::TpmIsReady(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+void CryptohomeClientStubImpl::TpmIsEnabled(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+bool CryptohomeClientStubImpl::CallTpmIsEnabledAndBlock(bool* enabled) {
+  *enabled = true;
+  return true;
+}
+
+void CryptohomeClientStubImpl::TpmGetPassword(
+    const StringDBusMethodCallback& callback) {
+  const char kStubTpmPassword[] = "Stub-TPM-password";
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, kStubTpmPassword));
+}
+
+void CryptohomeClientStubImpl::TpmIsOwned(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+bool CryptohomeClientStubImpl::CallTpmIsOwnedAndBlock(bool* owned) {
+  *owned = true;
+  return true;
+}
+
+void CryptohomeClientStubImpl::TpmIsBeingOwned(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+bool CryptohomeClientStubImpl::CallTpmIsBeingOwnedAndBlock(bool* owning) {
+  *owning = true;
+  return true;
+}
+
+void CryptohomeClientStubImpl::TpmCanAttemptOwnership(
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
+}
+
+void CryptohomeClientStubImpl::TpmClearStoredPassword(
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS));
+}
+
+bool CryptohomeClientStubImpl::CallTpmClearStoredPasswordAndBlock() {
+  return true;
+}
+
+void CryptohomeClientStubImpl::Pkcs11IsTpmTokenReady(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+void CryptohomeClientStubImpl::Pkcs11GetTpmTokenInfo(
+    const Pkcs11GetTpmTokenInfoCallback& callback) {
+  const char kStubLabel[] = "Stub TPM Token";
+  const char kStubUserPin[] = "012345";
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback,
+                                                    DBUS_METHOD_CALL_SUCCESS,
+                                                    std::string(kStubLabel),
+                                                    std::string(kStubUserPin)));
+}
+
+bool CryptohomeClientStubImpl::InstallAttributesGet(const std::string& name,
+                                                    std::vector<uint8>* value,
+                                                    bool* successful) {
+  if (install_attrs_.find(name) != install_attrs_.end()) {
+    *value = install_attrs_[name];
+    *successful = true;
+  } else {
+    value->clear();
+    *successful = false;
+  }
+  return true;
+}
+
+bool CryptohomeClientStubImpl::InstallAttributesSet(
+    const std::string& name,
+    const std::vector<uint8>& value,
+    bool* successful) {
+  install_attrs_[name] = value;
+  *successful = true;
+  return true;
+}
+
+bool CryptohomeClientStubImpl::InstallAttributesFinalize(bool* successful) {
+  locked_ = true;
+  *successful = true;
+  return true;
+}
+
+void CryptohomeClientStubImpl::InstallAttributesIsReady(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+bool CryptohomeClientStubImpl::InstallAttributesIsInvalid(bool* is_invalid) {
+  *is_invalid = false;
+  return true;
+}
+
+bool CryptohomeClientStubImpl::InstallAttributesIsFirstInstall(
+    bool* is_first_install) {
+  *is_first_install = !locked_;
+  return true;
+}
+
+void CryptohomeClientStubImpl::TpmAttestationIsPrepared(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+void CryptohomeClientStubImpl::TpmAttestationIsEnrolled(
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
+}
+
+void CryptohomeClientStubImpl::AsyncTpmAttestationCreateEnrollRequest(
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, true);
+}
+
+void CryptohomeClientStubImpl::AsyncTpmAttestationEnroll(
+    const std::string& pca_response,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, false);
+}
+
+void CryptohomeClientStubImpl::AsyncTpmAttestationCreateCertRequest(
+    int options,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, true);
+}
+
+void CryptohomeClientStubImpl::AsyncTpmAttestationFinishCertRequest(
+    const std::string& pca_response,
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, true);
+}
+
+void CryptohomeClientStubImpl::TpmAttestationDoesKeyExist(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
+}
+
+void CryptohomeClientStubImpl::TpmAttestationGetCertificate(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const DataMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
+}
+
+void CryptohomeClientStubImpl::TpmAttestationGetPublicKey(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const DataMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
+}
+
+void CryptohomeClientStubImpl::TpmAttestationRegisterKey(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, true);
+}
+
+void CryptohomeClientStubImpl::TpmAttestationSignEnterpriseChallenge(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const std::string& domain,
+    const std::string& device_id,
+    attestation::AttestationChallengeOptions options,
+    const std::string& challenge,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, true);
+}
+
+void CryptohomeClientStubImpl::TpmAttestationSignSimpleChallenge(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const std::string& challenge,
+    const AsyncMethodCallback& callback) {
+  ReturnAsyncMethodResult(callback, true);
+}
+
+void CryptohomeClientStubImpl::TpmAttestationGetKeyPayload(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const DataMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false, std::string()));
+}
+
+void CryptohomeClientStubImpl::TpmAttestationSetKeyPayload(
+    attestation::AttestationKeyType key_type,
+    const std::string& key_name,
+    const std::string& payload,
+    const BoolDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, false));
+}
+
+void CryptohomeClientStubImpl::ReturnAsyncMethodResult(
+    const AsyncMethodCallback& callback,
+    bool returns_data) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&CryptohomeClientStubImpl::ReturnAsyncMethodResultInternal,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback,
+                 returns_data));
+}
+
+void CryptohomeClientStubImpl::ReturnAsyncMethodResultInternal(
+    const AsyncMethodCallback& callback,
+    bool returns_data) {
+  callback.Run(async_call_id_);
+  if (!returns_data && !async_call_status_handler_.is_null()) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(async_call_status_handler_,
+                   async_call_id_,
+                   true,
+                   cryptohome::MOUNT_ERROR_NONE));
+  } else if (returns_data && !async_call_status_data_handler_.is_null()) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(async_call_status_data_handler_,
+                   async_call_id_,
+                   true,
+                   std::string()));
+  }
+  ++async_call_id_;
+}
+
+}  // namespace chromeos
diff --git a/chromeos/dbus/cryptohome_client_stub.h b/chromeos/dbus/cryptohome_client_stub.h
new file mode 100644
index 0000000..e38925a
--- /dev/null
+++ b/chromeos/dbus/cryptohome_client_stub.h
@@ -0,0 +1,164 @@
+// Copyright 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.
+
+#ifndef CHROMEOS_DBUS_CRYPTOHOME_CLIENT_STUB_H_
+#define CHROMEOS_DBUS_CRYPTOHOME_CLIENT_STUB_H_
+
+#include <map>
+
+#include "base/basictypes.h"
+#include "base/memory/weak_ptr.h"
+#include "chromeos/dbus/cryptohome_client.h"
+
+namespace chromeos {
+
+class CryptohomeClientStubImpl : public CryptohomeClient {
+ public:
+  CryptohomeClientStubImpl();
+  virtual ~CryptohomeClientStubImpl();
+
+  virtual void SetAsyncCallStatusHandlers(
+      const AsyncCallStatusHandler& handler,
+      const AsyncCallStatusWithDataHandler& data_handler) OVERRIDE;
+  virtual void ResetAsyncCallStatusHandlers() OVERRIDE;
+  virtual void IsMounted(const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual bool Unmount(bool* success) OVERRIDE;
+  virtual void AsyncCheckKey(const std::string& username,
+                             const std::string& key,
+                             const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncMigrateKey(const std::string& username,
+                               const std::string& from_key,
+                               const std::string& to_key,
+                               const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncRemove(const std::string& username,
+                           const AsyncMethodCallback& callback) OVERRIDE;
+  virtual bool GetSystemSalt(std::vector<uint8>* salt) OVERRIDE;
+  virtual void GetSanitizedUsername(
+      const std::string& username,
+      const StringDBusMethodCallback& callback) OVERRIDE;
+  virtual std::string BlockingGetSanitizedUsername(
+      const std::string& username) OVERRIDE;
+  virtual void AsyncMount(const std::string& username,
+                          const std::string& key,
+                          int flags,
+                          const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncAddKey(const std::string& username,
+                           const std::string& key,
+                           const std::string& new_key,
+                           const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncMountGuest(const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncMountPublic(const std::string& public_mount_id,
+                                int flags,
+                                const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void TpmIsReady(const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual void TpmIsEnabled(const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual bool CallTpmIsEnabledAndBlock(bool* enabled) OVERRIDE;
+  virtual void TpmGetPassword(
+      const StringDBusMethodCallback& callback) OVERRIDE;
+  virtual void TpmIsOwned(const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual bool CallTpmIsOwnedAndBlock(bool* owned) OVERRIDE;
+  virtual void TpmIsBeingOwned(const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual bool CallTpmIsBeingOwnedAndBlock(bool* owning) OVERRIDE;
+  virtual void TpmCanAttemptOwnership(
+      const VoidDBusMethodCallback& callback) OVERRIDE;
+  virtual void TpmClearStoredPassword(
+      const VoidDBusMethodCallback& callback) OVERRIDE;
+  virtual bool CallTpmClearStoredPasswordAndBlock() OVERRIDE;
+  virtual void Pkcs11IsTpmTokenReady(
+      const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual void Pkcs11GetTpmTokenInfo(
+      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE;
+  virtual bool InstallAttributesGet(const std::string& name,
+                                    std::vector<uint8>* value,
+                                    bool* successful) OVERRIDE;
+  virtual bool InstallAttributesSet(const std::string& name,
+                                    const std::vector<uint8>& value,
+                                    bool* successful) OVERRIDE;
+  virtual bool InstallAttributesFinalize(bool* successful) OVERRIDE;
+  virtual void InstallAttributesIsReady(
+      const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual bool InstallAttributesIsInvalid(bool* is_invalid) OVERRIDE;
+  virtual bool InstallAttributesIsFirstInstall(bool* is_first_install) OVERRIDE;
+  virtual void TpmAttestationIsPrepared(
+      const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationIsEnrolled(
+      const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual void AsyncTpmAttestationCreateEnrollRequest(
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncTpmAttestationEnroll(
+      const std::string& pca_response,
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncTpmAttestationCreateCertRequest(
+      int options,
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void AsyncTpmAttestationFinishCertRequest(
+      const std::string& pca_response,
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationDoesKeyExist(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const BoolDBusMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationGetCertificate(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const DataMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationGetPublicKey(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const DataMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationRegisterKey(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationSignEnterpriseChallenge(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const std::string& domain,
+      const std::string& device_id,
+      attestation::AttestationChallengeOptions options,
+      const std::string& challenge,
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationSignSimpleChallenge(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const std::string& challenge,
+      const AsyncMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationGetKeyPayload(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const DataMethodCallback& callback) OVERRIDE;
+  virtual void TpmAttestationSetKeyPayload(
+      attestation::AttestationKeyType key_type,
+      const std::string& key_name,
+      const std::string& payload,
+      const BoolDBusMethodCallback& callback) OVERRIDE;
+
+ private:
+  // Posts tasks which return fake results to the UI thread.
+  void ReturnAsyncMethodResult(const AsyncMethodCallback& callback,
+                               bool returns_data);
+
+  // This method is used to implement ReturnAsyncMethodResult.
+  void ReturnAsyncMethodResultInternal(const AsyncMethodCallback& callback,
+                                       bool returns_data);
+
+  int async_call_id_;
+  AsyncCallStatusHandler async_call_status_handler_;
+  AsyncCallStatusWithDataHandler async_call_status_data_handler_;
+  int tpm_is_ready_counter_;
+
+  // A stub store for InstallAttributes, mapping an attribute name to the
+  // associated data blob. Used to implement InstallAttributesSet and -Get.
+  std::map<std::string, std::vector<uint8> > install_attrs_;
+  bool locked_;
+  base::WeakPtrFactory<CryptohomeClientStubImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CryptohomeClientStubImpl);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_CRYPTOHOME_CLIENT_STUB_H_