Hey Alex and Dan,

In the 2.21.x cycle, GSimpleAsyncResult started printing

 g_simple_async_result_complete() called from outside main loop!

in some of my programs using the GIO async stack for D-Bus operations. Let me first explain when this happens and then we can discuss what to do about it.

In both EggDBus [1] and some of the work that this work inspired, the GDBus work [2], the basic primitive is this asynchronous method

 guint        g_dbus_connection_send_dbus_1_message_with_reply
                (GDBusConnection    *connection,
                 DBusMessage        *message,
                 gint                timeout_msec,
                 GCancellable       *cancellable,
                 GAsyncReadyCallback callback,
                 gpointer            user_data);
 
 DBusMessage *g_dbus_connection_send_dbus_1_message_with_reply_finish
                (GDBusConnection *connection,
                 GAsyncResult    *res,
                 GError         **error);

and generated code (from IDL) typically end up calling these methods.

Now, to easily implement synchronous D-Bus calls, the send_dbus_1_message_with_reply() returns an opaque pending call id so the user can call

 void         g_dbus_connection_send_dbus_1_message_block
                (GDBusConnection *connection,
                 guint pending_call_id);

which will block the thread (e.g. not wait in the mainloop). It guarantees that @callback will be invoked before the _send_dbus_1_message_block() function returns (this uses dbus_pending_call_block() internally). This makes it really simple to generate small client proxies - e.g.

 void foo_invoke_bar (Foo                *foo,
                      const gchar        *some_arg_with_signature_s,
                      GCancellable       *cancellable,
                      GAsyncReadyCallback callback,
                      gpointer            user_data)
 {
   ..
 }

 void foo_invoke_bar_finish (Foo             *foo,
                             GArray          *out_some_arg_with_signature_ay,
                             GAsyncResult    *res,
                             GError         **error)
 {
   ..
 }

which just encodes/decodes DBusMessage objects (using a utility methods on the GDBusProxy base-class that the Foo class inherits). Notably, the generated _sync function just calls foo_invoke_bar(), then the _block() method and then foo_invoke_bar_finish() to collect the results. Simple as pie, just like the doctor ordered for generated code.

Now, the problem here is that there may not _even_ be a mainloop available for all this: people should be able to call foo_invoke_bar_sync() from main() and have things work. In this case, however, g_main_current_source() returns NULL and this makes g_simple_async_result_complete() issue a warning...

(Btw, I know that the GDBusConnection code needs to check that g_dbus_connection_send_dbus_1_message_block() is called from the same thread that g_dbus_connection_send_dbus_1_message_with_reply() was called from).

It seems to me, but I'm not 100% sure, that it really isn't right for GSimpleAsyncResult to print "g_simple_async_result_complete() called from outside main loop!" - what is the exact reasoning for this?

Thanks,
David

[1] : http://cgit.freedesktop.org/~david/eggdbus
[2] : http://cgit.freedesktop.org/~david/gdbus-standalone