chromeos: Remove SystemSaltGetter::GetSystemSaltSync

chromeos/dbus/cryptohome_client.cc

 // 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.
 
 #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"
@@ skipping 92 matching lines @@
                                  cryptohome::kCryptohomeAsyncRemove);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
-  virtual bool GetSystemSalt(std::vector<uint8>* salt) OVERRIDE {
+  virtual void GetSystemSalt(const GetSystemSaltCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeGetSystemSalt);
-    scoped_ptr<dbus::Response> response(
-        blocking_method_caller_->CallMethodAndBlock(&method_call));
-    if (!response.get())
-      return false;
-    dbus::MessageReader reader(response.get());
-    uint8* bytes = NULL;
-    size_t length = 0;
-    if (!reader.PopArrayOfBytes(&bytes, &length))
-      return false;
-    salt->assign(bytes, bytes + length);
-    return true;
+    proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                       base::Bind(&CryptohomeClientImpl::OnGetSystemSalt,
+                                  weak_ptr_factory_.GetWeakPtr(),
+                                  callback));
   }
 
   // CryptohomeClient override,
   virtual void GetSanitizedUsername(
       const std::string& username,
       const StringDBusMethodCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeGetSanitizedUsername);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
@@ skipping 576 matching lines @@
       return;
     dbus::MessageReader reader(response);
     int async_id = 0;
     if (!reader.PopInt32(&async_id)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       return;
     }
     callback.Run(async_id);
   }
 
+  // Handles the result of GetSystemSalt().
+  void OnGetSystemSalt(const GetSystemSaltCallback& callback,
+                       dbus::Response* response) {
+    if (!response) {
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8>());
+      return;
+    }
+    dbus::MessageReader reader(response);
+    uint8* bytes = NULL;
+    size_t length = 0;
+    if (!reader.PopArrayOfBytes(&bytes, &length)) {
+      callback.Run(DBUS_METHOD_CALL_FAILURE, std::vector<uint8>());
+      return;
+    }
+    callback.Run(DBUS_METHOD_CALL_SUCCESS,
+                 std::vector<uint8>(bytes, bytes + length));
+  }
+
   // Calls a method without result values.
   void CallVoidMethod(dbus::MethodCall* method_call,
                       const VoidDBusMethodCallback& callback) {
     proxy_->CallMethod(method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CryptohomeClientImpl::OnVoidMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   void OnVoidMethod(const VoidDBusMethodCallback& callback,
@@ skipping 192 matching lines @@
   return new FakeCryptohomeClient();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const std::string& username) {
   return username + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos