Convert to GTaskwip/hughsie/deprecated-fixes

7 files changed, 117 insertions, 301 deletions

diff --git a/src/sensors/cd-sensor-argyll.c b/src/sensors/cd-sensor-argyll.c
index d7b909c..163368a 100644
--- a/src/sensors/cd-sensor-argyll.c
+++ b/src/sensors/cd-sensor-argyll.c
@@ -244,7 +244,7 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 
 	/* save state */
 	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_get_sample_async);
@@ -498,7 +498,7 @@ cd_sensor_unlock_async (CdSensor *sensor,
 
 	/* save state */
 	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_unlock_async);
diff --git a/src/sensors/cd-sensor-colorhug.c b/src/sensors/cd-sensor-colorhug.c
index efc7f6e..0c40260 100644
--- a/src/sensors/cd-sensor-colorhug.c
+++ b/src/sensors/cd-sensor-colorhug.c
@@ -166,7 +166,7 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 	state = g_slice_new0 (CdSensorAsyncState);
 	if (cancellable != NULL)
 		state->cancellable = g_object_ref (cancellable);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_get_sample_async);
@@ -343,7 +343,7 @@ cd_sensor_lock_async (CdSensor *sensor,
 	state = g_slice_new0 (CdSensorAsyncState);
 	if (cancellable != NULL)
 		state->cancellable = g_object_ref (cancellable);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_lock_async);
@@ -376,16 +376,8 @@ cd_sensor_lock_finish (CdSensor *sensor,
 		       GAsyncResult *res,
 		       GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 static void
@@ -418,20 +410,16 @@ cd_sensor_unlock_async (CdSensor *sensor,
 			GAsyncReadyCallback callback,
 			gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_unlock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_unlock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -439,16 +427,8 @@ cd_sensor_unlock_finish (CdSensor *sensor,
 			 GAsyncResult *res,
 			 GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 /**********************************************************************/
@@ -512,7 +492,7 @@ cd_sensor_colorhug_write_eeprom_cb (GObject *object,
 {
 	gboolean ret = FALSE;
 	ChDeviceQueue *device_queue = CH_DEVICE_QUEUE (object);
-	CdSensorAsyncState *state = (CdSensorAsyncState *) user_data;
+	GTask *task = G_TASK (user_data);
 	g_autoptr(GError) error = NULL;
 
 	/* get data */
@@ -523,14 +503,15 @@ cd_sensor_colorhug_write_eeprom_cb (GObject *object,
 	}
 
 	/* all done */
-	state->ret = TRUE;
-	cd_sensor_colorhug_set_options_state_finish (state, NULL);
+	g_task_return_boolean (task, TRUE);
 }
 
 static void
-cd_sensor_set_next_option (CdSensorAsyncState *state)
+cd_sensor_set_next_option (GTask *task)
 {
-	CdSensorColorhugPrivate *priv = cd_sensor_colorhug_get_private (state->sensor);
+	CdSensor *sensor = CD_SENSOR (g_task_get_source_object (task));
+	CdSensorColorhugPrivate *priv = cd_sensor_colorhug_get_private (sensor);
+	GHashTable *options = g_task_get_task_data (task);
 	ChSha1 sha1;
 	const gchar *key = NULL;
 	const gchar *magic = "Un1c0rn2";
@@ -540,23 +521,23 @@ cd_sensor_set_next_option (CdSensorAsyncState *state)
 	g_autoptr(GList) keys = NULL;
 
 	/* write eeprom to preserve settings */
-	keys = g_hash_table_get_keys (state->options);
+	keys = g_hash_table_get_keys (options);
 	if (keys == NULL) {
 		ch_device_queue_write_eeprom (priv->device_queue,
-					       priv->device,
-					       magic);
+					      priv->device,
+					      magic);
 		ch_device_queue_process_async (priv->device_queue,
 					       CH_DEVICE_QUEUE_PROCESS_FLAGS_NONE,
 					       state->cancellable,
 					       cd_sensor_colorhug_write_eeprom_cb,
-					       state);
+					       task);
 		return;
 	}
 
 	/* request */
 	key = (const gchar *) keys->data;
 	g_debug ("trying to set key %s", key);
-	value = g_hash_table_lookup (state->options, key);
+	value = g_hash_table_lookup (options, key);
 	if (g_strcmp0 (key, "remote-profile-hash") == 0) {
 
 		/* parse the hash */
@@ -572,7 +553,7 @@ cd_sensor_set_next_option (CdSensorAsyncState *state)
 		/* set the remote hash */
 		g_debug ("setting remote hash value %s",
 			 g_variant_get_string (value, NULL));
-		cd_sensor_add_option (state->sensor, key, value);
+		cd_sensor_add_option (sensor, key, value);
 		ch_device_queue_set_remote_hash (priv->device_queue,
 						 priv->device,
 						 &sha1);
@@ -580,15 +561,15 @@ cd_sensor_set_next_option (CdSensorAsyncState *state)
 					       CH_DEVICE_QUEUE_PROCESS_FLAGS_NONE,
 					       state->cancellable,
 					       cd_sensor_colorhug_set_options_cb,
-					       state);
+					       task);
 	} else {
-		g_set_error (&error,
-			     CD_SENSOR_ERROR,
-			     CD_SENSOR_ERROR_NO_SUPPORT,
-			     "Sensor option %s is not supported",
-			     key);
-		cd_sensor_colorhug_set_options_state_finish (state, error);
-		g_hash_table_remove (state->options, key);
+		g_task_return_new_error (task,
+					 CD_SENSOR_ERROR,
+					 CD_SENSOR_ERROR_NO_SUPPORT,
+					 "Sensor option %s is not supported",
+					 key);
+		g_hash_table_remove (options, key);
+		return;
 	}
 }
 
