diff options
author | ruff <me@ruff.mobi> | 2020-09-23 20:22:28 +0200 |
---|---|---|
committer | GitHub <noreply@github.com> | 2020-09-23 20:22:28 +0200 |
commit | 67edd727512749faa0bcb4c5202cd4146c0e389e (patch) | |
tree | 060dd2b5f89aaa6cd9e943b2ec308073ef1ef2dd | |
parent | 58fde5ea4b0b9fbeb931a37c501aa06f93e5c0c1 (diff) | |
parent | f4edec086666e759d97093c42422bee754262d3a (diff) |
Merge pull request #12 from rufferson/glib-latest
Bump the glib api implementation to the latest version
55 files changed, 1288 insertions, 1621 deletions
diff --git a/configure.ac b/configure.ac index 6a99912..d66c64f 100644 --- a/configure.ac +++ b/configure.ac @@ -120,10 +120,7 @@ AC_C_BIGENDIAN dnl Check for Glib PKG_CHECK_MODULES(GLIB, - [glib-2.0 >= 2.44, gobject-2.0 >= 2.44, gthread-2.0 >= 2.44, gio-2.0 >= 2.44]) - -AC_DEFINE([GLIB_VERSION_MIN_REQUIRED], [GLIB_VERSION_2_44], [Ignore post 2.44 deprecations]) -AC_DEFINE([GLIB_VERSION_MAX_ALLOWED], [GLIB_VERSION_2_44], [Prevent post 2.44 APIs]) + [glib-2.0 >= 2.46, gobject-2.0 >= 2.46, gthread-2.0 >= 2.46, gio-2.0 >= 2.46]) AC_SUBST(GLIB_CFLAGS) AC_SUBST(GLIB_LIBS) diff --git a/examples/dump-certificates.c b/examples/dump-certificates.c index 1946056..ff1ad82 100644 --- a/examples/dump-certificates.c +++ b/examples/dump-certificates.c @@ -59,7 +59,7 @@ dump_tls_handler_verify_async (WockyTLSHandler *self, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *res; + GTask *task; GPtrArray *chain; gnutls_x509_crt_t cert; gnutls_datum_t datum; @@ -106,10 +106,9 @@ dump_tls_handler_verify_async (WockyTLSHandler *self, g_ptr_array_unref (chain); - res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - dump_tls_handler_verify_async); - g_simple_async_result_complete_in_idle (res); - g_object_unref (res); + task = g_task_new (G_OBJECT (self), NULL, callback, user_data); + g_task_return_boolean (task, TRUE); + g_object_unref (task); } static gboolean @@ -117,8 +116,9 @@ dump_tls_handler_verify_finish (WockyTLSHandler *self, GAsyncResult *result, GError **error) { - return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } static void diff --git a/tests/test-resolver.c b/tests/test-resolver.c index 9e7ae89..5ae9051 100644 --- a/tests/test-resolver.c +++ b/tests/test-resolver.c @@ -114,18 +114,6 @@ find_fake_hosts (TestResolver *tr, const char *name) return rval; } -static GList * -srv_target_list_copy (GList *addr) -{ - GList *copy = NULL; - GList *l; - - for (l = addr; l != NULL; l = l->next) - copy = g_list_prepend (copy, g_srv_target_copy (l->data)); - - return g_list_reverse (copy); -} - static void srv_target_list_free (GList *addr) { @@ -133,13 +121,6 @@ srv_target_list_free (GList *addr) g_list_free (addr); } -static GList * -object_list_copy (GList *objs) -{ - g_list_foreach (objs, (GFunc) g_object_ref, NULL); - return g_list_copy (objs); -} - static void object_list_free (GList *objs) { @@ -157,7 +138,7 @@ lookup_service_async (GResolver *resolver, TestResolver *tr = TEST_RESOLVER (resolver); GList *addr = find_fake_services (tr, rr); GObject *source = G_OBJECT (resolver); - GSimpleAsyncResult *res = NULL; + GTask *task = g_task_new (source, cancellable, cb, data); #ifdef DEBUG_FAKEDNS GList *x; #endif @@ -172,19 +153,16 @@ lookup_service_async (GResolver *resolver, g_srv_target_get_priority ((GSrvTarget *) x->data), g_srv_target_get_weight ((GSrvTarget *) x->data)); #endif - res = g_simple_async_result_new (source, cb, data, lookup_service_async); + g_task_return_pointer (task, addr, (GDestroyNotify) srv_target_list_free); } else { - res = g_simple_async_result_new_error (source, cb, data, + g_task_return_new_error (task, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, "No fake SRV record registered"); } - g_simple_async_result_set_op_res_gpointer (res, addr, - (GDestroyNotify) srv_target_list_free); - g_simple_async_result_complete (res); - g_object_unref (res); + g_object_unref (task); } static GList * @@ -192,16 +170,16 @@ lookup_service_finish (GResolver *resolver, GAsyncResult *result, GError **error) { - GList *res = NULL; - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); + g_return_val_if_fail (g_task_is_valid (result, resolver), NULL); - if (g_simple_async_result_propagate_error (simple, error)) - return NULL; - - res = g_simple_async_result_get_op_res_gpointer (simple); - return srv_target_list_copy (res); + return g_task_propagate_pointer (G_TASK (result), error); } +#if GLIB_VERSION_CUR_STABLE < G_ENCODE_VERSION(2,60) +typedef enum { + G_RESOLVER_NAME_LOOKUP_FLAGS_DEFAULT +} GResolverNameLookupFlags; +#endif static void lookup_by_name_with_flags_async (GResolver *resolver, const gchar *hostname, @@ -213,7 +191,7 @@ lookup_by_name_with_flags_async (GResolver *resolver, TestResolver *tr = TEST_RESOLVER (resolver); GList *addr = find_fake_hosts (tr, hostname); GObject *source = G_OBJECT (resolver); - GSimpleAsyncResult *res = NULL; + GTask *task = g_task_new (source, cancellable, cb, data); #ifdef DEBUG_FAKEDNS GList *x; char a[32]; @@ -227,20 +205,16 @@ lookup_by_name_with_flags_async (GResolver *resolver, inet_ntop (AF_INET, g_inet_address_to_bytes (x->data), a, sizeof (a))); #endif - res = g_simple_async_result_new (source, cb, data, - lookup_by_name_with_flags_async); + g_task_return_pointer (task, addr, (GDestroyNotify) object_list_free); } else { - res = g_simple_async_result_new_error (source, cb, data, + g_task_return_new_error (task, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, "No fake hostname record registered"); } - g_simple_async_result_set_op_res_gpointer (res, addr, - (GDestroyNotify) object_list_free); - g_simple_async_result_complete_in_idle (res); - g_object_unref (res); + g_object_unref (task); } static void @@ -260,14 +234,9 @@ lookup_by_name_finish (GResolver *resolver, GAsyncResult *result, GError **error) { - GList *res = NULL; - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); - - if (g_simple_async_result_propagate_error (simple, error)) - return NULL; + g_return_val_if_fail (g_task_is_valid (result, resolver), NULL); - res = g_simple_async_result_get_op_res_gpointer (simple); - return object_list_copy (res); + return g_task_propagate_pointer (G_TASK (result), error); } #if GLIB_VERSION_CUR_STABLE >= (G_ENCODE_VERSION (2, 60)) diff --git a/tests/wocky-connector-test.c b/tests/wocky-connector-test.c index b451fbe..e08710e 100644 --- a/tests/wocky-connector-test.c +++ b/tests/wocky-connector-test.c @@ -3385,8 +3385,19 @@ test_server_teardown_cb (GObject *source, static gboolean test_server_idle_quit_loop_cb (GMainLoop *loop) { - g_main_loop_quit (loop); - return G_SOURCE_REMOVE; + static int retries = 0; + + if (retries == 5) + { + g_main_loop_quit (loop); + retries = 0; + return G_SOURCE_REMOVE; + } + else + { + retries ++; + return G_SOURCE_CONTINUE; + } } static void @@ -3419,6 +3430,7 @@ test_server_teardown (test_t *test, g_main_loop_run (loop); g_clear_object (&srv->server); + g_main_loop_unref (loop); } if (srv->watch != 0) diff --git a/tests/wocky-loopback-test.c b/tests/wocky-loopback-test.c index f8a6f9f..75e819c 100644 --- a/tests/wocky-loopback-test.c +++ b/tests/wocky-loopback-test.c @@ -90,17 +90,11 @@ start_test (loopback_test_t *test) test_wait_pending (&(test->data)); } -static void -close_cb (GObject *source, - GAsyncResult *res, - gpointer user_data) +static gboolean +cleanup_in_idle (gpointer user_data) { loopback_test_t *test = user_data; - g_assert (wocky_porter_close_finish (WOCKY_PORTER (source), - res, NULL)); - - test->data.outstanding--; g_main_loop_quit (test->data.loop); g_main_loop_unref (test->data.loop); @@ -114,6 +108,23 @@ close_cb (GObject *source, g_queue_free (test->data.expected_stanzas); g_slice_free (loopback_test_t, test); + + return G_SOURCE_REMOVE; +} + +static void +close_cb (GObject *source, + GAsyncResult *res, + gpointer user_data) +{ + loopback_test_t *test = user_data; + + g_assert (wocky_porter_close_finish (WOCKY_PORTER (source), + res, NULL)); + + g_idle_add (cleanup_in_idle, user_data); + g_main_loop_quit (test->data.loop); + test->data.outstanding--; } static void diff --git a/tests/wocky-pubsub-node-test.c b/tests/wocky-pubsub-node-test.c index f4eb5ba..798d7d6 100644 --- a/tests/wocky-pubsub-node-test.c +++ b/tests/wocky-pubsub-node-test.c @@ -503,6 +503,61 @@ test_list_subscribers (void) teardown_test (test); } +static void +test_can_list_subs_cb (GObject *source, + GAsyncResult *res, + gpointer user_data) +{ + test_data_t *test = (test_data_t *) user_data; + + g_assert (wocky_pubsub_node_list_subscribers_finish ( + WOCKY_PUBSUB_NODE (source), res, NULL, NULL)); + + test->outstanding--; + g_main_loop_quit (test->loop); +} + +static void +test_can_list_subs (void) +{ + test_data_t *test = setup_test (); + WockyPubsubService *pubsub; + WockyPubsubNode *node; + + test_open_both_connections (test); + + wocky_porter_start (test->sched_out); + wocky_session_start (test->session_in); + + pubsub = wocky_pubsub_service_new (test->session_in, "pubsub.localhost"); + + wocky_porter_register_handler_from_anyone (test->sched_out, + WOCKY_STANZA_TYPE_IQ, WOCKY_STANZA_SUB_TYPE_GET, + WOCKY_PORTER_HANDLER_PRIORITY_MAX, + test_list_subscribers_iq_cb, test, + '(', "pubsub", + ':', WOCKY_XMPP_NS_PUBSUB_OWNER, + '(', "subscriptions", + '@', "node", "princely_musings", + ')', + ')', NULL); + + node = wocky_pubsub_service_ensure_node (pubsub, "princely_musings"); + g_assert (node != NULL); + + wocky_pubsub_node_list_subscribers_async (node, NULL, + test_can_list_subs_cb, test); + + test->outstanding += 2; + test_wait_pending (test); + + g_object_unref (node); + g_object_unref (pubsub); + + test_close_both_porters (test); + teardown_test (test); +} + /* Test retrieving a list of entities affiliated to a node you own. See * XEP-0060 §8.9.1 Retrieve Affiliations List @@ -1308,6 +1363,7 @@ main (int argc, char **argv) g_test_add_func ("/pubsub-node/unsubscribe", test_unsubscribe); g_test_add_func ("/pubsub-node/delete", test_delete); + g_test_add_func ("/pubsub-node/can-list-subscribers", test_can_list_subs); g_test_add_func ("/pubsub-node/list-subscribers", test_list_subscribers); g_test_add_func ("/pubsub-node/list-affiliates", test_list_affiliates); g_test_add_func ("/pubsub-node/modify-affiliates", test_modify_affiliates); diff --git a/tests/wocky-pubsub-service-test.c b/tests/wocky-pubsub-service-test.c index 2493f14..30ae4e4 100644 --- a/tests/wocky-pubsub-service-test.c +++ b/tests/wocky-pubsub-service-test.c @@ -643,6 +643,7 @@ test_create_node_config (void) /* Four examples taken from §5.6 Retrieve Subscriptions */ typedef enum { + MODE_CAN_DO, MODE_NORMAL, MODE_NO_SUBSCRIPTIONS, MODE_BZZT, @@ -734,6 +735,7 @@ test_retrieve_subscriptions_iq_cb ( switch (ctx->mode) { + case MODE_CAN_DO: case MODE_NORMAL: reply = make_subscriptions_response (stanza, NULL, normal_subs); break; @@ -790,6 +792,10 @@ retrieve_subscriptions_cb (GObject *source, switch (ctx->mode) { + case MODE_CAN_DO: + g_assert (wocky_pubsub_service_retrieve_subscriptions_finish ( + WOCKY_PUBSUB_SERVICE (source), res, NULL, &error)); + break; case MODE_NORMAL: check_subscriptions (source, res, normal_subs); break; @@ -874,6 +880,9 @@ main (int argc, char **argv) "/pubsub-service/get-default-node-configuration-insufficient", test_get_default_node_configuration_insufficient); + g_test_add_data_func ("/pubsub-service/retrieve-subscriptions/can-do", + GUINT_TO_POINTER (MODE_CAN_DO), + test_retrieve_subscriptions); g_test_add_data_func ("/pubsub-service/retrieve-subscriptions/normal", GUINT_TO_POINTER (MODE_NORMAL), test_retrieve_subscriptions); diff --git a/tests/wocky-test-connector-server.c b/tests/wocky-test-connector-server.c index 4f663d5..1796ed5 100644 --- a/tests/wocky-test-connector-server.c +++ b/tests/wocky-test-connector-server.c @@ -40,8 +40,6 @@ #include <wocky/wocky-debug-internal.h> #undef WOCKY_COMPILATION -G_DEFINE_TYPE (TestConnectorServer, test_connector_server, G_TYPE_OBJECT); - typedef void (*stanza_func)(TestConnectorServer *self, WockyStanza *xml); typedef struct _stanza_handler stanza_handler; struct _stanza_handler { @@ -109,7 +107,7 @@ struct _TestConnectorServerPrivate GCancellable *cancellable; gint outstanding; - GSimpleAsyncResult *teardown_result; + GTask *teardown_task; struct { ServerProblem sasl; ConnectorProblem *connector; } problem; @@ -117,6 +115,9 @@ struct _TestConnectorServerPrivate guint other_port; }; +G_DEFINE_TYPE_WITH_CODE (TestConnectorServer, test_connector_server, G_TYPE_OBJECT, + G_ADD_PRIVATE (TestConnectorServer)); + static void test_connector_server_dispose (GObject *object) { @@ -145,6 +146,8 @@ test_connector_server_dispose (GObject *object) g_object_unref (priv->tls_sess); priv->tls_sess = NULL; + g_clear_pointer (&(priv->other_host), g_free); + if (G_OBJECT_CLASS (test_connector_server_parent_class)->dispose) G_OBJECT_CLASS (test_connector_server_parent_class)->dispose (object); } @@ -169,8 +172,7 @@ test_connector_server_init (TestConnectorServer *self) { TestConnectorServerPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, TEST_TYPE_CONNECTOR_SERVER, - TestConnectorServerPrivate); + self->priv = test_connector_server_get_instance_private (self); priv = self->priv; priv->tls_started = FALSE; @@ -183,8 +185,6 @@ test_connector_server_class_init (TestConnectorServerClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (TestConnectorServerPrivate)); - object_class->dispose = test_connector_server_dispose; object_class->finalize = test_connector_server_finalise; } @@ -1390,8 +1390,17 @@ force_closed_cb (GObject *source, success = wocky_xmpp_connection_force_close_finish ( WOCKY_XMPP_CONNECTION (source), result, &error); - g_assert_no_error (error); - g_assert (success); + if (success) + { + g_assert_no_error (error); + } + else if (self->priv->teardown_task && self->priv->cancellable == NULL) + { + g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED); + g_error_free (error); + } + else + g_assert_not_reached (); server_dec_outstanding (self); } @@ -1522,6 +1531,7 @@ xmpp_init (GObject *source, self->priv->cancellable, see_other_host_cb, self); g_object_unref (stanza); + g_free (host_and_port); } else { @@ -1615,15 +1625,15 @@ server_dec_outstanding (TestConnectorServer *self) priv->outstanding--; g_assert (priv->outstanding >= 0); - if (priv->teardown_result != NULL && priv->outstanding == 0) + if (priv->teardown_task != NULL && priv->outstanding == 0) { - GSimpleAsyncResult *r = priv->teardown_result; - priv->teardown_result = NULL; + GTask *t = priv->teardown_task; + priv->teardown_task = NULL; DEBUG ("Tearing down, bye bye"); - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_boolean (t, TRUE); + g_object_unref (t); DEBUG ("Unreffed!"); return TRUE; } @@ -1633,14 +1643,25 @@ server_dec_outstanding (TestConnectorServer *self) return FALSE; } +static gboolean +test_connector_server_complete_in_idle (gpointer data) +{ + GTask *task = G_TASK (data); + + g_task_return_boolean (task, TRUE); + + g_object_unref (task); + return G_SOURCE_REMOVE; +} + void test_connector_server_teardown (TestConnectorServer *self, GAsyncReadyCallback callback, gpointer user_data) { TestConnectorServerPrivate *priv = self->priv; - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, test_connector_server_teardown); + GTask *task = g_task_new (G_OBJECT (self), priv->cancellable, callback, + user_data); /* For now, we'll assert if this gets called twice */ g_assert (priv->cancellable != NULL); @@ -1653,21 +1674,33 @@ test_connector_server_teardown (TestConnectorServer *self, if (priv->outstanding == 0) { - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_idle_add (test_connector_server_complete_in_idle, task); } else { - priv->teardown_result = result; + priv->teardown_task = task; } } gboolean test_connector_server_teardown_finish (TestConnectorServer *self, GAsyncResult *result, - GError *error) + GError **error) { - return TRUE; + GError *e = NULL; + gboolean r = g_task_propagate_boolean (G_TASK (result), &e); + if (!r && e) + { + DEBUG ("Teardown Error: %s[%d] %s", + g_quark_to_string (e->domain), e->code, e->message); + if (g_error_matches (e, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + r = TRUE; + if (error != NULL) + *error = e; + else + g_error_free (e); + } + return r; } diff --git a/tests/wocky-test-connector-server.h b/tests/wocky-test-connector-server.h index 20c2993..4e781a3 100644 --- a/tests/wocky-test-connector-server.h +++ b/tests/wocky-test-connector-server.h @@ -190,7 +190,7 @@ void test_connector_server_teardown (TestConnectorServer *self, gboolean test_connector_server_teardown_finish (TestConnectorServer *self, GAsyncResult *result, - GError *error); + GError **error); const gchar *test_connector_server_get_used_mech (TestConnectorServer *self); diff --git a/tests/wocky-test-sasl-auth-server.c b/tests/wocky-test-sasl-auth-server.c index c76a658..b0f2308 100644 --- a/tests/wocky-test-sasl-auth-server.c +++ b/tests/wocky-test-sasl-auth-server.c @@ -67,8 +67,6 @@ G_STMT_START { \ #endif -G_DEFINE_TYPE(TestSaslAuthServer, test_sasl_auth_server, G_TYPE_OBJECT) - #if 0 /* signal enum */ enum @@ -101,10 +99,13 @@ struct _TestSaslAuthServerPrivate gchar *selected_mech; AuthState state; ServerProblem problem; - GSimpleAsyncResult *result; + GTask *task; GCancellable *cancellable; }; +G_DEFINE_TYPE_WITH_CODE (TestSaslAuthServer, test_sasl_auth_server, G_TYPE_OBJECT, + G_ADD_PRIVATE (TestSaslAuthServer)) + static void received_stanza (GObject *source, GAsyncResult *result, gpointer user_data); @@ -113,8 +114,7 @@ test_sasl_auth_server_init (TestSaslAuthServer *self) { TestSaslAuthServerPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, TEST_TYPE_SASL_AUTH_SERVER, - TestSaslAuthServerPrivate); + self->priv = test_sasl_auth_server_get_instance_private (self); priv = self->priv; priv->username = NULL; @@ -132,9 +132,6 @@ test_sasl_auth_server_class_init ( { GObjectClass *object_class = G_OBJECT_CLASS (test_sasl_auth_server_class); - g_type_class_add_private (test_sasl_auth_server_class, - sizeof (TestSaslAuthServerPrivate)); - object_class->dispose = test_sasl_auth_server_dispose; object_class->finalize = test_sasl_auth_server_finalize; @@ -166,7 +163,7 @@ test_sasl_auth_server_dispose (GObject *object) priv->sasl_conn = NULL; #endif - g_warn_if_fail (priv->result == NULL); + g_warn_if_fail (priv->task == NULL); g_warn_if_fail (priv->cancellable == NULL); if (G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->dispose) @@ -293,20 +290,18 @@ post_auth_recv_stanza (GObject *source, } else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { - GSimpleAsyncResult *r = priv->result; + GTask *t = priv->task; - priv->result = NULL; + priv->task = NULL; if (priv->cancellable != NULL) g_object_unref (priv->cancellable); priv->cancellable = NULL; - g_simple_async_result_set_from_error (r, error); + g_task_return_error (t, error); - g_simple_async_result_complete (r); - g_object_unref (r); - g_error_free (error); + g_object_unref (t); } else { @@ -353,19 +348,19 @@ post_auth_open_sent (GObject *source, g_assert (ok); /* if our caller wanted control back, hand it back here: */ - if (priv->result != NULL) + if (priv->task != NULL) { - GSimpleAsyncResult *r = priv->result; + GTask *t = priv->task; - priv->result = NULL; + priv->task = NULL; if (priv->cancellable != NULL) g_object_unref (priv->cancellable); priv->cancellable = NULL; - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_boolean (t, TRUE); + g_object_unref (t); } else { @@ -440,25 +435,27 @@ failure_sent (GObject *source, { TestSaslAuthServer *tsas = TEST_SASL_AUTH_SERVER (user_data); TestSaslAuthServerPrivate *priv = tsas->priv; - GSimpleAsyncResult *r = priv->result; + GTask *t = priv->task; GError *error = NULL; gboolean ok; - priv->result = NULL; + priv->task = NULL; ok = wocky_xmpp_connection_send_stanza_finish ( WOCKY_XMPP_CONNECTION (source), result, &error); g_assert_no_error (error); g_assert (ok); - if (r != NULL) + if (t != NULL) { if (priv->cancellable != NULL) g_object_unref (priv->cancellable); priv->cancellable = NULL; - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_boolean (t, TRUE); + g_object_unref (t); } + /* release the grip, we're done */ + g_object_unref (tsas); } static void @@ -474,7 +471,9 @@ not_authorized (TestSaslAuthServer *self) WOCKY_STANZA_SUB_TYPE_NONE, NULL, NULL, '(', "not-authorized", ')', NULL); - wocky_xmpp_connection_send_stanza_async (priv->conn, s, NULL, + /* Ensure we have something to handle the callback at the end of the test */ + g_object_ref (self); + wocky_xmpp_connection_send_stanza_async (priv->conn, s, priv->cancellable, failure_sent, self); g_object_unref (s); @@ -957,6 +956,7 @@ test_sasl_server_auth_getopt (void *context, const char *plugin_name, { "scram_secret_generate", "1"}, { NULL, NULL }, }; + *result = NULL; for (i = 0; options[i].name != NULL; i++) { @@ -1053,19 +1053,11 @@ test_sasl_auth_server_auth_finish (TestSaslAuthServer *self, GAsyncResult *res, GError **error) { - gboolean ok = FALSE; - TestSaslAuthServerPrivate *priv = self->priv; - - if (g_simple_async_result_propagate_error ( - G_SIMPLE_ASYNC_RESULT (res), error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (res, self), FALSE); - ok = g_simple_async_result_is_valid (G_ASYNC_RESULT (res), - G_OBJECT (self), - test_sasl_auth_server_auth_async); - g_return_val_if_fail (ok, FALSE); + g_return_val_if_fail (g_task_propagate_boolean (G_TASK (res), error), FALSE); - return (priv->state == AUTH_STATE_AUTHENTICATED); + return (self->priv->state == AUTH_STATE_AUTHENTICATED); } void @@ -1091,8 +1083,7 @@ test_sasl_auth_server_auth_async (GObject *obj, if (cancellable != NULL) priv->cancellable = g_object_ref (cancellable); - priv->result = g_simple_async_result_new (obj, cb, data, - test_sasl_auth_server_auth_async); + priv->task = g_task_new (obj, cancellable, cb, data); } handle_auth (self, auth); diff --git a/tests/wocky-test-stream.c b/tests/wocky-test-stream.c index 152f2e4..ad9275e 100644 --- a/tests/wocky-test-stream.c +++ b/tests/wocky-test-stream.c @@ -28,12 +28,13 @@ #include "wocky-test-stream.h" -G_DEFINE_TYPE (WockyTestStream, wocky_test_stream, G_TYPE_OBJECT); - struct _WockyTestStreamPrivate { gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyTestStream, wocky_test_stream, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyTestStream)); + enum { PROP_IO_INPUT_STREAM = 1, PROP_IO_OUTPUT_STREAM @@ -70,7 +71,7 @@ typedef struct { GAsyncQueue *queue; guint offset; GArray *out_array; - GSimpleAsyncResult *read_result; + GTask *read_task; GCancellable *read_cancellable; gulong read_cancellable_sig_id; void *buffer; @@ -125,8 +126,7 @@ static void wocky_test_stream_init (WockyTestStream *self) { /* allocate any data required by the object here */ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_TEST_STREAM, - WockyTestStreamPrivate); + self->priv = wocky_test_stream_get_instance_private (self); self->stream0_output = g_object_new (WOCKY_TYPE_TEST_OUTPUT_STREAM, NULL); @@ -163,9 +163,6 @@ wocky_test_stream_class_init (WockyTestStreamClass *wocky_test_stream_class) { GObjectClass *object_class = G_OBJECT_CLASS (wocky_test_stream_class); - g_type_class_add_private (wocky_test_stream_class, \ - sizeof (WockyTestStreamPrivate)); - object_class->dispose = wocky_test_stream_dispose; } @@ -281,6 +278,15 @@ wocky_test_input_stream_read (GInputStream *stream, void *buffer, gsize count, do { gsize towrite; + if (self->dispose_has_run) + { + g_assert_not_reached (); + return written; + } + g_assert_nonnull (self->out_array); + if (self->out_array->data == NULL && self->out_array->len == 0) + return written; + if (self->mode == WOCK_TEST_STREAM_READ_COMBINE_SLICE && self->offset == 0) towrite = MIN (count - written, MAX (self->out_array->len/2, 1)); else @@ -312,11 +318,23 @@ wocky_test_input_stream_read (GInputStream *stream, void *buffer, gsize count, return written; } +static gboolean +read_async_complete_in_idle (gpointer data) +{ + GTask *task = G_TASK (data); + + g_task_return_boolean (task, TRUE); + + g_object_unref (task); + return G_SOURCE_REMOVE; +} + static void read_async_complete (WockyTestInputStream *self) { - GSimpleAsyncResult *r = self->read_result; + GTask *t = self->read_task; + self->read_task = NULL; if (self->read_cancellable != NULL) { g_signal_handler_disconnect (self->read_cancellable, @@ -325,17 +343,27 @@ read_async_complete (WockyTestInputStream *self) self->read_cancellable = NULL; } - self->read_result = NULL; - - g_simple_async_result_complete_in_idle (r); - g_object_unref (r); + if (self->read_error != NULL) + { + g_task_return_error (t, self->read_error); + self->read_error = NULL; + } + else + { + g_idle_add (read_async_complete_in_idle, t); + return; + } + g_object_unref (t); } static void read_cancelled_cb (GCancellable *cancellable, WockyTestInputStream *self) { - g_simple_async_result_set_error (self->read_result, + if (self->read_task == NULL) + return; + + self->read_error = g_error_new_literal ( G_IO_ERROR, G_IO_ERROR_CANCELLED, "Reading cancelled"); self->buffer = NULL; @@ -354,22 +382,18 @@ wocky_test_input_stream_read_async (GInputStream *stream, WockyTestInputStream *self = WOCKY_TEST_INPUT_STREAM (stream); g_assert (self->buffer == NULL); - g_assert (self->read_result == NULL); + g_assert (self->read_task == NULL); g_assert (self->read_cancellable == NULL); self->buffer = buffer; self->count = count; - self->read_result = g_simple_async_result_new (G_OBJECT (stream), - callback, user_data, wocky_test_input_stream_read_async); + self->read_task = g_task_new (G_OBJECT (stream), cancellable, + callback, user_data); + g_task_set_task_data (self->read_task, g_object_ref (self), g_object_unref); if (self->read_error != NULL) { - g_simple_async_result_set_from_error (self->read_result, - self->read_error); - - g_error_free (self->read_error); - self->read_error = NULL; read_async_complete (self); return; } @@ -392,12 +416,11 @@ wocky_test_input_stream_read_finish (GInputStream *stream, WockyTestInputStream *self = WOCKY_TEST_INPUT_STREAM (stream); gssize len = -1; - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) + if (!g_task_is_valid (result, stream)) goto out; - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_test_input_stream_read_async), -1); + if (!g_task_propagate_boolean (G_TASK (result), error)) + goto out; len = wocky_test_input_stream_read (stream, self->buffer, self->count, NULL, error); @@ -411,7 +434,7 @@ out: static gboolean wocky_test_input_stream_try_read (WockyTestInputStream *self) { - if (self->read_result == NULL) + if (self->read_task == NULL) /* No pending read operation */ return FALSE; @@ -448,7 +471,7 @@ wocky_test_input_stream_dispose (GObject *object) g_async_queue_unref (self->queue); self->queue = NULL; - g_warn_if_fail (self->read_result == NULL); + g_warn_if_fail (self->read_task == NULL); g_warn_if_fail (self->read_cancellable == NULL); /* release any references held by the object here */ @@ -594,6 +617,8 @@ wocky_test_output_stream_write (GOutputStream *stream, const void *buffer, data = g_array_sized_new (FALSE, FALSE, sizeof (guint8), written); g_array_insert_vals (data, 0, buffer, written); + g_assert (written > 0); + g_assert_nonnull (buffer); g_async_queue_push (self->queue, data); g_signal_emit (self, output_signals[OUTPUT_DATA_WRITTEN], 0); @@ -610,28 +635,25 @@ wocky_test_output_stream_write_async (GOutputStream *stream, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; GError *error = NULL; gssize result; result = wocky_test_output_stream_write (stream, buffer, count, cancellable, &error); - simple = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, - wocky_test_output_stream_write_async); + task = g_task_new (G_OBJECT (stream), cancellable, callback, user_data); if (result == -1) { - g_simple_async_result_set_from_error (simple, error); - g_error_free (error); + g_task_return_error (task, error); } else { - g_simple_async_result_set_op_res_gssize (simple, result); + g_task_return_int (task, result); } - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_object_unref (task); } static gssize @@ -639,15 +661,9 @@ wocky_test_output_stream_write_finish (GOutputStream *stream, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return -1; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (stream), wocky_test_output_stream_write_async), -1); + g_return_val_if_fail (g_task_is_valid (result, stream), -1); - return g_simple_async_result_get_op_res_gssize ( - G_SIMPLE_ASYNC_RESULT (result)); + return g_task_propagate_int (G_TASK (result), error); } static void @@ -709,16 +725,15 @@ wocky_test_input_stream_set_read_error (GInputStream *stream) { WockyTestInputStream *self = WOCKY_TEST_INPUT_STREAM (stream); - if (self->read_result == NULL) + self->read_error = g_error_new_literal (G_IO_ERROR, + G_IO_ERROR_FAILED, "read error"); + + if (self->read_task == NULL) { - /* No pending read operation. Set the error so next read will fail */ - self->read_error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED, - "read error"); + /* No pending read operation. We've set the error so the next read will fail */ return; } - g_simple_async_result_set_error (self->read_result, G_IO_ERROR, - G_IO_ERROR_FAILED, "read error"); read_async_complete (self); } diff --git a/tests/wocky-xmpp-connection-test.c b/tests/wocky-xmpp-connection-test.c index 0e83764..ef2e9b5 100644 --- a/tests/wocky-xmpp-connection-test.c +++ b/tests/wocky-xmpp-connection-test.c @@ -740,13 +740,13 @@ test_error_is_open_or_closed (void) WOCKY_STANZA_SUB_TYPE_CHAT, "a"," b", NULL); + wocky_xmpp_connection_recv_open_async (WOCKY_XMPP_CONNECTION (test->out), + NULL, is_open_recv_open_cb, test); + wocky_xmpp_connection_send_open_async (WOCKY_XMPP_CONNECTION (test->in), NULL, NULL, NULL, NULL, NULL, NULL, is_open_send_open_cb, test); - wocky_xmpp_connection_recv_open_async (WOCKY_XMPP_CONNECTION (test->out), - NULL, is_open_recv_open_cb, test); - test->outstanding = 2; test_wait_pending (test); diff --git a/wocky/wocky-auth-registry.c b/wocky/wocky-auth-registry.c index 9ff42d1..4e3f483 100644 --- a/wocky/wocky-auth-registry.c +++ b/wocky/wocky-auth-registry.c @@ -16,7 +16,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_AUTH #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyAuthRegistry, wocky_auth_registry, G_TYPE_OBJECT) /* private structure */ struct _WockyAuthRegistryPrivate @@ -27,6 +26,9 @@ struct _WockyAuthRegistryPrivate GSList *handlers; }; +G_DEFINE_TYPE_WITH_CODE (WockyAuthRegistry, wocky_auth_registry, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyAuthRegistry)) + static void wocky_auth_registry_start_auth_async_func (WockyAuthRegistry *self, GSList *mechanisms, gboolean allow_plain, @@ -142,8 +144,6 @@ wocky_auth_registry_class_init (WockyAuthRegistryClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockyAuthRegistryPrivate)); - object_class->constructed = wocky_auth_registry_constructed; object_class->get_property = wocky_auth_registry_get_property; object_class->set_property = wocky_auth_registry_set_property; @@ -165,8 +165,7 @@ wocky_auth_registry_class_init (WockyAuthRegistryClass *klass) static void wocky_auth_registry_init (WockyAuthRegistry *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_AUTH_REGISTRY, - WockyAuthRegistryPrivate); + self->priv = wocky_auth_registry_get_instance_private (self); } WockyAuthRegistry * @@ -325,10 +324,9 @@ wocky_auth_registry_start_auth_async_func (WockyAuthRegistry *self, gpointer user_data) { WockyAuthRegistryPrivate *priv = self->priv; - GSimpleAsyncResult *result; + GTask *task; - result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - wocky_auth_registry_start_auth_async); + task = g_task_new (G_OBJECT (self), NULL, callback, user_data); g_assert (priv->handler == NULL); @@ -336,7 +334,7 @@ wocky_auth_registry_start_auth_async_func (WockyAuthRegistry *self, allow_plain, username, password, server, session_id, &priv->handler)) { - g_simple_async_result_set_error (result, WOCKY_AUTH_ERROR, + g_task_return_new_error (task, WOCKY_AUTH_ERROR, WOCKY_AUTH_ERROR_NO_SUPPORTED_MECHANISMS, "No supported mechanisms found"); } @@ -348,8 +346,7 @@ wocky_auth_registry_start_auth_async_func (WockyAuthRegistry *self, if (!wocky_auth_handler_get_initial_response (priv->handler, &initial_data, &error)) { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); + g_task_return_error (task, error); } else { @@ -358,15 +355,14 @@ wocky_auth_registry_start_auth_async_func (WockyAuthRegistry *self, wocky_auth_handler_get_mechanism (priv->handler), initial_data); - g_simple_async_result_set_op_res_gpointer (result, start_data, + g_task_return_pointer (task, start_data, (GDestroyNotify) wocky_auth_registry_start_data_free); wocky_g_string_free (initial_data); } } - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_object_unref (task); } void @@ -404,10 +400,10 @@ wocky_auth_registry_start_auth_finish_func (WockyAuthRegistry *self, WockyAuthRegistryStartData **start_data, GError **error) { - wocky_implement_finish_copy_pointer (self, - wocky_auth_registry_start_auth_async, - wocky_auth_registry_start_data_dup, - start_data); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + *start_data = g_task_propagate_pointer (G_TASK (result), error); + + return !g_task_had_error (G_TASK (result)); } static void @@ -419,25 +415,22 @@ wocky_auth_registry_challenge_async_func (WockyAuthRegistry *self, WockyAuthRegistryPrivate *priv = self->priv; GString *response = NULL; GError *error = NULL; - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_auth_registry_challenge_async); + GTask *task = g_task_new (G_OBJECT (self), NULL, callback, user_data); g_assert (priv->handler != NULL); if (!wocky_auth_handler_handle_auth_data (priv->handler, challenge_data, &response, &error)) { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); + g_task_return_error (task, error); } else { - g_simple_async_result_set_op_res_gpointer (result, response, + g_task_return_pointer (task, response, (GDestroyNotify) wocky_g_string_free); } - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_object_unref (task); } void @@ -468,10 +461,10 @@ wocky_auth_registry_challenge_finish_func (WockyAuthRegistry *self, GString **response, GError **error) { - wocky_implement_finish_copy_pointer (self, - wocky_auth_registry_challenge_async, - wocky_g_string_dup, - response); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + *response = g_task_propagate_pointer (G_TASK (result), error); + + return !g_task_had_error (G_TASK (result)); } static void @@ -481,19 +474,16 @@ wocky_auth_registry_success_async_func (WockyAuthRegistry *self, { WockyAuthRegistryPrivate *priv = self->priv; GError *error = NULL; - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_auth_registry_success_async); + GTask *task = g_task_new (G_OBJECT (self), NULL, callback, user_data); g_assert (priv->handler != NULL); if (!wocky_auth_handler_handle_success (priv->handler, &error)) - { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); - } + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_object_unref (task); } @@ -522,7 +512,9 @@ wocky_auth_registry_success_finish_func (WockyAuthRegistry *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_auth_registry_success_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } void diff --git a/wocky/wocky-bare-contact.c b/wocky/wocky-bare-contact.c index 4431260..29ece8e 100644 --- a/wocky/wocky-bare-contact.c +++ b/wocky/wocky-bare-contact.c @@ -50,8 +50,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_ROSTER #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyBareContact, wocky_bare_contact, WOCKY_TYPE_CONTACT) - /* properties */ enum { @@ -87,12 +85,13 @@ struct _WockyBareContactPrivate GSList *resources; }; +G_DEFINE_TYPE_WITH_CODE (WockyBareContact, wocky_bare_contact, + WOCKY_TYPE_CONTACT, G_ADD_PRIVATE(WockyBareContact)) + static void wocky_bare_contact_init (WockyBareContact *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - WOCKY_TYPE_BARE_CONTACT, WockyBareContactPrivate); - + self->priv = wocky_bare_contact_get_instance_private (self); self->priv->resources = NULL; } @@ -228,9 +227,6 @@ wocky_bare_contact_class_init (WockyBareContactClass *wocky_bare_contact_class) WockyContactClass *contact_class = WOCKY_CONTACT_CLASS (wocky_bare_contact_class); GParamSpec *spec; - g_type_class_add_private (wocky_bare_contact_class, - sizeof (WockyBareContactPrivate)); - object_class->constructed = wocky_bare_contact_constructed; object_class->set_property = wocky_bare_contact_set_property; object_class->get_property = wocky_bare_contact_get_property; diff --git a/wocky/wocky-c2s-porter.c b/wocky/wocky-c2s-porter.c index 02c46cd..7214337 100644 --- a/wocky/wocky-c2s-porter.c +++ b/wocky/wocky-c2s-porter.c @@ -54,10 +54,6 @@ static void wocky_porter_iface_init (gpointer g_iface, gpointer iface_data); -G_DEFINE_TYPE_WITH_CODE (WockyC2SPorter, wocky_c2s_porter, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_PORTER, - wocky_porter_iface_init)); - /* properties */ enum { @@ -83,12 +79,12 @@ struct _WockyC2SPorterPrivate GCancellable *receive_cancellable; gboolean sending_whitespace_ping; - GSimpleAsyncResult *close_result; + GTask *close_task; gboolean waiting_to_close; gboolean remote_closed; gboolean local_closed; GCancellable *close_cancellable; - GSimpleAsyncResult *force_close_result; + GTask *force_close_task; GCancellable *force_close_cancellable; /* guint => owned (StanzaHandler *) */ @@ -109,12 +105,16 @@ struct _WockyC2SPorterPrivate WockyXmppConnection *connection; }; +G_DEFINE_TYPE_WITH_CODE (WockyC2SPorter, wocky_c2s_porter, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyC2SPorter) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_PORTER, wocky_porter_iface_init)); + typedef struct { WockyC2SPorter *self; WockyStanza *stanza; GCancellable *cancellable; - GSimpleAsyncResult *result; + GTask *task; gulong cancelled_sig_id; } sending_queue_elem; @@ -136,8 +136,7 @@ sending_queue_elem_new (WockyC2SPorter *self, if (cancellable != NULL) elem->cancellable = g_object_ref (cancellable); - elem->result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_c2s_porter_send_async); + elem->task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); return elem; } @@ -154,7 +153,7 @@ sending_queue_elem_free (sending_queue_elem *elem) /* FIXME: we should use g_cancellable_disconnect but it raises a dead * lock (#587300) */ } - g_object_unref (elem->result); + g_object_unref (elem->task); g_slice_free (sending_queue_elem, elem); } @@ -236,7 +235,7 @@ stanza_handler_free (StanzaHandler *handler) typedef struct { WockyC2SPorter *self; - GSimpleAsyncResult *result; + GTask *task; GCancellable *cancellable; gulong cancelled_sig_id; gchar *recipient; @@ -247,7 +246,7 @@ typedef struct static StanzaIqHandler * stanza_iq_handler_new (WockyC2SPorter *self, gchar *id, - GSimpleAsyncResult *result, + GTask *task, GCancellable *cancellable, const gchar *recipient) { @@ -266,7 +265,7 @@ stanza_iq_handler_new (WockyC2SPorter *self, } handler->self = self; - handler->result = result; + handler->task = task; handler->id = id; if (cancellable != NULL) handler->cancellable = g_object_ref (cancellable); @@ -295,8 +294,8 @@ stanza_iq_handler_remove_cancellable (StanzaIqHandler *handler) static void stanza_iq_handler_free (StanzaIqHandler *handler) { - if (handler->result != NULL) - g_object_unref (handler->result); + if (handler->task != NULL) + g_object_unref (handler->task); stanza_iq_handler_remove_cancellable (handler); @@ -310,7 +309,7 @@ stanza_iq_handler_maybe_remove (StanzaIqHandler *handler) { /* Always wait till the iq sent operation has finished and something * completed the operation from the perspective of the API user */ - if (handler->sent && handler->result == NULL) + if (handler->sent && handler->task == NULL) { WockyC2SPorterPrivate *priv = handler->self->priv; g_hash_table_remove (priv->iq_reply_handlers, handler->id); @@ -328,16 +327,14 @@ static gboolean handle_iq_reply (WockyPorter *porter, gpointer user_data); static void remote_connection_closed (WockyC2SPorter *self, - GError *error); + const GError *error); static void wocky_c2s_porter_init (WockyC2SPorter *self) { - WockyC2SPorterPrivate *priv; + WockyC2SPorterPrivate *priv = wocky_c2s_porter_get_instance_private (self); - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_C2S_PORTER, - WockyC2SPorterPrivate); - priv = self->priv; + self->priv = priv; priv->sending_queue = g_queue_new (); @@ -486,9 +483,6 @@ wocky_c2s_porter_class_init ( { GObjectClass *object_class = G_OBJECT_CLASS (wocky_c2s_porter_class); - g_type_class_add_private (wocky_c2s_porter_class, - sizeof (WockyC2SPorterPrivate)); - object_class->constructed = wocky_c2s_porter_constructed; object_class->set_property = wocky_c2s_porter_set_property; object_class->get_property = wocky_c2s_porter_get_property; @@ -517,11 +511,7 @@ wocky_c2s_porter_dispose (GObject *object) priv->dispose_has_run = TRUE; - if (priv->connection != NULL) - { - g_object_unref (priv->connection); - priv->connection = NULL; - } + g_clear_object (&(priv->connection)); if (priv->receive_cancellable != NULL) { @@ -531,29 +521,10 @@ wocky_c2s_porter_dispose (GObject *object) priv->receive_cancellable = NULL; } - if (priv->close_result != NULL) - { - g_object_unref (priv->close_result); - priv->close_result = NULL; - } - - if (priv->close_cancellable != NULL) - { - g_object_unref (priv->close_cancellable); - priv->close_cancellable = NULL; - } - - if (priv->force_close_result != NULL) - { - g_object_unref (priv->force_close_result); - priv->force_close_result = NULL; - } - - if (priv->force_close_cancellable != NULL) - { - g_object_unref (priv->force_close_cancellable); - priv->force_close_cancellable = NULL; - } + g_clear_object (&(priv->close_task)); + g_clear_object (&(priv->close_cancellable)); + g_clear_object (&(priv->force_close_task)); + g_clear_object (&(priv->force_close_cancellable)); if (G_OBJECT_CLASS (wocky_c2s_porter_parent_class)->dispose) G_OBJECT_CLASS (wocky_c2s_porter_parent_class)->dispose (object); @@ -569,7 +540,7 @@ wocky_c2s_porter_finalize (GObject *object) DEBUG ("finalize porter %p", self); /* sending_queue_elem keeps a ref on the Porter (through the - * GSimpleAsyncResult) so it shouldn't be destroyed while there are + * GTask) so it shouldn't be destroyed while there are * elements in the queue. */ g_assert_cmpuint (g_queue_get_length (priv->sending_queue), ==, 0); g_queue_free (priv->sending_queue); @@ -638,7 +609,7 @@ send_head_stanza (WockyC2SPorter *self) static void terminate_sending_operations (WockyC2SPorter *self, - GError *error) + const GError *error) { WockyC2SPorterPrivate *priv = self->priv; sending_queue_elem *elem; @@ -647,8 +618,7 @@ terminate_sending_operations (WockyC2SPorter *self, while ((elem = g_queue_pop_head (priv->sending_queue))) { - g_simple_async_result_set_from_error (elem->result, error); - g_simple_async_result_complete (elem->result); + g_task_return_error (elem->task, g_error_copy (error)); sending_queue_elem_free (elem); } } @@ -702,7 +672,7 @@ send_stanza_cb (GObject *source, * close the connection). */ return; - g_simple_async_result_complete (elem->result); + g_task_return_boolean (elem->task, TRUE); sending_queue_elem_free (elem); @@ -724,10 +694,9 @@ send_cancelled_cb (GCancellable *cancellable, { sending_queue_elem *elem = (sending_queue_elem *) user_data; WockyC2SPorterPrivate *priv = elem->self->priv; - GError error = { G_IO_ERROR, G_IO_ERROR_CANCELLED, "Sending was cancelled" }; - g_simple_async_result_set_from_error (elem->result, &error); - g_simple_async_result_complete_in_idle (elem->result); + g_task_return_new_error (elem->task, G_IO_ERROR, G_IO_ERROR_CANCELLED, + "Sending was cancelled"); g_queue_remove (priv->sending_queue, elem); sending_queue_elem_free (elem); @@ -744,11 +713,11 @@ wocky_c2s_porter_send_async (WockyPorter *porter, WockyC2SPorterPrivate *priv = self->priv; sending_queue_elem *elem; - if (priv->close_result != NULL || priv->force_close_result != NULL) + if (priv->close_task != NULL || priv->force_close_task != NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_CLOSING, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_send_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_CLOSING, "Porter is closing"); return; } @@ -774,45 +743,49 @@ wocky_c2s_porter_send_finish (WockyPorter *porter, GAsyncResult *result, GError **error) { - WockyC2SPorter *self = WOCKY_C2S_PORTER (porter); - - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_c2s_porter_send_async), FALSE); + g_return_val_if_fail (g_task_is_valid (result, porter), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } static void receive_stanza (WockyC2SPorter *self); static void -complete_close (WockyC2SPorter *self) +complete_close (WockyC2SPorter *self, const GError *error) { WockyC2SPorterPrivate *priv = self->priv; - GSimpleAsyncResult *tmp; + GTask *tmp; - if (g_cancellable_is_cancelled (priv->close_cancellable)) - { - g_simple_async_result_set_error (priv->close_result, G_IO_ERROR, - G_IO_ERROR_CANCELLED, "closing operation was cancelled"); - } - - if (priv->close_cancellable) - g_object_unref (priv->close_cancellable); - - priv->close_cancellable = NULL; + tmp = priv->close_task; + priv->close_task = NULL; if (priv->force_close_cancellable) g_object_unref (priv->force_close_cancellable); priv->force_close_cancellable = NULL; - tmp = priv->close_result; - priv->close_result = NULL; - g_simple_async_result_complete (tmp); + if (priv->close_cancellable) + { + GCancellable *cc = priv->close_cancellable; + + priv->close_cancellable = NULL; + + if (g_cancellable_is_cancelled (cc)) + { + g_task_return_new_error (tmp, G_IO_ERROR, G_IO_ERROR_CANCELLED, + "closing operation was cancelled"); + } + g_object_unref (cc); + } + + if (!g_task_had_error (tmp)) + { + if (error != NULL) + g_task_return_error (tmp, g_error_copy (error)); + else + g_task_return_boolean (tmp, TRUE); + } + g_object_unref (tmp); } @@ -922,18 +895,17 @@ handle_iq_reply (WockyPorter *porter, if (!check_spoofing (self, reply, handler->recipient)) return FALSE; - if (handler->result != NULL) + if (handler->task != NULL) { - GSimpleAsyncResult *r = handler->result; + GTask *t = handler->task; - handler->result = NULL; + handler->task = NULL; /* Don't want to get cancelled during completion */ stanza_iq_handler_remove_cancellable (handler); - g_simple_async_result_set_op_res_gpointer (r, reply, NULL); - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_pointer (t, g_object_ref (reply), g_object_unref); + g_object_unref (t); ret = TRUE; } @@ -1152,7 +1124,7 @@ queue_or_handle_stanza (WockyC2SPorter *self, static void abort_pending_iqs (WockyC2SPorter *self, - GError *error) + const GError *error) { WockyC2SPorterPrivate *priv = self->priv; GHashTableIter iter; @@ -1163,17 +1135,16 @@ abort_pending_iqs (WockyC2SPorter *self, { StanzaIqHandler *handler = value; - if (handler->result == NULL) + if (handler->task == NULL) continue; /* Don't want to get cancelled during completion */ stanza_iq_handler_remove_cancellable (handler); - g_simple_async_result_set_from_error (handler->result, error); - g_simple_async_result_complete_in_idle (handler->result); + g_task_return_error (handler->task, g_error_copy (error)); - g_object_unref (handler->result); - handler->result = NULL; + g_object_unref (handler->task); + handler->task = NULL; if (handler->sent) g_hash_table_iter_remove (&iter); @@ -1182,7 +1153,7 @@ abort_pending_iqs (WockyC2SPorter *self, static void remote_connection_closed (WockyC2SPorter *self, - GError *error) + const GError *error) { WockyC2SPorterPrivate *priv = self->priv; gboolean error_occured = TRUE; @@ -1216,17 +1187,19 @@ remote_connection_closed (WockyC2SPorter *self, g_signal_emit_by_name (self, "remote-closed"); } - if (priv->close_result != NULL && priv->local_closed) + if (priv->close_task != NULL && priv->local_closed) { if (error_occured) { /* We sent our close but something went wrong with the connection * so we won't be able to receive close from the other side. * Complete the close operation. */ - g_simple_async_result_set_from_error (priv->close_result, error); + complete_close (self, error); + } + else + { + complete_close (self, NULL); } - - complete_close (self); } if (priv->receive_cancellable != NULL) @@ -1245,25 +1218,24 @@ connection_force_close_cb (GObject *source, { WockyC2SPorter *self = WOCKY_C2S_PORTER (user_data); WockyC2SPorterPrivate *priv = self->priv; - GSimpleAsyncResult *r = priv->force_close_result; + GTask *t = priv->force_close_task; GError *error = NULL; /* null out the result so no-one else can use it after us * * this should never happen, but nullifying it lets us trap * * that internal inconsistency if it arises */ - priv->force_close_result = NULL; + priv->force_close_task = NULL; priv->local_closed = TRUE; /* This can fail if the porter has put two * * wocky_xmpp_connection_force_close_async ops in flight * * at the same time: this is bad and should never happen: */ - g_assert (r != NULL); + g_assert (t != NULL); if (!wocky_xmpp_connection_force_close_finish (WOCKY_XMPP_CONNECTION (source), res, &error)) { - g_simple_async_result_set_from_error (r, error); - g_error_free (error); + g_task_return_error (t, error); } if (priv->receive_cancellable != NULL) @@ -1273,8 +1245,8 @@ connection_force_close_cb (GObject *source, } DEBUG ("XMPP connection has been closed; complete the force close operation"); - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_boolean (t, TRUE); + g_object_unref (t); g_object_unref (self); } @@ -1303,7 +1275,7 @@ stanza_received_cb (GObject *source, DEBUG ("Error receiving stanza: %s", error->message); } - if (priv->force_close_result != NULL) + if (priv->force_close_task != NULL) { DEBUG ("Receive operation has been cancelled; "); if (!priv->forced_shutdown) @@ -1353,7 +1325,7 @@ stanza_received_cb (GObject *source, { DEBUG ("forced shutdown of the XMPP connection already in progress"); } - else if (priv->force_close_result != NULL) + else if (priv->force_close_task != NULL) { DEBUG ("force shutdown of the XMPP connection"); g_object_ref (self); @@ -1403,12 +1375,7 @@ close_sent_cb (GObject *source, if (!wocky_xmpp_connection_send_close_finish (WOCKY_XMPP_CONNECTION (source), res, &error)) - { - g_simple_async_result_set_from_error (priv->close_result, error); - g_error_free (error); - - goto out; - } + goto out; if (!g_cancellable_is_cancelled (priv->close_cancellable) && !priv->remote_closed) @@ -1419,11 +1386,11 @@ close_sent_cb (GObject *source, } out: - if (priv->close_result != NULL) + if (priv->close_task != NULL) { /* close operation could already be completed if the other side closes * before we send our close */ - complete_close (self); + complete_close (self, error); } } @@ -1446,43 +1413,45 @@ wocky_c2s_porter_close_async (WockyPorter *porter, WockyC2SPorter *self = WOCKY_C2S_PORTER (porter); WockyC2SPorterPrivate *priv = self->priv; + DEBUG ("Start closing %p", self); if (priv->local_closed) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_CLOSED, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_close_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_CLOSED, "Porter has already been closed"); return; } if (priv->receive_cancellable == NULL && !priv->remote_closed) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_NOT_STARTED, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_close_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_NOT_STARTED, "Porter has not been started"); return; } - if (priv->close_result != NULL) + if (priv->close_task != NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, G_IO_ERROR, - G_IO_ERROR_PENDING, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_close_async, + G_IO_ERROR, G_IO_ERROR_PENDING, "Another close operation is pending"); return; } - if (priv->force_close_result != NULL) + if (priv->force_close_task != NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, G_IO_ERROR, G_IO_ERROR_PENDING, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_close_async, + G_IO_ERROR, G_IO_ERROR_PENDING, "A force close operation is pending"); return; } - priv->close_result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_c2s_porter_close_async); + priv->close_task = g_task_new (G_OBJECT (self), cancellable, callback, + user_data); g_assert (priv->close_cancellable == NULL); @@ -1507,14 +1476,9 @@ wocky_c2s_porter_close_finish (WockyPorter *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_c2s_porter_close_async), FALSE); + g_return_val_if_fail (g_task_is_valid (result, G_OBJECT (self)), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } static gint @@ -1835,17 +1799,16 @@ send_iq_cancelled_cb (GCancellable *cancellable, gpointer user_data) { StanzaIqHandler *handler = (StanzaIqHandler *) user_data; - GError error = { G_IO_ERROR, G_IO_ERROR_CANCELLED, - "IQ sending was cancelled" }; /* The disconnect should always be disconnected if the result has been * finished */ - g_assert (handler->result != NULL); + g_assert (handler->task != NULL); - g_simple_async_result_set_from_error (handler->result, &error); - g_simple_async_result_complete_in_idle (handler->result); - g_object_unref (handler->result); - handler->result = NULL; + g_task_return_new_error (handler->task, G_IO_ERROR, G_IO_ERROR_CANCELLED, + "IQ sending was cancelled"); + + g_object_unref (handler->task); + handler->task = NULL; stanza_iq_handler_maybe_remove (handler); } @@ -1865,19 +1828,21 @@ iq_sent_cb (GObject *source, goto finished; /* Raise an error */ - if (handler->result != NULL) + if (handler->task != NULL) { - GSimpleAsyncResult *r = handler->result; - handler->result = NULL; + GTask *t = handler->task; + handler->task = NULL; /* Don't want to get cancelled during completion */ stanza_iq_handler_remove_cancellable (handler); - g_simple_async_result_set_from_error (r, error); - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_error (t, error); + g_object_unref (t); + } + else + { + g_error_free (error); } - g_error_free (error); finished: stanza_iq_handler_maybe_remove (handler); @@ -1895,20 +1860,20 @@ wocky_c2s_porter_send_iq_async (WockyPorter *porter, StanzaIqHandler *handler; const gchar *recipient; gchar *id = NULL; - GSimpleAsyncResult *result; + GTask *task; WockyStanzaType type; WockyStanzaSubType sub_type; - if (priv->close_result != NULL || priv->force_close_result != NULL) + if (priv->close_task != NULL || priv->force_close_task != NULL) { gchar *node = NULL; g_assert (stanza != NULL && wocky_stanza_get_top_node (stanza) != NULL); node = wocky_node_to_string (wocky_stanza_get_top_node (stanza)); - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_CLOSING, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_send_iq_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_CLOSING, "Porter is closing: iq '%s' aborted", node); g_free (node); @@ -1936,10 +1901,9 @@ wocky_c2s_porter_send_iq_async (WockyPorter *porter, wocky_node_set_attribute (wocky_stanza_get_top_node (stanza), "id", id); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_c2s_porter_send_iq_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); - handler = stanza_iq_handler_new (self, id, result, cancellable, + handler = stanza_iq_handler_new (self, id, task, cancellable, recipient); if (cancellable != NULL) @@ -1955,9 +1919,9 @@ wocky_c2s_porter_send_iq_async (WockyPorter *porter, return; wrong_stanza: - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_NOT_IQ, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_send_iq_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_NOT_IQ, "Stanza is not an IQ query"); } @@ -1966,19 +1930,9 @@ wocky_c2s_porter_send_iq_finish (WockyPorter *self, GAsyncResult *result, GError **error) { - WockyStanza *reply; + g_return_val_if_fail (g_task_is_valid (result, G_OBJECT (self)), NULL); - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return NULL; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_c2s_porter_send_iq_async), NULL); - - reply = g_simple_async_result_get_op_res_gpointer ( - G_SIMPLE_ASYNC_RESULT (result)); - - return g_object_ref (reply); + return g_task_propagate_pointer (G_TASK (result), error); } static void @@ -1992,28 +1946,29 @@ wocky_c2s_porter_force_close_async (WockyPorter *porter, GError err = { WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_FORCIBLY_CLOSED, "Porter was closed forcibly" }; - if (priv->force_close_result != NULL) + if (priv->force_close_task != NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, G_IO_ERROR, G_IO_ERROR_PENDING, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_force_close_async, + G_IO_ERROR, G_IO_ERROR_PENDING, "Another force close operation is pending"); return; } if (priv->receive_cancellable == NULL && priv->local_closed) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_CLOSED, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_force_close_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_CLOSED, "Porter has already been closed"); return; } if (priv->receive_cancellable == NULL && !priv->remote_closed) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_NOT_STARTED, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_force_close_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_NOT_STARTED, "Porter has not been started"); return; } @@ -2021,13 +1976,12 @@ wocky_c2s_porter_force_close_async (WockyPorter *porter, /* Ensure to keep us alive during the closing */ g_object_ref (self); - if (priv->close_result != NULL) + if (priv->close_task != NULL) { /* Finish pending close operation */ - g_simple_async_result_set_from_error (priv->close_result, &err); - g_simple_async_result_complete_in_idle (priv->close_result); - g_object_unref (priv->close_result); - priv->close_result = NULL; + g_task_return_error (priv->close_task, g_error_copy (&err)); + g_object_unref (priv->close_task); + priv->close_task = NULL; } else { @@ -2036,8 +1990,8 @@ wocky_c2s_porter_force_close_async (WockyPorter *porter, g_signal_emit_by_name (self, "closing"); } - priv->force_close_result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_c2s_porter_force_close_async); + priv->force_close_task = g_task_new (G_OBJECT (self), cancellable, + callback, user_data); g_assert (priv->force_close_cancellable == NULL); @@ -2059,12 +2013,12 @@ wocky_c2s_porter_force_close_async (WockyPorter *porter, /* forced shutdown in progress. noop */ if (priv->forced_shutdown) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, - WOCKY_PORTER_ERROR_FORCIBLY_CLOSED, + g_task_report_new_error (G_OBJECT (self), callback, user_data, + wocky_c2s_porter_force_close_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_FORCIBLY_CLOSED, "Porter is already executing a forced-shutdown"); - g_object_unref (priv->force_close_result); - priv->force_close_result = NULL; + g_object_unref (priv->force_close_task); + priv->force_close_task = NULL; return; } /* No need to wait, close connection right now */ @@ -2090,14 +2044,9 @@ wocky_c2s_porter_force_close_finish ( GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_c2s_porter_force_close_async), FALSE); - - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } static void @@ -2105,9 +2054,8 @@ send_whitespace_ping_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *res_out = user_data; - WockyC2SPorter *self = WOCKY_C2S_PORTER ( - g_async_result_get_source_object (G_ASYNC_RESULT (res_out))); + GTask *task = G_TASK (user_data); + WockyC2SPorter *self = WOCKY_C2S_PORTER (g_task_get_source_object (task)); WockyC2SPorterPrivate *priv = self->priv; GError *error = NULL; @@ -2116,8 +2064,7 @@ send_whitespace_ping_cb (GObject *source, if (!wocky_xmpp_connection_send_whitespace_ping_finish ( WOCKY_XMPP_CONNECTION (source), res, &error)) { - g_simple_async_result_set_from_error (res_out, error); - g_simple_async_result_complete (res_out); + g_task_return_error (task, g_error_copy (error)); /* Sending the ping failed; there is no point in trying to send * anything else at this point. */ @@ -2127,7 +2074,7 @@ send_whitespace_ping_cb (GObject *source, } else { - g_simple_async_result_complete (res_out); + g_task_return_boolean (task, TRUE); /* Somebody could have tried sending a stanza while we were sending * the ping */ @@ -2137,8 +2084,7 @@ send_whitespace_ping_cb (GObject *source, close_if_waiting (self); - g_object_unref (self); - g_object_unref (res_out); + g_object_unref (task); } /** @@ -2162,30 +2108,28 @@ wocky_c2s_porter_send_whitespace_ping_async (WockyC2SPorter *self, gpointer user_data) { WockyC2SPorterPrivate *priv = self->priv; - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_c2s_porter_send_whitespace_ping_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); - if (priv->close_result != NULL || priv->force_close_result != NULL) + if (priv->close_task != NULL || priv->force_close_task != NULL) { - g_simple_async_result_set_error (result, WOCKY_PORTER_ERROR, + g_task_return_new_error (task, WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_CLOSING, "Porter is closing"); - g_simple_async_result_complete_in_idle (result); } else if (sending_in_progress (self)) { - g_simple_async_result_complete_in_idle (result); + g_task_return_boolean (task, TRUE); } else { priv->sending_whitespace_ping = TRUE; wocky_xmpp_connection_send_whitespace_ping_async (priv->connection, - cancellable, send_whitespace_ping_cb, g_object_ref (result)); + cancellable, send_whitespace_ping_cb, g_object_ref (task)); g_signal_emit_by_name (self, "sending", NULL); } - g_object_unref (result); + g_object_unref (task); } /** @@ -2203,8 +2147,9 @@ wocky_c2s_porter_send_whitespace_ping_finish (WockyC2SPorter *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, - wocky_c2s_porter_send_whitespace_ping_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } static const gchar * diff --git a/wocky/wocky-caps-cache.c b/wocky/wocky-caps-cache.c index 810f748..5bd7e8d 100644 --- a/wocky/wocky-caps-cache.c +++ b/wocky/wocky-caps-cache.c @@ -40,8 +40,6 @@ #define DB_USER_VERSION 2 -G_DEFINE_TYPE (WockyCapsCache, wocky_caps_cache, G_TYPE_OBJECT) - static WockyCapsCache *shared_cache = NULL; struct _WockyCapsCachePrivate @@ -54,6 +52,9 @@ struct _WockyCapsCachePrivate WockyXmppWriter *writer; }; +G_DEFINE_TYPE_WITH_CODE (WockyCapsCache, wocky_caps_cache, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyCapsCache)) + enum { PROP_PATH = 1, @@ -140,8 +141,6 @@ wocky_caps_cache_class_init (WockyCapsCacheClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockyCapsCachePrivate)); - object_class->constructed = wocky_caps_cache_constructed; object_class->get_property = wocky_caps_cache_get_property; object_class->set_property = wocky_caps_cache_set_property; @@ -359,8 +358,7 @@ wocky_caps_cache_constructed (GObject *object) static void wocky_caps_cache_init (WockyCapsCache *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE ( - self, WOCKY_TYPE_CAPS_CACHE, WockyCapsCachePrivate); + self->priv = wocky_caps_cache_get_instance_private (self); } /** diff --git a/wocky/wocky-connector.c b/wocky/wocky-connector.c index f821ad9..a09e939 100644 --- a/wocky/wocky-connector.c +++ b/wocky/wocky-connector.c @@ -111,8 +111,6 @@ #include "wocky-signals-marshal.h" #include "wocky-utils.h" -G_DEFINE_TYPE (WockyConnector, wocky_connector, G_TYPE_OBJECT); - enum { CONNECTION_ESTABLISHED, LAST_SIGNAL @@ -282,7 +280,7 @@ struct _WockyConnectorPrivate gboolean connected; /* register/cancel account, or normal login */ WockyConnectorXEP77Op reg_op; - GSimpleAsyncResult *result; + GTask *task; GCancellable *cancellable; /* Used to hold the error from connecting to the result of an SRV lookup @@ -301,6 +299,9 @@ struct _WockyConnectorPrivate guint see_other_host_count; }; +G_DEFINE_TYPE_WITH_CODE (WockyConnector, wocky_connector, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyConnector)); + /* choose an appropriate chunk of text describing our state for debug/error */ static const gchar * state_message (WockyConnectorPrivate *priv) @@ -324,11 +325,12 @@ static void complete_operation (WockyConnector *connector) { WockyConnectorPrivate *priv = connector->priv; - GSimpleAsyncResult *tmp; + GTask *tmp; - tmp = priv->result; - priv->result = NULL; - g_simple_async_result_complete (tmp); + tmp = priv->task; + priv->task = NULL; + if (!g_task_had_error (tmp)) + g_task_return_boolean (tmp, TRUE); g_object_unref (tmp); } @@ -370,8 +372,7 @@ abort_connect_error (WockyConnector *connector, priv->cancellable = NULL; } - g_simple_async_result_set_from_error (priv->result, *error); - complete_operation (connector); + g_task_return_error (priv->task, g_error_copy (*error)); } static void @@ -393,8 +394,7 @@ abort_connect (WockyConnector *connector, priv->cancellable = NULL; } - g_simple_async_result_set_from_error (priv->result, error); - complete_operation (connector); + g_task_return_error (priv->task, g_error_copy (error)); } static void @@ -428,8 +428,7 @@ wocky_connector_error_quark (void) static void wocky_connector_init (WockyConnector *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_CONNECTOR, - WockyConnectorPrivate); + self->priv = wocky_connector_get_instance_private (self); } static void @@ -572,8 +571,6 @@ wocky_connector_class_init (WockyConnectorClass *klass) GObjectClass *oclass = G_OBJECT_CLASS (klass); GParamSpec *spec; - g_type_class_add_private (klass, sizeof (WockyConnectorPrivate)); - oclass->set_property = wocky_connector_set_property; oclass->get_property = wocky_connector_get_property; oclass->dispose = wocky_connector_dispose; @@ -1489,8 +1486,7 @@ xep77_cancel_recv (GObject *source, if (iq == NULL) { - g_simple_async_result_set_from_error (priv->result, error); - g_error_free (error); + g_task_return_error (priv->task, error); goto out; } @@ -1501,15 +1497,15 @@ xep77_cancel_recv (GObject *source, if (wocky_stanza_extract_stream_error (iq, &error)) { if (error->code != WOCKY_XMPP_STREAM_ERROR_NOT_AUTHORIZED) - g_simple_async_result_set_from_error (priv->result, error); - - g_error_free (error); + g_task_return_error (priv->task, error); + else + g_error_free (error); goto out; } if (type != WOCKY_STANZA_TYPE_IQ) { - g_simple_async_result_set_error (priv->result, + g_task_return_new_error (priv->task, WOCKY_CONNECTOR_ERROR, WOCKY_CONNECTOR_ERROR_UNREGISTER_FAILED, "Unregister: Invalid response"); @@ -1533,7 +1529,7 @@ xep77_cancel_recv (GObject *source, code = WOCKY_CONNECTOR_ERROR_UNREGISTER_FAILED; } - g_simple_async_result_set_error (priv->result, + g_task_return_new_error (priv->task, WOCKY_CONNECTOR_ERROR, code, "Unregister: %s", error->message); g_clear_error (&error); break; @@ -1543,7 +1539,7 @@ xep77_cancel_recv (GObject *source, break; default: - g_simple_async_result_set_error (priv->result, + g_task_return_new_error (priv->task, WOCKY_CONNECTOR_ERROR, WOCKY_CONNECTOR_ERROR_UNREGISTER_FAILED, "Unregister: Malformed Response"); @@ -2225,14 +2221,11 @@ wocky_connector_connect_finish (WockyConnector *self, gchar **sid, GError **error) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (res); + g_return_val_if_fail (g_task_is_valid (res, self), NULL); - if (g_simple_async_result_propagate_error (result, error)) + if (!g_task_propagate_boolean (G_TASK (res), error)) return NULL; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (self), - wocky_connector_connect_async), NULL); - connector_propagate_jid_and_sid (self, jid, sid); return self->priv->conn; } @@ -2256,14 +2249,11 @@ wocky_connector_register_finish (WockyConnector *self, gchar **sid, GError **error) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (res); + g_return_val_if_fail (g_task_is_valid (res, self), NULL); - if (g_simple_async_result_propagate_error (result, error)) + if (!g_task_propagate_boolean (G_TASK (res), error)) return NULL; - g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (self), - wocky_connector_register_async), NULL); - connector_propagate_jid_and_sid (self, jid, sid); return self->priv->conn; } @@ -2283,16 +2273,9 @@ wocky_connector_unregister_finish (WockyConnector *self, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (res); - GObject *obj = G_OBJECT (self); - - if (g_simple_async_result_propagate_error (result, error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (res, obj, - wocky_connector_unregister_async), FALSE); + g_return_val_if_fail (g_task_is_valid (res, self), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (res), error); } static void @@ -2315,9 +2298,9 @@ connector_connect_async (WockyConnector *self, gchar *host = NULL; /* domain.tld */ /* / */ gchar *uniq = NULL; /* uniquifier */ - if (priv->result != NULL) + if (priv->task != NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), cb, user_data, + g_task_report_new_error (G_OBJECT (self), cb, user_data, source_tag, WOCKY_CONNECTOR_ERROR, WOCKY_CONNECTOR_ERROR_IN_PROGRESS, "Connection already established or in progress"); return; @@ -2331,8 +2314,7 @@ connector_connect_async (WockyConnector *self, priv->cancellable = NULL; } - priv->result = g_simple_async_result_new (G_OBJECT (self), cb, user_data, - source_tag); + priv->task = g_task_new (G_OBJECT (self), cancellable, cb, user_data); if (cancellable != NULL) priv->cancellable = g_object_ref (cancellable); diff --git a/wocky/wocky-contact-factory.c b/wocky/wocky-contact-factory.c index 48794a3..d1ca8ea 100644 --- a/wocky/wocky-contact-factory.c +++ b/wocky/wocky-contact-factory.c @@ -51,8 +51,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_ROSTER #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyContactFactory, wocky_contact_factory, G_TYPE_OBJECT) - #if 0 /* properties */ enum @@ -84,13 +82,15 @@ struct _WockyContactFactoryPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyContactFactory, wocky_contact_factory, + G_TYPE_OBJECT, G_ADD_PRIVATE (WockyContactFactory)) + static void wocky_contact_factory_init (WockyContactFactory *self) { WockyContactFactoryPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_CONTACT_FACTORY, - WockyContactFactoryPrivate); + self->priv = wocky_contact_factory_get_instance_private (self); priv = self->priv; priv->bare_contacts = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, @@ -211,9 +211,6 @@ wocky_contact_factory_class_init ( { GObjectClass *object_class = G_OBJECT_CLASS (wocky_contact_factory_class); - g_type_class_add_private (wocky_contact_factory_class, - sizeof (WockyContactFactoryPrivate)); - object_class->constructed = wocky_contact_factory_constructed; object_class->set_property = wocky_contact_factory_set_property; object_class->get_property = wocky_contact_factory_get_property; diff --git a/wocky/wocky-contact.c b/wocky/wocky-contact.c index c63dd96..3b80a27 100644 --- a/wocky/wocky-contact.c +++ b/wocky/wocky-contact.c @@ -48,8 +48,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_ROSTER #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyContact, wocky_contact, G_TYPE_OBJECT) - /* signal enum */ enum { @@ -66,11 +64,13 @@ struct _WockyContactPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyContact, wocky_contact, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyContact)) + static void wocky_contact_init (WockyContact *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_CONTACT, - WockyContactPrivate); + self->priv = wocky_contact_get_instance_private (self); } static void @@ -147,9 +147,6 @@ wocky_contact_class_init (WockyContactClass *wocky_contact_class) { GObjectClass *object_class = G_OBJECT_CLASS (wocky_contact_class); - g_type_class_add_private (wocky_contact_class, - sizeof (WockyContactPrivate)); - object_class->constructed = wocky_contact_constructed; object_class->set_property = wocky_contact_set_property; object_class->get_property = wocky_contact_get_property; diff --git a/wocky/wocky-data-form.c b/wocky/wocky-data-form.c index fc4265e..19ca510 100644 --- a/wocky/wocky-data-form.c +++ b/wocky/wocky-data-form.c @@ -42,8 +42,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_DATA_FORM #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyDataForm, wocky_data_form, G_TYPE_OBJECT) - /* properties */ enum { @@ -63,6 +61,9 @@ struct _WockyDataFormPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyDataForm, wocky_data_form, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyDataForm)) + GQuark wocky_data_form_error_quark (void) { @@ -150,8 +151,7 @@ wocky_data_form_field_free (WockyDataFormField *field) static void wocky_data_form_init (WockyDataForm *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_DATA_FORM, - WockyDataFormPrivate); + self->priv = wocky_data_form_get_instance_private (self); self->fields = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL); self->fields_list = NULL; @@ -257,9 +257,6 @@ wocky_data_form_class_init ( GObjectClass *object_class = G_OBJECT_CLASS (wocky_data_form_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_data_form_class, - sizeof (WockyDataFormPrivate)); - object_class->set_property = wocky_data_form_set_property; object_class->get_property = wocky_data_form_get_property; object_class->dispose = wocky_data_form_dispose; diff --git a/wocky/wocky-jabber-auth-digest.c b/wocky/wocky-jabber-auth-digest.c index c832d33..42974b6 100644 --- a/wocky/wocky-jabber-auth-digest.c +++ b/wocky/wocky-jabber-auth-digest.c @@ -11,9 +11,6 @@ static void auth_handler_iface_init (gpointer g_iface); -G_DEFINE_TYPE_WITH_CODE (WockyJabberAuthDigest, wocky_jabber_auth_digest, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) - enum { PROP_SESSION_ID = 1, @@ -26,6 +23,10 @@ struct _WockyJabberAuthDigestPrivate gchar *password; }; +G_DEFINE_TYPE_WITH_CODE (WockyJabberAuthDigest, wocky_jabber_auth_digest, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJabberAuthDigest) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) + static void wocky_jabber_auth_digest_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) @@ -88,8 +89,6 @@ wocky_jabber_auth_digest_class_init (WockyJabberAuthDigestClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockyJabberAuthDigestPrivate)); - object_class->get_property = wocky_jabber_auth_digest_get_property; object_class->set_property = wocky_jabber_auth_digest_set_property; object_class->dispose = wocky_jabber_auth_digest_dispose; @@ -123,8 +122,7 @@ auth_handler_iface_init (gpointer g_iface) static void wocky_jabber_auth_digest_init (WockyJabberAuthDigest *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE ( - self, WOCKY_TYPE_JABBER_AUTH_DIGEST, WockyJabberAuthDigestPrivate); + self->priv = wocky_jabber_auth_digest_get_instance_private (self); } WockyJabberAuthDigest * diff --git a/wocky/wocky-jabber-auth-password.c b/wocky/wocky-jabber-auth-password.c index 25d5cbc..c667b5a 100644 --- a/wocky/wocky-jabber-auth-password.c +++ b/wocky/wocky-jabber-auth-password.c @@ -11,9 +11,6 @@ static void auth_handler_iface_init (gpointer g_iface); -G_DEFINE_TYPE_WITH_CODE (WockyJabberAuthPassword, wocky_jabber_auth_password, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) - enum { PROP_PASSWORD = 1 @@ -24,6 +21,10 @@ struct _WockyJabberAuthPasswordPrivate gchar *password; }; +G_DEFINE_TYPE_WITH_CODE (WockyJabberAuthPassword, wocky_jabber_auth_password, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJabberAuthPassword) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) + static void wocky_jabber_auth_password_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) @@ -76,8 +77,6 @@ wocky_jabber_auth_password_class_init (WockyJabberAuthPasswordClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockyJabberAuthPasswordPrivate)); - object_class->get_property = wocky_jabber_auth_password_get_property; object_class->set_property = wocky_jabber_auth_password_set_property; object_class->dispose = wocky_jabber_auth_password_dispose; @@ -106,8 +105,7 @@ auth_handler_iface_init (gpointer g_iface) static void wocky_jabber_auth_password_init (WockyJabberAuthPassword *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE ( - self, WOCKY_TYPE_JABBER_AUTH_PASSWORD, WockyJabberAuthPasswordPrivate); + self->priv = wocky_jabber_auth_password_get_instance_private (self); } WockyJabberAuthPassword * diff --git a/wocky/wocky-jabber-auth.c b/wocky/wocky-jabber-auth.c index 18c033f..5a989f4 100644 --- a/wocky/wocky-jabber-auth.c +++ b/wocky/wocky-jabber-auth.c @@ -34,8 +34,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_AUTH #include "wocky-debug-internal.h" -G_DEFINE_TYPE(WockyJabberAuth, wocky_jabber_auth, G_TYPE_OBJECT) - enum { PROP_SESSION_ID = 1, @@ -56,17 +54,19 @@ struct _WockyJabberAuthPrivate gchar *password; gchar *session_id; GCancellable *cancel; - GSimpleAsyncResult *result; + GTask *task; WockyAuthRegistry *auth_registry; gboolean allow_plain; gboolean is_secure; }; +G_DEFINE_TYPE_WITH_CODE (WockyJabberAuth, wocky_jabber_auth, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJabberAuth)) + static void wocky_jabber_auth_init (WockyJabberAuth *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_JABBER_AUTH, - WockyJabberAuthPrivate); + self->priv = wocky_jabber_auth_get_instance_private (self); } static void wocky_jabber_auth_dispose (GObject *object); @@ -146,9 +146,6 @@ wocky_jabber_auth_class_init (WockyJabberAuthClass *wocky_jabber_auth_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_jabber_auth_class); GParamSpec *spec; - g_type_class_add_private (wocky_jabber_auth_class, - sizeof (WockyJabberAuthPrivate)); - object_class->set_property = wocky_jabber_auth_set_property; object_class->get_property = wocky_jabber_auth_get_property; @@ -255,16 +252,18 @@ static void auth_succeeded (WockyJabberAuth *self) { WockyJabberAuthPrivate *priv = self->priv; - GSimpleAsyncResult *r; + GTask *t; DEBUG ("Authentication succeeded"); auth_reset (self); - r = priv->result; - priv->result = NULL; + t = priv->task; + priv->task = NULL; - g_simple_async_result_complete (r); - g_object_unref (r); + if (!g_task_had_error (t)) + g_task_return_boolean (t, TRUE); + + g_object_unref (t); } static void @@ -272,7 +271,7 @@ auth_failed (WockyJabberAuth *self, gint code, const gchar *format, ...) { gchar *message; va_list args; - GSimpleAsyncResult *r; + GTask *t; GError *error = NULL; WockyJabberAuthPrivate *priv = self->priv; @@ -284,19 +283,16 @@ auth_failed (WockyJabberAuth *self, gint code, const gchar *format, ...) DEBUG ("Authentication failed!: %s", message); - r = priv->result; - priv->result = NULL; + t = priv->task; + priv->task = NULL; error = g_error_new_literal (WOCKY_AUTH_ERROR, code, message); - g_simple_async_result_set_from_error (r, error); - wocky_auth_registry_failure (priv->auth_registry, error); - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_error (t, error); - g_error_free (error); + g_object_unref (t); g_free (message); } @@ -348,7 +344,9 @@ wocky_jabber_auth_authenticate_finish (WockyJabberAuth *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_jabber_auth_authenticate_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } static void @@ -635,8 +633,7 @@ wocky_jabber_auth_authenticate_async (WockyJabberAuth *self, priv->allow_plain = allow_plain; priv->is_secure = is_secure; - priv->result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_jabber_auth_authenticate_async); + priv->task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); if (cancellable != NULL) priv->cancel = g_object_ref (cancellable); diff --git a/wocky/wocky-jingle-content.c b/wocky/wocky-jingle-content.c index 5ddd8d1..e941df9 100644 --- a/wocky/wocky-jingle-content.c +++ b/wocky/wocky-jingle-content.c @@ -94,7 +94,8 @@ struct _WockyJingleContentPrivate /* lookup tables */ -G_DEFINE_TYPE(WockyJingleContent, wocky_jingle_content, G_TYPE_OBJECT); +G_DEFINE_TYPE_WITH_CODE (WockyJingleContent, wocky_jingle_content, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleContent)); static void new_transport_candidates_cb (WockyJingleTransportIface *trans, GList *candidates, WockyJingleContent *content); @@ -105,8 +106,7 @@ static void wocky_jingle_content_init (WockyJingleContent *obj) { WockyJingleContentPrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_CONTENT, - WockyJingleContentPrivate); + wocky_jingle_content_get_instance_private (obj); obj->priv = priv; DEBUG ("%p", obj); @@ -274,8 +274,6 @@ wocky_jingle_content_class_init (WockyJingleContentClass *cls) GParamSpec *param_spec; GObjectClass *object_class = G_OBJECT_CLASS (cls); - g_type_class_add_private (cls, sizeof (WockyJingleContentPrivate)); - object_class->get_property = wocky_jingle_content_get_property; object_class->set_property = wocky_jingle_content_set_property; object_class->dispose = wocky_jingle_content_dispose; diff --git a/wocky/wocky-jingle-factory.c b/wocky/wocky-jingle-factory.c index 3d4237d..8bef2bb 100644 --- a/wocky/wocky-jingle-factory.c +++ b/wocky/wocky-jingle-factory.c @@ -40,8 +40,6 @@ #include "wocky-google-relay.h" -G_DEFINE_TYPE(WockyJingleFactory, wocky_jingle_factory, G_TYPE_OBJECT); - /* signal enum */ enum { @@ -75,6 +73,9 @@ struct _WockyJingleFactoryPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyJingleFactory, wocky_jingle_factory, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleFactory)); + static gboolean jingle_cb ( WockyPorter *porter, WockyStanza *msg, @@ -102,8 +103,7 @@ static void wocky_jingle_factory_init (WockyJingleFactory *obj) { WockyJingleFactoryPrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_FACTORY, - WockyJingleFactoryPrivate); + wocky_jingle_factory_get_instance_private (obj); obj->priv = priv; priv->sessions = g_hash_table_new_full (g_str_hash, g_str_equal, @@ -213,8 +213,6 @@ wocky_jingle_factory_class_init (WockyJingleFactoryClass *cls) GObjectClass *object_class = G_OBJECT_CLASS (cls); GParamSpec *param_spec; - g_type_class_add_private (cls, sizeof (WockyJingleFactoryPrivate)); - object_class->constructed = wocky_jingle_factory_constructed; object_class->get_property = wocky_jingle_factory_get_property; object_class->set_property = wocky_jingle_factory_set_property; diff --git a/wocky/wocky-jingle-info.c b/wocky/wocky-jingle-info.c index 94b189e..9c57034 100644 --- a/wocky/wocky-jingle-info.c +++ b/wocky/wocky-jingle-info.c @@ -102,13 +102,13 @@ wocky_stun_server_free (WockyStunServer *stun_server) } } -G_DEFINE_TYPE (WockyJingleInfo, wocky_jingle_info, G_TYPE_OBJECT) +G_DEFINE_TYPE_WITH_CODE (WockyJingleInfo, wocky_jingle_info, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleInfo)) static void wocky_jingle_info_init (WockyJingleInfo *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_JINGLE_INFO, - WockyJingleInfoPrivate); + self->priv = wocky_jingle_info_get_instance_private (self); self->priv->relay_http_port = 80; self->priv->get_stun_from_jingle = TRUE; @@ -222,8 +222,6 @@ wocky_jingle_info_class_init (WockyJingleInfoClass *klass) object_class->constructed = wocky_jingle_info_constructed; object_class->dispose = wocky_jingle_info_dispose; - g_type_class_add_private (klass, sizeof (WockyJingleInfoPrivate)); - param_spec = g_param_spec_object ("porter", "WockyC2SPorter", "Porter for the current connection", WOCKY_TYPE_C2S_PORTER, diff --git a/wocky/wocky-jingle-media-rtp.c b/wocky/wocky-jingle-media-rtp.c index 24b0a10..fddc427 100644 --- a/wocky/wocky-jingle-media-rtp.c +++ b/wocky/wocky-jingle-media-rtp.c @@ -40,9 +40,6 @@ #include "wocky-jingle-transport-google.h" #include "wocky-utils.h" -G_DEFINE_TYPE (WockyJingleMediaRtp, - wocky_jingle_media_rtp, WOCKY_TYPE_JINGLE_CONTENT); - /* signal enum */ enum { @@ -85,12 +82,15 @@ struct _WockyJingleMediaRtpPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyJingleMediaRtp, + wocky_jingle_media_rtp, WOCKY_TYPE_JINGLE_CONTENT, + G_ADD_PRIVATE (WockyJingleMediaRtp)); + static void wocky_jingle_media_rtp_init (WockyJingleMediaRtp *obj) { WockyJingleMediaRtpPrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_MEDIA_RTP, - WockyJingleMediaRtpPrivate); + wocky_jingle_media_rtp_get_instance_private (obj); obj->priv = priv; priv->dispose_has_run = FALSE; } @@ -314,8 +314,6 @@ wocky_jingle_media_rtp_class_init (WockyJingleMediaRtpClass *cls) WockyJingleContentClass *content_class = WOCKY_JINGLE_CONTENT_CLASS (cls); GParamSpec *param_spec; - g_type_class_add_private (cls, sizeof (WockyJingleMediaRtpPrivate)); - object_class->get_property = wocky_jingle_media_rtp_get_property; object_class->set_property = wocky_jingle_media_rtp_set_property; object_class->dispose = wocky_jingle_media_rtp_dispose; diff --git a/wocky/wocky-jingle-session.c b/wocky/wocky-jingle-session.c index 7ac044e..99a037f 100644 --- a/wocky/wocky-jingle-session.c +++ b/wocky/wocky-jingle-session.c @@ -41,8 +41,6 @@ #include "wocky-resource-contact.h" #include "wocky-utils.h" -G_DEFINE_TYPE(WockyJingleSession, wocky_jingle_session, G_TYPE_OBJECT); - /* signal enum */ enum { @@ -107,6 +105,9 @@ struct _WockyJingleSessionPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyJingleSession, wocky_jingle_session, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleSession)); + typedef struct { WockyJingleState state; WockyJingleAction *actions; @@ -189,8 +190,7 @@ static void wocky_jingle_session_init (WockyJingleSession *obj) { WockyJingleSessionPrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_SESSION, - WockyJingleSessionPrivate); + wocky_jingle_session_get_instance_private (obj); obj->priv = priv; DEBUG ("Initializing the jingle session %p", obj); @@ -414,8 +414,6 @@ wocky_jingle_session_class_init (WockyJingleSessionClass *cls) GObjectClass *object_class = G_OBJECT_CLASS (cls); GParamSpec *param_spec; - g_type_class_add_private (cls, sizeof (WockyJingleSessionPrivate)); - object_class->constructed = wocky_jingle_session_constructed; object_class->get_property = wocky_jingle_session_get_property; object_class->set_property = wocky_jingle_session_set_property; diff --git a/wocky/wocky-jingle-transport-google.c b/wocky/wocky-jingle-transport-google.c index ed6a0cc..8d17302 100644 --- a/wocky/wocky-jingle-transport-google.c +++ b/wocky/wocky-jingle-transport-google.c @@ -38,11 +38,6 @@ static void transport_iface_init (gpointer g_iface, gpointer iface_data); -G_DEFINE_TYPE_WITH_CODE (WockyJingleTransportGoogle, - wocky_jingle_transport_google, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_JINGLE_TRANSPORT_IFACE, - transport_iface_init)); - /* signal enum */ enum { @@ -82,12 +77,17 @@ struct _WockyJingleTransportGooglePrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyJingleTransportGoogle, + wocky_jingle_transport_google, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleTransportGoogle) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_JINGLE_TRANSPORT_IFACE, + transport_iface_init)); + static void wocky_jingle_transport_google_init (WockyJingleTransportGoogle *obj) { WockyJingleTransportGooglePrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_TRANSPORT_GOOGLE, - WockyJingleTransportGooglePrivate); + wocky_jingle_transport_google_get_instance_private (obj); obj->priv = priv; priv->component_names = g_hash_table_new_full (g_str_hash, g_str_equal, @@ -181,8 +181,6 @@ wocky_jingle_transport_google_class_init (WockyJingleTransportGoogleClass *cls) GObjectClass *object_class = G_OBJECT_CLASS (cls); GParamSpec *param_spec; - g_type_class_add_private (cls, sizeof (WockyJingleTransportGooglePrivate)); - object_class->get_property = wocky_jingle_transport_google_get_property; object_class->set_property = wocky_jingle_transport_google_set_property; object_class->dispose = wocky_jingle_transport_google_dispose; diff --git a/wocky/wocky-jingle-transport-iceudp.c b/wocky/wocky-jingle-transport-iceudp.c index ab4e0ef..36094c2 100644 --- a/wocky/wocky-jingle-transport-iceudp.c +++ b/wocky/wocky-jingle-transport-iceudp.c @@ -38,11 +38,6 @@ static void transport_iface_init (gpointer g_iface, gpointer iface_data); -G_DEFINE_TYPE_WITH_CODE (WockyJingleTransportIceUdp, - wocky_jingle_transport_iceudp, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_JINGLE_TRANSPORT_IFACE, - transport_iface_init)); - /* signal enum */ enum { @@ -85,12 +80,17 @@ struct _WockyJingleTransportIceUdpPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyJingleTransportIceUdp, + wocky_jingle_transport_iceudp, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleTransportIceUdp) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_JINGLE_TRANSPORT_IFACE, + transport_iface_init)); + static void wocky_jingle_transport_iceudp_init (WockyJingleTransportIceUdp *obj) { WockyJingleTransportIceUdpPrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_TRANSPORT_ICEUDP, - WockyJingleTransportIceUdpPrivate); + wocky_jingle_transport_iceudp_get_instance_private (obj); obj->priv = priv; priv->id_sequence = 1; @@ -185,8 +185,6 @@ wocky_jingle_transport_iceudp_class_init (WockyJingleTransportIceUdpClass *cls) GObjectClass *object_class = G_OBJECT_CLASS (cls); GParamSpec *param_spec; - g_type_class_add_private (cls, sizeof (WockyJingleTransportIceUdpPrivate)); - object_class->get_property = wocky_jingle_transport_iceudp_get_property; object_class->set_property = wocky_jingle_transport_iceudp_set_property; object_class->dispose = wocky_jingle_transport_iceudp_dispose; diff --git a/wocky/wocky-jingle-transport-rawudp.c b/wocky/wocky-jingle-transport-rawudp.c index e9ecafa..eadf4f5 100644 --- a/wocky/wocky-jingle-transport-rawudp.c +++ b/wocky/wocky-jingle-transport-rawudp.c @@ -37,11 +37,6 @@ static void transport_iface_init (gpointer g_iface, gpointer iface_data); -G_DEFINE_TYPE_WITH_CODE (WockyJingleTransportRawUdp, - wocky_jingle_transport_rawudp, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_JINGLE_TRANSPORT_IFACE, - transport_iface_init)); - /* signal enum */ enum { @@ -71,12 +66,17 @@ struct _WockyJingleTransportRawUdpPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyJingleTransportRawUdp, + wocky_jingle_transport_rawudp, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyJingleTransportRawUdp) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_JINGLE_TRANSPORT_IFACE, + transport_iface_init)); + static void wocky_jingle_transport_rawudp_init (WockyJingleTransportRawUdp *obj) { WockyJingleTransportRawUdpPrivate *priv = - G_TYPE_INSTANCE_GET_PRIVATE (obj, WOCKY_TYPE_JINGLE_TRANSPORT_RAWUDP, - WockyJingleTransportRawUdpPrivate); + wocky_jingle_transport_rawudp_get_instance_private (obj); obj->priv = priv; priv->dispose_has_run = FALSE; @@ -164,8 +164,6 @@ wocky_jingle_transport_rawudp_class_init (WockyJingleTransportRawUdpClass *cls) GObjectClass *object_class = G_OBJECT_CLASS (cls); GParamSpec *param_spec; - g_type_class_add_private (cls, sizeof (WockyJingleTransportRawUdpPrivate)); - object_class->get_property = wocky_jingle_transport_rawudp_get_property; object_class->set_property = wocky_jingle_transport_rawudp_set_property; object_class->dispose = wocky_jingle_transport_rawudp_dispose; diff --git a/wocky/wocky-ll-connection-factory.c b/wocky/wocky-ll-connection-factory.c index 998fe12..8fda65d 100644 --- a/wocky/wocky-ll-connection-factory.c +++ b/wocky/wocky-ll-connection-factory.c @@ -28,14 +28,16 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_CONNECTION_FACTORY #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyLLConnectionFactory, wocky_ll_connection_factory, G_TYPE_OBJECT) - /* private structure */ struct _WockyLLConnectionFactoryPrivate { GSocketClient *client; }; +G_DEFINE_TYPE_WITH_CODE (WockyLLConnectionFactory, + wocky_ll_connection_factory, G_TYPE_OBJECT, + G_ADD_PRIVATE(WockyLLConnectionFactory)) + GQuark wocky_ll_connection_factory_error_quark (void) { @@ -53,8 +55,6 @@ wocky_ll_connection_factory_init (WockyLLConnectionFactory *self) { WockyLLConnectionFactoryPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_LL_CONNECTION_FACTORY, - WockyLLConnectionFactoryPrivate); priv = self->priv; priv->client = g_socket_client_new (); @@ -78,9 +78,6 @@ wocky_ll_connection_factory_class_init ( GObjectClass *object_class = G_OBJECT_CLASS (wocky_ll_connection_factory_class); object_class->dispose = wocky_ll_connection_factory_dispose; - - g_type_class_add_private (wocky_ll_connection_factory_class, - sizeof (WockyLLConnectionFactoryPrivate)); } /** @@ -102,7 +99,7 @@ typedef struct /* the simple async result will hold a ref to this */ WockyLLConnectionFactory *self; - GSimpleAsyncResult *simple; + GTask *task; GCancellable *cancellable; GQueue *addresses; @@ -117,7 +114,7 @@ free_new_connection_data (NewConnectionData *data) if (data->cancellable != NULL) g_object_unref (data->cancellable); - g_object_unref (data->simple); + g_object_unref (data->task); g_slice_free (NewConnectionData, data); } @@ -150,8 +147,7 @@ connect_to_host_cb (GObject *source_object, DEBUG ("made connection"); - g_simple_async_result_set_op_res_gpointer (data->simple, connection, NULL); - g_simple_async_result_complete (data->simple); + g_task_return_pointer (data->task, connection, NULL); free_new_connection_data (data); } @@ -161,11 +157,8 @@ process_one_address (NewConnectionData *data) GInetSocketAddress *addr; gchar *host; - if (g_cancellable_is_cancelled (data->cancellable)) + if (g_task_return_error_if_cancelled (data->task)) { - g_simple_async_result_set_error (data->simple, G_IO_ERROR, - G_IO_ERROR_CANCELLED, "Operation cancelled"); - g_simple_async_result_complete (data->simple); free_new_connection_data (data); return; } @@ -175,11 +168,9 @@ process_one_address (NewConnectionData *data) /* check we haven't gotten to the end of the list */ if (addr == NULL) { - g_simple_async_result_set_error (data->simple, - WOCKY_LL_CONNECTION_FACTORY_ERROR, + g_task_return_new_error (data->task, WOCKY_LL_CONNECTION_FACTORY_ERROR, WOCKY_LL_CONNECTION_FACTORY_ERROR_NO_CONTACT_ADDRESS_CAN_BE_CONNECTED_TO, "Failed to connect to any of the contact's addresses"); - g_simple_async_result_complete (data->simple); free_new_connection_data (data); return; } @@ -241,8 +232,7 @@ wocky_ll_connection_factory_make_connection_async ( if (cancellable != NULL) data->cancellable = g_object_ref (cancellable); - data->simple = g_simple_async_result_new (G_OBJECT (self), callback, - user_data, wocky_ll_connection_factory_make_connection_async); + data->task = g_task_new (G_OBJECT (self), NULL, callback, user_data); data->addresses = g_queue_new (); @@ -252,11 +242,10 @@ wocky_ll_connection_factory_make_connection_async ( if (data->addresses == NULL) { - g_simple_async_result_set_error (data->simple, + g_task_return_new_error (data->task, WOCKY_LL_CONNECTION_FACTORY_ERROR, WOCKY_LL_CONNECTION_FACTORY_ERROR_NO_CONTACT_ADDRESSES, "No addresses available for contact"); - g_simple_async_result_complete (data->simple); free_new_connection_data (data); return; } @@ -281,7 +270,8 @@ wocky_ll_connection_factory_make_connection_finish ( GAsyncResult *result, GError **error) { - wocky_implement_finish_return_pointer (self, - wocky_ll_connection_factory_make_connection_async); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); + + return g_task_propagate_pointer (G_TASK (result), error); } diff --git a/wocky/wocky-ll-connector.c b/wocky/wocky-ll-connector.c index fdf7d3a..2bd6dec 100644 --- a/wocky/wocky-ll-connector.c +++ b/wocky/wocky-ll-connector.c @@ -33,9 +33,6 @@ static void initable_iface_init (gpointer, gpointer); -G_DEFINE_TYPE_WITH_CODE (WockyLLConnector, wocky_ll_connector, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, initable_iface_init)) - enum { PROP_STREAM = 1, @@ -56,10 +53,14 @@ struct _WockyLLConnectorPrivate gchar *from; - GSimpleAsyncResult *simple; + GTask *task; GCancellable *cancellable; }; +G_DEFINE_TYPE_WITH_CODE (WockyLLConnector, wocky_ll_connector, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyLLConnector) + G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, initable_iface_init)) + GQuark wocky_ll_connector_error_quark (void) { @@ -75,8 +76,7 @@ wocky_ll_connector_error_quark (void) static void wocky_ll_connector_init (WockyLLConnector *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_LL_CONNECTOR, - WockyLLConnectorPrivate); + self->priv = wocky_ll_connector_get_instance_private (self); } static void @@ -224,9 +224,6 @@ wocky_ll_connector_class_init ( FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); g_object_class_install_property (object_class, PROP_INCOMING, spec); - - g_type_class_add_private (wocky_ll_connector_class, - sizeof (WockyLLConnectorPrivate)); } /** @@ -309,15 +306,16 @@ features_sent_cb (GObject *source_object, { DEBUG ("Failed to send stream features: %s", error->message); - g_simple_async_result_set_error (priv->simple, WOCKY_LL_CONNECTOR_ERROR, + g_task_return_new_error (priv->task, WOCKY_LL_CONNECTOR_ERROR, WOCKY_LL_CONNECTOR_ERROR_FAILED_TO_SEND_STANZA, "Failed to send stream features: %s", error->message); g_clear_error (&error); } + else + g_task_return_boolean (priv->task, TRUE); - g_simple_async_result_complete (priv->simple); - g_object_unref (priv->simple); - priv->simple = NULL; + g_object_unref (priv->task); + priv->task = NULL; g_object_unref (self); } @@ -341,14 +339,13 @@ recv_open_cb (GObject *source_object, { DEBUG ("Failed to receive stream open: %s", error->message); - g_simple_async_result_set_error (priv->simple, WOCKY_LL_CONNECTOR_ERROR, + g_task_return_new_error (priv->task, WOCKY_LL_CONNECTOR_ERROR, WOCKY_LL_CONNECTOR_ERROR_FAILED_TO_RECEIVE_STANZA, "Failed to receive stream open: %s", error->message); g_clear_error (&error); - g_simple_async_result_complete (priv->simple); - g_object_unref (priv->simple); - priv->simple = NULL; + g_object_unref (priv->task); + priv->task = NULL; return; } @@ -392,14 +389,13 @@ send_open_cb (GObject *source_object, { DEBUG ("Failed to send stream open: %s", error->message); - g_simple_async_result_set_error (priv->simple, WOCKY_LL_CONNECTOR_ERROR, + g_task_return_new_error (priv->task, WOCKY_LL_CONNECTOR_ERROR, WOCKY_LL_CONNECTOR_ERROR_FAILED_TO_SEND_STANZA, "Failed to send stream open: %s", error->message); g_clear_error (&error); - g_simple_async_result_complete (priv->simple); - g_object_unref (priv->simple); - priv->simple = NULL; + g_object_unref (priv->task); + priv->task = NULL; return; } @@ -464,10 +460,9 @@ wocky_ll_connector_init_async (GAsyncInitable *initable, WockyLLConnector *self = WOCKY_LL_CONNECTOR (initable); WockyLLConnectorPrivate *priv = self->priv; - g_return_if_fail (priv->simple == NULL); + g_return_if_fail (priv->task == NULL); - priv->simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_ll_connector_init_async); + priv->task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); if (cancellable != NULL) priv->cancellable = g_object_ref (cancellable); @@ -493,18 +488,12 @@ wocky_ll_connector_init_finish (GAsyncInitable *initable, GError **error) { WockyLLConnector *self = WOCKY_LL_CONNECTOR (initable); - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); WockyLLConnectorPrivate *priv = self->priv; - g_return_val_if_fail (priv->simple == simple, FALSE); - - if (g_simple_async_result_propagate_error (simple, error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_ll_connector_init_async), FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + g_return_val_if_fail (priv->task == G_TASK (result), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } static void diff --git a/wocky/wocky-ll-contact.c b/wocky/wocky-ll-contact.c index 9cae218..5914730 100644 --- a/wocky/wocky-ll-contact.c +++ b/wocky/wocky-ll-contact.c @@ -35,8 +35,6 @@ #include "wocky-utils.h" -G_DEFINE_TYPE (WockyLLContact, wocky_ll_contact, WOCKY_TYPE_CONTACT) - /* properties */ enum { @@ -57,11 +55,13 @@ struct _WockyLLContactPrivate gchar *jid; }; +G_DEFINE_TYPE_WITH_CODE (WockyLLContact, wocky_ll_contact, WOCKY_TYPE_CONTACT, + G_ADD_PRIVATE (WockyLLContact)) + static void wocky_ll_contact_init (WockyLLContact *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - WOCKY_TYPE_LL_CONTACT, WockyLLContactPrivate); + self->priv = wocky_ll_contact_get_instance_private (self); } static void @@ -137,9 +137,6 @@ wocky_ll_contact_class_init (WockyLLContactClass *wocky_ll_contact_class) WockyContactClass *contact_class = WOCKY_CONTACT_CLASS (wocky_ll_contact_class); GParamSpec *spec; - g_type_class_add_private (wocky_ll_contact_class, - sizeof (WockyLLContactPrivate)); - object_class->constructed = wocky_ll_contact_constructed; object_class->set_property = wocky_ll_contact_set_property; object_class->get_property = wocky_ll_contact_get_property; diff --git a/wocky/wocky-loopback-stream.c b/wocky/wocky-loopback-stream.c index 28ada4f..8880b42 100644 --- a/wocky/wocky-loopback-stream.c +++ b/wocky/wocky-loopback-stream.c @@ -60,7 +60,7 @@ typedef struct GAsyncQueue *queue; guint offset; GArray *out_array; - GSimpleAsyncResult *read_result; + GTask *read_task; GCancellable *read_cancellable; gulong read_cancellable_sig_id; void *buffer; @@ -75,8 +75,8 @@ typedef struct } WockyLoopbackInputStreamClass; -G_DEFINE_TYPE (WockyLoopbackStream, wocky_loopback_stream, - G_TYPE_IO_STREAM); +G_DEFINE_TYPE_WITH_CODE (WockyLoopbackStream, wocky_loopback_stream, + G_TYPE_IO_STREAM, G_ADD_PRIVATE (WockyLoopbackStream)); G_DEFINE_TYPE (WockyLoopbackInputStream, wocky_loopback_input_stream, G_TYPE_INPUT_STREAM); G_DEFINE_TYPE (WockyLoopbackOutputStream, wocky_loopback_output_stream, @@ -108,8 +108,7 @@ wocky_loopback_stream_init (WockyLoopbackStream *self) { WockyLoopbackStreamPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_LOOPBACK_STREAM, - WockyLoopbackStreamPrivate); + self->priv = wocky_loopback_stream_get_instance_private (self); priv = self->priv; priv->output = g_object_new (WOCKY_TYPE_LOOPBACK_OUTPUT_STREAM, NULL); @@ -179,9 +178,6 @@ wocky_loopback_stream_class_init ( GIOStreamClass *stream_class = G_IO_STREAM_CLASS ( wocky_loopback_stream_class); - g_type_class_add_private (wocky_loopback_stream_class, - sizeof (WockyLoopbackStreamPrivate)); - obj_class->dispose = wocky_loopback_stream_dispose; obj_class->get_property = wocky_loopback_stream_get_property; @@ -262,7 +258,7 @@ wocky_loopback_input_stream_read (GInputStream *stream, static void read_async_complete (WockyLoopbackInputStream *self) { - GSimpleAsyncResult *r = self->read_result; + GTask *r = self->read_task; if (self->read_cancellable != NULL) { @@ -272,9 +268,10 @@ read_async_complete (WockyLoopbackInputStream *self) self->read_cancellable = NULL; } - self->read_result = NULL; + self->read_task = NULL; - g_simple_async_result_complete_in_idle (r); + if (!g_task_had_error (r)) + g_task_return_boolean (r, TRUE); g_object_unref (r); } @@ -282,7 +279,7 @@ static void read_cancelled_cb (GCancellable *cancellable, WockyLoopbackInputStream *self) { - g_simple_async_result_set_error (self->read_result, + g_task_return_new_error (self->read_task, G_IO_ERROR, G_IO_ERROR_CANCELLED, "Reading cancelled"); self->buffer = NULL; @@ -301,21 +298,19 @@ wocky_loopback_input_stream_read_async (GInputStream *stream, WockyLoopbackInputStream *self = WOCKY_LOOPBACK_INPUT_STREAM (stream); g_assert (self->buffer == NULL); - g_assert (self->read_result == NULL); + g_assert (self->read_task == NULL); g_assert (self->read_cancellable == NULL); self->buffer = buffer; self->count = count; - self->read_result = g_simple_async_result_new (G_OBJECT (stream), - callback, user_data, wocky_loopback_input_stream_read_async); + self->read_task = g_task_new (G_OBJECT (stream), cancellable, callback, + user_data); if (self->read_error != NULL) { - g_simple_async_result_set_from_error (self->read_result, - self->read_error); + g_task_return_error (self->read_task, self->read_error); - g_error_free (self->read_error); self->read_error = NULL; read_async_complete (self); return; @@ -339,12 +334,11 @@ wocky_loopback_input_stream_read_finish (GInputStream *stream, WockyLoopbackInputStream *self = WOCKY_LOOPBACK_INPUT_STREAM (stream); gssize len = -1; - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) + if (!g_task_is_valid (result, self)) goto out; - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_loopback_input_stream_read_async), -1); + if (!g_task_propagate_boolean (G_TASK (result), error)) + goto out; len = wocky_loopback_input_stream_read (stream, self->buffer, self->count, NULL, error); @@ -358,7 +352,7 @@ wocky_loopback_input_stream_read_finish (GInputStream *stream, static gboolean wocky_loopback_input_stream_try_read (WockyLoopbackInputStream *self) { - if (self->read_result == NULL) + if (self->read_task == NULL) /* No pending read operation */ return FALSE; @@ -393,7 +387,7 @@ wocky_loopback_input_stream_dispose (GObject *object) g_async_queue_unref (self->queue); self->queue = NULL; - g_warn_if_fail (self->read_result == NULL); + g_warn_if_fail (self->read_task == NULL); g_warn_if_fail (self->read_cancellable == NULL); /* release any references held by the object here */ @@ -453,28 +447,21 @@ wocky_loopback_output_stream_write_async (GOutputStream *stream, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; GError *error = NULL; gssize result; result = wocky_loopback_output_stream_write (stream, buffer, count, cancellable, &error); - simple = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, - wocky_loopback_output_stream_write_async); + task = g_task_new (G_OBJECT (stream), cancellable, callback, user_data); if (result == -1) - { - g_simple_async_result_set_from_error (simple, error); - g_error_free (error); - } + g_task_return_error (task, error); else - { - g_simple_async_result_set_op_res_gssize (simple, result); - } + g_task_return_int (task, result); - g_simple_async_result_complete_in_idle (simple); - g_object_unref (simple); + g_object_unref (task); } static gssize @@ -482,15 +469,9 @@ wocky_loopback_output_stream_write_finish (GOutputStream *stream, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return -1; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (stream), wocky_loopback_output_stream_write_async), -1); + g_return_val_if_fail (g_task_is_valid (result, stream), -1); - return g_simple_async_result_get_op_res_gssize ( - G_SIMPLE_ASYNC_RESULT (result)); + return g_task_propagate_int (G_TASK (result), error); } static void diff --git a/wocky/wocky-meta-porter.c b/wocky/wocky-meta-porter.c index f1ca936..0613a42 100644 --- a/wocky/wocky-meta-porter.c +++ b/wocky/wocky-meta-porter.c @@ -52,10 +52,6 @@ typedef uint16_t u_int16_t; static void wocky_porter_iface_init (gpointer g_iface, gpointer iface_data); -G_DEFINE_TYPE_WITH_CODE (WockyMetaPorter, wocky_meta_porter, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_PORTER, - wocky_porter_iface_init)); - /* properties */ enum { @@ -116,6 +112,11 @@ typedef struct WockyStanza *stanza; } StanzaHandler; +G_DEFINE_TYPE_WITH_CODE (WockyMetaPorter, wocky_meta_porter, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyMetaPorter) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_PORTER, + wocky_porter_iface_init)); + GQuark wocky_meta_porter_error_quark (void) { @@ -437,8 +438,8 @@ wocky_meta_porter_unhold (WockyMetaPorter *self, static void wocky_meta_porter_init (WockyMetaPorter *self) { - WockyMetaPorterPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - WOCKY_TYPE_META_PORTER, WockyMetaPorterPrivate); + WockyMetaPorterPrivate *priv = + wocky_meta_porter_get_instance_private (self); self->priv = priv; } @@ -842,9 +843,6 @@ wocky_meta_porter_class_init ( GObjectClass *object_class = G_OBJECT_CLASS (wocky_meta_porter_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_meta_porter_class, - sizeof (WockyMetaPorterPrivate)); - object_class->dispose = wocky_meta_porter_dispose; object_class->finalize = wocky_meta_porter_finalize; object_class->constructed = wocky_meta_porter_constructed; @@ -918,7 +916,7 @@ typedef void (*OpenPorterIfNecessaryFunc) (WockyMetaPorter *self, WockyPorter *porter, GCancellable *cancellable, const GError *error, - GSimpleAsyncResult *simple, + GTask *task, gpointer user_data); typedef struct @@ -927,7 +925,7 @@ typedef struct WockyLLContact *contact; OpenPorterIfNecessaryFunc callback; GCancellable *cancellable; - GSimpleAsyncResult *simple; + GTask *task; gpointer user_data; } OpenPorterData; @@ -949,7 +947,7 @@ made_connection_connect_cb (GObject *source_object, { DEBUG ("failed to connect: %s", error->message); data->callback (data->self, NULL, NULL, error, - data->simple, data->user_data); + data->task, data->user_data); g_clear_error (&error); goto out; } @@ -959,7 +957,7 @@ made_connection_connect_cb (GObject *source_object, porter = create_porter (data->self, connection, WOCKY_CONTACT (data->contact)); data->callback (data->self, porter, data->cancellable, NULL, - data->simple, data->user_data); + data->task, data->user_data); g_object_unref (connection); @@ -987,7 +985,7 @@ make_connection_cb (GObject *source_object, DEBUG ("making connection failed: %s", error->message); data->callback (data->self, NULL, NULL, error, - data->simple, data->user_data); + data->task, data->user_data); g_clear_error (&error); @@ -1011,7 +1009,7 @@ open_porter_if_necessary (WockyMetaPorter *self, WockyLLContact *contact, GCancellable *cancellable, OpenPorterIfNecessaryFunc callback, - GSimpleAsyncResult *simple, + GTask *task, gpointer user_data) { WockyMetaPorterPrivate *priv = self->priv; @@ -1020,7 +1018,7 @@ open_porter_if_necessary (WockyMetaPorter *self, if (porter_data != NULL && porter_data->porter != NULL) { - callback (self, porter_data->porter, cancellable, NULL, simple, user_data); + callback (self, porter_data->porter, cancellable, NULL, task, user_data); return; } @@ -1029,7 +1027,7 @@ open_porter_if_necessary (WockyMetaPorter *self, data->contact = g_object_ref (contact); data->callback = callback; data->cancellable = cancellable; - data->simple = simple; + data->task = task; data->user_data = user_data; wocky_ll_connection_factory_make_connection_async (priv->connection_factory, @@ -1041,17 +1039,15 @@ meta_porter_send_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { - GSimpleAsyncResult *simple = user_data; + GTask *task = user_data; GError *error = NULL; if (!wocky_porter_send_finish (WOCKY_PORTER (source_object), result, &error)) - { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); - } + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_object_unref (task); } static void @@ -1059,21 +1055,20 @@ meta_porter_send_got_porter_cb (WockyMetaPorter *self, WockyPorter *porter, GCancellable *cancellable, const GError *error, - GSimpleAsyncResult *simple, + GTask *task, gpointer user_data) { WockyStanza *stanza = user_data; if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_return_error (task, g_error_copy (error)); + g_object_unref (task); } else { wocky_porter_send_async (porter, stanza, cancellable, - meta_porter_send_cb, simple); + meta_porter_send_cb, task); } g_object_unref (stanza); @@ -1088,11 +1083,10 @@ wocky_meta_porter_send_async (WockyPorter *porter, { WockyMetaPorter *self = WOCKY_META_PORTER (porter); WockyMetaPorterPrivate *priv = self->priv; - GSimpleAsyncResult *simple; + GTask *task; WockyContact *to; - simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - wocky_meta_porter_send_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); to = wocky_stanza_get_to_contact (stanza); @@ -1106,7 +1100,7 @@ wocky_meta_porter_send_async (WockyPorter *porter, } open_porter_if_necessary (self, WOCKY_LL_CONTACT (to), cancellable, - meta_porter_send_got_porter_cb, simple, g_object_ref (stanza)); + meta_porter_send_got_porter_cb, task, g_object_ref (stanza)); } static gboolean @@ -1114,9 +1108,9 @@ wocky_meta_porter_send_finish (WockyPorter *self, GAsyncResult *result, GError **error) { - g_return_val_if_fail (WOCKY_IS_META_PORTER (self), FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - wocky_implement_finish_void (self, wocky_meta_porter_send_async); + return g_task_propagate_boolean (G_TASK (result), error); } static guint16 @@ -1272,7 +1266,7 @@ stanza_handler_new (WockyMetaPorter *self, out->porters = g_hash_table_new (NULL, NULL); if (contact != NULL) - out->contact = g_object_ref (contact); + out->contact = WOCKY_CONTACT (g_object_ref (contact)); out->type = type; out->sub_type = sub_type; @@ -1381,7 +1375,7 @@ typedef void (* ClosePorterAsyncFunc) (WockyPorter *, typedef struct { - GSimpleAsyncResult *simple; + GTask *task; guint remaining; gboolean failed; ClosePorterFinishFunc close_finish; @@ -1413,14 +1407,16 @@ porter_close_cb (GObject *source_object, if (data->failed) { - g_simple_async_result_set_error (data->simple, WOCKY_META_PORTER_ERROR, + g_task_return_new_error (data->task, WOCKY_META_PORTER_ERROR, WOCKY_META_PORTER_ERROR_FAILED_TO_CLOSE, "Failed to close at least one porter"); } + else + { + g_task_return_boolean (data->task, TRUE); + } - g_simple_async_result_complete (data->simple); - - g_object_unref (data->simple); + g_object_unref (data->task); g_slice_free (ClosePorterData, data); } @@ -1434,14 +1430,13 @@ close_all_porters (WockyMetaPorter *self, gpointer user_data) { WockyMetaPorterPrivate *priv = self->priv; - GSimpleAsyncResult *simple; + GTask *task; GList *porters, *l; gboolean close_called = FALSE; porters = g_hash_table_get_values (priv->porters); - simple = g_simple_async_result_new (G_OBJECT (self), callback, - user_data, source_tag); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); g_signal_emit_by_name (self, "closing"); @@ -1450,7 +1445,7 @@ close_all_porters (WockyMetaPorter *self, ClosePorterData *data = g_slice_new0 (ClosePorterData); data->close_finish = close_finish_func; data->remaining = 0; - data->simple = simple; + data->task = task; for (l = porters; l != NULL; l = l->next) { @@ -1475,8 +1470,8 @@ close_all_porters (WockyMetaPorter *self, if (!close_called) { /* there were no porters to close anyway */ - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_task_return_boolean (task, TRUE); + g_object_unref (task); } g_list_free (porters); @@ -1500,13 +1495,15 @@ wocky_meta_porter_close_finish (WockyPorter *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_meta_porter_close_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } typedef struct { - WockyMetaPorter *self; /* already reffed by simple */ - GSimpleAsyncResult *simple; + WockyMetaPorter *self; /* already reffed by task */ + GTask *task; WockyContact *contact; } SendIQData; @@ -1516,7 +1513,7 @@ meta_porter_send_iq_cb (GObject *source_object, gpointer user_data) { SendIQData *data = user_data; - GSimpleAsyncResult *simple = data->simple; + GTask *task = data->task; GError *error = NULL; WockyStanza *stanza; @@ -1525,22 +1522,19 @@ meta_porter_send_iq_cb (GObject *source_object, if (stanza == NULL) { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); + g_task_return_error (task, error); } else { wocky_stanza_set_from_contact (stanza, data->contact); - g_simple_async_result_set_op_res_gpointer (simple, stanza, g_object_unref); + g_task_return_pointer (task, stanza, g_object_unref); } - g_simple_async_result_complete (simple); - wocky_meta_porter_unhold (data->self, data->contact); /* unref simple here as we depend on it holding potentially the last * ref on self */ - g_object_unref (data->simple); + g_object_unref (data->task); g_object_unref (data->contact); g_slice_free (SendIQData, data); } @@ -1550,7 +1544,7 @@ meta_porter_send_iq_got_porter_cb (WockyMetaPorter *self, WockyPorter *porter, GCancellable *cancellable, const GError *error, - GSimpleAsyncResult *simple, + GTask *task, gpointer user_data) { WockyStanza *stanza = user_data; @@ -1560,20 +1554,19 @@ meta_porter_send_iq_got_porter_cb (WockyMetaPorter *self, if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); - g_simple_async_result_complete (simple); + g_task_return_error (task, g_error_copy (error)); wocky_meta_porter_unhold (self, contact); /* unref simple here as we depend on it potentially holding the * last ref to self */ - g_object_unref (simple); + g_object_unref (task); } else { SendIQData *data = g_slice_new0 (SendIQData); data->self = self; - data->simple = simple; + data->task = task; data->contact = g_object_ref (contact); wocky_porter_send_iq_async (porter, stanza, cancellable, @@ -1592,15 +1585,14 @@ wocky_meta_porter_send_iq_async (WockyPorter *porter, { WockyMetaPorter *self = WOCKY_META_PORTER (porter); WockyMetaPorterPrivate *priv = self->priv; - GSimpleAsyncResult *simple; + GTask *task; WockyContact *to; to = wocky_stanza_get_to_contact (stanza); g_return_if_fail (WOCKY_IS_LL_CONTACT (to)); - simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - wocky_meta_porter_send_iq_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); wocky_meta_porter_hold (self, to); @@ -1613,7 +1605,7 @@ wocky_meta_porter_send_iq_async (WockyPorter *porter, } open_porter_if_necessary (self, WOCKY_LL_CONTACT (to), cancellable, - meta_porter_send_iq_got_porter_cb, simple, g_object_ref (stanza)); + meta_porter_send_iq_got_porter_cb, task, g_object_ref (stanza)); } static WockyStanza * @@ -1621,8 +1613,9 @@ wocky_meta_porter_send_iq_finish (WockyPorter *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_return_copy_pointer (self, wocky_meta_porter_send_iq_async, - g_object_ref); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); + + return g_task_propagate_pointer (G_TASK (result), error); } static void @@ -1643,7 +1636,9 @@ wocky_meta_porter_force_close_finish (WockyPorter *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_meta_porter_force_close_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } /** @@ -1701,21 +1696,23 @@ meta_porter_open_got_porter_cb (WockyMetaPorter *self, WockyPorter *porter, GCancellable *cancellable, const GError *error, - GSimpleAsyncResult *simple, + GTask *task, gpointer user_data) { WockyContact *contact = user_data; if (error != NULL) { - g_simple_async_result_set_from_error (simple, error); + g_task_return_error (task, g_error_copy (error)); wocky_meta_porter_unhold (self, contact); } - - g_simple_async_result_complete (simple); + else + { + g_task_return_boolean (task, TRUE); + } g_object_unref (contact); - g_object_unref (simple); + g_object_unref (task); } /** @@ -1742,19 +1739,18 @@ wocky_meta_porter_open_async (WockyMetaPorter *self, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *simple; + GTask *task; g_return_if_fail (WOCKY_IS_META_PORTER (self)); g_return_if_fail (WOCKY_IS_LL_CONTACT (contact)); g_return_if_fail (callback != NULL); - simple = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - wocky_meta_porter_open_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); wocky_meta_porter_hold (self, WOCKY_CONTACT (contact)); open_porter_if_necessary (self, contact, - cancellable, meta_porter_open_got_porter_cb, simple, + cancellable, meta_porter_open_got_porter_cb, task, g_object_ref (contact)); } @@ -1774,7 +1770,9 @@ wocky_meta_porter_open_finish (WockyMetaPorter *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_meta_porter_open_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } /** diff --git a/wocky/wocky-muc.c b/wocky/wocky-muc.c index fbe3ea4..42bf0d0 100644 --- a/wocky/wocky-muc.c +++ b/wocky/wocky-muc.c @@ -87,9 +87,6 @@ static const feature feature_map[] = static void wocky_muc_class_init (WockyMucClass *klass); -/* create MUC object */ -G_DEFINE_TYPE (WockyMuc, wocky_muc, G_TYPE_OBJECT); - /* private methods */ static void wocky_muc_dispose (GObject *object); static void wocky_muc_finalize (GObject *object); @@ -160,9 +157,12 @@ struct _WockyMucPrivate WockyMucAffiliation affiliation; guint pres_handler; guint mesg_handler; - GSimpleAsyncResult *join_cb; }; +/* create MUC object */ +G_DEFINE_TYPE_WITH_CODE (WockyMuc, wocky_muc, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyMuc)); + static void free_member (gpointer data) { @@ -188,8 +188,7 @@ alloc_member (void) static void wocky_muc_init (WockyMuc *muc) { - muc->priv = G_TYPE_INSTANCE_GET_PRIVATE (muc, WOCKY_TYPE_MUC, - WockyMucPrivate); + muc->priv = wocky_muc_get_instance_private (muc); muc->priv->members = g_hash_table_new_full (g_str_hash, g_str_equal, @@ -257,8 +256,6 @@ wocky_muc_class_init (WockyMucClass *klass) GType ctype = G_OBJECT_CLASS_TYPE (klass); GParamSpec *spec; - g_type_class_add_private (klass, sizeof (WockyMucPrivate)); - oclass->get_property = wocky_muc_get_property; oclass->set_property = wocky_muc_set_property; oclass->dispose = wocky_muc_dispose; @@ -770,9 +767,9 @@ muc_disco_info (GObject *source, WockyStanza *iq; WockyStanzaType type; WockyStanzaSubType sub; - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (data); + GTask *task = G_TASK (data); - muc = WOCKY_MUC (g_async_result_get_source_object (G_ASYNC_RESULT (result))); + muc = WOCKY_MUC (g_task_get_source_object (task)); priv = muc->priv; iq = wocky_porter_send_iq_finish (priv->porter, res, &error); @@ -858,14 +855,11 @@ muc_disco_info (GObject *source, out: if (error != NULL) - { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); - } + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); - g_simple_async_result_complete (result); - g_object_unref (result); - g_object_unref (muc); + g_object_unref (task); if (iq != NULL) g_object_unref (iq); @@ -876,12 +870,9 @@ wocky_muc_disco_info_finish (WockyMuc *muc, GAsyncResult *res, GError **error) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (res); - - if (g_simple_async_result_propagate_error (result, error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (res, muc), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (res), error); } void @@ -891,7 +882,7 @@ wocky_muc_disco_info_async (WockyMuc *muc, gpointer data) { WockyMucPrivate *priv = muc->priv; - GSimpleAsyncResult *result; + GTask *task; WockyStanza *iq = wocky_stanza_build (WOCKY_STANZA_TYPE_IQ, WOCKY_STANZA_SUB_TYPE_GET, priv->user, @@ -901,11 +892,10 @@ wocky_muc_disco_info_async (WockyMuc *muc, ')', NULL); - result = g_simple_async_result_new (G_OBJECT (muc), callback, data, - wocky_muc_disco_info_async); + task = g_task_new (G_OBJECT (muc), cancel, callback, data); wocky_porter_send_iq_async (priv->porter, iq, cancel, muc_disco_info, - result); + task); } /* ask for MUC member list */ @@ -1249,12 +1239,6 @@ handle_presence_standard (WockyMuc *muc, if (priv->state < WOCKY_MUC_JOINED) { priv->state = WOCKY_MUC_JOINED; - if (priv->join_cb != NULL) - { - g_simple_async_result_complete (priv->join_cb); - g_object_unref (priv->join_cb); - priv->join_cb = NULL; - } g_signal_emit (muc, signals[SIG_JOINED], 0, stanza, codes); } else @@ -1441,16 +1425,8 @@ extract_timestamp (WockyNode *msg) */ if (tm != NULL) { - GTimeVal timeval = { 0, 0 }; - gchar *tm_dup = g_strdup_printf ("%sZ", tm); - - /* FIXME: GTimeVal should go away */ - if (!g_time_val_from_iso8601 (tm_dup, &timeval)) + if ((stamp = g_date_time_new_from_iso8601 (tm, NULL)) == NULL) DEBUG ("Malformed date string '%s' for " WOCKY_XMPP_NS_DELAY, tm); - else - stamp = g_date_time_new_from_timeval_local (&timeval); - - g_free (tm_dup); } } diff --git a/wocky/wocky-node-tree.c b/wocky/wocky-node-tree.c index 6e0bd00..4ea0431 100644 --- a/wocky/wocky-node-tree.c +++ b/wocky/wocky-node-tree.c @@ -29,8 +29,6 @@ #include "wocky-node-tree.h" #include "wocky-node-private.h" -G_DEFINE_TYPE(WockyNodeTree, wocky_node_tree, G_TYPE_OBJECT) - /* properties */ enum { PROP_TOP_NODE = 1, @@ -42,11 +40,13 @@ struct _WockyNodeTreePrivate WockyNode *node; }; +G_DEFINE_TYPE_WITH_CODE (WockyNodeTree, wocky_node_tree, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyNodeTree)) + static void wocky_node_tree_init (WockyNodeTree *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_NODE_TREE, - WockyNodeTreePrivate); + self->priv = wocky_node_tree_get_instance_private (self); } static void wocky_node_tree_dispose (GObject *object); @@ -97,9 +97,6 @@ wocky_node_tree_class_init (WockyNodeTreeClass *wocky_node_tree_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_node_tree_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_node_tree_class, - sizeof (WockyNodeTreePrivate)); - object_class->dispose = wocky_node_tree_dispose; object_class->finalize = wocky_node_tree_finalize; diff --git a/wocky/wocky-pep-service.c b/wocky/wocky-pep-service.c index 98b31a4..eca31b4 100644 --- a/wocky/wocky-pep-service.c +++ b/wocky/wocky-pep-service.c @@ -41,8 +41,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_PUBSUB #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyPepService, wocky_pep_service, G_TYPE_OBJECT) - /* signal enum */ enum { @@ -72,11 +70,13 @@ struct _WockyPepServicePrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyPepService, wocky_pep_service, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyPepService)) + static void wocky_pep_service_init (WockyPepService *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_PEP_SERVICE, - WockyPepServicePrivate); + self->priv = wocky_pep_service_get_instance_private (self); } static void @@ -177,9 +177,6 @@ wocky_pep_service_class_init (WockyPepServiceClass *wocky_pep_service_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_pep_service_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_pep_service_class, - sizeof (WockyPepServicePrivate)); - object_class->set_property = wocky_pep_service_set_property; object_class->get_property = wocky_pep_service_get_property; object_class->dispose = wocky_pep_service_dispose; @@ -336,23 +333,21 @@ send_query_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GError *error = NULL; WockyStanza *reply; reply = wocky_porter_send_iq_finish (WOCKY_PORTER (source), res, &error); if (reply == NULL) { - g_simple_async_result_set_from_error (result, error); - g_error_free (error); + g_task_return_error (task, error); } else { - g_simple_async_result_set_op_res_gpointer (result, reply, g_object_unref); + g_task_return_pointer (task, reply, g_object_unref); } - g_simple_async_result_complete (result); - g_object_unref (result); + g_object_unref (task); } /** @@ -378,13 +373,14 @@ wocky_pep_service_get_async (WockyPepService *self, { WockyPepServicePrivate *priv = self->priv; WockyStanza *msg; - GSimpleAsyncResult *result; + GTask *task; const gchar *jid; if (priv->porter == NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_NOT_STARTED, + g_task_report_new_error (G_OBJECT (self), callback, + user_data, wocky_pep_service_get_async, + WOCKY_PORTER_ERROR, WOCKY_PORTER_ERROR_NOT_STARTED, "Service has not been started"); return; } @@ -401,11 +397,10 @@ wocky_pep_service_get_async (WockyPepService *self, ')', ')', NULL); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pep_service_get_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); wocky_porter_send_iq_async (priv->porter, msg, cancellable, send_query_cb, - result); + task); g_object_unref (msg); } @@ -430,17 +425,12 @@ wocky_pep_service_get_finish (WockyPepService *self, WockyNode **item, GError **error) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result); WockyStanza *reply; - if (g_simple_async_result_propagate_error (simple, error)) - return NULL; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_pep_service_get_async), NULL); - reply = WOCKY_STANZA (g_simple_async_result_get_op_res_gpointer (simple)); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); + reply = WOCKY_STANZA (g_task_propagate_pointer (G_TASK (result), error)); - if (item != NULL) + if (reply != NULL && item != NULL) { WockyNode *pubsub_node = wocky_node_get_child_ns ( wocky_stanza_get_top_node (reply), "pubsub", WOCKY_XMPP_NS_PUBSUB); @@ -455,7 +445,7 @@ wocky_pep_service_get_finish (WockyPepService *self, *item = NULL; } - return g_object_ref (reply); + return reply; } /** diff --git a/wocky/wocky-ping.c b/wocky/wocky-ping.c index f109d6c..c9fbe0d 100644 --- a/wocky/wocky-ping.c +++ b/wocky/wocky-ping.c @@ -39,8 +39,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_PING #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyPing, wocky_ping, G_TYPE_OBJECT) - /* properties */ enum { @@ -61,6 +59,9 @@ struct _WockyPingPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyPing, wocky_ping, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyPing)) + static void send_ping (WockyPing *self); static gboolean ping_iq_cb (WockyPorter *porter, WockyStanza *stanza, gpointer data); @@ -68,8 +69,7 @@ static gboolean ping_iq_cb (WockyPorter *porter, WockyStanza *stanza, static void wocky_ping_init (WockyPing *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_PING, - WockyPingPrivate); + self->priv = wocky_ping_get_instance_private (self); } static void @@ -181,9 +181,6 @@ wocky_ping_class_init (WockyPingClass *wocky_ping_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_ping_class); GParamSpec *spec; - g_type_class_add_private (wocky_ping_class, - sizeof (WockyPingPrivate)); - object_class->constructed = wocky_ping_constructed; object_class->set_property = wocky_ping_set_property; object_class->get_property = wocky_ping_get_property; diff --git a/wocky/wocky-pubsub-node.c b/wocky/wocky-pubsub-node.c index 677ecd2..adf76e9 100644 --- a/wocky/wocky-pubsub-node.c +++ b/wocky/wocky-pubsub-node.c @@ -35,8 +35,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_PUBSUB #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyPubsubNode, wocky_pubsub_node, G_TYPE_OBJECT) - enum { SIG_EVENT_RECEIVED, @@ -65,11 +63,13 @@ struct _WockyPubsubNodePrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyPubsubNode, wocky_pubsub_node, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyPubsubNode)) + static void wocky_pubsub_node_init (WockyPubsubNode *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_PUBSUB_NODE, - WockyPubsubNodePrivate); + self->priv = wocky_pubsub_node_get_instance_private (self); } static void @@ -214,9 +214,6 @@ wocky_pubsub_node_class_init ( GType ctype = G_OBJECT_CLASS_TYPE (wocky_pubsub_node_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_pubsub_node_class, - sizeof (WockyPubsubNodePrivate)); - object_class->set_property = wocky_pubsub_node_set_property; object_class->get_property = wocky_pubsub_node_get_property; object_class->dispose = wocky_pubsub_node_dispose; @@ -418,9 +415,8 @@ subscribe_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - WockyPubsubNode *self = WOCKY_PUBSUB_NODE ( - g_async_result_get_source_object (user_data)); + GTask *task = G_TASK (user_data); + WockyPubsubNode *self = WOCKY_PUBSUB_NODE (g_task_get_source_object (task)); WockyPubsubNodePrivate *priv = self->priv; WockyNodeTree *sub_tree; WockyPubsubSubscription *sub = NULL; @@ -438,19 +434,15 @@ subscribe_cb (GObject *source, if (sub != NULL) { - g_simple_async_result_set_op_res_gpointer (simple, - sub, + g_task_return_pointer (task, sub, (GDestroyNotify) wocky_pubsub_subscription_free); } else { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); + g_task_return_error (task, error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); - g_object_unref (self); + g_object_unref (task); } /** @@ -472,8 +464,7 @@ wocky_pubsub_node_subscribe_async (WockyPubsubNode *self, gpointer user_data) { WockyPubsubNodePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_node_subscribe_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; g_return_if_fail (jid != NULL); @@ -481,7 +472,7 @@ wocky_pubsub_node_subscribe_async (WockyPubsubNode *self, stanza = wocky_pubsub_node_make_subscribe_stanza (self, jid, NULL, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - subscribe_cb, simple); + subscribe_cb, task); g_object_unref (stanza); } @@ -491,18 +482,10 @@ wocky_pubsub_node_subscribe_finish (WockyPubsubNode *self, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; + g_return_val_if_fail (g_task_is_valid (result, self), NULL); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_pubsub_node_subscribe_async), NULL); - - simple = (GSimpleAsyncResult *) result; - - if (g_simple_async_result_propagate_error (simple, error)) - return NULL; - else - return wocky_pubsub_subscription_copy ( - g_simple_async_result_get_op_res_gpointer (simple)); + /* XXX `twas wocky_pubsub_subscription_copy but GTask has transfer-full */ + return g_task_propagate_pointer (G_TASK (result), error); } WockyStanza * @@ -540,17 +523,15 @@ pubsub_node_void_iq_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GError *error = NULL; if (!wocky_pubsub_distill_void_iq_reply (source, res, &error)) - { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); - } + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_object_unref (task); } /** @@ -574,8 +555,7 @@ wocky_pubsub_node_unsubscribe_async (WockyPubsubNode *self, gpointer user_data) { WockyPubsubNodePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_node_unsubscribe_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; g_return_if_fail (jid != NULL); @@ -584,7 +564,7 @@ wocky_pubsub_node_unsubscribe_async (WockyPubsubNode *self, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - pubsub_node_void_iq_cb, simple); + pubsub_node_void_iq_cb, task); g_object_unref (stanza); } @@ -594,7 +574,9 @@ wocky_pubsub_node_unsubscribe_finish (WockyPubsubNode *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_pubsub_node_unsubscribe_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } WockyStanza * @@ -615,13 +597,12 @@ wocky_pubsub_node_delete_async (WockyPubsubNode *self, { WockyPubsubNodePrivate *priv = self->priv; WockyStanza *stanza; - GSimpleAsyncResult *result; + GTask *task; stanza = wocky_pubsub_node_make_delete_stanza (self, NULL, NULL); - result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - wocky_pubsub_node_delete_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); wocky_porter_send_iq_async (priv->porter, stanza, NULL, - pubsub_node_void_iq_cb, result); + pubsub_node_void_iq_cb, task); g_object_unref (stanza); } @@ -630,7 +611,9 @@ wocky_pubsub_node_delete_finish (WockyPubsubNode *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_pubsub_node_delete_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } WockyStanza * @@ -649,9 +632,8 @@ list_subscribers_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - WockyPubsubNode *self = WOCKY_PUBSUB_NODE ( - g_async_result_get_source_object (user_data)); + GTask *task = G_TASK (user_data); + WockyPubsubNode *self = WOCKY_PUBSUB_NODE (g_task_get_source_object (task)); WockyPubsubNodePrivate *priv = self->priv; WockyNodeTree *subs_tree; GError *error = NULL; @@ -662,19 +644,16 @@ list_subscribers_cb (GObject *source, GList *subs = wocky_pubsub_service_parse_subscriptions (priv->service, wocky_node_tree_get_top_node (subs_tree), NULL); - g_simple_async_result_set_op_res_gpointer (simple, subs, + g_task_return_pointer (task, subs, (GDestroyNotify) wocky_pubsub_subscription_list_free); g_object_unref (subs_tree); } else { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); + g_task_return_error (task, error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); - g_object_unref (self); + g_object_unref (task); } /** @@ -700,14 +679,13 @@ wocky_pubsub_node_list_subscribers_async ( gpointer user_data) { WockyPubsubNodePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_node_list_subscribers_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; stanza = wocky_pubsub_node_make_list_subscribers_stanza (self, NULL, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - list_subscribers_cb, simple); + list_subscribers_cb, task); g_object_unref (stanza); } @@ -733,9 +711,14 @@ wocky_pubsub_node_list_subscribers_finish ( GList **subscribers, GError **error) { - wocky_implement_finish_copy_pointer (self, - wocky_pubsub_node_list_subscribers_async, - wocky_pubsub_subscription_list_copy, subscribers); + GList *ret = g_task_propagate_pointer (G_TASK (result), error); + + if (subscribers) + *subscribers = ret; + else + wocky_pubsub_subscription_list_free (ret); + + return !g_task_had_error (G_TASK (result)); } WockyStanza * @@ -798,9 +781,8 @@ list_affiliates_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); - WockyPubsubNode *self = WOCKY_PUBSUB_NODE ( - g_async_result_get_source_object (user_data)); + GTask *task = G_TASK (user_data); + WockyPubsubNode *self = WOCKY_PUBSUB_NODE (g_task_get_source_object (task)); WockyNodeTree *affs_tree; GError *error = NULL; @@ -809,20 +791,17 @@ list_affiliates_cb (GObject *source, { WockyNode *affiliations_node = wocky_node_tree_get_top_node (affs_tree); - g_simple_async_result_set_op_res_gpointer (simple, + g_task_return_pointer (task, wocky_pubsub_node_parse_affiliations (self, affiliations_node), (GDestroyNotify) wocky_pubsub_affiliation_list_free); g_object_unref (affs_tree); } else { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); + g_task_return_error (task, error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); - g_object_unref (self); + g_object_unref (task); } /** @@ -848,14 +827,13 @@ wocky_pubsub_node_list_affiliates_async ( gpointer user_data) { WockyPubsubNodePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_node_list_affiliates_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; stanza = wocky_pubsub_node_make_list_affiliates_stanza (self, NULL, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - list_affiliates_cb, simple); + list_affiliates_cb, task); g_object_unref (stanza); } @@ -881,9 +859,14 @@ wocky_pubsub_node_list_affiliates_finish ( GList **affiliates, GError **error) { - wocky_implement_finish_copy_pointer (self, - wocky_pubsub_node_list_affiliates_async, - wocky_pubsub_affiliation_list_copy, affiliates); + GList *ret = g_task_propagate_pointer (G_TASK (result), error); + + if (affiliates) + *affiliates = ret; + else + wocky_pubsub_affiliation_list_free (ret); + + return !g_task_had_error (G_TASK (result)); } /** @@ -977,14 +960,13 @@ wocky_pubsub_node_modify_affiliates_async ( gpointer user_data) { WockyPubsubNodePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_node_modify_affiliates_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; stanza = wocky_pubsub_node_make_modify_affiliates_stanza ( self, affiliates, NULL, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - pubsub_node_void_iq_cb, simple); + pubsub_node_void_iq_cb, task); g_object_unref (stanza); } @@ -1005,7 +987,7 @@ wocky_pubsub_node_modify_affiliates_finish ( GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_pubsub_node_modify_affiliates_async); + return g_task_propagate_boolean (G_TASK (result), error); } /** @@ -1034,7 +1016,7 @@ get_configuration_iq_cb (GObject *source, GAsyncResult *result, gpointer user_data) { - GSimpleAsyncResult *simple = user_data; + GTask *task = user_data; WockyNodeTree *conf_tree; WockyDataForm *form = NULL; GError *error = NULL; @@ -1048,17 +1030,11 @@ get_configuration_iq_cb (GObject *source, } if (form != NULL) - { - g_simple_async_result_set_op_res_gpointer (simple, form, g_object_unref); - } + g_task_return_pointer (task, form, g_object_unref); else - { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); - } + g_task_return_error (task, error); - g_simple_async_result_complete (simple); - g_object_unref (simple); + g_object_unref (task); } /** @@ -1078,14 +1054,13 @@ wocky_pubsub_node_get_configuration_async ( gpointer user_data) { WockyPubsubNodePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_node_get_configuration_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; stanza = wocky_pubsub_node_make_get_configuration_stanza ( self, NULL, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - get_configuration_iq_cb, simple); + get_configuration_iq_cb, task); g_object_unref (stanza); } @@ -1106,8 +1081,9 @@ wocky_pubsub_node_get_configuration_finish ( GAsyncResult *result, GError **error) { - wocky_implement_finish_return_copy_pointer (self, - wocky_pubsub_node_get_configuration_async, g_object_ref); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); + + return g_task_propagate_pointer (G_TASK (result), error); } WockyPorter * diff --git a/wocky/wocky-pubsub-service.c b/wocky/wocky-pubsub-service.c index 84db58e..893ac28 100644 --- a/wocky/wocky-pubsub-service.c +++ b/wocky/wocky-pubsub-service.c @@ -40,8 +40,6 @@ static gboolean pubsub_service_propagate_event (WockyPorter *porter, WockyStanza *event_stanza, gpointer user_data); -G_DEFINE_TYPE (WockyPubsubService, wocky_pubsub_service, G_TYPE_OBJECT) - /* signal enum */ enum { @@ -84,6 +82,9 @@ struct _WockyPubsubServicePrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyPubsubService, wocky_pubsub_service, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyPubsubService)) + GQuark wocky_pubsub_service_error_quark (void) { @@ -97,8 +98,7 @@ wocky_pubsub_service_error_quark (void) static void wocky_pubsub_service_init (WockyPubsubService *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - WOCKY_TYPE_PUBSUB_SERVICE, WockyPubsubServicePrivate); + self->priv = wocky_pubsub_service_get_instance_private (self); self->priv->nodes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); @@ -242,9 +242,6 @@ wocky_pubsub_service_class_init ( GType ctype = G_OBJECT_CLASS_TYPE (wocky_pubsub_service_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_pubsub_service_class, - sizeof (WockyPubsubServicePrivate)); - object_class->set_property = wocky_pubsub_service_set_property; object_class->get_property = wocky_pubsub_service_get_property; object_class->dispose = wocky_pubsub_service_dispose; @@ -513,7 +510,7 @@ default_configuration_iq_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); GError *error = NULL; WockyNodeTree *default_tree; WockyDataForm *form; @@ -524,20 +521,16 @@ default_configuration_iq_cb (GObject *source, form = wocky_data_form_new_from_form ( wocky_node_tree_get_top_node (default_tree), &error); - if (form != NULL) - g_simple_async_result_set_op_res_gpointer (result, form, NULL); + g_task_return_pointer (task, form, g_object_unref); g_object_unref (default_tree); } - - if (error != NULL) + else { - g_simple_async_result_set_from_error (result, error); - g_clear_error (&error); + g_task_return_error (task, error); } - g_simple_async_result_complete (result); - g_object_unref (result); + g_object_unref (task); } void @@ -549,16 +542,15 @@ wocky_pubsub_service_get_default_node_configuration_async ( { WockyPubsubServicePrivate *priv = self->priv; WockyStanza *stanza; - GSimpleAsyncResult *result; + GTask *task; stanza = wocky_pubsub_make_stanza (priv->jid, WOCKY_STANZA_SUB_TYPE_GET, WOCKY_XMPP_NS_PUBSUB_OWNER, "default", NULL, NULL); - result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, - wocky_pubsub_service_get_default_node_configuration_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); wocky_porter_send_iq_async (priv->porter, stanza, NULL, - default_configuration_iq_cb, result); + default_configuration_iq_cb, task); g_object_unref (stanza); } @@ -569,16 +561,9 @@ wocky_pubsub_service_get_default_node_configuration_finish ( GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return NULL; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), - wocky_pubsub_service_get_default_node_configuration_async), NULL); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); - return g_simple_async_result_get_op_res_gpointer ( - G_SIMPLE_ASYNC_RESULT (result)); + return g_task_propagate_pointer (G_TASK (result), error); } WockyPubsubSubscription * @@ -679,9 +664,9 @@ receive_subscriptions_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); WockyPubsubService *self = WOCKY_PUBSUB_SERVICE ( - g_async_result_get_source_object (user_data)); + g_task_get_source_object (task)); WockyNodeTree *subs_tree; GError *error = NULL; @@ -691,19 +676,16 @@ receive_subscriptions_cb (GObject *source, GList *subs = wocky_pubsub_service_parse_subscriptions (self, wocky_node_tree_get_top_node (subs_tree), NULL); - g_simple_async_result_set_op_res_gpointer (simple, subs, + g_task_return_pointer (task, subs, (GDestroyNotify) wocky_pubsub_subscription_list_free); g_object_unref (subs_tree); } else { - g_simple_async_result_set_from_error (simple, error); - g_clear_error (&error); + g_task_return_error (task, error); } - g_simple_async_result_complete (simple); - g_object_unref (simple); - g_object_unref (self); + g_object_unref (task); } WockyStanza * @@ -739,15 +721,14 @@ wocky_pubsub_service_retrieve_subscriptions_async ( gpointer user_data) { WockyPubsubServicePrivate *priv = self->priv; - GSimpleAsyncResult *simple = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_service_retrieve_subscriptions_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); WockyStanza *stanza; stanza = wocky_pubsub_service_create_retrieve_subscriptions_stanza (self, node, NULL, NULL); wocky_porter_send_iq_async (priv->porter, stanza, cancellable, - receive_subscriptions_cb, simple); + receive_subscriptions_cb, task); g_object_unref (stanza); } @@ -759,9 +740,14 @@ wocky_pubsub_service_retrieve_subscriptions_finish ( GList **subscriptions, GError **error) { - wocky_implement_finish_copy_pointer (self, - wocky_pubsub_service_retrieve_subscriptions_async, - wocky_pubsub_subscription_list_copy, subscriptions); + GList *ret = g_task_propagate_pointer (G_TASK (result), error); + + if (subscriptions) + *subscriptions = ret; + else if (ret) + wocky_pubsub_subscription_list_free (ret); + + return !g_task_had_error (G_TASK (result)); } /** @@ -831,15 +817,15 @@ create_node_iq_cb (GObject *source, GAsyncResult *res, gpointer user_data) { - GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (user_data); + GTask *task = G_TASK (user_data); WockyPubsubService *self; WockyPubsubNode *node = NULL; const gchar *requested_name; WockyNodeTree *create_tree; GError *error = NULL; - self = WOCKY_PUBSUB_SERVICE (g_async_result_get_source_object (user_data)); - requested_name = g_object_get_data ((GObject *) result, "requested-name"); + self = WOCKY_PUBSUB_SERVICE (g_task_get_source_object (task)); + requested_name = g_object_get_data (G_OBJECT (task), "requested-name"); if (wocky_pubsub_distill_ambivalent_iq_reply (source, res, WOCKY_XMPP_NS_PUBSUB, "create", &create_tree, &error)) @@ -854,18 +840,15 @@ create_node_iq_cb (GObject *source, if (node != NULL) { /* 'result' steals our reference to 'node' */ - g_simple_async_result_set_op_res_gpointer (result, node, g_object_unref); + g_task_return_pointer (task, node, g_object_unref); } else { g_assert (error != NULL); - g_simple_async_result_set_from_error (result, error); - g_clear_error (&error); + g_task_return_error (task, error); } - g_simple_async_result_complete (result); - g_object_unref (result); - g_object_unref (self); + g_object_unref (task); } WockyStanza * @@ -910,14 +893,13 @@ wocky_pubsub_service_create_node_async (WockyPubsubService *self, WockyPubsubServicePrivate *priv = self->priv; WockyStanza *stanza = wocky_pubsub_service_create_create_node_stanza ( self, name, config, NULL, NULL); - GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_pubsub_service_create_node_async); + GTask *task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); - g_object_set_data_full ((GObject *) result, "requested-name", + g_object_set_data_full (G_OBJECT (task), "requested-name", g_strdup (name), g_free); wocky_porter_send_iq_async (priv->porter, stanza, NULL, - create_node_iq_cb, result); + create_node_iq_cb, task); g_object_unref (stanza); } @@ -926,20 +908,9 @@ wocky_pubsub_service_create_node_finish (WockyPubsubService *self, GAsyncResult *result, GError **error) { - GSimpleAsyncResult *simple; - WockyPubsubNode *node; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_pubsub_service_create_node_async), NULL); - - simple = (GSimpleAsyncResult *) result; - - if (g_simple_async_result_propagate_error (simple, error)) - return NULL; - - node = WOCKY_PUBSUB_NODE (g_simple_async_result_get_op_res_gpointer (simple)); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); - return g_object_ref (node); + return g_task_propagate_pointer (G_TASK (result), error); } WockyPorter * diff --git a/wocky/wocky-resource-contact.c b/wocky/wocky-resource-contact.c index 67b207a..a2f8afc 100644 --- a/wocky/wocky-resource-contact.c +++ b/wocky/wocky-resource-contact.c @@ -48,8 +48,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_ROSTER #include "wocky-debug-internal.h" -G_DEFINE_TYPE (WockyResourceContact, wocky_resource_contact, WOCKY_TYPE_CONTACT) - /* properties */ enum { @@ -76,11 +74,13 @@ struct _WockyResourceContactPrivate WockyBareContact *bare_contact; }; +G_DEFINE_TYPE_WITH_CODE (WockyResourceContact, wocky_resource_contact, + WOCKY_TYPE_CONTACT, G_ADD_PRIVATE (WockyResourceContact)) + static void wocky_resource_contact_init (WockyResourceContact *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_RESOURCE_CONTACT, - WockyResourceContactPrivate); + self->priv = wocky_resource_contact_get_instance_private (self); } static void @@ -184,9 +184,6 @@ wocky_resource_contact_class_init ( WockyContactClass *contact_class = WOCKY_CONTACT_CLASS (wocky_resource_contact_class); GParamSpec *spec; - g_type_class_add_private (wocky_resource_contact_class, - sizeof (WockyResourceContactPrivate)); - object_class->constructed = wocky_resource_contact_constructed; object_class->set_property = wocky_resource_contact_set_property; object_class->get_property = wocky_resource_contact_get_property; diff --git a/wocky/wocky-roster.c b/wocky/wocky-roster.c index 43b1f53..8ad3bbe 100644 --- a/wocky/wocky-roster.c +++ b/wocky/wocky-roster.c @@ -51,8 +51,6 @@ #define GOOGLE_ROSTER_VERSION "2" -G_DEFINE_TYPE (WockyRoster, wocky_roster, G_TYPE_OBJECT) - typedef struct { WockyRoster *self; @@ -84,18 +82,18 @@ typedef struct static PendingOperation * pending_operation_new (WockyRoster *self, - GSimpleAsyncResult *result, + GTask *task, const gchar *jid) { PendingOperation *pending = g_slice_new0 (PendingOperation); g_assert (self != NULL); - g_assert (result != NULL); + g_assert (task != NULL); g_assert (jid != NULL); pending->self = g_object_ref (self); pending->flying_operations = g_slist_append (pending->flying_operations, - result); + task); pending->jid = g_strdup (jid); pending->groups_to_add = g_hash_table_new_full (g_str_hash, g_str_equal, @@ -180,10 +178,10 @@ pending_operation_set_remove (PendingOperation *pending) static void pending_operation_add_waiting_operation (PendingOperation *pending, - GSimpleAsyncResult *result) + GTask *task) { pending->waiting_operations = g_slist_append (pending->waiting_operations, - result); + task); } static gboolean @@ -254,11 +252,14 @@ struct _WockyRosterPrivate * we already sent is acknowledged. This prevents some race conditions. */ GHashTable *pending_operations; - GSimpleAsyncResult *fetch_result; + GTask *fetch_task; gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyRoster, wocky_roster, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyRoster)) + /** * wocky_roster_error_quark * @@ -284,8 +285,7 @@ static void change_roster_iq_cb (GObject *source_object, static void wocky_roster_init (WockyRoster *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_ROSTER, - WockyRosterPrivate); + self->priv = wocky_roster_get_instance_private (self); } static void @@ -608,9 +608,6 @@ wocky_roster_class_init (WockyRosterClass *wocky_roster_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_roster_class); GParamSpec *spec; - g_type_class_add_private (wocky_roster_class, - sizeof (WockyRosterPrivate)); - object_class->constructed = wocky_roster_constructed; object_class->set_property = wocky_roster_set_property; object_class->get_property = wocky_roster_get_property; @@ -659,25 +656,16 @@ roster_fetch_roster_cb (GObject *source_object, iq = wocky_porter_send_iq_finish (WOCKY_PORTER (source_object), res, &error); - if (iq == NULL) - goto out; - - if (!roster_update (self, iq, FALSE, &error)) - goto out; - -out: - if (error != NULL) - { - g_simple_async_result_set_from_error (priv->fetch_result, error); - g_error_free (error); - } + if (!iq || !roster_update (self, iq, FALSE, &error)) + g_task_return_error (priv->fetch_task, error); + else + g_task_return_boolean (priv->fetch_task, TRUE); if (iq != NULL) g_object_unref (iq); - g_simple_async_result_complete (priv->fetch_result); - g_object_unref (priv->fetch_result); - priv->fetch_result = NULL; + g_object_unref (priv->fetch_task); + priv->fetch_task = NULL; } void @@ -693,9 +681,10 @@ wocky_roster_fetch_roster_async (WockyRoster *self, priv = self->priv; - if (priv->fetch_result != NULL) + if (priv->fetch_task != NULL) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, + g_task_report_new_error (G_OBJECT (self), callback, + wocky_roster_fetch_roster_async, user_data, G_IO_ERROR, G_IO_ERROR_PENDING, "Another fetch operation is pending"); return; @@ -708,8 +697,8 @@ wocky_roster_fetch_roster_async (WockyRoster *self, ')', NULL); - priv->fetch_result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_roster_fetch_roster_async); + priv->fetch_task = g_task_new (G_OBJECT (self), cancellable, callback, + user_data); wocky_porter_send_iq_async (priv->porter, iq, cancellable, roster_fetch_roster_cb, self); @@ -721,14 +710,9 @@ wocky_roster_fetch_roster_finish (WockyRoster *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_roster_fetch_roster_async), FALSE); - - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } WockyBareContact * @@ -865,9 +849,9 @@ build_iq_for_pending (WockyRoster *self, for (l = pending->waiting_operations; l != NULL; l = g_slist_next (l)) { - GSimpleAsyncResult *result = (GSimpleAsyncResult *) l->data; + GTask *task = G_TASK (l->data); - g_simple_async_result_set_error (result, WOCKY_ROSTER_ERROR, + g_task_return_new_error (task, WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, "Contact %s is not in the roster any more", pending->jid); } @@ -926,9 +910,10 @@ waiting_operations_completed (WockyRoster *self, for (l = pending->waiting_operations; l != NULL; l = g_slist_next (l)) { - GSimpleAsyncResult *result = (GSimpleAsyncResult *) l->data; + GTask *task = G_TASK (l->data); - g_simple_async_result_complete (result); + if (!g_task_had_error (task)) + g_task_return_boolean (task, TRUE); } } @@ -944,12 +929,12 @@ flying_operation_completed (PendingOperation *pending, /* Flying operations are completed */ for (l = pending->flying_operations; l != NULL; l = g_slist_next (l)) { - GSimpleAsyncResult *result = (GSimpleAsyncResult *) l->data; + GTask *task = G_TASK (l->data); if (error != NULL) - g_simple_async_result_set_from_error (result, error); - - g_simple_async_result_complete (result); + g_task_return_error (task, error); + else + g_task_return_boolean (task, TRUE); } if (g_slist_length (pending->waiting_operations) == 0) @@ -1030,10 +1015,10 @@ get_pending_operation (WockyRoster *self, static PendingOperation * add_pending_operation (WockyRoster *self, const gchar *jid, - GSimpleAsyncResult *result) + GTask *task) { WockyRosterPrivate *priv = self->priv; - PendingOperation *pending = pending_operation_new (self, result, jid); + PendingOperation *pending = pending_operation_new (self, task, jid); DEBUG ("Add pending operation for %s", jid); g_hash_table_insert (priv->pending_operations, g_strdup (jid), pending); @@ -1051,14 +1036,13 @@ wocky_roster_add_contact_async (WockyRoster *self, { WockyRosterPrivate *priv = self->priv; WockyStanza *iq; - GSimpleAsyncResult *result; + GTask *task; WockyBareContact *contact, *existing_contact; PendingOperation *pending; g_return_if_fail (jid != NULL); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_roster_add_contact_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); pending = get_pending_operation (self, jid); if (pending != NULL) @@ -1067,7 +1051,7 @@ wocky_roster_add_contact_async (WockyRoster *self, jid); pending_operation_set_new_name (pending, name); pending_operation_set_groups (pending, (GStrv) groups); - pending_operation_add_waiting_operation (pending, result); + pending_operation_add_waiting_operation (pending, task); pending_operation_set_add (pending); return; } @@ -1090,16 +1074,16 @@ wocky_roster_add_contact_async (WockyRoster *self, { DEBUG ("Contact %s is already present in the roster; " "no need to change him", jid); - g_simple_async_result_complete_in_idle (result); + g_task_return_boolean (task, TRUE); g_object_unref (contact); - g_object_unref (result); + g_object_unref (task); return; } } iq = build_iq_for_contact (contact, NULL); - pending = add_pending_operation (self, jid, result); + pending = add_pending_operation (self, jid, task); wocky_porter_send_iq_async (priv->porter, iq, cancellable, change_roster_iq_cb, pending); @@ -1115,14 +1099,9 @@ wocky_roster_add_contact_finish (WockyRoster *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_roster_add_contact_async), FALSE); - - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } static gboolean @@ -1151,15 +1130,14 @@ wocky_roster_remove_contact_async (WockyRoster *self, { WockyRosterPrivate *priv = self->priv; WockyStanza *iq; - GSimpleAsyncResult *result; + GTask *task; PendingOperation *pending; const gchar *jid; g_return_if_fail (contact != NULL); jid = wocky_bare_contact_get_jid (contact); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_roster_remove_contact_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); pending = get_pending_operation (self, jid); if (pending != NULL) @@ -1167,7 +1145,7 @@ wocky_roster_remove_contact_async (WockyRoster *self, DEBUG ("Another operation is pending for contact %s; queuing this one", jid); pending_operation_set_remove (pending); - pending_operation_add_waiting_operation (pending, result); + pending_operation_add_waiting_operation (pending, task); return; } @@ -1175,12 +1153,12 @@ wocky_roster_remove_contact_async (WockyRoster *self, { DEBUG ("Contact %s is not in the roster", wocky_bare_contact_get_jid ( contact)); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_task_return_boolean (task, TRUE); + g_object_unref (task); return; } - pending = add_pending_operation (self, jid, result); + pending = add_pending_operation (self, jid, task); iq = build_remove_contact_iq (contact); @@ -1195,14 +1173,9 @@ wocky_roster_remove_contact_finish (WockyRoster *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_roster_remove_contact_async), FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } void @@ -1216,15 +1189,14 @@ wocky_roster_change_contact_name_async (WockyRoster *self, WockyRosterPrivate *priv = self->priv; WockyStanza *iq; WockyNode *item; - GSimpleAsyncResult *result; + GTask *task; PendingOperation *pending; const gchar *jid; g_return_if_fail (contact != NULL); jid = wocky_bare_contact_get_jid (contact); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_roster_change_contact_name_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); pending = get_pending_operation (self, jid); if (pending != NULL) @@ -1232,28 +1204,28 @@ wocky_roster_change_contact_name_async (WockyRoster *self, DEBUG ("Another operation is pending for contact %s; queuing this one", jid); pending_operation_set_new_name (pending, name); - pending_operation_add_waiting_operation (pending, result); + pending_operation_add_waiting_operation (pending, task); return; } if (!contact_in_roster (self, contact)) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, + g_task_return_new_error (task, /* XXX - why was report and not return here? */ + WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, "Contact %s is not in the roster", wocky_bare_contact_get_jid (contact)); - g_object_unref (result); + g_object_unref (task); return; } if (!wocky_strdiff (wocky_bare_contact_get_name (contact), name)) { DEBUG ("No need to change name; complete immediately"); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_task_return_boolean (task, TRUE); + g_object_unref (task); return; } - pending = add_pending_operation (self, jid, result); + pending = add_pending_operation (self, jid, task); iq = build_iq_for_contact (contact, &item); @@ -1271,15 +1243,9 @@ wocky_roster_change_contact_name_finish (WockyRoster *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_roster_change_contact_name_async), - FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } void @@ -1293,15 +1259,14 @@ wocky_roster_contact_add_group_async (WockyRoster *self, WockyRosterPrivate *priv = self->priv; WockyStanza *iq; WockyNode *item, *group_node; - GSimpleAsyncResult *result; + GTask *task; PendingOperation *pending; const gchar *jid; g_return_if_fail (contact != NULL); jid = wocky_bare_contact_get_jid (contact); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_roster_contact_add_group_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); pending = get_pending_operation (self, jid); if (pending != NULL) @@ -1309,16 +1274,16 @@ wocky_roster_contact_add_group_async (WockyRoster *self, DEBUG ("Another operation is pending for contact %s; queuing this one", jid); pending_operation_add_group (pending, group); - pending_operation_add_waiting_operation (pending, result); + pending_operation_add_waiting_operation (pending, task); return; } if (!contact_in_roster (self, contact)) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, + g_task_return_new_error (task, /* XXX - why was report and not return here? */ + WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, "Contact %s is not in the roster", jid); - g_object_unref (result); + g_object_unref (task); return; } @@ -1326,12 +1291,12 @@ wocky_roster_contact_add_group_async (WockyRoster *self, { DEBUG ("Contact %s in already in group %s; complete immediately", wocky_bare_contact_get_jid (contact), group); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_task_return_boolean (task, TRUE); + g_object_unref (task); return; } - pending = add_pending_operation (self, jid, result); + pending = add_pending_operation (self, jid, task); iq = build_iq_for_contact (contact, &item); @@ -1350,15 +1315,9 @@ wocky_roster_contact_add_group_finish (WockyRoster *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_roster_contact_add_group_async), - FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } void @@ -1372,7 +1331,7 @@ wocky_roster_contact_remove_group_async (WockyRoster *self, WockyRosterPrivate *priv = self->priv; WockyStanza *iq; WockyNode *item; - GSimpleAsyncResult *result; + GTask *task; GSList *l; PendingOperation *pending; const gchar *jid; @@ -1380,8 +1339,7 @@ wocky_roster_contact_remove_group_async (WockyRoster *self, g_return_if_fail (contact != NULL); jid = wocky_bare_contact_get_jid (contact); - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_roster_contact_remove_group_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); pending = get_pending_operation (self, jid); if (pending != NULL) @@ -1389,28 +1347,28 @@ wocky_roster_contact_remove_group_async (WockyRoster *self, DEBUG ("Another operation is pending for contact %s; queuing this one", jid); pending_operation_remove_group (pending, group); - pending_operation_add_waiting_operation (pending, result); + pending_operation_add_waiting_operation (pending, task); return; } if (!contact_in_roster (self, contact)) { - g_simple_async_report_error_in_idle (G_OBJECT (self), callback, - user_data, WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, + g_task_return_new_error (task, /* XXX see similar above */ + WOCKY_ROSTER_ERROR, WOCKY_ROSTER_ERROR_NOT_IN_ROSTER, "Contact %s is not in the roster", jid); - g_object_unref (result); + g_object_unref (task); return; } if (!wocky_bare_contact_in_group (contact, group)) { DEBUG ("Contact %s is not in group %s; complete immediately", jid, group); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_task_return_boolean (task, TRUE); + g_object_unref (task); return; } - pending = add_pending_operation (self, jid, result); + pending = add_pending_operation (self, jid, task); iq = build_iq_for_contact (contact, &item); @@ -1442,13 +1400,7 @@ wocky_roster_contact_remove_group_finish (WockyRoster *self, GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (self), wocky_roster_contact_remove_group_async), - FALSE); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } diff --git a/wocky/wocky-sasl-auth.c b/wocky/wocky-sasl-auth.c index 70dcbcc..31da74d 100644 --- a/wocky/wocky-sasl-auth.c +++ b/wocky/wocky-sasl-auth.c @@ -36,8 +36,6 @@ #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_AUTH #include "wocky-debug-internal.h" -G_DEFINE_TYPE(WockySaslAuth, wocky_sasl_auth, G_TYPE_OBJECT) - enum { PROP_SERVER = 1, @@ -56,18 +54,20 @@ struct _WockySaslAuthPrivate gchar *password; gchar *server; GCancellable *cancel; - GSimpleAsyncResult *result; + GTask *task; WockyAuthRegistry *auth_registry; }; +G_DEFINE_TYPE_WITH_CODE (WockySaslAuth, wocky_sasl_auth, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockySaslAuth)) + static void sasl_auth_stanza_received (GObject *source, GAsyncResult *res, gpointer user_data); static void wocky_sasl_auth_init (WockySaslAuth *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_SASL_AUTH, - WockySaslAuthPrivate); + self->priv = wocky_sasl_auth_get_instance_private (self); } static void wocky_sasl_auth_dispose (GObject *object); @@ -143,9 +143,6 @@ wocky_sasl_auth_class_init (WockySaslAuthClass *wocky_sasl_auth_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_sasl_auth_class); GParamSpec *spec; - g_type_class_add_private (wocky_sasl_auth_class, - sizeof (WockySaslAuthPrivate)); - object_class->set_property = wocky_sasl_auth_set_property; object_class->get_property = wocky_sasl_auth_get_property; @@ -244,16 +241,16 @@ static void auth_succeeded (WockySaslAuth *sasl) { WockySaslAuthPrivate *priv = sasl->priv; - GSimpleAsyncResult *r; + GTask *t; DEBUG ("Authentication succeeded"); auth_reset (sasl); - r = priv->result; - priv->result = NULL; + t = priv->task; + priv->task = NULL; - g_simple_async_result_complete (r); - g_object_unref (r); + g_task_return_boolean (t, TRUE); + g_object_unref (t); } static void @@ -261,7 +258,7 @@ auth_failed (WockySaslAuth *sasl, gint code, const gchar *format, ...) { gchar *message; va_list args; - GSimpleAsyncResult *r; + GTask *t; GError *error = NULL; WockySaslAuthPrivate *priv = sasl->priv; @@ -273,17 +270,16 @@ auth_failed (WockySaslAuth *sasl, gint code, const gchar *format, ...) DEBUG ("Authentication failed!: %s", message); - r = priv->result; - priv->result = NULL; + t = priv->task; + priv->task = NULL; error = g_error_new_literal (WOCKY_AUTH_ERROR, code, message); - g_simple_async_result_set_from_error (r, error); + g_task_return_error (t, g_error_copy (error)); wocky_auth_registry_failure (priv->auth_registry, error); - g_simple_async_result_complete (r); - g_object_unref (r); + g_object_unref (t); g_error_free (error); g_free (message); @@ -610,7 +606,9 @@ wocky_sasl_auth_authenticate_finish (WockySaslAuth *sasl, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (sasl, wocky_sasl_auth_authenticate_async); + g_return_val_if_fail (g_task_is_valid (result, sasl), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } static void @@ -685,15 +683,15 @@ wocky_sasl_auth_authenticate_async (WockySaslAuth *sasl, if (G_UNLIKELY (mechanisms == NULL)) { - g_simple_async_report_error_in_idle (G_OBJECT (sasl), - callback, user_data, + g_task_report_new_error (G_OBJECT (sasl), callback, user_data, + wocky_sasl_auth_authenticate_async, WOCKY_AUTH_ERROR, WOCKY_AUTH_ERROR_NOT_SUPPORTED, "Server doesn't have any sasl mechanisms"); goto out; } - priv->result = g_simple_async_result_new (G_OBJECT (sasl), - callback, user_data, wocky_sasl_auth_authenticate_async); + + priv->task = g_task_new (G_OBJECT (sasl), cancellable, callback, user_data); if (cancellable != NULL) priv->cancel = g_object_ref (cancellable); diff --git a/wocky/wocky-sasl-digest-md5.c b/wocky/wocky-sasl-digest-md5.c index eb79b55..6e1f078 100644 --- a/wocky/wocky-sasl-digest-md5.c +++ b/wocky/wocky-sasl-digest-md5.c @@ -20,10 +20,6 @@ typedef enum { static void auth_handler_iface_init (gpointer g_iface); -G_DEFINE_TYPE_WITH_CODE (WockySaslDigestMd5, wocky_sasl_digest_md5, - G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE ( - WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) - enum { PROP_SERVER = 1, @@ -40,6 +36,10 @@ struct _WockySaslDigestMd5Private gchar *digest_md5_rspauth; }; +G_DEFINE_TYPE_WITH_CODE (WockySaslDigestMd5, wocky_sasl_digest_md5, + G_TYPE_OBJECT, G_ADD_PRIVATE (WockySaslDigestMd5) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) + static void wocky_sasl_digest_md5_get_property ( GObject *object, guint property_id, GValue *value, GParamSpec *pspec) @@ -115,8 +115,6 @@ wocky_sasl_digest_md5_class_init ( { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockySaslDigestMd5Private)); - object_class->dispose = wocky_sasl_digest_md5_dispose; object_class->set_property = wocky_sasl_digest_md5_set_property; object_class->get_property = wocky_sasl_digest_md5_get_property; @@ -159,8 +157,7 @@ auth_handler_iface_init (gpointer g_iface) static void wocky_sasl_digest_md5_init (WockySaslDigestMd5 *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - WOCKY_TYPE_SASL_DIGEST_MD5, WockySaslDigestMd5Private); + self->priv = wocky_sasl_digest_md5_get_instance_private (self); self->priv->state = WOCKY_SASL_DIGEST_MD5_STATE_STARTED; } diff --git a/wocky/wocky-sasl-plain.c b/wocky/wocky-sasl-plain.c index 2136bd6..ac2c91b 100644 --- a/wocky/wocky-sasl-plain.c +++ b/wocky/wocky-sasl-plain.c @@ -12,9 +12,6 @@ static void auth_handler_iface_init (gpointer g_iface); -G_DEFINE_TYPE_WITH_CODE (WockySaslPlain, wocky_sasl_plain, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) - enum { PROP_USERNAME = 1, @@ -27,6 +24,10 @@ struct _WockySaslPlainPrivate gchar *password; }; +G_DEFINE_TYPE_WITH_CODE (WockySaslPlain, wocky_sasl_plain, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockySaslPlain) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, auth_handler_iface_init)) + static void wocky_sasl_plain_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) @@ -89,8 +90,6 @@ wocky_sasl_plain_class_init (WockySaslPlainClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockySaslPlainPrivate)); - object_class->get_property = wocky_sasl_plain_get_property; object_class->set_property = wocky_sasl_plain_set_property; object_class->dispose = wocky_sasl_plain_dispose; @@ -124,8 +123,7 @@ auth_handler_iface_init (gpointer g_iface) static void wocky_sasl_plain_init (WockySaslPlain *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE ( - self, WOCKY_TYPE_SASL_PLAIN, WockySaslPlainPrivate); + self->priv = wocky_sasl_plain_get_instance_private (self); } WockySaslPlain * diff --git a/wocky/wocky-sasl-scram.c b/wocky/wocky-sasl-scram.c index fc28553..fe2eddc 100644 --- a/wocky/wocky-sasl-scram.c +++ b/wocky/wocky-sasl-scram.c @@ -41,10 +41,6 @@ typedef enum { static void sasl_handler_iface_init (gpointer g_iface); -G_DEFINE_TYPE_WITH_CODE (WockySaslScram, wocky_sasl_scram, - G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE ( - WOCKY_TYPE_AUTH_HANDLER, sasl_handler_iface_init)) - enum { PROP_SERVER = 1, @@ -73,6 +69,10 @@ struct _WockySaslScramPrivate GByteArray *salted_password; }; +G_DEFINE_TYPE_WITH_CODE (WockySaslScram, wocky_sasl_scram, + G_TYPE_OBJECT, G_ADD_PRIVATE (WockySaslScram) + G_IMPLEMENT_INTERFACE (WOCKY_TYPE_AUTH_HANDLER, sasl_handler_iface_init)) + static void wocky_sasl_scram_get_property ( GObject *object, guint property_id, GValue *value, GParamSpec *pspec) @@ -159,8 +159,6 @@ wocky_sasl_scram_class_init ( { GObjectClass *object_class = G_OBJECT_CLASS (klass); - g_type_class_add_private (klass, sizeof (WockySaslScramPrivate)); - object_class->dispose = wocky_sasl_scram_dispose; object_class->set_property = wocky_sasl_scram_set_property; object_class->get_property = wocky_sasl_scram_get_property; @@ -209,8 +207,7 @@ sasl_handler_iface_init (gpointer g_iface) static void wocky_sasl_scram_init (WockySaslScram *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - WOCKY_TYPE_SASL_SCRAM, WockySaslScramPrivate); + self->priv = wocky_sasl_scram_get_instance_private (self); self->priv->state = WOCKY_SASL_SCRAM_STATE_STARTED; } diff --git a/wocky/wocky-session.c b/wocky/wocky-session.c index 48c3837..d3dc08b 100644 --- a/wocky/wocky-session.c +++ b/wocky/wocky-session.c @@ -45,8 +45,6 @@ #include "wocky-c2s-porter.h" #include "wocky-meta-porter.h" -G_DEFINE_TYPE (WockySession, wocky_session, G_TYPE_OBJECT) - /* properties */ enum { @@ -77,11 +75,13 @@ struct _WockySessionPrivate WockyContactFactory *contact_factory; }; +G_DEFINE_TYPE_WITH_CODE (WockySession, wocky_session, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockySession)) + static void wocky_session_init (WockySession *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_SESSION, - WockySessionPrivate); + self->priv = wocky_session_get_instance_private (self); self->priv->contact_factory = wocky_contact_factory_new (); } @@ -196,9 +196,6 @@ wocky_session_class_init (WockySessionClass *wocky_session_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_session_class); GParamSpec *spec; - g_type_class_add_private (wocky_session_class, - sizeof (WockySessionPrivate)); - object_class->constructed = wocky_session_constructed; object_class->set_property = wocky_session_set_property; object_class->get_property = wocky_session_get_property; diff --git a/wocky/wocky-stanza.c b/wocky/wocky-stanza.c index a44fe6a..2e5fd56 100644 --- a/wocky/wocky-stanza.c +++ b/wocky/wocky-stanza.c @@ -33,8 +33,6 @@ #include "wocky-node-private.h" -G_DEFINE_TYPE(WockyStanza, wocky_stanza, WOCKY_TYPE_NODE_TREE) - /* private structure */ struct _WockyStanzaPrivate { @@ -44,6 +42,9 @@ struct _WockyStanzaPrivate gboolean dispose_has_run; }; +G_DEFINE_TYPE_WITH_CODE (WockyStanza, wocky_stanza, WOCKY_TYPE_NODE_TREE, + G_ADD_PRIVATE (WockyStanza)) + typedef struct { WockyStanzaType type; @@ -139,8 +140,7 @@ static const StanzaSubTypeName sub_type_names[NUM_WOCKY_STANZA_SUB_TYPE] = static void wocky_stanza_init (WockyStanza *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_STANZA, - WockyStanzaPrivate); + self->priv = wocky_stanza_get_instance_private (self); self->priv->from_contact = NULL; self->priv->to_contact = NULL; @@ -154,8 +154,6 @@ wocky_stanza_class_init (WockyStanzaClass *wocky_stanza_class) { GObjectClass *object_class = G_OBJECT_CLASS (wocky_stanza_class); - g_type_class_add_private (wocky_stanza_class, sizeof (WockyStanzaPrivate)); - object_class->dispose = wocky_stanza_dispose; object_class->finalize = wocky_stanza_finalize; diff --git a/wocky/wocky-tls-connector.c b/wocky/wocky-tls-connector.c index 46c8ade..324a00c 100644 --- a/wocky/wocky-tls-connector.c +++ b/wocky/wocky-tls-connector.c @@ -45,7 +45,7 @@ struct _WockyTLSConnectorPrivate { WockyXmppConnection *connection; WockyXmppConnection *tls_connection; - GSimpleAsyncResult *secure_result; + GTask *secure_task; GCancellable *cancellable; }; @@ -59,7 +59,8 @@ session_handshake_cb (GObject *source, GAsyncResult *res, gpointer user_data); -G_DEFINE_TYPE (WockyTLSConnector, wocky_tls_connector, G_TYPE_OBJECT); +G_DEFINE_TYPE_WITH_CODE (WockyTLSConnector, wocky_tls_connector, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyTLSConnector)); static void wocky_tls_connector_get_property (GObject *object, @@ -137,8 +138,6 @@ wocky_tls_connector_class_init (WockyTLSConnectorClass *klass) GObjectClass *oclass = G_OBJECT_CLASS (klass); GParamSpec *pspec; - g_type_class_add_private (klass, sizeof (WockyTLSConnectorPrivate)); - oclass->get_property = wocky_tls_connector_get_property; oclass->set_property = wocky_tls_connector_set_property; oclass->finalize = wocky_tls_connector_finalize; @@ -158,10 +157,9 @@ wocky_tls_connector_class_init (WockyTLSConnectorClass *klass) static void wocky_tls_connector_init (WockyTLSConnector *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_TLS_CONNECTOR, - WockyTLSConnectorPrivate); + self->priv = wocky_tls_connector_get_instance_private (self); - self->priv->secure_result = NULL; + self->priv->secure_task = NULL; } static void @@ -215,18 +213,13 @@ report_error_in_idle (WockyTLSConnector *self, DEBUG ("%s", error->message); - g_simple_async_result_set_from_error (self->priv->secure_result, - error); - g_error_free (error); - g_simple_async_result_complete_in_idle (self->priv->secure_result); - - g_object_unref (self->priv->secure_result); - if (self->priv->cancellable != NULL) { g_object_unref (self->priv->cancellable); self->priv->cancellable = NULL; } + g_task_return_error (self->priv->secure_task, error); + g_object_unref (self->priv->secure_task); } static void @@ -235,17 +228,14 @@ report_error_in_idle_gerror (WockyTLSConnector *self, { DEBUG ("Reporting error %s", error->message); - g_simple_async_result_set_from_error (self->priv->secure_result, - error); - g_simple_async_result_complete_in_idle (self->priv->secure_result); - - g_object_unref (self->priv->secure_result); - if (self->priv->cancellable != NULL) { g_object_unref (self->priv->cancellable); self->priv->cancellable = NULL; } + + g_task_return_error (self->priv->secure_task, g_error_copy (error)); + g_object_unref (self->priv->secure_task); } static void @@ -294,18 +284,17 @@ tls_handler_verify_async_cb (GObject *source, return; } - g_simple_async_result_set_op_res_gpointer (self->priv->secure_result, - self->priv->tls_connection, (GDestroyNotify) g_object_unref); - self->priv->tls_connection = NULL; - g_simple_async_result_complete_in_idle (self->priv->secure_result); - - g_object_unref (self->priv->secure_result); - if (self->priv->cancellable != NULL) { g_object_unref (self->priv->cancellable); self->priv->cancellable = NULL; } + + g_task_return_pointer (self->priv->secure_task, + self->priv->tls_connection, (GDestroyNotify) g_object_unref); + self->priv->tls_connection = NULL; + + g_object_unref (self->priv->secure_task); } static void @@ -468,19 +457,18 @@ wocky_tls_connector_secure_async (WockyTLSConnector *self, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *async_result; + GTask *task; - g_assert (self->priv->secure_result == NULL); + g_assert (self->priv->secure_task == NULL); g_assert (self->priv->cancellable == NULL); - async_result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_tls_connector_secure_async); + task = g_task_new (G_OBJECT (self), cancellable, callback, user_data); if (cancellable != NULL) self->priv->cancellable = g_object_ref (cancellable); self->priv->connection = connection; - self->priv->secure_result = async_result; + self->priv->secure_task = task; self->priv->legacy_ssl = old_style_ssl; self->priv->peername = g_strdup (peername); self->priv->extra_identities = g_strdupv (extra_identities); @@ -496,6 +484,7 @@ wocky_tls_connector_secure_finish (WockyTLSConnector *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_return_copy_pointer (self, - wocky_tls_connector_secure_async, g_object_ref); + g_return_val_if_fail (g_task_is_valid (result, self), NULL); + + return g_task_propagate_pointer (G_TASK (result), error); } diff --git a/wocky/wocky-tls-handler.c b/wocky/wocky-tls-handler.c index ef005f7..04a8b01 100644 --- a/wocky/wocky-tls-handler.c +++ b/wocky/wocky-tls-handler.c @@ -39,8 +39,6 @@ real_verify_finish (WockyTLSHandler *self, GAsyncResult *result, GError **error); -G_DEFINE_TYPE (WockyTLSHandler, wocky_tls_handler, G_TYPE_OBJECT) - enum { PROP_TLS_INSECURE_OK = 1, }; @@ -52,6 +50,9 @@ struct _WockyTLSHandlerPrivate { GSList *crl; }; +G_DEFINE_TYPE_WITH_CODE (WockyTLSHandler, wocky_tls_handler, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyTLSHandler)) + static void wocky_tls_handler_get_property (GObject *object, guint property_id, @@ -117,8 +118,6 @@ wocky_tls_handler_class_init (WockyTLSHandlerClass *klass) GObjectClass *oclass = G_OBJECT_CLASS (klass); GParamSpec *pspec; - g_type_class_add_private (klass, sizeof (WockyTLSHandlerPrivate)); - klass->verify_async_func = real_verify_async; klass->verify_finish_func = real_verify_finish; @@ -141,8 +140,7 @@ wocky_tls_handler_class_init (WockyTLSHandlerClass *klass) static void wocky_tls_handler_init (WockyTLSHandler *self) { - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_TLS_HANDLER, - WockyTLSHandlerPrivate); + self->priv = wocky_tls_handler_get_instance_private (self); #ifdef GTLS_SYSTEM_CA_CERTIFICATES wocky_tls_handler_add_ca (self, GTLS_SYSTEM_CA_CERTIFICATES); @@ -156,15 +154,14 @@ real_verify_async (WockyTLSHandler *self, GAsyncReadyCallback callback, gpointer user_data) { - GSimpleAsyncResult *result; + GTask *task; glong flags = WOCKY_TLS_VERIFY_NORMAL; WockyTLSCertStatus status = WOCKY_TLS_CERT_UNKNOWN_ERROR; GSocketConnectable *identity; const gchar *peername = NULL; GStrv verify_extra_identities = NULL; - result = g_simple_async_result_new (G_OBJECT (self), - callback, user_data, wocky_tls_handler_verify_async); + task = g_task_new (G_OBJECT (self), NULL, callback, user_data); /* When ignore_ssl_errors is true, don't check the peername. Otherwise: * - Under legacy SSL, the connect hostname is the preferred peername; @@ -234,12 +231,9 @@ real_verify_async (WockyTLSHandler *self, cert_error = g_error_new (WOCKY_TLS_CERT_ERROR, status, msg, peername); - g_simple_async_result_set_from_error (result, cert_error); - - g_error_free (cert_error); - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_task_return_error (task, cert_error); + g_object_unref (task); return; } else @@ -252,8 +246,8 @@ real_verify_async (WockyTLSHandler *self, } } - g_simple_async_result_complete_in_idle (result); - g_object_unref (result); + g_task_return_boolean (task, TRUE); + g_object_unref (task); } static gboolean @@ -261,7 +255,9 @@ real_verify_finish (WockyTLSHandler *self, GAsyncResult *result, GError **error) { - wocky_implement_finish_void (self, wocky_tls_handler_verify_async); + g_return_val_if_fail (g_task_is_valid (result, self), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } void diff --git a/wocky/wocky-xmpp-connection.c b/wocky/wocky-xmpp-connection.c index 6097763..4d4fdce 100644 --- a/wocky/wocky-xmpp-connection.c +++ b/wocky/wocky-xmpp-connection.c @@ -55,8 +55,6 @@ static void _xmpp_connection_received_data (GObject *source, GAsyncResult *result, gpointer user_data); static void wocky_xmpp_connection_do_write (WockyXmppConnection *self); -G_DEFINE_TYPE(WockyXmppConnection, wocky_xmpp_connection, G_TYPE_OBJECT) - /* properties */ enum { @@ -74,14 +72,14 @@ struct _WockyXmppConnectionPrivate /* received open from the input stream */ gboolean input_open; - GSimpleAsyncResult *input_result; + GTask *input_task; GCancellable *input_cancellable; /* sent open to the output stream */ gboolean output_open; /* sent close to the output stream */ gboolean output_closed; - GSimpleAsyncResult *output_result; + GTask *output_task; GCancellable *output_cancellable; guint8 input_buffer[BUFFER_SIZE]; @@ -90,11 +88,12 @@ struct _WockyXmppConnectionPrivate gsize offset; gsize length; - GSimpleAsyncResult *force_close_result; - - guint last_id; + GTask *force_close_task; }; +G_DEFINE_TYPE_WITH_CODE (WockyXmppConnection, wocky_xmpp_connection, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyXmppConnection)) + /** * wocky_xmpp_connection_error_quark * @@ -118,8 +117,7 @@ wocky_xmpp_connection_init (WockyXmppConnection *self) { WockyXmppConnectionPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_XMPP_CONNECTION, - WockyXmppConnectionPrivate); + self->priv = wocky_xmpp_connection_get_instance_private (self); priv = self->priv; priv->writer = wocky_xmpp_writer_new (); @@ -180,9 +178,6 @@ wocky_xmpp_connection_class_init ( GObjectClass *object_class = G_OBJECT_CLASS (wocky_xmpp_connection_class); GParamSpec *spec; - g_type_class_add_private (wocky_xmpp_connection_class, - sizeof (WockyXmppConnectionPrivate)); - object_class->set_property = wocky_xmpp_connection_set_property; object_class->get_property = wocky_xmpp_connection_get_property; object_class->dispose = wocky_xmpp_connection_dispose; @@ -207,51 +202,18 @@ wocky_xmpp_connection_dispose (GObject *object) if (priv->dispose_has_run) return; - g_warn_if_fail (priv->input_result == NULL); - g_warn_if_fail (priv->output_result == NULL); + g_warn_if_fail (priv->input_task == NULL); + g_warn_if_fail (priv->output_task == NULL); priv->dispose_has_run = TRUE; - if (priv->stream != NULL) - { - g_object_unref (priv->stream); - priv->stream = NULL; - } - - if (priv->reader != NULL) - { - g_object_unref (priv->reader); - priv->reader = NULL; - } - - if (priv->writer != NULL) - { - g_object_unref (priv->writer); - priv->writer = NULL; - } - - if (priv->output_result != NULL) - { - g_object_unref (priv->output_result); - priv->output_result = NULL; - } - - if (priv->output_cancellable != NULL) - { - g_object_unref (priv->output_cancellable); - priv->output_cancellable = NULL; - } - if (priv->input_result != NULL) - { - g_object_unref (priv->input_result); - priv->input_result = NULL; - } - - if (priv->input_cancellable != NULL) - { - g_object_unref (priv->input_cancellable); - priv->input_cancellable = NULL; - } + g_clear_object (&(priv->stream)); + g_clear_object (&(priv->reader)); + g_clear_object (&(priv->writer)); + g_clear_object (&(priv->output_task)); + g_clear_object (&(priv->output_cancellable)); + g_clear_object (&(priv->input_task)); + g_clear_object (&(priv->input_cancellable)); /* release any references held by the object here */ @@ -300,15 +262,13 @@ wocky_xmpp_connection_write_cb (GObject *source, if (G_UNLIKELY (written < 0)) { - g_simple_async_result_set_from_error (priv->output_result, error); - g_error_free (error); - + g_task_return_error (priv->output_task, error); goto finished; } if (G_UNLIKELY (written == 0)) { - g_simple_async_result_set_error (priv->output_result, + g_task_return_new_error (priv->output_task, WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_EOS, "Connection got disconnected" ); goto finished; @@ -327,16 +287,18 @@ wocky_xmpp_connection_write_cb (GObject *source, finished: { - GSimpleAsyncResult *r = priv->output_result; + GTask *t = priv->output_task; if (priv->output_cancellable != NULL) g_object_unref (priv->output_cancellable); priv->output_cancellable = NULL; - priv->output_result = NULL; + priv->output_task = NULL; + + if (!g_task_had_error (t)) + g_task_return_boolean (t, TRUE); - g_simple_async_result_complete (r); - g_object_unref (r); + g_object_unref (t); } } @@ -389,20 +351,37 @@ wocky_xmpp_connection_send_open_async (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->output_result != NULL)) - goto pending; + if (G_UNLIKELY (priv->output_task != NULL)) + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_open_async, G_IO_ERROR, + G_IO_ERROR_PENDING, "Another send operation is pending"); + return; + } if (G_UNLIKELY (priv->output_closed)) - goto is_closed; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_open_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, + "Connection is already open"); + return; + } if (G_UNLIKELY (priv->output_open)) - goto is_open; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_open_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_OPEN, + "Connection is closed for sending"); + return; + } - g_assert (priv->output_result == NULL); + g_assert (priv->output_task == NULL); g_assert (priv->output_cancellable == NULL); - priv->output_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_send_open_async); + priv->output_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); if (cancellable != NULL) priv->output_cancellable = g_object_ref (cancellable); @@ -416,26 +395,6 @@ wocky_xmpp_connection_send_open_async (WockyXmppConnection *connection, wocky_xmpp_connection_do_write (connection); return; - -pending: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Another send operation is pending"); - return; - -is_open: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_OPEN, - "Connection is already open"); - return; - -is_closed: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, - "Connection is closed for sending"); - return; } /** @@ -453,15 +412,12 @@ wocky_xmpp_connection_send_open_finish (WockyXmppConnection *connection, GAsyncResult *result, GError **error) { - WockyXmppConnectionPrivate *priv = - connection->priv; + WockyXmppConnectionPrivate *priv = connection->priv; - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, connection), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (connection), wocky_xmpp_connection_send_open_async), FALSE); + if (!g_task_propagate_boolean (G_TASK (result), error)) + return FALSE; priv->output_open = TRUE; @@ -507,15 +463,13 @@ _xmpp_connection_received_data (GObject *source, if (G_UNLIKELY (size < 0)) { - g_simple_async_result_set_from_error (priv->input_result, error); - g_error_free (error); - + g_task_return_error (priv->input_task, error); goto finished; } if (G_UNLIKELY (size == 0)) { - g_simple_async_result_set_error (priv->input_result, + g_task_return_new_error (priv->input_task, WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_EOS, "Connection got disconnected" ); goto finished; @@ -551,16 +505,18 @@ _xmpp_connection_received_data (GObject *source, finished: { - GSimpleAsyncResult *r = priv->input_result; + GTask *t = priv->input_task; if (priv->input_cancellable != NULL) g_object_unref (priv->input_cancellable); priv->input_cancellable = NULL; - priv->input_result = NULL; + priv->input_task = NULL; + + if (!g_task_had_error (t)) + g_task_return_boolean (t, TRUE); - g_simple_async_result_complete (r); - g_object_unref (r); + g_object_unref (t); } } @@ -585,20 +541,37 @@ wocky_xmpp_connection_recv_open_async (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->input_result != NULL)) - goto pending; + if (G_UNLIKELY (priv->input_task != NULL)) + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_recv_open_async, G_IO_ERROR, + G_IO_ERROR_PENDING, "Another receive operation is pending"); + return; + } if (G_UNLIKELY (input_is_closed (connection))) - goto is_closed; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_recv_open_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, + "Connection is closed for receiving"); + return; + } if (G_UNLIKELY (priv->input_open)) - goto is_open; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_recv_open_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_OPEN, + "Connection has already received open"); + return; + } - g_assert (priv->input_result == NULL); + g_assert (priv->input_task == NULL); g_assert (priv->input_cancellable == NULL); - priv->input_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_recv_open_async); + priv->input_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); if (cancellable != NULL) priv->input_cancellable = g_object_ref (cancellable); @@ -606,26 +579,6 @@ wocky_xmpp_connection_recv_open_async (WockyXmppConnection *connection, wocky_xmpp_connection_do_read (connection); return; - -pending: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Another receive operation is pending"); - return; - -is_closed: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, - "Connection is closed for receiving"); - return; - -is_open: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_OPEN, - "Connection has already received open"); - return; } /** @@ -660,12 +613,10 @@ wocky_xmpp_connection_recv_open_finish (WockyXmppConnection *connection, { WockyXmppConnectionPrivate *priv; - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, connection), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (connection), wocky_xmpp_connection_recv_open_async), FALSE); + if (!g_task_propagate_boolean (G_TASK (result), error)) + return FALSE; priv = connection->priv; priv->input_open = TRUE; @@ -715,21 +666,39 @@ wocky_xmpp_connection_send_stanza_async (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->output_result != NULL)) - goto pending; + if (G_UNLIKELY (priv->output_task != NULL)) + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_stanza_async, G_IO_ERROR, + G_IO_ERROR_PENDING, "Another send operation is pending"); + return; + } + if (G_UNLIKELY (!priv->output_open)) - goto not_open; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_stanza_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, + "Connections hasn't been opened for sending"); + return; + } if (G_UNLIKELY (priv->output_closed)) - goto is_closed; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_stanza_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, + "Connections has been closed for sending"); + return; + } g_assert (!priv->output_closed); - g_assert (priv->output_result == NULL); + g_assert (priv->output_task == NULL); g_assert (priv->output_cancellable == NULL); - priv->output_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_send_stanza_async); + priv->output_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); if (cancellable != NULL) priv->output_cancellable = g_object_ref (cancellable); @@ -742,26 +711,6 @@ wocky_xmpp_connection_send_stanza_async (WockyXmppConnection *connection, wocky_xmpp_connection_do_write (connection); return; - -pending: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Another send operation is pending"); - return; - -not_open: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, - "Connections hasn't been opened for sending"); - return; - -is_closed: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, - "Connections has been closed for sending"); - return; } /** @@ -780,15 +729,9 @@ wocky_xmpp_connection_send_stanza_finish ( GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; - - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (connection), wocky_xmpp_connection_send_stanza_async), - FALSE); + g_return_val_if_fail (g_task_is_valid (result, connection), FALSE); - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } /** @@ -815,30 +758,47 @@ wocky_xmpp_connection_recv_stanza_async (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->input_result != NULL)) - goto pending; + if (G_UNLIKELY (priv->input_task != NULL)) + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_recv_stanza_async, G_IO_ERROR, + G_IO_ERROR_PENDING, "Another receive operation is pending"); + return; + } if (G_UNLIKELY (!priv->input_open)) - goto not_open; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_recv_stanza_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, + "Connection hasn't been opened for reading stanzas"); + return; + } if (G_UNLIKELY (input_is_closed (connection))) - goto is_closed; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_recv_stanza_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, + "Connection has been closed for reading stanzas"); + return; + } - g_assert (priv->input_result == NULL); + g_assert (priv->input_task == NULL); g_assert (priv->input_cancellable == NULL); - priv->input_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_recv_stanza_async); + priv->input_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); /* There is already a stanza waiting, no need to read */ if (wocky_xmpp_reader_peek_stanza (priv->reader) != NULL) { - GSimpleAsyncResult *r = priv->input_result; + GTask *t = priv->input_task; - priv->input_result = NULL; + priv->input_task = NULL; - g_simple_async_result_complete_in_idle (r); - g_object_unref (r); + g_task_return_boolean (t, TRUE); + g_object_unref (t); return; } @@ -847,26 +807,6 @@ wocky_xmpp_connection_recv_stanza_async (WockyXmppConnection *connection, wocky_xmpp_connection_do_read (connection); return; - -pending: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Another receive operation is pending"); - return; - -not_open: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, - "Connection hasn't been opened for reading stanzas"); - return; - -is_closed: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, - "Connection has been closed for reading stanzas"); - return; } /** @@ -888,12 +828,10 @@ wocky_xmpp_connection_recv_stanza_finish (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv; WockyStanza *stanza = NULL; - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return NULL; + g_return_val_if_fail (g_task_is_valid (result, connection), NULL); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (connection), wocky_xmpp_connection_recv_stanza_async), NULL); + if (!g_task_propagate_boolean (G_TASK (result), error)) + return NULL; priv = connection->priv; @@ -952,20 +890,37 @@ wocky_xmpp_connection_send_close_async (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->output_result != NULL)) - goto pending; + if (G_UNLIKELY (priv->output_task != NULL)) + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_close_async, G_IO_ERROR, + G_IO_ERROR_PENDING, "Another send operation is pending"); + return; + } if (G_UNLIKELY (priv->output_closed)) - goto is_closed; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_close_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, + "Connections has been closed sending"); + return; + } if (G_UNLIKELY (!priv->output_open)) - goto not_open; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_close_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, + "Connections hasn't been opened for sending"); + return; + } - g_assert (priv->output_result == NULL); + g_assert (priv->output_task == NULL); g_assert (priv->output_cancellable == NULL); - priv->output_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_send_close_async); + priv->output_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); if (cancellable != NULL) priv->output_cancellable = g_object_ref (cancellable); @@ -979,26 +934,6 @@ wocky_xmpp_connection_send_close_async (WockyXmppConnection *connection, wocky_xmpp_connection_do_write (connection); return; - -pending: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Another send operation is pending"); - return; - -not_open: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, - "Connections hasn't been opened for sending"); - return; - -is_closed: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, - "Connections has been closed sending"); - return; } /** @@ -1016,15 +951,12 @@ wocky_xmpp_connection_send_close_finish (WockyXmppConnection *connection, GAsyncResult *result, GError **error) { - WockyXmppConnectionPrivate *priv = - connection->priv; + WockyXmppConnectionPrivate *priv = connection->priv; - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, connection), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (connection), wocky_xmpp_connection_send_close_async), FALSE); + if (!g_task_propagate_boolean (G_TASK (result), error)) + return FALSE; priv->output_closed = TRUE; @@ -1055,21 +987,38 @@ wocky_xmpp_connection_send_whitespace_ping_async (WockyXmppConnection *connectio WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->output_result != NULL)) - goto pending; + if (G_UNLIKELY (priv->output_task != NULL)) + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_whitespace_ping_async, G_IO_ERROR, + G_IO_ERROR_PENDING, "Another send operation is pending"); + return; + } if (G_UNLIKELY (!priv->output_open)) - goto not_open; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_whitespace_ping_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, + "Connections hasn't been opened for sending"); + return; + } if (G_UNLIKELY (priv->output_closed)) - goto is_closed; + { + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_send_whitespace_ping_async, + WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, + "Connections has been closed for sending"); + return; + } g_assert (!priv->output_closed); - g_assert (priv->output_result == NULL); + g_assert (priv->output_task == NULL); g_assert (priv->output_cancellable == NULL); - priv->output_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_send_whitespace_ping_async); + priv->output_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); if (cancellable != NULL) priv->output_cancellable = g_object_ref (cancellable); @@ -1081,26 +1030,6 @@ wocky_xmpp_connection_send_whitespace_ping_async (WockyXmppConnection *connectio wocky_xmpp_connection_do_write (connection); return; - -pending: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - G_IO_ERROR, G_IO_ERROR_PENDING, "Another send operation is pending"); - return; - -not_open: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_NOT_OPEN, - "Connections hasn't been opened for sending"); - return; - -is_closed: - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, - WOCKY_XMPP_CONNECTION_ERROR, WOCKY_XMPP_CONNECTION_ERROR_IS_CLOSED, - "Connections has been closed for sending"); - return; } /** @@ -1119,8 +1048,9 @@ wocky_xmpp_connection_send_whitespace_ping_finish ( GAsyncResult *result, GError **error) { - wocky_implement_finish_void (connection, - wocky_xmpp_connection_send_whitespace_ping_async); + g_return_val_if_fail (g_task_is_valid (result, connection), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); } /** @@ -1138,8 +1068,8 @@ wocky_xmpp_connection_reset (WockyXmppConnection *connection) connection->priv; /* There can't be any pending operations */ - g_assert (priv->input_result == NULL); - g_assert (priv->output_result == NULL); + g_assert (priv->input_task == NULL); + g_assert (priv->output_task == NULL); priv->input_open = FALSE; @@ -1159,15 +1089,7 @@ wocky_xmpp_connection_reset (WockyXmppConnection *connection) gchar * wocky_xmpp_connection_new_id (WockyXmppConnection *self) { - WockyXmppConnectionPrivate *priv = - self->priv; - GTimeVal tv; - glong val; - - g_get_current_time (&tv); - val = (tv.tv_sec & tv.tv_usec) + priv->last_id++; - - return g_strdup_printf ("%ld%ld", val, tv.tv_usec); + return g_uuid_string_random (); } static void @@ -1179,17 +1101,15 @@ stream_close_cb (GObject *source, WockyXmppConnectionPrivate *priv = connection->priv; GError *error = NULL; - GSimpleAsyncResult *r = priv->force_close_result; + GTask *t = priv->force_close_task; if (!g_io_stream_close_finish (G_IO_STREAM (source), res, &error)) - { - g_simple_async_result_set_from_error (priv->force_close_result, error); - g_error_free (error); - } + g_task_return_error (t, error); + else + g_task_return_boolean (t, TRUE); - priv->force_close_result = NULL; - g_simple_async_result_complete (r); - g_object_unref (r); + priv->force_close_task = NULL; + g_object_unref (t); } void @@ -1201,16 +1121,16 @@ wocky_xmpp_connection_force_close_async (WockyXmppConnection *connection, WockyXmppConnectionPrivate *priv = connection->priv; - if (G_UNLIKELY (priv->force_close_result != NULL)) + if (G_UNLIKELY (priv->force_close_task != NULL)) { - g_simple_async_report_error_in_idle (G_OBJECT (connection), - callback, user_data, + g_task_report_new_error (G_OBJECT (connection), callback, user_data, + wocky_xmpp_connection_force_close_async, G_IO_ERROR, G_IO_ERROR_PENDING, "Another close operation is pending"); return; } - priv->force_close_result = g_simple_async_result_new (G_OBJECT (connection), - callback, user_data, wocky_xmpp_connection_force_close_async); + priv->force_close_task = g_task_new (G_OBJECT (connection), cancellable, + callback, user_data); g_io_stream_close_async (priv->stream, G_PRIORITY_HIGH, cancellable, stream_close_cb, connection); @@ -1222,12 +1142,7 @@ wocky_xmpp_connection_force_close_finish ( GAsyncResult *result, GError **error) { - if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), - error)) - return FALSE; + g_return_val_if_fail (g_task_is_valid (result, connection), FALSE); - g_return_val_if_fail (g_simple_async_result_is_valid (result, - G_OBJECT (connection), wocky_xmpp_connection_force_close_async), FALSE); - - return TRUE; + return g_task_propagate_boolean (G_TASK (result), error); } diff --git a/wocky/wocky-xmpp-reader.c b/wocky/wocky-xmpp-reader.c index f0eaa92..cb1e967 100644 --- a/wocky/wocky-xmpp-reader.c +++ b/wocky/wocky-xmpp-reader.c @@ -59,8 +59,6 @@ enum { PROP_ID, }; -G_DEFINE_TYPE (WockyXmppReader, wocky_xmpp_reader, G_TYPE_OBJECT) - /* Parser prototypes */ static void _start_element_ns (void *user_data, const xmlChar *localname, const xmlChar *prefix, const xmlChar *uri, @@ -130,6 +128,9 @@ struct _WockyXmppReaderPrivate WockyXmppReaderState state; }; +G_DEFINE_TYPE_WITH_CODE (WockyXmppReader, wocky_xmpp_reader, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyXmppReader)) + /** * wocky_xmpp_reader_error_quark * @@ -217,8 +218,7 @@ wocky_xmpp_reader_init (WockyXmppReader *self) { WockyXmppReaderPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_XMPP_READER, - WockyXmppReaderPrivate); + self->priv = wocky_xmpp_reader_get_instance_private (self); priv = self->priv; priv->nodes = g_queue_new (); @@ -242,8 +242,6 @@ wocky_xmpp_reader_class_init (WockyXmppReaderClass *wocky_xmpp_reader_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_xmpp_reader_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_xmpp_reader_class, - sizeof (WockyXmppReaderPrivate)); wocky_xmpp_reader_class->stream_element_name = "stream"; wocky_xmpp_reader_class->stream_element_ns = WOCKY_XMPP_NS_STREAM; @@ -332,6 +330,8 @@ wocky_xmpp_reader_finalize (GObject *object) if (priv->error != NULL) g_error_free (priv->error); + g_free (priv->default_namespace); + G_OBJECT_CLASS (wocky_xmpp_reader_parent_class)->finalize (object); } diff --git a/wocky/wocky-xmpp-writer.c b/wocky/wocky-xmpp-writer.c index e8acee8..6c19670 100644 --- a/wocky/wocky-xmpp-writer.c +++ b/wocky/wocky-xmpp-writer.c @@ -40,8 +40,6 @@ #include "wocky-xmpp-writer.h" -G_DEFINE_TYPE (WockyXmppWriter, wocky_xmpp_writer, G_TYPE_OBJECT) - #define WOCKY_DEBUG_FLAG WOCKY_DEBUG_XMPP_WRITER #include "wocky-debug-internal.h" @@ -61,13 +59,15 @@ struct _WockyXmppWriterPrivate xmlBufferPtr buffer; }; +G_DEFINE_TYPE_WITH_CODE (WockyXmppWriter, wocky_xmpp_writer, G_TYPE_OBJECT, + G_ADD_PRIVATE (WockyXmppWriter)) + static void wocky_xmpp_writer_init (WockyXmppWriter *self) { WockyXmppWriterPrivate *priv; - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, WOCKY_TYPE_XMPP_WRITER, - WockyXmppWriterPrivate); + self->priv = wocky_xmpp_writer_get_instance_private (self); priv = self->priv; priv->current_ns = 0; @@ -95,9 +95,6 @@ wocky_xmpp_writer_class_init (WockyXmppWriterClass *wocky_xmpp_writer_class) GObjectClass *object_class = G_OBJECT_CLASS (wocky_xmpp_writer_class); GParamSpec *param_spec; - g_type_class_add_private (wocky_xmpp_writer_class, - sizeof (WockyXmppWriterPrivate)); - object_class->dispose = wocky_xmpp_writer_dispose; object_class->finalize = wocky_xmpp_writer_finalize; |