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 OnVoidMethod(const VoidDBusMethodCallback& callback,

[Daniel Erat, 2017/04/08 01:13:32]

nit: OnVoidResponse?

[sammiequon, 2017/04/08 01:31:47]

Done.

+                  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(&OnVoidMethod, 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(&OnVoidMethod, 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(&OnVoidMethod, 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(&OnVoidMethod, 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(&OnVoidMethod, 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 92 matching lines @@
       dbus::MessageReader reader(response);
       if (!reader.PopVariantOfUint32(&result)) {
         LOG(ERROR) << biod::kBiometricsManagerBiometricTypeProperty
                    << " had incorrect response.";
       }
     }
 
     callback.Run(static_cast<biod::BiometricType>(result));
   }
 
-  void OnRequestRecordLabel(const LabelCallback& callback,

[Daniel Erat, 2017/04/08 01:13:32]

did you re-run the tests? this looks like it was deleted accidentally; it's
still being called.

[sammiequon, 2017/04/08 01:31:47]

Oh no, oops. Good thing you caught it..

-                            dbus::Response* response) {
-    std::string result;
-    if (response) {
-      dbus::MessageReader reader(response);
-      if (!reader.PopString(&result))
-        LOG(ERROR) << biod::kRecordLabelProperty << " had incorrect response.";
-    }
-
-    callback.Run(result);
-  }
-
   // Called when the biometrics signal is initially connected.
   void OnSignalConnected(const std::string& interface_name,
                          const std::string& signal_name,
                          bool success) {
     LOG_IF(ERROR, !success)
         << "Failed to connect to biometrics signal: " << signal_name;
   }
 
   void NameOwnerChangedReceived(const std::string& /* old_owner */,
                                 const std::string& new_owner) {
@@ skipping 75 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