[glibmm] giomm: Provide non-cancellable overloads for newly added API.

[José Alburquerque <jaalburqu src gnome org>]

commit 14eaf3223fa42bab37fc70112030f76b5f49e46c
Author: José Alburquerque <jaalburqu svn gnome org>
Date:   Sun Nov 14 23:29:35 2010 -0500

    	giomm: Provide non-cancellable overloads for newly added API.
    
    	* gio/src/application.hg: Completed a TODO.
    	* gio/src/asyncinitable.hg (init_async): Refer to existing method docs
    	in the non-cancellable version instead of duplicating docs.
    	* gio/src/dbusconnection.{ccg,hg}: Add non-cancellable overloads of
    	the constructors and create methods instead of having a default null
    	Cancellable parameter.  Renamed the synchronized create*() methods to
    	create*_sync().
    	(get): Added a non-cancellable overload as above.
    	* gio/src/dbusproxy.{ccg,hg}: Added non-cancellable overloads of the
    	constructors and create methods.  Renamed the create*() synchronized
    	methods to create*_sync() as above.
    	(call): Added a non-cancellable overload as above.
    	* gio/src/dbusserver.{ccg,hg}: Add non-cancellable overloads of the
    	constructor and create method.  Renamed the create() synchronized
    	method to create_sync() as above.

 ChangeLog                  |   20 ++++
 gio/src/application.hg     |    3 +-
 gio/src/asyncinitable.hg   |   30 +-----
 gio/src/dbusconnection.ccg |  185 ++++++++++++++++++++++++++++-----
 gio/src/dbusconnection.hg  |  119 +++++++++++++++++----
 gio/src/dbusproxy.ccg      |  247 +++++++++++++++++++++++++++++++++++++-------
 gio/src/dbusproxy.hg       |  160 +++++++++++++++++++++++------
 gio/src/dbusserver.ccg     |   36 ++++++-
 gio/src/dbusserver.hg      |   26 ++++-
 9 files changed, 666 insertions(+), 160 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index cafd0cf..8a13304 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,25 @@
 2010-11-14  José Alburquerque  <jaalburqu svn gnome org>
 
+	giomm: Provide non-cancellable overloads for newly added API.
+
+	* gio/src/application.hg: Completed a TODO.
+	* gio/src/asyncinitable.hg (init_async): Refer to existing method docs
+	in the non-cancellable version instead of duplicating docs.
+	* gio/src/dbusconnection.{ccg,hg}: Add non-cancellable overloads of
+	the constructors and create methods instead of having a default null
+	Cancellable parameter.  Renamed the synchronized create*() methods to
+	create*_sync().
+	(get): Added a non-cancellable overload as above.
+	* gio/src/dbusproxy.{ccg,hg}: Added non-cancellable overloads of the
+	constructors and create methods.  Renamed the create*() synchronized
+	methods to create*_sync() as above.
+	(call): Added a non-cancellable overload as above.
+	* gio/src/dbusserver.{ccg,hg}: Add non-cancellable overloads of the
+	constructor and create method.  Renamed the create() synchronized
+	method to create_sync() as above.
+
+2010-11-14  José Alburquerque  <jaalburqu svn gnome org>
+
 	Correct @newin{}'s and add class docs of newly added API.
 
 	* gio/src/application.hg:
diff --git a/gio/src/application.hg b/gio/src/application.hg
index ed70482..54e7109 100644
--- a/gio/src/application.hg
+++ b/gio/src/application.hg
@@ -104,9 +104,10 @@ public:
   _WRAP_METHOD(bool is_registered() const, g_application_get_is_registered)
   _WRAP_METHOD(bool is_remote() const, g_application_get_is_remote)
 
-  //TODO: Add a version with no cancellable.
   //Renamed from register() because that is a C++ keyword.
   _WRAP_METHOD(bool register_application(const Glib::RefPtr<Gio::Cancellable>& cancellable), g_application_register, errthrow)
+
+  /// Non-cancellable version of register_application().
   bool register_application();
 
   _WRAP_METHOD(void hold(), g_application_hold)
diff --git a/gio/src/asyncinitable.hg b/gio/src/asyncinitable.hg
index e75985f..973341e 100644
--- a/gio/src/asyncinitable.hg
+++ b/gio/src/asyncinitable.hg
@@ -93,35 +93,7 @@ protected:
     int io_priority = Glib::PRIORITY_DEFAULT);
   _IGNORE(g_async_initable_init_async)
 
