Two changes to the DBus C++ library.

src/common/chromeos/dbus/dbus.h

 // Copyright (c) 2009 The Chromium OS 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_H_
 #define CHROMEOS_DBUS_H_
 
 #include <dbus/dbus-glib.h>
 #include <glib-object.h>
 
@@ skipping 33 matching lines @@
   BusConnection& operator=(BusConnection x) {
     swap(*this, x);
     return *this;
   }
 
  private:
   friend void swap(BusConnection& x, BusConnection& y);
 
   friend class Proxy;
   friend BusConnection GetSystemBusConnection();
+  friend BusConnection GetPrivateBusConnection(const char* address);
 
   // Constructor takes ownership
   explicit BusConnection(::DBusGConnection* x)
       : object_(x) {
     DCHECK(object_) << "Constructing BusConnection with NULL object.";
   }
 
   value_type object_;
 };
 
 inline void swap(BusConnection& x, BusConnection& y) {
   std::swap(x.object_, y.object_);
 }
 
 // \brief Proxy manages the ref-count for a ::DBusGProxy*.
 //
 // Proxy has reference semantics and represents a connection to on object on
 // the bus. A proxy object is constructed with a connection to a bus, a name
 // to an entity on the bus, a path to an object owned by the entity, and an
 // interface protocol name used to communicate with the object.
 
 class Proxy {
  public:
   typedef ::DBusGProxy* value_type;
 
   Proxy()
       : object_(NULL) {
   }
 
+  // Set |connect_to_name_owner| true if you'd like to use
+  // dbus_g_proxy_new_for_name_owner() rather than dbus_g_proxy_new_for_name().
+  Proxy(const BusConnection& connection,
+        const char* name,
+        const char* path,
+        const char* interface,
+        bool connect_to_name_owner)
+      : object_(GetGProxy(
+          connection, name, path, interface, connect_to_name_owner)) {
+  }
+
+  // Equivalent to Proxy(connection, name, path, interface, false).
   Proxy(const BusConnection& connection,
         const char* name,
         const char* path,
         const char* interface)
-      : object_(::dbus_g_proxy_new_for_name(connection.object_, name, path,
-                                            interface)) {
-    DCHECK(object_) << "Failed to construct proxy.";
+      : object_(GetGProxy(connection, name, path, interface, false)) {
   }
 
   Proxy(const Proxy& x)
       : object_(x.object_) {
     if (object_)
       ::g_object_ref(object_);
   }
 
   ~Proxy() {
     if (object_)
@@ skipping 16 matching lines @@
   const value_type& gproxy() const {
     DCHECK(object_) << "referencing an empty proxy";
     return object_;
   }
 
   operator bool() const {
     return object_;
   }
 
  private:
+  static value_type GetGProxy(const BusConnection& connection,
+                              const char* name,
+                              const char* path,
+                              const char* interface,
+                              bool connect_to_name_owner);
+
   operator int() const;  // for safe bool cast
   friend void swap(Proxy& x, Proxy& y);
 
   value_type object_;
 };
 
 inline void swap(Proxy& x, Proxy& y) {
   std::swap(x.object_, y.object_);
 }
 
@@ skipping 137 matching lines @@
                       T* result) {
   glib::ScopedError error;
   glib::Value value;
 
   if (!::dbus_g_proxy_call(proxy.gproxy(), "Get", &Resetter(&error).lvalue(),
                            G_TYPE_STRING, interface,
                            G_TYPE_STRING, property,
                            G_TYPE_INVALID,
                            G_TYPE_VALUE, &value,
                            G_TYPE_INVALID)){
-    LOG(ERROR) << "Getting property failed: " << (error->message ? error->message : "Unknown Error.");
+    LOG(ERROR) << "Getting property failed: "
+               << (error->message ? error->message : "Unknown Error.");
     return false;
 
   }
   return glib::Retrieve(value, result);
 }
 
 // \brief RetrieveProperties returns a HashTable of all properties for the
 // specified interface.
 
 bool RetrieveProperties(const Proxy& proxy,
                         const char* interface,
                         glib::ScopedHashTable* result);
 
 // \brief Returns a connection to the system bus.
 
 BusConnection GetSystemBusConnection();
 
+// \brief Returns a private connection to a bus at |address|.
+
+BusConnection GetPrivateBusConnection(const char* address);
+
 }  // namespace dbus
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_H_