CrOS: Add success/failure indicators for biod methods with no callback.

chromeos/dbus/biod/biod_client.cc

 // Copyright 2017 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/biod/biod_client.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "chromeos/dbus/biod/fake_biod_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
 namespace chromeos {
 
+namespace {
+
+// D-Bus response handler for methods that use void callbacks.
+void OnVoidResponse(const VoidDBusMethodCallback& callback,
+                    dbus::Response* response) {
+  callback.Run(response ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE);
+}
+
+}  // namespace
+
 // The BiodClient implementation used in production.
 class BiodClientImpl : public BiodClient {
  public:
   BiodClientImpl() : weak_ptr_factory_(this) {}
 
   ~BiodClientImpl() override {}
 
   // BiodClient overrides:
   void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
@@ skipping 30 matching lines @@
         biod::kBiometricsManagerGetRecordsForUserMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(user_id);
 
     biod_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BiodClientImpl::OnGetRecordsForUser,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
-  void DestroyAllRecords() override {
+  void DestroyAllRecords(const VoidDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         biod::kBiometricsManagerInterface,
         biod::kBiometricsManagerDestroyAllRecordsMethod);
 
     biod_proxy_->CallMethod(&method_call,
                             dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-                            dbus::ObjectProxy::EmptyResponseCallback());
+                            base::Bind(&OnVoidResponse, callback));
   }
 
   void StartAuthSession(const ObjectPathCallback& callback) override {
     dbus::MethodCall method_call(
         biod::kBiometricsManagerInterface,
         biod::kBiometricsManagerStartAuthSessionMethod);
 
     biod_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BiodClientImpl::OnStartAuthSession,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
   void RequestType(const BiometricTypeCallback& callback) override {
     dbus::MethodCall method_call(dbus::kDBusPropertiesInterface,
                                  dbus::kDBusPropertiesGet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(biod::kBiometricsManagerInterface);
     writer.AppendString(biod::kBiometricsManagerBiometricTypeProperty);
 
     biod_proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&BiodClientImpl::OnRequestType,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
-  void CancelEnrollSession(
-      const dbus::ObjectPath& enroll_session_path) override {
+  void CancelEnrollSession(const dbus::ObjectPath& enroll_session_path,
+                           const VoidDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(biod::kEnrollSessionInterface,
                                  biod::kEnrollSessionCancelMethod);
 
     dbus::ObjectProxy* enroll_session_proxy =
         bus_->GetObjectProxy(biod::kBiodServiceName, enroll_session_path);
-    enroll_session_proxy->CallMethod(
-        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        dbus::ObjectProxy::EmptyResponseCallback());
+    enroll_session_proxy->CallMethod(&method_call,
+                                     dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                                     base::Bind(&OnVoidResponse, callback));
   }
 
-  void EndAuthSession(const dbus::ObjectPath& auth_session_path) override {
+  void EndAuthSession(const dbus::ObjectPath& auth_session_path,
+                      const VoidDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(biod::kAuthSessionInterface,
                                  biod::kAuthSessionEndMethod);
 
     dbus::ObjectProxy* auth_session_proxy =
         bus_->GetObjectProxy(biod::kBiodServiceName, auth_session_path);
     auth_session_proxy->CallMethod(&method_call,
                                    dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-                                   dbus::ObjectProxy::EmptyResponseCallback());
+                                   base::Bind(&OnVoidResponse, callback));
   }
 
   void SetRecordLabel(const dbus::ObjectPath& record_path,
-                      const std::string& label) override {
+                      const std::string& label,
+                      const VoidDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(biod::kRecordInterface,
                                  biod::kRecordSetLabelMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(label);
 
     dbus::ObjectProxy* record_proxy =
         bus_->GetObjectProxy(biod::kBiodServiceName, record_path);
     record_proxy->CallMethod(&method_call,
                              dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-                             dbus::ObjectProxy::EmptyResponseCallback());
+                             base::Bind(&OnVoidResponse, callback));
   }
 
-  void RemoveRecord(const dbus::ObjectPath& record_path) override {
+  void RemoveRecord(const dbus::ObjectPath& record_path,
+                    const VoidDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(biod::kRecordInterface,
                                  biod::kRecordRemoveMethod);
 
     dbus::ObjectProxy* record_proxy =
         bus_->GetObjectProxy(biod::kBiodServiceName, record_path);
     record_proxy->CallMethod(&method_call,
                              dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-                             dbus::ObjectProxy::EmptyResponseCallback());
+                             base::Bind(&OnVoidResponse, callback));
   }
 
   void RequestRecordLabel(const dbus::ObjectPath& record_path,
                           const LabelCallback& callback) override {
     dbus::MethodCall method_call(dbus::kDBusPropertiesInterface,
                                  dbus::kDBusPropertiesGet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(biod::kRecordInterface);
     writer.AppendString(biod::kRecordLabelProperty);
 
@@ skipping 199 matching lines @@
 
 // static
 BiodClient* BiodClient::Create(DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new BiodClientImpl();
   DCHECK_EQ(FAKE_DBUS_CLIENT_IMPLEMENTATION, type);
   return new FakeBiodClient();
 }
 
 }  // namespace chromeos