-  /** Starts asynchronous initialization of the object implementing the
-   * interface. This must be done before any real use of the object after
-   * initial construction. If the object also implements Initable you can
-   * optionally call Gio::Initable::init() instead.
-   *
-   * When the initialization is finished, @a slot will be called. You can
-   * then call init_finish() to get the result of the initialization.
-   *
-   * If this function is not called, or returns with an error, then all
-   * operations on the object should fail, generally returning the error
-   * Gio::IO_ERROR_NOT_INITIALIZED.
-   *
-   * Implementations of this method must be idempotent: i.e. multiple calls to
-   * this function with the same argument should return the same results. Only
-   * the first call initializes the object; further calls return the result of
-   * the first call. This is so that it's safe to implement the singleton
-   * pattern in the GObject constructor function.
-   *
-   * For classes that also support the Initable interface, the default
-   * implementation of this method will run the Gio::Initable::init() method
-   * in a thread, so if you want to support asynchronous initialization via
-   * threads, just implement the AsyncInitable interface without overriding
-   * any interface methods.
-   *
-   * @param io_priority The I/O priority of the operation.
-   * @param slot a SlotAsyncReady to call when the request is satisfied.
-   *
-   * @newin{2,28}
-   */
+  /// Non-cancellable version of init_async().
   void init_async(const SlotAsyncReady& slot,
     int io_priority = Glib::PRIORITY_DEFAULT);
 
diff --git a/gio/src/dbusconnection.ccg b/gio/src/dbusconnection.ccg
index cf3cc8d..bdb98ff 100644
--- a/gio/src/dbusconnection.ccg
+++ b/gio/src/dbusconnection.ccg
@@ -25,9 +25,11 @@ namespace Gio
 {
 
 DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
-  const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-  const SlotAsyncReady& slot, DBusConnectionFlags flags,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 :
   _CONSTRUCT("stream", Glib::unwrap(stream),
     "guid", (guid.empty() ? 0 : guid.c_str()),
@@ -37,9 +39,25 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
   init_async(slot, cancellable);
 }
 
+DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  DBusConnectionFlags flags)
+:
+  _CONSTRUCT("stream", Glib::unwrap(stream),
+    "guid", (guid.empty() ? 0 : guid.c_str()),
+    "flags", static_cast<GDBusConnectionFlags>(flags),
+    "authentication-observer", Glib::unwrap(observer))
+{
+  init_async(slot, 0);
+}
+
 DBusConnection::DBusConnection(const Glib::ustring& address,
-  const Glib::RefPtr<DBusAuthObserver>& observer, const SlotAsyncReady& slot,
-  DBusConnectionFlags flags, const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 :
   _CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
     "flags", static_cast<GDBusConnectionFlags>(flags),
@@ -48,9 +66,23 @@ DBusConnection::DBusConnection(const Glib::ustring& address,
   init_async(slot, cancellable);
 }
 
+DBusConnection::DBusConnection(const Glib::ustring& address,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  DBusConnectionFlags flags)
+:
+  _CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
+    "flags", static_cast<GDBusConnectionFlags>(flags),
+    "observer", Glib::unwrap(observer))
+{
+  init_async(slot, 0);
+}
+
 DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
-  const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-  DBusConnectionFlags flags, const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 :
   _CONSTRUCT("stream", Glib::unwrap(stream),
     "guid", (guid.empty() ? 0 : guid.c_str()),
@@ -60,9 +92,23 @@ DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
   init(cancellable);
 }
 
+DBusConnection::DBusConnection(const Glib::RefPtr<IOStream>& stream,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  DBusConnectionFlags flags)
+:
+  _CONSTRUCT("stream", Glib::unwrap(stream),
+    "guid", (guid.empty() ? 0 : guid.c_str()),
+    "flags", static_cast<GDBusConnectionFlags>(flags),
+    "authentication-observer", Glib::unwrap(observer))
+{
+  init(Glib::RefPtr<Cancellable>(0));
+}
+
 DBusConnection::DBusConnection(const Glib::ustring& address,
-  const Glib::RefPtr<DBusAuthObserver>& observer, DBusConnectionFlags flags,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 :
   _CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
     "flags", static_cast<GDBusConnectionFlags>(flags),
@@ -71,10 +117,23 @@ DBusConnection::DBusConnection(const Glib::ustring& address,
   init(cancellable);
 }
 
+DBusConnection::DBusConnection(const Glib::ustring& address,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  DBusConnectionFlags flags)
+:
+  _CONSTRUCT("address", (address.empty() ? 0 : address.c_str()),
+    "flags", static_cast<GDBusConnectionFlags>(flags),
+    "observer", Glib::unwrap(observer))
+{
+  init(Glib::RefPtr<Cancellable>(0));
+}
+
 void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
-  const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-  const SlotAsyncReady& slot, DBusConnectionFlags flags,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 {
   // Note that this does not return anything, because it is async - see
   // create_finish().
@@ -84,22 +143,52 @@ void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
   // goes out of scope.  The finished connection will be returned in the slot
   // by calling create_finish().
   Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid, observer,
-    slot, flags, cancellable))->reference();
+    slot, cancellable, flags))->reference();
 }
 