@@ -599,24 +580,13 @@ cd_sensor_set_options_async (CdSensor *sensor,
 			     GAsyncReadyCallback callback,
 			     gpointer user_data)
 {
-	CdSensorAsyncState *state;
-
 	g_return_if_fail (CD_IS_SENSOR (sensor));
-
-	/* set state */
+	task = g_task_new (sensor, cancellable, callback, user_data);
+	g_task_set_task_data (task,
+			      g_hash_table_ref (options),
+			      (GDestroyNotify) g_hash_table_unref);
 	cd_sensor_set_state (sensor, CD_SENSOR_STATE_BUSY);
-
-	/* save state */
-	state = g_slice_new0 (CdSensorAsyncState);
-	if (cancellable != NULL)
-		state->cancellable = g_object_ref (cancellable);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
-						callback,
-						user_data,
-						cd_sensor_set_options_async);
-	state->sensor = g_object_ref (sensor);
-	state->options = g_hash_table_ref (options);
-	cd_sensor_set_next_option (state);
+	cd_sensor_set_next_option (task);
 }
 
 gboolean
@@ -624,19 +594,8 @@ cd_sensor_set_options_finish (CdSensor *sensor,
 			      GAsyncResult *res,
 			      GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	/* failed */
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-
-	/* grab detail */
-	return g_simple_async_result_get_op_res_gboolean (simple);
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 static void
diff --git a/src/sensors/cd-sensor-dtp94.c b/src/sensors/cd-sensor-dtp94.c
index 5e0663a..7cf92d5 100644
--- a/src/sensors/cd-sensor-dtp94.c
+++ b/src/sensors/cd-sensor-dtp94.c
@@ -128,7 +128,7 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 
 	/* save state */
 	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_get_sample_async);
