consts for imageburning

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 229 matching lines @@
   }
 
  private:
   Proxy proxy_;
   std::string name_;
   void (*monitor_)(void*, A1, A2);
   void* object_;
 
 };
 
+template <typename A1, typename A2, typename A3>
+class MonitorConnection<void (A1, A2, A3)> {
+ public:
+  MonitorConnection(const Proxy& proxy, const char* name,
+                    void (*monitor)(void*, A1, A2, A3), void* object)
+      : proxy_(proxy), name_(name), monitor_(monitor), object_(object) {
+  }
+
+  static void Run(::DBusGProxy*, A1 x, A2 y, A3 z, MonitorConnection* self) {
+    self->monitor_(self->object_, x, y, z);
+  }
+  const Proxy& proxy() const {
+    return proxy_;
+  }
+  const std::string& name() const {
+    return name_;
+  }
+
+ private:
+  Proxy proxy_;
+  std::string name_;
+  void (*monitor_)(void*, A1, A2, A3);
+  void* object_;
+
+};
+
 template <typename A1>
 MonitorConnection<void (A1)>* Monitor(const Proxy& proxy, const char* name,
                                       void (*monitor)(void*, A1),
                                       void* object) {
   typedef MonitorConnection<void (A1)> ConnectionType;
 
   ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
 
   ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
                             glib::type_to_gtypeid<A1>(), G_TYPE_INVALID);
@@ skipping 14 matching lines @@
   ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
                             glib::type_to_gtypeid<A1>(),
                             glib::type_to_gtypeid<A2>(),
                             G_TYPE_INVALID);
   ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
                                 G_CALLBACK(&ConnectionType::Run),
                                 result, NULL);
   return result;
 }
 
+template <typename A1, typename A2, typename A3>
+MonitorConnection<void (A1, A2, A3)>* Monitor(const Proxy& proxy,
+                                          const char* name,
+                                          void (*monitor)(void*, A1, A2, A3),
+                                          void* object) {
+  typedef MonitorConnection<void (A1, A2, A3)> ConnectionType;
+
+  ConnectionType* result = new ConnectionType(proxy, name, monitor, object);
+
+  ::dbus_g_proxy_add_signal(proxy.gproxy(), name,
+                            glib::type_to_gtypeid<A1>(),
+                            glib::type_to_gtypeid<A2>(),
+                            glib::type_to_gtypeid<A3>(),
+                            G_TYPE_INVALID);
+  ::dbus_g_proxy_connect_signal(proxy.gproxy(), name,
+                                G_CALLBACK(&ConnectionType::Run),
+                                result, NULL);
+  return result;
+}
+
 template <typename F>
 void Disconnect(MonitorConnection<F>* connection) {
   typedef MonitorConnection<F> ConnectionType;
 
   ::dbus_g_proxy_disconnect_signal(connection->proxy().gproxy(),
                                    connection->name().c_str(),
                                    G_CALLBACK(&ConnectionType::Run),
                                    connection);
   delete connection;
 }
@@ skipping 66 matching lines @@
 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_