-Glib::RefPtr<DBusConnection> DBusConnection::create(
-  const Glib::RefPtr<IOStream>& stream, const Glib::ustring& guid,
-  const Glib::RefPtr<DBusAuthObserver>& observer, DBusConnectionFlags flags,
-  const Glib::RefPtr<Cancellable>& cancellable)
+void DBusConnection::create(const Glib::RefPtr<IOStream>& stream,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  DBusConnectionFlags flags)
+{
+  // Note that this does not return anything, because it is async - see
+  // create_finish().
+
+  // Create the connection, taking an extra reference without returning it.
+  // The extra reference is taken so the connection is not destroyed when it
+  // goes out of scope.  The finished connection will be returned in the slot
+  // by calling create_finish().
+  Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid, observer,
+    slot, flags))->reference();
+}
+
+Glib::RefPtr<DBusConnection> DBusConnection::create_sync(
+  const Glib::RefPtr<IOStream>& stream,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 {
   return Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid,
-    observer, flags, cancellable));
+    observer, cancellable, flags));
 }
 
+Glib::RefPtr<DBusConnection> DBusConnection::create_sync(
+  const Glib::RefPtr<IOStream>& stream,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  DBusConnectionFlags flags)
+{
+  return Glib::RefPtr<DBusConnection>(new DBusConnection(stream, guid,
+    observer, flags));
+}
 
 void DBusConnection::create_for_address(const Glib::ustring& address,
-  const Glib::RefPtr<DBusAuthObserver>& observer, const SlotAsyncReady& slot,
-  DBusConnectionFlags flags, const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
 {
   // Note that this does not return anything, because it is async - see
   // create_finish().
@@ -109,15 +198,42 @@ void DBusConnection::create_for_address(const Glib::ustring& address,
   // goes out of scope.  The finished connection will be returned in the slot
   // by calling create_finish().
   Glib::RefPtr<DBusConnection>(new DBusConnection(address, observer, slot,
-    flags, cancellable))->reference();
+    cancellable, flags))->reference();
 }
 
-Glib::RefPtr<DBusConnection> DBusConnection::create_for_address(
-  const Glib::ustring& address, const Glib::RefPtr<DBusAuthObserver>& observer,
-  DBusConnectionFlags flags, const Glib::RefPtr<Cancellable>& cancellable)
+void DBusConnection::create_for_address(const Glib::ustring& address,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const SlotAsyncReady& slot,
+  DBusConnectionFlags flags)
+{
+  // Note that this does not return anything, because it is async - see
+  // create_finish().
+
+  // Create the connection, taking an extra reference without returning it.
+  // The extra reference is taken so the connection is not destroyed when it
+  // goes out of scope.  The finished connection will be returned in the slot
+  // by calling create_finish().
+  Glib::RefPtr<DBusConnection>(new DBusConnection(address, observer, slot,
+    flags))->reference();
+}
+
+Glib::RefPtr<DBusConnection> DBusConnection::create_for_address_sync(
+  const Glib::ustring& address,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusConnectionFlags flags)
+{
+  return Glib::RefPtr<DBusConnection>(new DBusConnection(address, observer,
+    cancellable, flags));
+}
+
+Glib::RefPtr<DBusConnection> DBusConnection::create_for_address_sync(
+  const Glib::ustring& address,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  DBusConnectionFlags flags)
 {
   return Glib::RefPtr<DBusConnection>(new DBusConnection(address, observer,
-    flags, cancellable));
+    flags));
 }
 
 void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot,
@@ -129,6 +245,13 @@ void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot,
     &SignalProxy_async_callback, slot_copy);
 }
 
+void DBusConnection::get(BusType bus_type, const SlotAsyncReady& slot)
+{
+  SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+  g_bus_get(static_cast<GBusType>(bus_type), 0, &SignalProxy_async_callback,
+    slot_copy);
+}
 
 void DBusConnection::close()
 {
@@ -208,4 +331,16 @@ void DBusConnection::send_message_with_reply(const Glib::RefPtr<DBusMessage>& me
   message->set_serial(out_serial);
 }
 
+void DBusConnection::send_message_with_reply(const Glib::RefPtr<DBusMessage>& message, int timeout_msec,const SlotAsyncReady& slot)
+{
+  SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+  volatile guint32 out_serial;
+  g_dbus_connection_send_message_with_reply(gobj(), Glib::unwrap(message),
+                                      static_cast<GDBusSendMessageFlags>(message->get_flags()),
+                                      timeout_msec, &out_serial,
+                                      0, &SignalProxy_async_callback,
+                                      slot_copy);
+  message->set_serial(out_serial);
+}
+
 } // namespace Gio