@@ -221,20 +221,16 @@ cd_sensor_lock_async (CdSensor *sensor,
 		      GAsyncReadyCallback callback,
 		      gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_lock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_dtp94_lock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -242,16 +238,8 @@ cd_sensor_lock_finish (CdSensor *sensor,
 		       GAsyncResult *res,
 		       GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 static void
@@ -284,20 +272,16 @@ cd_sensor_unlock_async (CdSensor *sensor,
 			GAsyncReadyCallback callback,
 			gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_unlock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_unlock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -305,16 +289,8 @@ cd_sensor_unlock_finish (CdSensor *sensor,
 			 GAsyncResult *res,
 			 GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 gboolean
diff --git a/src/sensors/cd-sensor-dummy.c b/src/sensors/cd-sensor-dummy.c
index a079f9a..b322e22 100644
--- a/src/sensors/cd-sensor-dummy.c
+++ b/src/sensors/cd-sensor-dummy.c
@@ -1,6 +1,6 @@
 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
  *
- * Copyright (C) 2010-2011 Richard Hughes <richard@hughsie.com>
+ * Copyright (C) 2010-2015 Richard Hughes <richard@hughsie.com>
  *
  * Licensed under the GNU General Public License Version 2
  *
@@ -51,71 +51,46 @@ cd_sensor_dummy_get_private (CdSensor *sensor)
 	return g_object_get_data (G_OBJECT (sensor), "priv");
 }
 
-static void
-cd_sensor_get_sample_state_finish (CdSensorAsyncState *state,
-				   const GError *error)
-{
-	if (state->ret) {
-		g_simple_async_result_set_op_res_gpointer (state->res,
-							   state->sample,
-							   (GDestroyNotify) cd_color_xyz_free);
-	} else {
-		g_simple_async_result_set_from_error (state->res, error);
-	}
-
-	/* set state */
-	cd_sensor_set_state (state->sensor, CD_SENSOR_STATE_IDLE);
-
-	/* complete */
-	g_simple_async_result_complete_in_idle (state->res);
-
-	g_object_unref (state->res);
-	g_object_unref (state->sensor);
-	g_slice_free (CdSensorAsyncState, state);
-}
-
 static gboolean
-cd_sensor_get_ambient_wait_cb (CdSensorAsyncState *state)
+cd_sensor_get_ambient_wait_cb (GTask *task)
 {
-	state->ret = TRUE;
-	state->sample = cd_color_xyz_new ();
-	state->sample->X = 7.7f;
-	state->sample->Y = CD_SENSOR_NO_VALUE;
-	state->sample->Z = CD_SENSOR_NO_VALUE;
+	CdColorXYZ *sample = NULL;
+
+	sample = cd_color_xyz_new ();
+	sample->X = 7.7f;
+	sample->Y = CD_SENSOR_NO_VALUE;
+	sample->Z = CD_SENSOR_NO_VALUE;
+	g_task_return_pointer (task, sample, (GDestroyNotify) cd_color_xyz_free);
 
-	/* just return without a problem */
-	cd_sensor_get_sample_state_finish (state, NULL);
 	return G_SOURCE_REMOVE;
 }
 
 static gboolean
-cd_sensor_get_sample_wait_cb (CdSensorAsyncState *state)
+cd_sensor_get_sample_wait_cb (GTask *task)
 {
-	CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (state->sensor);
+	CdSensor *sensor = CD_SENSOR (g_task_get_source_object (task));
+	CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (sensor);
+	CdColorXYZ *sample = NULL;
 	g_autoptr(GError) error = NULL;
 
 	/* never setup */
 	if (priv->transform_fake == NULL) {
-		g_set_error_literal (&error,
-				     CD_SENSOR_ERROR,
-				     CD_SENSOR_ERROR_NO_SUPPORT,
-				     "no fake transfor set up");
-		cd_sensor_get_sample_state_finish (state, error);
+		g_task_return_new_error (task,
+					 CD_SENSOR_ERROR,
+					 CD_SENSOR_ERROR_NO_SUPPORT,
+					 "no fake transfor set up");
 		return G_SOURCE_REMOVE;
 	}
 
 	/* run the sample through the profile */
-	state->ret = TRUE;
-	state->sample = cd_color_xyz_new ();
-	cmsDoTransform (priv->transform_fake,
-			&priv->sample_fake,
-			state->sample, 1);
+	sample = cd_color_xyz_new ();
+	cmsDoTransform (priv->transform_fake, &priv->sample_fake, sample, 1);
 
 	/* emulate */
-	cd_sensor_button_pressed (state->sensor);
+	cd_sensor_button_pressed (sensor);
 
 	/* just return without a problem */
-	cd_sensor_get_sample_state_finish (state, NULL);
+	g_task_return_pointer (task, sample, (GDestroyNotify) cd_color_xyz_free);
 	return G_SOURCE_REMOVE;
 }
 
@@ -126,26 +101,20 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 			    GAsyncReadyCallback callback,
 			    gpointer user_data)
 {
-	CdSensorAsyncState *state;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
-	/* save state */
-	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
-						callback,
-						user_data,
-						cd_sensor_get_sample_async);
-	state->sensor = g_object_ref (sensor);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 
 	/* set state */
 	cd_sensor_set_state (sensor, CD_SENSOR_STATE_MEASURING);
 
 	/* just complete in idle */
 	if (cap != CD_SENSOR_CAP_AMBIENT)
-		g_timeout_add_seconds (2, (GSourceFunc) cd_sensor_get_sample_wait_cb, state);
+		g_timeout_add_seconds (2, (GSourceFunc) cd_sensor_get_sample_wait_cb, task);
 	else
-		g_timeout_add_seconds (2, (GSourceFunc) cd_sensor_get_ambient_wait_cb, state);
+		g_timeout_add_seconds (2, (GSourceFunc) cd_sensor_get_ambient_wait_cb, task);
 }
 
 CdColorXYZ *
@@ -153,19 +122,8 @@ cd_sensor_get_sample_finish (CdSensor *sensor,
 			     GAsyncResult *res,
 			     GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), NULL);
