Bump the glib api implementation to the latest version

* Switch to G_ADD_PRIVATE and *_get_instance_private to define and assign object instance's private struct. * Switch to GTask from deprecated GSimpleAsyncResult for async operations. GTask has a bit different asynchronous execution order. * Fix tests for new GTask order and concurrency.
author: Ruslan N. Marchenko <me@ruff.mobi> 2020-06-15 18:33:09 +0200
committer: Ruslan N. Marchenko <me@ruff.mobi> 2020-09-23 17:54:43 +0200
commit: 431ce45f3ccfc603fd84392255e52be8cf0d06bc (patch)
tree: 35d2976b7f5336daccbdb78c3a3f7883f6ad13b8
parent: 58fde5ea4b0b9fbeb931a37c501aa06f93e5c0c1 (diff)
55 files changed, 1264 insertions, 1617 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..7811ea1 100644
--- a/tests/wocky-connector-test.c
+++ b/tests/wocky-connector-test.c
@@ -3419,6 +3419,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..8221267 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;
 }
@@ -1522,6 +1522,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 +1616,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 +1634,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 +1665,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;
author	Ruslan N. Marchenko <me@ruff.mobi>	2020-06-15 18:33:09 +0200
committer	Ruslan N. Marchenko <me@ruff.mobi>	2020-09-23 17:54:43 +0200
commit	431ce45f3ccfc603fd84392255e52be8cf0d06bc (patch)
tree	35d2976b7f5336daccbdb78c3a3f7883f6ad13b8
parent	58fde5ea4b0b9fbeb931a37c501aa06f93e5c0c1 (diff)