diff --git a/gio/src/dbusconnection.hg b/gio/src/dbusconnection.hg
index a8b69a1..336e742 100644
--- a/gio/src/dbusconnection.hg
+++ b/gio/src/dbusconnection.hg
@@ -63,22 +63,48 @@ protected:
 protected:
 
   DBusConnection(const Glib::RefPtr<IOStream>& stream,
-    const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-    const SlotAsyncReady& slot, DBusConnectionFlags flags,
-    const Glib::RefPtr<Cancellable>& cancellable);
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags);
+
+  DBusConnection(const Glib::RefPtr<IOStream>& stream,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const SlotAsyncReady& slot,
+    DBusConnectionFlags flags);
+
+  DBusConnection(const Glib::RefPtr<IOStream>& stream,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags);
 
   DBusConnection(const Glib::RefPtr<IOStream>& stream,
-    const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-    DBusConnectionFlags flags, const Glib::RefPtr<Cancellable>& cancellable);
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    DBusConnectionFlags flags);
 
   DBusConnection(const Glib::ustring& address,
     const Glib::RefPtr<DBusAuthObserver>& observer,
-    const SlotAsyncReady& slot, DBusConnectionFlags flags,
-    const Glib::RefPtr<Cancellable>& cancellable);
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags);
+
+  DBusConnection(const Glib::ustring& address,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const SlotAsyncReady& slot,
+    DBusConnectionFlags flags);
 
   DBusConnection(const Glib::ustring& address,
     const Glib::RefPtr<DBusAuthObserver>& observer,
-    DBusConnectionFlags flags, const Glib::RefPtr<Cancellable>& cancellable);
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags);
+
+  DBusConnection(const Glib::ustring& address,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    DBusConnectionFlags flags);
 
 public:
 
@@ -96,28 +122,48 @@ public:
    *
    * @newin{2,28}
    */