-	g_return_val_if_fail (error == NULL || *error == NULL, NULL);
-
-	/* failed */
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NULL;
-
-	/* grab detail */
-	return cd_color_xyz_dup (g_simple_async_result_get_op_res_gpointer (simple));
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_pointer (G_TASK (res), error);
 }
 
 gboolean
@@ -173,19 +131,8 @@ cd_sensor_set_options_finish (CdSensor *sensor,
 			      GAsyncResult *res,
 			      GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	/* failed */
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-
-	/* grab detail */
-	return g_simple_async_result_get_op_res_gboolean (simple);
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 void
@@ -196,19 +143,15 @@ cd_sensor_set_options_async (CdSensor *sensor,
 			     gpointer user_data)
 {
 	CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (sensor);
-	GSimpleAsyncResult *res;
 	GList *l;
-	gboolean ret = TRUE;
 	const gchar *key_name;
 	GVariant *value;
+	g_autoptr(GTask) task = NULL;
 	g_autoptr(GList) keys = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_set_options_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 
 	/* look for any keys we recognise */
 	keys = g_hash_table_get_keys (options);
@@ -216,13 +159,12 @@ cd_sensor_set_options_async (CdSensor *sensor,
 		key_name = (const gchar *) l->data;
 		value = g_hash_table_lookup (options, key_name);
 		if (g_strcmp0 (g_variant_get_type_string (value), "d") != 0) {
-			ret = FALSE;
-			g_simple_async_result_set_error (res,
-							 CD_SENSOR_ERROR,
-							 CD_SENSOR_ERROR_NO_SUPPORT,
-							 "unexpected type '%s' not supported",
-							 g_variant_get_type_string (value));
-			break;
+			g_task_return_new_error (task,
+						 CD_SENSOR_ERROR,
+						 CD_SENSOR_ERROR_NO_SUPPORT,
+						 "unexpected type '%s' not supported",
+						 g_variant_get_type_string (value));
+			return;
 		}
 		if (g_strcmp0 (key_name, "sample[red]") == 0) {
 			priv->sample_fake.R = g_variant_get_double (value);
@@ -231,22 +173,17 @@ cd_sensor_set_options_async (CdSensor *sensor,
 		} else if (g_strcmp0 (key_name, "sample[blue]") == 0) {
 			priv->sample_fake.B = g_variant_get_double (value);
 		} else {
-			ret = FALSE;
-			g_simple_async_result_set_error (res,
-							 CD_SENSOR_ERROR,
-							 CD_SENSOR_ERROR_NO_SUPPORT,
-							 "option '%s' is not supported",
-							 key_name);
-			break;
+			g_task_return_new_error (task,
+						 CD_SENSOR_ERROR,
+						 CD_SENSOR_ERROR_NO_SUPPORT,
+						 "option '%s' is not supported",
+						 key_name);
+			return;
 		}
 	}
 
 	/* success */
-	if (ret)
-		g_simple_async_result_set_op_res_gboolean (res, TRUE);
-
-	/* complete */
-	g_simple_async_result_complete_in_idle (res);
+	g_task_return_boolean (task, TRUE);
 }
 
 static void
diff --git a/src/sensors/cd-sensor-huey.c b/src/sensors/cd-sensor-huey.c
index 123e70e..a330e7f 100644
--- a/src/sensors/cd-sensor-huey.c
+++ b/src/sensors/cd-sensor-huey.c
@@ -156,7 +156,7 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 
 	/* save state */
 	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_get_sample_async);
@@ -274,20 +274,16 @@ cd_sensor_lock_async (CdSensor *sensor,
 		      GAsyncReadyCallback callback,
 		      gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_lock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_huey_lock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -295,16 +291,8 @@ cd_sensor_lock_finish (CdSensor *sensor,
 		       GAsyncResult *res,
 		       GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 static void
@@ -337,20 +325,16 @@ cd_sensor_unlock_async (CdSensor *sensor,
 			GAsyncReadyCallback callback,
 			gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_unlock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_unlock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -358,16 +342,8 @@ cd_sensor_unlock_finish (CdSensor *sensor,
 			 GAsyncResult *res,
 			 GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 gboolean
diff --git a/src/sensors/cd-sensor-munki.c b/src/sensors/cd-sensor-munki.c
index c83bf45..8b34ed2 100644
--- a/src/sensors/cd-sensor-munki.c
+++ b/src/sensors/cd-sensor-munki.c
@@ -419,7 +419,7 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 
 	/* save state */
 	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_get_sample_async);
@@ -494,7 +494,7 @@ cd_sensor_munki_lock_thread_cb (GSimpleAsyncResult *res,
 	/* attach to the default mainloop */
 	ret = cd_usb_attach_to_context (priv->usb, NULL, &error);
 	if (!ret) {
-		g_simple_async_result_set_error (res, CD_SENSOR_ERROR,
+		g_task_return_new_error (task, CD_SENSOR_ERROR,
 						 CD_SENSOR_ERROR_NO_SUPPORT,
 						 "failed to attach to mainloop: %s",
 						 error->message);
@@ -508,7 +508,7 @@ cd_sensor_munki_lock_thread_cb (GSimpleAsyncResult *res,
 					  MUNKI_REQUEST_FIRMWARE_PARAMS,
 					  0, 0, buffer, 24, 2000);
 	if (retval < 0) {
-		g_simple_async_result_set_error (res, CD_SENSOR_ERROR,
+		g_task_return_new_error (task, CD_SENSOR_ERROR,
 						 CD_SENSOR_ERROR_NO_SUPPORT,
 						 "failed to get firmware parameters: %s",
 						 libusb_strerror (retval));
@@ -528,7 +528,7 @@ cd_sensor_munki_lock_thread_cb (GSimpleAsyncResult *res,
 					  MUNKI_REQUEST_CHIP_ID,
 					  0, 0, buffer, 8, 2000);
 	if (retval < 0) {
-		g_simple_async_result_set_error (res, CD_SENSOR_ERROR,
+		g_task_return_new_error (task, CD_SENSOR_ERROR,
 						 CD_SENSOR_ERROR_NO_SUPPORT,
 						 "failed to get chip id parameters: %s",
 						 libusb_strerror (retval));
@@ -545,7 +545,7 @@ cd_sensor_munki_lock_thread_cb (GSimpleAsyncResult *res,
 					  MUNKI_REQUEST_VERSION_STRING,
 					  0, 0, (guint8*) priv->version_string, 36, 2000);
 	if (retval < 0) {
-		g_simple_async_result_set_error (res, CD_SENSOR_ERROR,
+		g_task_return_new_error (task, CD_SENSOR_ERROR,
 						 CD_SENSOR_ERROR_NO_SUPPORT,
 						 "failed to get version string: %s",
 						 libusb_strerror (retval));
@@ -587,20 +587,16 @@ cd_sensor_lock_async (CdSensor *sensor,
 		      GAsyncReadyCallback callback,
 		      gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_lock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_munki_lock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -660,20 +656,16 @@ cd_sensor_unlock_async (CdSensor *sensor,
 			GAsyncReadyCallback callback,
 			gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_unlock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_unlock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
diff --git a/src/sensors/cd-sensor-spark.c b/src/sensors/cd-sensor-spark.c
index 3297ca4..da3c893 100644
--- a/src/sensors/cd-sensor-spark.c
+++ b/src/sensors/cd-sensor-spark.c
@@ -205,7 +205,7 @@ cd_sensor_get_sample_async (CdSensor *sensor,
 
 	/* save state */
 	state = g_slice_new0 (CdSensorAsyncState);
-	state->res = g_simple_async_result_new (G_OBJECT (sensor),
+	task = g_task_new (sensor,
 						callback,
 						user_data,
 						cd_sensor_get_sample_async);
@@ -289,20 +289,16 @@ cd_sensor_lock_async (CdSensor *sensor,
 		      GAsyncReadyCallback callback,
 		      gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_lock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_spark_lock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -310,16 +306,8 @@ cd_sensor_lock_finish (CdSensor *sensor,
 		       GAsyncResult *res,
 		       GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 static void
@@ -352,20 +340,16 @@ cd_sensor_unlock_async (CdSensor *sensor,
 			GAsyncReadyCallback callback,
 			gpointer user_data)
 {
-	GSimpleAsyncResult *res;
+	g_autoptr(GTask) task = NULL;
 
 	g_return_if_fail (CD_IS_SENSOR (sensor));
 
 	/* run in a thread */
-	res = g_simple_async_result_new (G_OBJECT (sensor),
-					 callback,
-					 user_data,
-					 cd_sensor_unlock_async);
+	task = g_task_new (sensor, cancellable, callback, user_data);
 	g_simple_async_result_run_in_thread (res,
 					     cd_sensor_unlock_thread_cb,
 					     0,
 					     cancellable);
-	g_object_unref (res);
 }
 
 gboolean
@@ -373,16 +357,8 @@ cd_sensor_unlock_finish (CdSensor *sensor,
 			 GAsyncResult *res,
 			 GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (res);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	return TRUE;
+	g_return_val_if_fail (g_task_is_valid (res, sensor), FALSE);
+	return g_task_propagate_boolean (G_TASK (res), error);
 }
 
 static void