Add DBus Bindings for leaderd

leaderd is a ChromeOS system daemon that exposes group leader
capability. Expose the ability to create groups, join and listen
to events on the groups.

BUG=453872

Review URL: https://codereview.chromium.org/887083002

Cr-Commit-Position: refs/heads/master@{#316288}

chromeos/chromeos.gyp

@@ -154,6 +154,8 @@
       'dbus/fake_image_burner_client.h',
       'dbus/fake_introspectable_client.cc',
       'dbus/fake_introspectable_client.h',
+      'dbus/fake_leadership_daemon_manager_client.cc',
+      'dbus/fake_leadership_daemon_manager_client.h',
       'dbus/fake_lorgnette_manager_client.cc',
       'dbus/fake_lorgnette_manager_client.h',
       'dbus/fake_modem_messaging_client.cc',
@@ -196,6 +198,8 @@
       'dbus/image_burner_client.h',
       'dbus/introspectable_client.cc',
       'dbus/introspectable_client.h',
+      'dbus/leadership_daemon_manager_client.cc',
+      'dbus/leadership_daemon_manager_client.h',
       'dbus/lorgnette_manager_client.cc',
       'dbus/lorgnette_manager_client.h',
       'dbus/modem_messaging_client.cc',

chromeos/dbus/dbus_client_bundle.cc

@@ -44,6 +44,7 @@
 #include "chromeos/dbus/fake_gsm_sms_client.h"
 #include "chromeos/dbus/fake_image_burner_client.h"
 #include "chromeos/dbus/fake_introspectable_client.h"
+#include "chromeos/dbus/fake_leadership_daemon_manager_client.h"
 #include "chromeos/dbus/fake_lorgnette_manager_client.h"
 #include "chromeos/dbus/fake_modem_messaging_client.h"
 #include "chromeos/dbus/fake_nfc_adapter_client.h"
@@ -65,6 +66,7 @@
 #include "chromeos/dbus/gsm_sms_client.h"
 #include "chromeos/dbus/image_burner_client.h"
 #include "chromeos/dbus/introspectable_client.h"
+#include "chromeos/dbus/leadership_daemon_manager_client.h"
 #include "chromeos/dbus/lorgnette_manager_client.h"
 #include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/nfc_adapter_client.h"
@@ -103,6 +105,7 @@ const struct {
     { "cryptohome",  DBusClientBundle::CRYPTOHOME },
     { "debug_daemon",  DBusClientBundle::DEBUG_DAEMON },
     { "easy_unlock",  DBusClientBundle::EASY_UNLOCK },
+    { "leadership_daemon",  DBusClientBundle::LEADERSHIP_DAEMON },
     { "lorgnette_manager",  DBusClientBundle::LORGNETTE_MANAGER },
     { "shill",  DBusClientBundle::SHILL },
     { "gsm_sms",  DBusClientBundle::GSM_SMS },
@@ -277,6 +280,14 @@ DBusClientBundle::DBusClientBundle(DBusClientTypeMask unstub_client_mask)
   else
     privet_daemon_client_.reset(new FakePrivetDaemonClient);
 
+  if (!IsUsingStub(LEADERSHIP_DAEMON)) {
+    leadership_daemon_manager_client_.reset(
+        LeadershipDaemonManagerClient::Create());
+  } else {
+    leadership_daemon_manager_client_.reset(
+        new FakeLeadershipDaemonManagerClient);
+  }
+
   power_manager_client_.reset(PowerManagerClient::Create(
       IsUsingStub(POWER_MANAGER) ? STUB_DBUS_CLIENT_IMPLEMENTATION
                                  : REAL_DBUS_CLIENT_IMPLEMENTATION));

chromeos/dbus/dbus_client_bundle.h

@@ -28,6 +28,7 @@ class CrosDisksClient;
 class CryptohomeClient;
 class DebugDaemonClient;
 class EasyUnlockClient;
+class LeadershipDaemonManagerClient;
 class LorgnetteManagerClient;
 class ShillDeviceClient;
 class ShillIPConfigClient;
@@ -85,6 +86,7 @@ class CHROMEOS_EXPORT DBusClientBundle {
     SYSTEM_CLOCK =         1 << 18,
     UPDATE_ENGINE =        1 << 19,
     PEER_DAEMON =          1 << 20,
+    LEADERSHIP_DAEMON =    1 << 21,
   };
 
   explicit DBusClientBundle(DBusClientTypeMask unstub_client_mask);
@@ -167,6 +169,10 @@ class CHROMEOS_EXPORT DBusClientBundle {
     return easy_unlock_client_.get();
   }
 
+  LeadershipDaemonManagerClient* leadership_daemon_manager_client() {
+    return leadership_daemon_manager_client_.get();
+  }
+
   LorgnetteManagerClient* lorgnette_manager_client() {
     return lorgnette_manager_client_.get();
   }
@@ -287,6 +293,7 @@ class CHROMEOS_EXPORT DBusClientBundle {
   scoped_ptr<CryptohomeClient> cryptohome_client_;
   scoped_ptr<DebugDaemonClient> debug_daemon_client_;
   scoped_ptr<EasyUnlockClient> easy_unlock_client_;
+  scoped_ptr<LeadershipDaemonManagerClient> leadership_daemon_manager_client_;
   scoped_ptr<LorgnetteManagerClient> lorgnette_manager_client_;
   scoped_ptr<PeerDaemonManagerClient> peer_daemon_manager_client_;
   scoped_ptr<PrivetDaemonClient> privet_daemon_client_;

chromeos/dbus/dbus_thread_manager.cc

@@ -29,6 +29,7 @@
 #include "chromeos/dbus/gsm_sms_client.h"
 #include "chromeos/dbus/image_burner_client.h"
 #include "chromeos/dbus/introspectable_client.h"
+#include "chromeos/dbus/leadership_daemon_manager_client.h"
 #include "chromeos/dbus/lorgnette_manager_client.h"
 #include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/nfc_adapter_client.h"
@@ -185,6 +186,12 @@ DebugDaemonClient* DBusThreadManager::GetDebugDaemonClient() {
 EasyUnlockClient* DBusThreadManager::GetEasyUnlockClient() {
   return client_bundle_->easy_unlock_client();
 }
+
+LeadershipDaemonManagerClient*
+DBusThreadManager::GetLeadershipDaemonManagerClient() {
+  return client_bundle_->leadership_daemon_manager_client();
+}
+
 LorgnetteManagerClient*
 DBusThreadManager::GetLorgnetteManagerClient() {
   return client_bundle_->lorgnette_manager_client();
@@ -308,6 +315,7 @@ void DBusThreadManager::InitializeClients() {
   GetGsmSMSClient()->Init(GetSystemBus());
   GetImageBurnerClient()->Init(GetSystemBus());
   GetIntrospectableClient()->Init(GetSystemBus());
+  GetLeadershipDaemonManagerClient()->Init(GetSystemBus());
   GetLorgnetteManagerClient()->Init(GetSystemBus());
   GetModemMessagingClient()->Init(GetSystemBus());
   GetPermissionBrokerClient()->Init(GetSystemBus());
@@ -536,6 +544,12 @@ void DBusThreadManagerSetter::SetEasyUnlockClient(
   DBusThreadManager::Get()->client_bundle_->easy_unlock_client_ = client.Pass();
 }
 
+void DBusThreadManagerSetter::SetLeadershipDaemonManagerClient(
+    scoped_ptr<LeadershipDaemonManagerClient> client) {
+  DBusThreadManager::Get()->client_bundle_->leadership_daemon_manager_client_ =
+      client.Pass();
+}
+
 void DBusThreadManagerSetter::SetLorgnetteManagerClient(
     scoped_ptr<LorgnetteManagerClient> client) {
   DBusThreadManager::Get()->client_bundle_->lorgnette_manager_client_ =

chromeos/dbus/dbus_thread_manager.h

@@ -45,6 +45,7 @@ class EasyUnlockClient;
 class GsmSMSClient;
 class ImageBurnerClient;
 class IntrospectableClient;
+class LeadershipDaemonManagerClient;
 class LorgnetteManagerClient;
 class ModemMessagingClient;
 class NfcAdapterClient;
@@ -136,6 +137,7 @@ class CHROMEOS_EXPORT DBusThreadManager {
   GsmSMSClient* GetGsmSMSClient();
   ImageBurnerClient* GetImageBurnerClient();
   IntrospectableClient* GetIntrospectableClient();
+  LeadershipDaemonManagerClient* GetLeadershipDaemonManagerClient();
   LorgnetteManagerClient* GetLorgnetteManagerClient();
   ModemMessagingClient* GetModemMessagingClient();
   NfcAdapterClient* GetNfcAdapterClient();
@@ -223,6 +225,8 @@ class CHROMEOS_EXPORT DBusThreadManagerSetter {
   void SetCryptohomeClient(scoped_ptr<CryptohomeClient> client);
   void SetDebugDaemonClient(scoped_ptr<DebugDaemonClient> client);
   void SetEasyUnlockClient(scoped_ptr<EasyUnlockClient> client);
+  void SetLeadershipDaemonManagerClient(
+      scoped_ptr<LeadershipDaemonManagerClient> client);
   void SetLorgnetteManagerClient(scoped_ptr<LorgnetteManagerClient> client);
   void SetShillDeviceClient(scoped_ptr<ShillDeviceClient> client);
   void SetShillIPConfigClient(scoped_ptr<ShillIPConfigClient> client);

chromeos/dbus/fake_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/fake_leadership_daemon_manager_client.h"
+
+#include "base/message_loop/message_loop.h"
+
+namespace chromeos {
+
+namespace {
+void StringDBBusMethodCallbackThunk(const StringDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, std::string());
+}
+
+void VoidDBBusMethodCallbackThunk(const VoidDBusMethodCallback& callback) {
+  callback.Run(DBUS_METHOD_CALL_SUCCESS);
+}
+}
+
+FakeLeadershipDaemonManagerClient::FakeLeadershipDaemonManagerClient() {
+}
+
+FakeLeadershipDaemonManagerClient::~FakeLeadershipDaemonManagerClient() {
+}
+
+void FakeLeadershipDaemonManagerClient::Init(dbus::Bus* bus) {
+}
+
+void FakeLeadershipDaemonManagerClient::AddObserver(Observer* observer) {
+}
+
+void FakeLeadershipDaemonManagerClient::RemoveObserver(Observer* observer) {
+}
+
+void FakeLeadershipDaemonManagerClient::JoinGroup(
+    const std::string& group,
+    const base::DictionaryValue& options,
+    const StringDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&StringDBBusMethodCallbackThunk, callback));
+}
+
+void FakeLeadershipDaemonManagerClient::LeaveGroup(
+    const std::string& object_path,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&VoidDBBusMethodCallbackThunk, callback));
+}
+
+void FakeLeadershipDaemonManagerClient::SetScore(
+    const std::string& object_path,
+    int score,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&VoidDBBusMethodCallbackThunk, callback));
+}
+
+void FakeLeadershipDaemonManagerClient::PokeLeader(
+    const std::string& object_path,
+    const VoidDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&VoidDBBusMethodCallbackThunk, callback));
+}
+
+void FakeLeadershipDaemonManagerClient::Ping(
+    const StringDBusMethodCallback& callback) {
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&StringDBBusMethodCallbackThunk, callback));
+}
+
+const LeadershipDaemonManagerClient::GroupProperties*
+FakeLeadershipDaemonManagerClient::GetGroupProperties(
+    const dbus::ObjectPath& object_path) {
+  return nullptr;
+}
+
+}  // namespace chromeos