-  void get(BusType bus_type, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+  void get(BusType bus_type, const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable);
   _IGNORE(g_bus_get)
 
+  /** Non-cancellable version of get().
+   */
+  void get(BusType bus_type, const SlotAsyncReady& slot);
+
   /** @throw Glib::Error.
    */
   _WRAP_METHOD(static Glib::RefPtr<DBusConnection> get_finish(const Glib::RefPtr<AsyncResult>& res), g_bus_get_finish, errthrow)
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new)
   void create(const Glib::RefPtr<IOStream>& stream,
-    const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+
+  /// Non-cancellable version of create().
+  void create(const Glib::RefPtr<IOStream>& stream,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
     const SlotAsyncReady& slot,
-    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
 
   /// @throw Glib::Error.
   _WRAP_METHOD(static Glib::RefPtr<DBusConnection> create_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_new_finish, errthrow)
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address)
   void create_for_address(const Glib::ustring& address,
-    const Glib::RefPtr<DBusAuthObserver>& observer, const SlotAsyncReady& slot,
-    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+
+  /// Non-cancellable version of create_for_address().
+  void create_for_address(const Glib::ustring& address,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const SlotAsyncReady& slot,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
 
   /// @throw Glib::Error.
   _WRAP_METHOD(static Glib::RefPtr<DBusConnection> create_for_address_finish(const Glib::RefPtr<AsyncResult>& res), g_dbus_connection_new_for_address_finish, errthrow)
@@ -125,18 +171,36 @@ public:
   _WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_sync)
   /** @throw Glib::Error.
    */
-  Glib::RefPtr<DBusConnection> create(const Glib::RefPtr<IOStream>& stream,
-    const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+  Glib::RefPtr<DBusConnection> create_sync(
+    const Glib::RefPtr<IOStream>& stream,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+
+  /** Non-cancellable version of create_sync().
+   */
+  Glib::RefPtr<DBusConnection> create_sync(
+    const Glib::RefPtr<IOStream>& stream,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_connection_new_for_address_sync)
   /** @throw Glib::Error.
    */
-  Glib::RefPtr<DBusConnection> create_for_address(const Glib::ustring& address,
+  Glib::RefPtr<DBusConnection> create_for_address_sync(
+    const Glib::ustring& address,
     const Glib::RefPtr<DBusAuthObserver>& observer,
-    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
+
+  /** Non-cancellable version of create_for_address_sync().
+   */
+  Glib::RefPtr<DBusConnection> create_for_address_sync(
+    const Glib::ustring& address,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    DBusConnectionFlags flags = Gio::DBUS_CONNECTION_FLAGS_NONE);
 
   /** Closes the connection. Note that this never causes the process to exit
    * (this might only happen if the other end of a shared message bus
@@ -333,9 +397,18 @@ public:
    *
    * @newin{2,28}
    */
-  void send_message_with_reply(const Glib::RefPtr<DBusMessage>& message, int timeout_msec, const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+  void send_message_with_reply(const Glib::RefPtr<DBusMessage>& message,
+    int timeout_msec,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable);
   _IGNORE(g_dbus_connection_send_message_with_reply)
 
+  /** Non-cancellable version of send_message_with_reply().
+   */
+  void send_message_with_reply(const Glib::RefPtr<DBusMessage>& message,
+    int timeout_msec,
+    const SlotAsyncReady& slot);
+
   /// @throw Glib::Error.
   _WRAP_METHOD(Glib::RefPtr<DBusMessage> send_message_with_reply_finish(const Glib::RefPtr<AsyncResult>& result), g_dbus_connection_send_message_with_reply_finish, errthrow)
 
diff --git a/gio/src/dbusproxy.ccg b/gio/src/dbusproxy.ccg
index 3259168..334ea4a 100644
--- a/gio/src/dbusproxy.ccg
+++ b/gio/src/dbusproxy.ccg
@@ -27,10 +27,13 @@ namespace Gio
 {
 
 DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
-  DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-  const Glib::ustring& name, const Glib::ustring& object_path,
-  const Glib::ustring& interface_name, const SlotAsyncReady& slot,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 :
 _CONSTRUCT("g-connection", Glib::unwrap(connection),
   "g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -43,10 +46,30 @@ _CONSTRUCT("g-connection", Glib::unwrap(connection),
 }
 
 DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
-  DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-  const Glib::ustring& name, const Glib::ustring& object_path,
+  const Glib::ustring& object_path,
   const Glib::ustring& interface_name,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const SlotAsyncReady& slot,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+:
+_CONSTRUCT("g-connection", Glib::unwrap(connection),
+  "g-flags", static_cast<GDBusProxyFlags>(flags),
+  "g-interface-info", Glib::unwrap(info),
+  "name", (name.empty() ? 0 : name.c_str()),
+  "g-object-path", (object_path.empty() ? 0 : object_path.c_str()),
+  "g-interface-name", (interface_name.empty() ? 0 : interface_name.c_str()))
+{
+  init_async(slot, Glib::RefPtr<Cancellable>());
+}
+
+DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 :
 _CONSTRUCT("g-connection", Glib::unwrap(connection),
   "g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -58,10 +81,31 @@ _CONSTRUCT("g-connection", Glib::unwrap(connection),
   init(cancellable);
 }
 
-DBusProxy::DBusProxy(BusType bus_type, DBusProxyFlags flags,
-  const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-  const Glib::ustring& object_path, const Glib::ustring& interface_name,
-  const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
+DBusProxy::DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+:
+_CONSTRUCT("g-connection", Glib::unwrap(connection),
+  "g-flags", static_cast<GDBusProxyFlags>(flags),
+  "g-interface-info", Glib::unwrap(info),
+  "name", (name.empty() ? 0 : name.c_str()),
+  "g-object-path", (object_path.empty() ? 0 : object_path.c_str()),
+  "g-interface-name", (interface_name.empty() ? 0 : interface_name.c_str()))
+{
+  init(Glib::RefPtr<Cancellable>());
+}
+
+DBusProxy::DBusProxy(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 :
 _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
   "g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -73,10 +117,31 @@ _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
   init_async(slot, cancellable);
 }
 
-DBusProxy::DBusProxy(BusType bus_type, DBusProxyFlags flags,
-  const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-  const Glib::ustring& object_path, const Glib::ustring& interface_name,
-  const Glib::RefPtr<Cancellable>& cancellable)
+DBusProxy::DBusProxy(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+:
+_CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
+  "g-flags", static_cast<GDBusProxyFlags>(flags),
+  "g-interface-info", Glib::unwrap(info),
+  "name", (name.empty() ? 0 : name.c_str()),
+  "g-object-path", (object_path.empty() ? 0 : object_path.c_str()),
+  "g-interface-name", (interface_name.empty() ? 0 : interface_name.c_str()))
+{
+  init_async(slot, Glib::RefPtr<Cancellable>());
+}
+
+DBusProxy::DBusProxy(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 :
 _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
   "g-flags", static_cast<GDBusProxyFlags>(flags),
@@ -88,52 +153,135 @@ _CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
   init(cancellable);
 }
 
+DBusProxy::DBusProxy(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+:
+_CONSTRUCT("g-bus-type", static_cast<GBusType>(bus_type),
+  "g-flags", static_cast<GDBusProxyFlags>(flags),
+  "g-interface-info", Glib::unwrap(info),
+  "name", (name.empty() ? 0 : name.c_str()),
+  "g-object-path", (object_path.empty() ? 0 : object_path.c_str()),
+  "g-interface-name", (interface_name.empty() ? 0 : interface_name.c_str()))
+{
+  init(Glib::RefPtr<Cancellable>());
+}
+
+void DBusProxy::create(const Glib::RefPtr<DBusConnection>& connection,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+{
+  // Create the proxy, taking an extra reference without returning it.  The
+  // extra reference is taken so the proxy is not destroyed when it goes out
+  // of scope.  The finished proxy will be returned in the slot by calling
+  // create_finish().
+  Glib::RefPtr<DBusProxy>(new DBusProxy(connection, object_path,
+    interface_name, slot, cancellable, name, info, flags))->reference();
+}
+
 void DBusProxy::create(const Glib::RefPtr<DBusConnection>& connection,
-  DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-  const Glib::ustring& name, const Glib::ustring& object_path,
+  const Glib::ustring& object_path,
   const Glib::ustring& interface_name,
-  const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
+  const SlotAsyncReady& slot,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 {
   // Create the proxy, taking an extra reference without returning it.  The
   // extra reference is taken so the proxy is not destroyed when it goes out
   // of scope.  The finished proxy will be returned in the slot by calling
   // create_finish().
-  Glib::RefPtr<DBusProxy>(new DBusProxy(connection, flags, info, name,
-    object_path, interface_name, slot, cancellable))->reference();
+  Glib::RefPtr<DBusProxy>(new DBusProxy(connection, object_path,
+    interface_name, slot, name, info, flags))->reference();
 }
 
 Glib::RefPtr<DBusProxy>
-DBusProxy::create(const Glib::RefPtr<DBusConnection>& connection,
-  DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-  const Glib::ustring& name, const Glib::ustring& object_path,
+DBusProxy::create_sync(const Glib::RefPtr<DBusConnection>& connection,
+  const Glib::ustring& object_path,
   const Glib::ustring& interface_name,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+{
+  return Glib::RefPtr<DBusProxy>(new DBusProxy(connection,
+    object_path, interface_name, cancellable, name, info, flags));
+}
+
+Glib::RefPtr<DBusProxy>
+DBusProxy::create_sync(const Glib::RefPtr<DBusConnection>& connection,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::ustring& name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 {
-  return Glib::RefPtr<DBusProxy>(new DBusProxy(connection, flags, info, name,
-    object_path, interface_name, cancellable));
+  return Glib::RefPtr<DBusProxy>(new DBusProxy(connection,
+    object_path, interface_name, name, info, flags));
 }
 
-void DBusProxy::create_for_bus(BusType bus_type, DBusProxyFlags flags,
-  const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-  const Glib::ustring& object_path, const Glib::ustring& interface_name,
-  const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable)
+void DBusProxy::create_for_bus(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 {
   // Create the proxy, taking an extra reference without returning it.  The
   // extra reference is taken so the proxy is not destroyed when it goes out
   // of scope.  The finished proxy will be returned in the slot by calling
   // create_finish().
-  Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, flags, info, name,
-    object_path, interface_name, slot, cancellable))->reference();
+  Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, name, object_path,
+    interface_name, slot, cancellable, info, flags))->reference();
 }
 
-Glib::RefPtr<DBusProxy> DBusProxy::create_for_bus(BusType bus_type,
-  DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-  const Glib::ustring& name, const Glib::ustring& object_path,
+void DBusProxy::create_for_bus(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
   const Glib::ustring& interface_name,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
 {
-  return Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, flags, info, name,
-    object_path, interface_name, cancellable));
+  // Create the proxy, taking an extra reference without returning it.  The
+  // extra reference is taken so the proxy is not destroyed when it goes out
+  // of scope.  The finished proxy will be returned in the slot by calling
+  // create_finish().
+  Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, name, object_path,
+    interface_name, slot, info, flags))->reference();
+}
+
+Glib::RefPtr<DBusProxy> DBusProxy::create_for_bus_sync(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+{
+  return Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, name,
+    object_path, interface_name, cancellable, info, flags));
+}
+
+Glib::RefPtr<DBusProxy> DBusProxy::create_for_bus_sync(BusType bus_type,
+  const Glib::ustring& name,
+  const Glib::ustring& object_path,
+  const Glib::ustring& interface_name,
+  const Glib::RefPtr<DBusInterfaceInfo>& info,
+  DBusProxyFlags flags)
+{
+  return Glib::RefPtr<DBusProxy>(new DBusProxy(bus_type, name,
+    object_path, interface_name, info, flags));
 }
 
 void DBusProxy::get_cached_property(Glib::VariantBase& property,
@@ -147,9 +295,11 @@ void DBusProxy::get_cached_property(Glib::VariantBase& property,
 }
 
 void DBusProxy::call(const Glib::ustring& method_name,
-  int timeout_msec, const SlotAsyncReady& slot, DBusCallFlags flags,
+  int timeout_msec,
+  const SlotAsyncReady& slot,
+  const Glib::RefPtr<Cancellable>& cancellable,
   const Glib::VariantBase& parameters,
-  const Glib::RefPtr<Cancellable>& cancellable)
+  DBusCallFlags flags)
 {
   // Create a copy of the slot.
   // A pointer to it will be passed through the callback's data parameter
@@ -162,6 +312,23 @@ void DBusProxy::call(const Glib::ustring& method_name,
     Glib::unwrap(cancellable), &SignalProxy_async_callback, slot_copy);
 }
 
+void DBusProxy::call(const Glib::ustring& method_name,
+  int timeout_msec,
+  const SlotAsyncReady& slot,
+  const Glib::VariantBase& parameters,
+  DBusCallFlags flags)
+{
+  // Create a copy of the slot.
+  // A pointer to it will be passed through the callback's data parameter
+  // and deleted in the callback.
+  SlotAsyncReady* slot_copy = new SlotAsyncReady(slot);
+
+  g_dbus_proxy_call(gobj(), method_name.c_str(),
+    const_cast<GVariant*>(parameters.gobj()),
+    static_cast<GDBusCallFlags>(flags), timeout_msec,
+    0, &SignalProxy_async_callback, slot_copy);
+}
+
 void DBusProxy::call_finish(Glib::VariantBase& ret, const Glib::RefPtr<AsyncResult>& res)
 {
   GError *g_error = 0;
diff --git a/gio/src/dbusproxy.hg b/gio/src/dbusproxy.hg
index a269f1f..73202fb 100644
--- a/gio/src/dbusproxy.hg
+++ b/gio/src/dbusproxy.hg
@@ -70,37 +70,91 @@ class DBusProxy
   _CLASS_GOBJECT(DBusProxy, GDBusProxy, G_DBUS_PROXY, Glib::Object, GObject)
 
 protected:
+
   DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
-    DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-    const Glib::ustring& name, const Glib::ustring& object_path,
-    const Glib::ustring& interface_name, const SlotAsyncReady& slot,
-    const Glib::RefPtr<Cancellable>& cancellable);
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
   DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
-    DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-    const Glib::ustring& name, const Glib::ustring& object_path,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const SlotAsyncReady& slot,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  DBusProxy(const Glib::RefPtr<DBusConnection>& connection,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  DBusProxy(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
     const Glib::ustring& interface_name,
-    const Glib::RefPtr<Cancellable>& cancellable);
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
-  DBusProxy(BusType bus_type, DBusProxyFlags flags,
-    const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-    const Glib::ustring& object_path, const Glib::ustring& interface_name,
-    const SlotAsyncReady& slot, const Glib::RefPtr<Cancellable>& cancellable);
+  DBusProxy(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
-  DBusProxy(BusType bus_type, DBusProxyFlags flags,
-    const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-    const Glib::ustring& object_path, const Glib::ustring& interface_name,
-    const Glib::RefPtr<Cancellable>& cancellable);
+  DBusProxy(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  DBusProxy(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
 public:
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new)
   static void create(const Glib::RefPtr<DBusConnection>& connection,
-    DBusProxyFlags flags, const Glib::RefPtr<DBusInterfaceInfo>& info,
-    const Glib::ustring& name, const Glib::ustring& object_path,
+    const Glib::ustring& object_path,
     const Glib::ustring& interface_name,
     const SlotAsyncReady& slot,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  /// Non-cancellable version of create().
+  static void create(const Glib::RefPtr<DBusConnection>& connection,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const SlotAsyncReady& slot,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
   /** @throw Glib::Error.
    */
@@ -108,17 +162,41 @@ public:
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_sync)
   static Glib::RefPtr<DBusProxy>
-  create(const Glib::RefPtr<DBusConnection>& connection, DBusProxyFlags flags,
-    const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-    const Glib::ustring& object_path, const Glib::ustring& interface_name,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+  create_sync(const Glib::RefPtr<DBusConnection>& connection,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  /// Non-cancellable version of create_sync().
+  static Glib::RefPtr<DBusProxy>
+  create_sync(const Glib::RefPtr<DBusConnection>& connection,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::ustring& name = Glib::ustring(),
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus)
-  static void create_for_bus(BusType bus_type, DBusProxyFlags flags,
-    const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-    const Glib::ustring& object_path, const Glib::ustring& interface_name,
+  static void create_for_bus(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
     const SlotAsyncReady& slot,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  /// Non-cancellable version of create_for_bus().
+  static void create_for_bus(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const SlotAsyncReady& slot,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
   /** @throw Glib::Error.
    */
@@ -126,10 +204,22 @@ public:
 
   _WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_new_for_bus_sync)
   static Glib::RefPtr<DBusProxy>
-  create_for_bus(BusType bus_type, DBusProxyFlags flags,
-    const Glib::RefPtr<DBusInterfaceInfo>& info, const Glib::ustring& name,
-    const Glib::ustring& object_path, const Glib::ustring& interface_name,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+  create_for_bus_sync(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
+
+  /// Non-cancellable version of create_for_bus_sync().
+  static Glib::RefPtr<DBusProxy>
+  create_for_bus_sync(BusType bus_type,
+    const Glib::ustring& name,
+    const Glib::ustring& object_path,
+    const Glib::ustring& interface_name,
+    const Glib::RefPtr<DBusInterfaceInfo>& info = Glib::RefPtr<DBusInterfaceInfo>(),
+    DBusProxyFlags flags = DBUS_PROXY_FLAGS_NONE);
 
   _WRAP_METHOD(DBusProxyFlags get_flags() const, g_dbus_proxy_get_flags)
 
@@ -172,9 +262,15 @@ public:
   _WRAP_METHOD_DOCS_ONLY(g_dbus_proxy_call)
   void call(const Glib::ustring& method_name,
     int timeout_msec, const SlotAsyncReady& slot,
-    DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE,
+    const Glib::RefPtr<Cancellable>& cancellable,
     const Glib::VariantBase& parameters = Glib::VariantBase(),
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>());
+    DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE);
+
+  /// A non-cancellable version of call().
+  void call(const Glib::ustring& method_name,
+    int timeout_msec, const SlotAsyncReady& slot,
+    const Glib::VariantBase& parameters = Glib::VariantBase(),
+    DBusCallFlags flags = Gio::DBUS_CALL_FLAGS_NONE);
 
   /** Finishes an operation started with call().
    *
diff --git a/gio/src/dbusserver.ccg b/gio/src/dbusserver.ccg
index aee3b39..9aa02a1 100644
--- a/gio/src/dbusserver.ccg
+++ b/gio/src/dbusserver.ccg
@@ -25,8 +25,10 @@ namespace Gio
 {
 
 DBusServer::DBusServer(const Glib::ustring& address,
-  const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-  const Glib::RefPtr<Cancellable>& cancellable, DBusServerFlags flags)
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusServerFlags flags)
   : _CONSTRUCT("address",
     (address.empty() ? static_cast<char*>(0) : address.c_str()),
     "flags", static_cast<GDBusServerFlags>(flags),
@@ -36,12 +38,36 @@ DBusServer::DBusServer(const Glib::ustring& address,
   init(cancellable);
 }
 
-Glib::RefPtr<DBusServer> DBusServer::create(const Glib::ustring& address,
-  const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-  const Glib::RefPtr<Cancellable>& cancellable, DBusServerFlags flags)
+DBusServer::DBusServer(const Glib::ustring& address,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  DBusServerFlags flags)
+  : _CONSTRUCT("address",
+    (address.empty() ? static_cast<char*>(0) : address.c_str()),
+    "flags", static_cast<GDBusServerFlags>(flags),
+    "guid", (guid.empty() ? static_cast<char*>(0) : guid.c_str()),
+    "authentication-observer", Glib::unwrap(observer))
+{
+  init(Glib::RefPtr<Cancellable>());
+}
+
+Glib::RefPtr<DBusServer> DBusServer::create_sync(const Glib::ustring& address,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  const Glib::RefPtr<Cancellable>& cancellable,
+  DBusServerFlags flags)
 {
   return Glib::RefPtr<DBusServer>(new DBusServer(address, guid, observer,
     cancellable, flags));
 }
 
+Glib::RefPtr<DBusServer> DBusServer::create_sync(const Glib::ustring& address,
+  const Glib::ustring& guid,
+  const Glib::RefPtr<DBusAuthObserver>& observer,
+  DBusServerFlags flags)
+{
+  return Glib::RefPtr<DBusServer>(new DBusServer(address, guid, observer,
+    flags));
+}
+
 } // namespace Gio
diff --git a/gio/src/dbusserver.hg b/gio/src/dbusserver.hg
index 54d556c..276c24e 100644
--- a/gio/src/dbusserver.hg
+++ b/gio/src/dbusserver.hg
@@ -45,15 +45,31 @@ class DBusServer : public Glib::Object, public Initable
   _IMPLEMENTS_INTERFACE(Initable)
 
 protected:
+
+  DBusServer(const Glib::ustring& address,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusServerFlags flags);
+
   DBusServer(const Glib::ustring& address,
-    const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-    const Glib::RefPtr<Cancellable>& cancellable, DBusServerFlags flags);
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    DBusServerFlags flags);
 
 public:
+
   _WRAP_METHOD_DOCS_ONLY(g_dbus_server_new_sync)
-  static Glib::RefPtr<DBusServer> create(const Glib::ustring& address,
-    const Glib::ustring& guid, const Glib::RefPtr<DBusAuthObserver>& observer,
-    const Glib::RefPtr<Cancellable>& cancellable = Glib::RefPtr<Cancellable>(),
+  static Glib::RefPtr<DBusServer> create_sync(const Glib::ustring& address,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
+    const Glib::RefPtr<Cancellable>& cancellable,
+    DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE);
+
+  /// Non-cancellable version of create_sync().
+  static Glib::RefPtr<DBusServer> create_sync(const Glib::ustring& address,
+    const Glib::ustring& guid,
+    const Glib::RefPtr<DBusAuthObserver>& observer,
     DBusServerFlags flags = Gio::DBUS_SERVER_FLAGS_NONE);
 
   _WRAP_METHOD(void start(), g_dbus_server_start)