ChromeOS DBus: leaderd API

chromeos/dbus/leadership_daemon_manager_client.cc

 // Copyright 2015 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/leadership_daemon_manager_client.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 35 matching lines @@
       public dbus::ObjectManager::Interface {
  public:
   LeadershipDaemonManagerClientImpl();
   ~LeadershipDaemonManagerClientImpl() override;
 
   // LeadershipDaemonManagerClient overrides.
   void AddObserver(Observer* observer) override;
   void RemoveObserver(Observer* observer) override;
   void JoinGroup(const std::string& group,
                  const base::DictionaryValue& options,
-                 const StringDBusMethodCallback& callback) override;
+                 const ObjectPathDBusMethodCallback& callback) override;
   void LeaveGroup(const std::string& object_path,
                   const VoidDBusMethodCallback& callback) override;
   void SetScore(const std::string& object_path,
                 int score,
                 const VoidDBusMethodCallback& callback) override;
   void PokeLeader(const std::string& object_path,
                   const VoidDBusMethodCallback& callback) override;
   void Ping(const StringDBusMethodCallback& callback) override;
   const GroupProperties* GetGroupProperties(
       const dbus::ObjectPath& object_path) override;
@@ skipping 11 matching lines @@
   void ObjectRemoved(const dbus::ObjectPath& object_path,
                      const std::string& interface_name) override;
 
  private:
   // Called by dbus::PropertySet when a property value is changed,
   // either by result of a signal or response to a GetAll() or Get()
   // call. Informs observers.
   void OnGroupPropertyChanged(const dbus::ObjectPath& object_path,
                               const std::string& property_name);
 
+  void OnObjectPathDBusMethod(const ObjectPathDBusMethodCallback& callback,
+                              dbus::Response* response);
   void OnStringDBusMethod(const StringDBusMethodCallback& callback,
                           dbus::Response* response);
   void OnVoidDBusMethod(const VoidDBusMethodCallback& callback,
                         dbus::Response* response);
 
   // List of observers interested in event notifications from us.
   ObserverList<Observer> observers_;
   dbus::ObjectManager* object_manager_;
   base::WeakPtrFactory<LeadershipDaemonManagerClientImpl> weak_ptr_factory_;
 
@@ skipping 17 matching lines @@
 }
 
 void LeadershipDaemonManagerClientImpl::RemoveObserver(Observer* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 void LeadershipDaemonManagerClientImpl::JoinGroup(
     const std::string& group,
     const base::DictionaryValue& options,
-    const StringDBusMethodCallback& callback) {
+    const ObjectPathDBusMethodCallback& callback) {
   dbus::ObjectProxy* object_proxy = object_manager_->GetObjectProxy(
       dbus::ObjectPath(leaderd::kLeaderdManagerPath));
   if (!object_proxy) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&LeadershipDaemonManagerClientImpl::OnStringDBusMethod,
+        base::Bind(&LeadershipDaemonManagerClientImpl::OnObjectPathDBusMethod,
                    weak_ptr_factory_.GetWeakPtr(), callback, nullptr));
     return;
   }
 
   dbus::MethodCall method_call(leaderd::kManagerInterface,
                                leaderd::kJoinGroupMethod);
   dbus::MessageWriter writer(&method_call);
   writer.AppendString(group);
   dbus::AppendValueData(&writer, options);
   object_proxy->CallMethod(
       &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-      base::Bind(&LeadershipDaemonManagerClientImpl::OnStringDBusMethod,
+      base::Bind(&LeadershipDaemonManagerClientImpl::OnObjectPathDBusMethod,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void LeadershipDaemonManagerClientImpl::LeaveGroup(
     const std::string& object_path,
     const VoidDBusMethodCallback& callback) {
   dbus::ObjectProxy* object_proxy =
       object_manager_->GetObjectProxy(dbus::ObjectPath(object_path));
   if (!object_proxy) {
     base::MessageLoop::current()->PostTask(
@@ skipping 137 matching lines @@
   }
 }
 
 void LeadershipDaemonManagerClientImpl::OnGroupPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   FOR_EACH_OBSERVER(Observer, observers_,
                     GroupPropertyChanged(object_path, property_name));
 }
 
+void LeadershipDaemonManagerClientImpl::OnObjectPathDBusMethod(
+    const ObjectPathDBusMethodCallback& callback,
+    dbus::Response* response) {
+  if (!response) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, dbus::ObjectPath());
+    return;
+  }
+
+  dbus::MessageReader reader(response);
+  dbus::ObjectPath result;
+  if (!reader.PopObjectPath(&result)) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, result);
+    return;
+  }
+
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
+}
+
 void LeadershipDaemonManagerClientImpl::OnStringDBusMethod(
     const StringDBusMethodCallback& callback,
     dbus::Response* response) {
   if (!response) {
     callback.Run(DBUS_METHOD_CALL_FAILURE, std::string());
     return;
   }
 
   dbus::MessageReader reader(response);
   std::string result;
@@ skipping 52 matching lines @@
 
 LeadershipDaemonManagerClient::~LeadershipDaemonManagerClient() {
 }
 
 // static
 LeadershipDaemonManagerClient* LeadershipDaemonManagerClient::Create() {
   return new LeadershipDaemonManagerClientImpl();
 }
 
 }  // namespace chromeos