chromeos: Wait for service to be available when getting system salt

chromeos/dbus/fake_cryptohome_client.cc

 // 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/fake_cryptohome_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "crypto/nss_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 FakeCryptohomeClient::FakeCryptohomeClient()
-    : async_call_id_(1),
+    : service_is_available_(true),
+      async_call_id_(1),
       tpm_is_ready_counter_(0),
       unmount_result_(true),
       locked_(false),
       weak_ptr_factory_(this) {}
 
 FakeCryptohomeClient::~FakeCryptohomeClient() {}
 
 void FakeCryptohomeClient::Init(dbus::Bus* bus) {
 }
 
 void FakeCryptohomeClient::SetAsyncCallStatusHandlers(
     const AsyncCallStatusHandler& handler,
     const AsyncCallStatusWithDataHandler& data_handler) {
   async_call_status_handler_ = handler;
   async_call_status_data_handler_ = data_handler;
 }
 
 void FakeCryptohomeClient::ResetAsyncCallStatusHandlers() {
   async_call_status_handler_.Reset();
   async_call_status_data_handler_.Reset();
 }
 
+void FakeCryptohomeClient::WaitForServiceToBeAvailable(
+    const WaitForServiceToBeAvailableCallback& callback) {
+  if (service_is_available_) {
+    base::MessageLoop::current()->PostTask(FROM_HERE,
+                                           base::Bind(callback, true));
+  } else {
+    pending_wait_for_service_to_be_available_callbacks_.push_back(callback);
+  }
+}
+
 void FakeCryptohomeClient::IsMounted(
     const BoolDBusMethodCallback& callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, DBUS_METHOD_CALL_SUCCESS, true));
 }
 
 bool FakeCryptohomeClient::Unmount(bool* success) {
   *success = unmount_result_;
   return true;
 }
@@ skipping 312 matching lines @@
 void FakeCryptohomeClient::TpmAttestationSetKeyPayload(
     attestation::AttestationKeyType key_type,
     const std::string& user_id,
     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 FakeCryptohomeClient::SetServiceIsAvailable(bool is_available) {
+  service_is_available_ = is_available;
+  if (is_available) {
+    std::vector<WaitForServiceToBeAvailableCallback> callbacks;
+    callbacks.swap(pending_wait_for_service_to_be_available_callbacks_);
+    for (size_t i = 0; i < callbacks.size(); ++i)
+      callbacks[i].Run(is_available);
+  }
+}
+
 // static
 std::vector<uint8> FakeCryptohomeClient::GetStubSystemSalt() {
   const char kStubSystemSalt[] = "stub_system_salt";
   return std::vector<uint8>(kStubSystemSalt,
                             kStubSystemSalt + arraysize(kStubSystemSalt) - 1);
 }
 
 void FakeCryptohomeClient::ReturnAsyncMethodResult(
     const AsyncMethodCallback& callback,
     bool returns_data) {
@@ skipping 21 matching lines @@
         FROM_HERE,
         base::Bind(async_call_status_data_handler_,
                    async_call_id_,
                    true,
                    std::string()));
   }
   ++async_call_id_;
 }
 
 }  // namespace chromeos