chromeos/dbus/fake_leadership_daemon_manager_client.h

+// 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.
+
+#ifndef CHROMEOS_DBUS_FAKE_LEADERSHIP_DAEMON_MANAGER_CLIENT_H_
+#define CHROMEOS_DBUS_FAKE_LEADERSHIP_DAEMON_MANAGER_CLIENT_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "chromeos/dbus/leadership_daemon_manager_client.h"
+
+namespace chromeos {
+
+// A fake implementation of LeadershipDaemonManagerClient. Invokes callbacks
+// immediately.
+class FakeLeadershipDaemonManagerClient : public LeadershipDaemonManagerClient {
+ public:
+  FakeLeadershipDaemonManagerClient();
+  ~FakeLeadershipDaemonManagerClient() override;
+
+  // DBusClient overrides:
+  void Init(dbus::Bus* bus) 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;
+  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;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeLeadershipDaemonManagerClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_FAKE_LEADERSHIP_DAEMON_MANAGER_CLIENT_H_

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/callback.h"
+#include "base/logging.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/observer_list.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "dbus/object_manager.h"
+#include "dbus/object_proxy.h"
+#include "dbus/values_util.h"
+
+namespace chromeos {
+
+// TODO(benchan): Move these constants to system_api.
+namespace leaderd {
+const char kLeaderdServiceName[] = "org.chromium.leaderd";
+const char kLeaderdObjectManagerServicePath[] = "/org/chromium/leaderd";
+const char kLeaderdManagerPath[] = "/org/chromium/leaderd/Manager";
+const char kManagerInterface[] = "org.chromium.leaderd.Manager";
+const char kGroupInterface[] = "org.chromium.leaderd.Group";
+const char kJoinGroupMethod[] = "JoinGroup";
+const char kLeaveGroupMethod[] = "LeaveGroup";
+const char kSetScoreMethod[] = "SetScore";
+const char kPokeLeaderMethod[] = "PokeLeader";
+const char kPingMethod[] = "Ping";
+const char kLeaderUUID[] = "LeaderUUID";
+const char kGroupMembers[] = "GroupMembers";
+}  // namespace leaderd
+
+namespace {
+
+// Since there is no property associated with Manager objects, an empty callback
+// is used.
+void DoNothing(const std::string& property_name) {
+}
+
+// The LeadershipDaemonManagerClient implementation used in production.
+class LeadershipDaemonManagerClientImpl
+    : public LeadershipDaemonManagerClient,
+      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;
+  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;
+
+  // DBusClient overrides.
+  void Init(dbus::Bus* bus) override;
+
+  // dbus::ObjectManager::Interface overrides.
+  dbus::PropertySet* CreateProperties(
+      dbus::ObjectProxy* object_proxy,
+      const dbus::ObjectPath& object_path,
+      const std::string& interface_name) override;
+  void ObjectAdded(const dbus::ObjectPath& object_path,
+                   const std::string& interface_name) override;
+  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 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_;
+
+  DISALLOW_COPY_AND_ASSIGN(LeadershipDaemonManagerClientImpl);
+};
+
+LeadershipDaemonManagerClientImpl::LeadershipDaemonManagerClientImpl()
+    : object_manager_(nullptr), weak_ptr_factory_(this) {
+}
+
+LeadershipDaemonManagerClientImpl::~LeadershipDaemonManagerClientImpl() {
+  if (object_manager_) {
+    object_manager_->UnregisterInterface(leaderd::kManagerInterface);
+    object_manager_->UnregisterInterface(leaderd::kGroupInterface);
+  }
+}
+
+void LeadershipDaemonManagerClientImpl::AddObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.AddObserver(observer);
+}
+
+void LeadershipDaemonManagerClientImpl::RemoveObserver(Observer* observer) {
+  DCHECK(observer);
+  observers_.RemoveObserver(observer);
+}
+
+void LeadershipDaemonManagerClientImpl::JoinGroup(
+    const std::string& group,
+    const base::DictionaryValue& options,
+    const StringDBusMethodCallback& 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,
+                   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,
+                 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(
+        FROM_HERE,
+        base::Bind(&LeadershipDaemonManagerClientImpl::OnVoidDBusMethod,
+                   weak_ptr_factory_.GetWeakPtr(), callback, nullptr));
+    return;
+  }
+
+  dbus::MethodCall method_call(leaderd::kGroupInterface,
+                               leaderd::kLeaveGroupMethod);
+  dbus::MessageWriter writer(&method_call);
+  object_proxy->CallMethod(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+      base::Bind(&LeadershipDaemonManagerClientImpl::OnVoidDBusMethod,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void LeadershipDaemonManagerClientImpl::SetScore(
+    const std::string& object_path,
+    int score,
+    const VoidDBusMethodCallback& callback) {
+  dbus::ObjectProxy* object_proxy =
+      object_manager_->GetObjectProxy(dbus::ObjectPath(object_path));
+  if (!object_proxy) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&LeadershipDaemonManagerClientImpl::OnVoidDBusMethod,
+                   weak_ptr_factory_.GetWeakPtr(), callback, nullptr));
+    return;
+  }
+
+  dbus::MethodCall method_call(leaderd::kGroupInterface,
+                               leaderd::kSetScoreMethod);
+  dbus::MessageWriter writer(&method_call);
+  writer.AppendInt32(score);
+  object_proxy->CallMethod(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+      base::Bind(&LeadershipDaemonManagerClientImpl::OnVoidDBusMethod,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void LeadershipDaemonManagerClientImpl::PokeLeader(
+    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(
+        FROM_HERE,
+        base::Bind(&LeadershipDaemonManagerClientImpl::OnVoidDBusMethod,
+                   weak_ptr_factory_.GetWeakPtr(), callback, nullptr));
+    return;
+  }
+
+  dbus::MethodCall method_call(leaderd::kGroupInterface,
+                               leaderd::kPokeLeaderMethod);
+  dbus::MessageWriter writer(&method_call);
+  object_proxy->CallMethod(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+      base::Bind(&LeadershipDaemonManagerClientImpl::OnVoidDBusMethod,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void LeadershipDaemonManagerClientImpl::Ping(
+    const StringDBusMethodCallback& 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,
+                   weak_ptr_factory_.GetWeakPtr(), callback, nullptr));
+    return;
+  }
+
+  dbus::MethodCall method_call(leaderd::kManagerInterface,
+                               leaderd::kPingMethod);
+  dbus::MessageWriter writer(&method_call);
+  object_proxy->CallMethod(
+      &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+      base::Bind(&LeadershipDaemonManagerClientImpl::OnStringDBusMethod,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+const LeadershipDaemonManagerClient::GroupProperties*
+LeadershipDaemonManagerClientImpl::GetGroupProperties(
+    const dbus::ObjectPath& object_path) {
+  return static_cast<GroupProperties*>(
+      object_manager_->GetProperties(object_path, leaderd::kGroupInterface));
+}
+
+void LeadershipDaemonManagerClientImpl::Init(dbus::Bus* bus) {
+  object_manager_ = bus->GetObjectManager(
+      leaderd::kLeaderdServiceName,
+      dbus::ObjectPath(leaderd::kLeaderdObjectManagerServicePath));
+  object_manager_->RegisterInterface(leaderd::kManagerInterface, this);
+  object_manager_->RegisterInterface(leaderd::kGroupInterface, this);
+}
+
+dbus::PropertySet* LeadershipDaemonManagerClientImpl::CreateProperties(
+    dbus::ObjectProxy* object_proxy,
+    const dbus::ObjectPath& object_path,
+    const std::string& interface_name) {
+  dbus::PropertySet* properties = nullptr;
+  if (interface_name == leaderd::kManagerInterface) {
+    properties = new dbus::PropertySet(object_proxy, interface_name,
+                                       base::Bind(&DoNothing));
+  } else if (interface_name == leaderd::kGroupInterface) {
+    properties = new GroupProperties(
+        object_proxy, interface_name,
+        base::Bind(&LeadershipDaemonManagerClientImpl::OnGroupPropertyChanged,
+                   weak_ptr_factory_.GetWeakPtr(), object_path));
+  } else {
+    NOTREACHED() << "Unhandled interface name " << interface_name;
+  }
+  return properties;
+}
+
+void LeadershipDaemonManagerClientImpl::ObjectAdded(
+    const dbus::ObjectPath& object_path,
+    const std::string& interface_name) {
+  if (interface_name == leaderd::kManagerInterface) {
+    FOR_EACH_OBSERVER(Observer, observers_, ManagerAdded());
+  } else if (interface_name == leaderd::kGroupInterface) {
+    FOR_EACH_OBSERVER(Observer, observers_, GroupAdded(object_path));
+  } else {
+    NOTREACHED() << "Unhandled interface name " << interface_name;
+  }
+}
+
+void LeadershipDaemonManagerClientImpl::ObjectRemoved(
+    const dbus::ObjectPath& object_path,
+    const std::string& interface_name) {
+  if (interface_name == leaderd::kManagerInterface) {
+    FOR_EACH_OBSERVER(Observer, observers_, ManagerRemoved());
+  } else if (interface_name == leaderd::kGroupInterface) {
+    FOR_EACH_OBSERVER(Observer, observers_, GroupRemoved(object_path));
+  } else {
+    NOTREACHED() << "Unhandled interface name " << interface_name;
+  }
+}
+
+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::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;
+  if (!reader.PopString(&result)) {
+    callback.Run(DBUS_METHOD_CALL_FAILURE, std::string());
+    return;
+  }
+
+  callback.Run(DBUS_METHOD_CALL_SUCCESS, result);
+}
+
+void LeadershipDaemonManagerClientImpl::OnVoidDBusMethod(
+    const VoidDBusMethodCallback& callback,
+    dbus::Response* response) {
+  callback.Run(response ? DBUS_METHOD_CALL_SUCCESS : DBUS_METHOD_CALL_FAILURE);
+}
+
+}  // namespace
+
+LeadershipDaemonManagerClient::GroupProperties::GroupProperties(
+    dbus::ObjectProxy* object_proxy,
+    const std::string& interface_name,
+    const PropertyChangedCallback& callback)
+    : dbus::PropertySet(object_proxy, interface_name, callback) {
+  RegisterProperty(leaderd::kLeaderUUID, &leader_uuid_);
+  RegisterProperty(leaderd::kGroupMembers, &group_members_);
+}
+
+LeadershipDaemonManagerClient::GroupProperties::~GroupProperties() {
+}
+
+LeadershipDaemonManagerClient::Observer::~Observer() {
+}
+
+void LeadershipDaemonManagerClient::Observer::ManagerAdded() {
+}
+
+void LeadershipDaemonManagerClient::Observer::ManagerRemoved() {
+}
+
+void LeadershipDaemonManagerClient::Observer::GroupAdded(
+    const dbus::ObjectPath& object_path) {
+}
+
+void LeadershipDaemonManagerClient::Observer::GroupRemoved(
+    const dbus::ObjectPath& object_path) {
+}
+
+void LeadershipDaemonManagerClient::Observer::GroupPropertyChanged(
+    const dbus::ObjectPath& object_path,
+    const std::string& property_name) {
+}
+
+LeadershipDaemonManagerClient::LeadershipDaemonManagerClient() {
+}
+
+LeadershipDaemonManagerClient::~LeadershipDaemonManagerClient() {
+}
+
+// static
+LeadershipDaemonManagerClient* LeadershipDaemonManagerClient::Create() {
+  return new LeadershipDaemonManagerClientImpl();
+}
+
+}  // namespace chromeos

chromeos/dbus/leadership_daemon_manager_client.h

+// 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.
+#ifndef CHROMEOS_DBUS_LEADERSHIP_DAEMON_MANAGER_CLIENT_H_
+#define CHROMEOS_DBUS_LEADERSHIP_DAEMON_MANAGER_CLIENT_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/values.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+#include "dbus/object_path.h"
+#include "dbus/property.h"
+
+namespace chromeos {
+
+// LeadershipDaemonManagerClient is used to communicate with the
+// leaderd's Manager service.  All methods should be called from
+// the origin thread which initializes the DBusThreadManager instance.
+class CHROMEOS_EXPORT LeadershipDaemonManagerClient : public DBusClient {
+ public:
+  // Structure of properties associated with advertised groups.
+  class GroupProperties : public dbus::PropertySet {
+   public:
+    GroupProperties(dbus::ObjectProxy* object_proxy,
+                    const std::string& interface_name,
+                    const PropertyChangedCallback& callback);
+    ~GroupProperties() override;
+
+    const std::string& leader_uuid() const { return leader_uuid_.value(); }
+    const std::vector<std::string>& group_members() const {
+      return group_members_.value();
+    }
+
+   private:
+    dbus::Property<std::string> leader_uuid_;
+    dbus::Property<std::vector<std::string>> group_members_;
+  };
+
+  // Interface for observing changes from a leadership daemon.
+  class Observer {
+   public:
+    virtual ~Observer();
+
+    // Called when the manager has been added.
+    virtual void ManagerAdded();
+
+    // Called when the manager has been removed.
+    virtual void ManagerRemoved();
+
+    // Called when the group with object path |object_path| is added to the
+    // system.
+    virtual void GroupAdded(const dbus::ObjectPath& object_path);
+
+    // Called when the group with object path |object_path| is removed from
+    // the system.
+    virtual void GroupRemoved(const dbus::ObjectPath& object_path);
+
+    // Called when the adapter with object path |object_path| has a
+    // change in value of the property named |property_name|.
+    virtual void GroupPropertyChanged(const dbus::ObjectPath& object_path,
+                                      const std::string& property_name);
+  };
+
+  ~LeadershipDaemonManagerClient() override;
+
+  // Factory function, creates a new instance which is owned by the caller.
+  // For normal usage, access the singleton via DBusThreadManager::Get().
+  static LeadershipDaemonManagerClient* Create();
+
+  // Adds and removes observers for events on all leadership group
+  // events. Check the |object_path| parameter of observer methods to
+  // determine which group is issuing the event.
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+
+  // Calls JoinGroup method.
+  // |callback| is called with its |call_status| argument set to
+  // DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
+  // |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
+  virtual void JoinGroup(const std::string& group,
+                         const base::DictionaryValue& options,
+                         const StringDBusMethodCallback& callback) = 0;
+
+  // Calls LeaveGroup method.
+  // |callback| is called with its |call_status| argument set to
+  // DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
+  // |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
+  virtual void LeaveGroup(const std::string& object_path,
+                          const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls SetScore method.
+  // |callback| is called with its |call_status| argument set to
+  // DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
+  // |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
+  virtual void SetScore(const std::string& object_path,
+                        int score,
+                        const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls PokeLeader method.
+  // |callback| is called with its |call_status| argument set to
+  // DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
+  // |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
+  virtual void PokeLeader(const std::string& object_path,
+                          const VoidDBusMethodCallback& callback) = 0;
+
+  // Calls Ping method.
+  // |callback| is called with its |call_status| argument set to
+  // DBUS_METHOD_CALL_SUCCESS if the method call succeeds. Otherwise,
+  // |callback| is called with |call_status| set to DBUS_METHOD_CALL_FAILURE.
+  virtual void Ping(const StringDBusMethodCallback& callback) = 0;
+
+  // Obtains the properties for the group with object path |object_path|,
+  // any values should be copied if needed.
+  virtual const GroupProperties* GetGroupProperties(
+      const dbus::ObjectPath& object_path) = 0;
+
+ protected:
+  // Create() should be used instead.
+  LeadershipDaemonManagerClient();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LeadershipDaemonManagerClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_LEADERSHIP_DAEMON_MANAGER_CLIENT_H_