[libgdata] gdata: Port various core APIs to GTask from GSimpleAsyncResult
- From: Philip Withnall <pwithnall src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [libgdata] gdata: Port various core APIs to GTask from GSimpleAsyncResult
- Date: Tue, 8 Aug 2017 20:12:16 +0000 (UTC)
commit cbf5a496e29e6aae93d368fa0cdd63426cced614
Author: Philip Withnall <withnall endlessm com>
Date: Tue Aug 8 21:10:01 2017 +0100
gdata: Port various core APIs to GTask from GSimpleAsyncResult
GSimpleAsyncResult has been deprecated for quite a long time, and we’re
way overdue on porting to GTask. Start doing that for some of the core
classes. Still a number of instances of it left, though.
Signed-off-by: Philip Withnall <withnall endlessm com>
gdata/gdata-access-handler.c | 35 +++---
gdata/gdata-authorizer.c | 48 ++++----
gdata/gdata-batch-operation.c | 44 +++----
gdata/gdata-client-login-authorizer.c | 43 +++----
gdata/gdata-service.c | 234 +++++++++++++--------------------
5 files changed, 163 insertions(+), 241 deletions(-)
---
diff --git a/gdata/gdata-access-handler.c b/gdata/gdata-access-handler.c
index eb09e63..0f228f2 100644
--- a/gdata/gdata-access-handler.c
+++ b/gdata/gdata-access-handler.c
@@ -69,7 +69,6 @@ typedef struct {
GDataQueryProgressCallback progress_callback;
gpointer progress_user_data;
GDestroyNotify destroy_progress_user_data;
- GDataFeed *feed;
} GetRulesAsyncData;
static void
@@ -77,8 +76,6 @@ get_rules_async_data_free (GetRulesAsyncData *self)
{
if (self->service != NULL)
g_object_unref (self->service);
- if (self->feed != NULL)
- g_object_unref (self->feed);
g_slice_free (GetRulesAsyncData, self);
}
@@ -136,24 +133,26 @@ gdata_access_handler_real_get_rules (GDataAccessHandler *self,
}
static void
-get_rules_thread (GSimpleAsyncResult *result, GDataAccessHandler *access_handler, GCancellable *cancellable)
+get_rules_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
+ GDataAccessHandler *access_handler = GDATA_ACCESS_HANDLER (source_object);
GDataAccessHandlerIface *iface;
- GError *error = NULL;
- GetRulesAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GDataFeed) feed = NULL;
+ GetRulesAsyncData *data = task_data;
/* Execute the query and return */
iface = GDATA_ACCESS_HANDLER_GET_IFACE (access_handler);
g_assert (iface->get_rules != NULL);
- data->feed = iface->get_rules (access_handler, data->service,
- cancellable, data->progress_callback,
- data->progress_user_data, &error);
+ feed = iface->get_rules (access_handler, data->service,
+ cancellable, data->progress_callback,
+ data->progress_user_data, &error);
- if (data->feed == NULL && error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- }
+ if (feed == NULL && error != NULL)
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_pointer (task, g_steal_pointer (&feed), g_object_unref);
if (data->destroy_progress_user_data != NULL) {
data->destroy_progress_user_data (data->progress_user_data);
@@ -189,7 +188,7 @@ gdata_access_handler_get_rules_async (GDataAccessHandler *self, GDataService *se
GDestroyNotify destroy_progress_user_data,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
GetRulesAsyncData *data;
g_return_if_fail (GDATA_IS_ACCESS_HANDLER (self));
@@ -203,10 +202,10 @@ gdata_access_handler_get_rules_async (GDataAccessHandler *self, GDataService *se
data->progress_user_data = progress_user_data;
data->destroy_progress_user_data = destroy_progress_user_data;
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, gdata_service_query_async);
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) get_rules_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) get_rules_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_service_query_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) get_rules_async_data_free);
+ g_task_run_in_thread (task, get_rules_thread);
}
/**
diff --git a/gdata/gdata-authorizer.c b/gdata/gdata-authorizer.c
index 5fa00a0..933e425 100644
--- a/gdata/gdata-authorizer.c
+++ b/gdata/gdata-authorizer.c
@@ -196,17 +196,18 @@ gdata_authorizer_refresh_authorization (GDataAuthorizer *self, GCancellable *can
}
static void
-refresh_authorization_thread (GSimpleAsyncResult *result, GDataAuthorizer *authorizer, GCancellable
*cancellable)
+refresh_authorization_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable
*cancellable)
{
- GError *error = NULL;
+ GDataAuthorizer *authorizer = GDATA_AUTHORIZER (source_object);
+ g_autoptr(GError) error = NULL;
/* Refresh the authorisation and return */
gdata_authorizer_refresh_authorization (authorizer, cancellable, &error);
- if (error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- }
+ if (error != NULL)
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
}
/**
@@ -247,20 +248,20 @@ gdata_authorizer_refresh_authorization_async (GDataAuthorizer *self, GCancellabl
if (iface->refresh_authorization_async != NULL) {
/* Call the method */
iface->refresh_authorization_async (self, cancellable, callback, user_data);
- } else if (iface->refresh_authorization != NULL) {
- /* If the _async() method isn't implemented, fall back to running the sync method in a thread
*/
- GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
-
gdata_authorizer_refresh_authorization_async);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc)
refresh_authorization_thread, G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
-
- return;
} else {
- /* If neither are implemented, immediately return FALSE with no error in a callback */
- GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
-
gdata_authorizer_refresh_authorization_async);
- g_simple_async_result_complete_in_idle (result);
- g_object_unref (result);
+ g_autoptr(GTask) task = NULL;
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_authorizer_refresh_authorization_async);
+
+
+ if (iface->refresh_authorization != NULL) {
+ /* If the _async() method isn't implemented, fall back to running the sync method in
a thread */
+ g_task_run_in_thread (task, refresh_authorization_thread);
+ } else {
+ /* If neither are implemented, immediately return FALSE with no error in a callback */
+ g_task_return_boolean (task, FALSE);
+ }
return;
}
@@ -300,13 +301,10 @@ gdata_authorizer_refresh_authorization_finish (GDataAuthorizer *self, GAsyncResu
return iface->refresh_authorization_finish (self, async_result, error);
} else if (iface->refresh_authorization != NULL) {
/* If the _async() method isn't implemented, fall back to finishing off running the sync
method in a thread */
- g_warn_if_fail (g_simple_async_result_is_valid (async_result, G_OBJECT (self),
gdata_authorizer_refresh_authorization_async) == TRUE);
-
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (async_result), error) ==
TRUE) {
- return FALSE;
- }
+ g_return_val_if_fail (g_task_is_valid (async_result, self), FALSE);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result,
gdata_authorizer_refresh_authorization_async), FALSE);
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (async_result), error);
}
/* Fall back to just returning FALSE if none of the methods are implemented */
diff --git a/gdata/gdata-batch-operation.c b/gdata/gdata-batch-operation.c
index 6e78c61..adac8b5 100644
--- a/gdata/gdata-batch-operation.c
+++ b/gdata/gdata-batch-operation.c
@@ -724,20 +724,16 @@ error:
}
static void
-run_thread (GSimpleAsyncResult *result, GDataBatchOperation *operation, GCancellable *cancellable)
+run_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
- gboolean success;
- GError *error = NULL;
+ GDataBatchOperation *operation = GDATA_BATCH_OPERATION (source_object);
+ g_autoptr(GError) error = NULL;
/* Run the batch operation and return */
- success = gdata_batch_operation_run (operation, cancellable, &error);
- g_simple_async_result_set_op_res_gboolean (result, success);
-
- /* Propagate any errors */
- if (success == FALSE) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- }
+ if (!gdata_batch_operation_run (operation, cancellable, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
}
/**
@@ -761,7 +757,7 @@ run_thread (GSimpleAsyncResult *result, GDataBatchOperation *operation, GCancell
void
gdata_batch_operation_run_async (GDataBatchOperation *self, GCancellable *cancellable, GAsyncReadyCallback
callback, gpointer user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
g_return_if_fail (GDATA_IS_BATCH_OPERATION (self));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
@@ -770,14 +766,9 @@ gdata_batch_operation_run_async (GDataBatchOperation *self, GCancellable *cancel
/* Mark the operation as async for the purposes of deciding where to call the callbacks */
self->priv->is_async = TRUE;
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
gdata_batch_operation_run_async);
-
- /* Disable handling of cancellation so that g_simple_async_result_run_in_thread() doesn't return
immediately without calling run_thread() if
- * cancellable has already been cancelled by this point. */
- g_simple_async_result_set_handle_cancellation (result, FALSE);
-
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) run_thread, G_PRIORITY_DEFAULT,
cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_batch_operation_run_async);
+ g_task_run_in_thread (task, run_thread);
}
/**
@@ -798,16 +789,15 @@ gboolean
gdata_batch_operation_run_finish (GDataBatchOperation *self, GAsyncResult *async_result, GError **error)
{
GDataBatchOperationPrivate *priv = self->priv;
- GError *child_error = NULL;
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
+ g_autoptr(GError) child_error = NULL;
g_return_val_if_fail (GDATA_IS_BATCH_OPERATION (self), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), FALSE);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result, gdata_batch_operation_run_async),
FALSE);
- g_warn_if_fail (g_simple_async_result_get_source_tag (result) == gdata_batch_operation_run_async);
-
- if (g_simple_async_result_propagate_error (result, &child_error) == TRUE) {
+ if (!g_task_propagate_boolean (G_TASK (async_result), &child_error)) {
if (priv->has_run == FALSE) {
GHashTableIter iter;
gpointer op_id;
@@ -826,10 +816,10 @@ gdata_batch_operation_run_finish (GDataBatchOperation *self, GAsyncResult *async
priv->is_async = TRUE;
}
- g_propagate_error (error, child_error);
+ g_propagate_error (error, g_steal_pointer (&child_error));
return FALSE;
}
- return g_simple_async_result_get_op_res_gboolean (result);
+ return TRUE;
}
diff --git a/gdata/gdata-client-login-authorizer.c b/gdata/gdata-client-login-authorizer.c
index 0586115..9edb789 100644
--- a/gdata/gdata-client-login-authorizer.c
+++ b/gdata/gdata-client-login-authorizer.c
@@ -981,20 +981,16 @@ authenticate_async_data_free (AuthenticateAsyncData *self)
}
static void
-authenticate_thread (GSimpleAsyncResult *result, GDataClientLoginAuthorizer *authorizer, GCancellable
*cancellable)
+authenticate_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
- GError *error = NULL;
- gboolean success;
- AuthenticateAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
-
- success = authenticate_loop (authorizer, TRUE, data->username, data->password, cancellable, &error);
-
- g_simple_async_result_set_op_res_gboolean (result, success);
-
- if (success == FALSE) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- }
+ GDataClientLoginAuthorizer *authorizer = GDATA_CLIENT_LOGIN_AUTHORIZER (source_object);
+ g_autoptr(GError) error = NULL;
+ AuthenticateAsyncData *data = task_data;
+
+ if (!authenticate_loop (authorizer, TRUE, data->username, data->password, cancellable, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
}
/**
@@ -1020,7 +1016,7 @@ void
gdata_client_login_authorizer_authenticate_async (GDataClientLoginAuthorizer *self, const gchar *username,
const gchar *password,
GCancellable *cancellable, GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
AuthenticateAsyncData *data;
g_return_if_fail (GDATA_IS_CLIENT_LOGIN_AUTHORIZER (self));
@@ -1032,11 +1028,10 @@ gdata_client_login_authorizer_authenticate_async (GDataClientLoginAuthorizer *se
data->username = g_strdup (username);
data->password = _gdata_service_secure_strdup (password);
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
gdata_client_login_authorizer_authenticate_async);
- g_simple_async_result_set_handle_cancellation (result, FALSE); /* we handle our own cancellation so
we can set ::username and ::password */
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify)
authenticate_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) authenticate_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_client_login_authorizer_authenticate_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) authenticate_async_data_free);
+ g_task_run_in_thread (task, authenticate_thread);
}
/**
@@ -1057,14 +1052,10 @@ gdata_client_login_authorizer_authenticate_finish (GDataClientLoginAuthorizer *s
g_return_val_if_fail (GDATA_IS_CLIENT_LOGIN_AUTHORIZER (self), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), FALSE);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result,
gdata_client_login_authorizer_authenticate_async), FALSE);
- g_warn_if_fail (g_simple_async_result_is_valid (async_result, G_OBJECT (self),
gdata_client_login_authorizer_authenticate_async));
-
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (async_result), error) == TRUE) {
- return FALSE;
- }
-
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (async_result), error);
}
/**
diff --git a/gdata/gdata-service.c b/gdata/gdata-service.c
index dfc4623..527805d 100644
--- a/gdata/gdata-service.c
+++ b/gdata/gdata-service.c
@@ -787,7 +787,6 @@ typedef struct {
GType entry_type;
/* Output */
- GDataFeed *feed;
GDataQueryProgressCallback progress_callback;
gpointer progress_user_data;
GDestroyNotify destroy_progress_user_data;
@@ -802,25 +801,25 @@ query_async_data_free (QueryAsyncData *self)
g_free (self->feed_uri);
if (self->query)
g_object_unref (self->query);
- if (self->feed)
- g_object_unref (self->feed);
g_slice_free (QueryAsyncData, self);
}
static void
-query_thread (GSimpleAsyncResult *result, GDataService *service, GCancellable *cancellable)
+query_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
- GError *error = NULL;
- QueryAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
+ GDataService *service = GDATA_SERVICE (source_object);
+ g_autoptr(GError) error = NULL;
+ QueryAsyncData *data = task_data;
+ g_autoptr(GDataFeed) feed = NULL;
/* Execute the query and return */
- data->feed = __gdata_service_query (service, data->domain, data->feed_uri, data->query,
data->entry_type, cancellable,
- data->progress_callback, data->progress_user_data, &error);
- if (data->feed == NULL && error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- }
+ feed = __gdata_service_query (service, data->domain, data->feed_uri, data->query, data->entry_type,
cancellable,
+ data->progress_callback, data->progress_user_data, &error);
+ if (feed == NULL && error != NULL)
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_pointer (task, g_steal_pointer (&feed), g_object_unref);
if (data->destroy_progress_user_data != NULL) {
data->destroy_progress_user_data (data->progress_user_data);
@@ -857,7 +856,7 @@ gdata_service_query_async (GDataService *self, GDataAuthorizationDomain *domain,
GCancellable *cancellable, GDataQueryProgressCallback progress_callback, gpointer
progress_user_data,
GDestroyNotify destroy_progress_user_data, GAsyncReadyCallback callback, gpointer
user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
QueryAsyncData *data;
g_return_if_fail (GDATA_IS_SERVICE (self));
@@ -872,15 +871,14 @@ gdata_service_query_async (GDataService *self, GDataAuthorizationDomain *domain,
data->feed_uri = g_strdup (feed_uri);
data->query = (query != NULL) ? g_object_ref (query) : NULL;
data->entry_type = entry_type;
- data->feed = NULL;
data->progress_callback = progress_callback;
data->progress_user_data = progress_user_data;
data->destroy_progress_user_data = destroy_progress_user_data;
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, gdata_service_query_async);
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) query_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) query_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_service_query_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) query_async_data_free);
+ g_task_run_in_thread (task, query_thread);
}
/**
@@ -896,22 +894,13 @@ gdata_service_query_async (GDataService *self, GDataAuthorizationDomain *domain,
GDataFeed *
gdata_service_query_finish (GDataService *self, GAsyncResult *async_result, GError **error)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
- QueryAsyncData *data;
-
g_return_val_if_fail (GDATA_IS_SERVICE (self), NULL);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
- g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
- g_warn_if_fail (g_simple_async_result_get_source_tag (result) == gdata_service_query_async);
-
- if (g_simple_async_result_propagate_error (result, error) == TRUE)
- return NULL;
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result, gdata_service_query_async), NULL);
- data = g_simple_async_result_get_op_res_gpointer (result);
- if (data->feed != NULL)
- return g_object_ref (data->feed);
- return NULL;
+ return g_task_propagate_pointer (G_TASK (async_result), error);
}
/* Does the bulk of the work of gdata_service_query. Split out because certain queries (such as that done by
@@ -1199,21 +1188,19 @@ query_single_entry_async_data_free (QuerySingleEntryAsyncData *data)
}
static void
-query_single_entry_thread (GSimpleAsyncResult *result, GDataService *service, GCancellable *cancellable)
+query_single_entry_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable
*cancellable)
{
- GDataEntry *entry;
- GError *error = NULL;
- QuerySingleEntryAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
+ GDataService *service = GDATA_SERVICE (source_object);
+ g_autoptr(GDataEntry) entry = NULL;
+ g_autoptr(GError) error = NULL;
+ QuerySingleEntryAsyncData *data = task_data;
/* Execute the query and return */
entry = gdata_service_query_single_entry (service, data->domain, data->entry_id, data->query,
data->entry_type, cancellable, &error);
- if (entry == NULL && error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- return;
- }
-
- g_simple_async_result_set_op_res_gpointer (result, entry, (GDestroyNotify) g_object_unref);
+ if (entry == NULL && error != NULL)
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_pointer (task, g_steal_pointer (&entry), g_object_unref);
}
/**
@@ -1242,7 +1229,7 @@ void
gdata_service_query_single_entry_async (GDataService *self, GDataAuthorizationDomain *domain, const gchar
*entry_id, GDataQuery *query,
GType entry_type, GCancellable *cancellable, GAsyncReadyCallback
callback, gpointer user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
QuerySingleEntryAsyncData *data;
g_return_if_fail (GDATA_IS_SERVICE (self));
@@ -1259,10 +1246,10 @@ gdata_service_query_single_entry_async (GDataService *self, GDataAuthorizationDo
data->entry_id = g_strdup (entry_id);
data->entry_type = entry_type;
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
gdata_service_query_single_entry_async);
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify)
query_single_entry_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) query_single_entry_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_service_query_single_entry_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify)
query_single_entry_async_data_free);
+ g_task_run_in_thread (task, query_single_entry_thread);
}
/**
@@ -1280,22 +1267,13 @@ gdata_service_query_single_entry_async (GDataService *self, GDataAuthorizationDo
GDataEntry *
gdata_service_query_single_entry_finish (GDataService *self, GAsyncResult *async_result, GError **error)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
- GDataEntry *entry;
-
g_return_val_if_fail (GDATA_IS_SERVICE (self), NULL);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result,
gdata_service_query_single_entry_async), NULL);
- g_warn_if_fail (g_simple_async_result_get_source_tag (result) ==
gdata_service_query_single_entry_async);
-
- if (g_simple_async_result_propagate_error (result, error) == TRUE)
- return NULL;
-
- entry = g_simple_async_result_get_op_res_gpointer (result);
- if (entry != NULL)
- return g_object_ref (entry);
- return NULL;
+ return g_task_propagate_pointer (G_TASK (async_result), error);
}
typedef struct {
@@ -1318,22 +1296,19 @@ insert_entry_async_data_free (InsertEntryAsyncData *self)
}
static void
-insert_entry_thread (GSimpleAsyncResult *result, GDataService *service, GCancellable *cancellable)
+insert_entry_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
- GDataEntry *updated_entry;
- GError *error = NULL;
- InsertEntryAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
+ GDataService *service = GDATA_SERVICE (source_object);
+ g_autoptr(GDataEntry) updated_entry = NULL;
+ g_autoptr(GError) error = NULL;
+ InsertEntryAsyncData *data = task_data;
/* Insert the entry and return */
updated_entry = gdata_service_insert_entry (service, data->domain, data->upload_uri, data->entry,
cancellable, &error);
- if (updated_entry == NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- return;
- }
-
- /* Swap the old entry with the new one */
- g_simple_async_result_set_op_res_gpointer (result, updated_entry, (GDestroyNotify) g_object_unref);
+ if (updated_entry == NULL)
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_pointer (task, g_steal_pointer (&updated_entry), g_object_unref);
}
/**
@@ -1360,7 +1335,7 @@ void
gdata_service_insert_entry_async (GDataService *self, GDataAuthorizationDomain *domain, const gchar
*upload_uri, GDataEntry *entry,
GCancellable *cancellable, GAsyncReadyCallback callback, gpointer
user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
InsertEntryAsyncData *data;
g_return_if_fail (GDATA_IS_SERVICE (self));
@@ -1374,10 +1349,10 @@ gdata_service_insert_entry_async (GDataService *self, GDataAuthorizationDomain *
data->upload_uri = g_strdup (upload_uri);
data->entry = g_object_ref (entry);
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
gdata_service_insert_entry_async);
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify)
insert_entry_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) insert_entry_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_service_insert_entry_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) insert_entry_async_data_free);
+ g_task_run_in_thread (task, insert_entry_thread);
}
/**
@@ -1395,22 +1370,13 @@ gdata_service_insert_entry_async (GDataService *self, GDataAuthorizationDomain *
GDataEntry *
gdata_service_insert_entry_finish (GDataService *self, GAsyncResult *async_result, GError **error)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
- GDataEntry *entry;
-
g_return_val_if_fail (GDATA_IS_SERVICE (self), NULL);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
- g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
- g_warn_if_fail (g_simple_async_result_get_source_tag (result) == gdata_service_insert_entry_async);
-
- if (g_simple_async_result_propagate_error (result, error) == TRUE)
- return NULL;
-
- entry = g_simple_async_result_get_op_res_gpointer (result);
- g_assert (entry != NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result, gdata_service_insert_entry_async),
NULL);
- return g_object_ref (entry);
+ return g_task_propagate_pointer (G_TASK (async_result), error);
}
/**
@@ -1529,22 +1495,19 @@ update_entry_async_data_free (UpdateEntryAsyncData *data)
}
static void
-update_entry_thread (GSimpleAsyncResult *result, GDataService *service, GCancellable *cancellable)
+update_entry_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
- GDataEntry *updated_entry;
- GError *error = NULL;
- UpdateEntryAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
+ GDataService *service = GDATA_SERVICE (source_object);
+ g_autoptr(GDataEntry) updated_entry = NULL;
+ g_autoptr(GError) error = NULL;
+ UpdateEntryAsyncData *data = task_data;
/* Update the entry and return */
updated_entry = gdata_service_update_entry (service, data->domain, data->entry, cancellable, &error);
- if (updated_entry == NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- return;
- }
-
- /* Swap the old entry with the new one */
- g_simple_async_result_set_op_res_gpointer (result, updated_entry, (GDestroyNotify) g_object_unref);
+ if (updated_entry == NULL)
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_pointer (task, g_steal_pointer (&updated_entry), g_object_unref);
}
/**
@@ -1570,7 +1533,7 @@ void
gdata_service_update_entry_async (GDataService *self, GDataAuthorizationDomain *domain, GDataEntry *entry,
GCancellable *cancellable, GAsyncReadyCallback callback, gpointer
user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
UpdateEntryAsyncData *data;
g_return_if_fail (GDATA_IS_SERVICE (self));
@@ -1582,10 +1545,10 @@ gdata_service_update_entry_async (GDataService *self, GDataAuthorizationDomain *
data->domain = (domain != NULL) ? g_object_ref (domain) : NULL;
data->entry = g_object_ref (entry);
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
gdata_service_update_entry_async);
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify)
update_entry_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) update_entry_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (task, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_service_update_entry_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) update_entry_async_data_free);
+ g_task_run_in_thread (task, update_entry_thread);
}
/**
@@ -1603,22 +1566,13 @@ gdata_service_update_entry_async (GDataService *self, GDataAuthorizationDomain *
GDataEntry *
gdata_service_update_entry_finish (GDataService *self, GAsyncResult *async_result, GError **error)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
- GDataEntry *entry;
-
g_return_val_if_fail (GDATA_IS_SERVICE (self), NULL);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), NULL);
- g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
- g_warn_if_fail (g_simple_async_result_get_source_tag (result) == gdata_service_update_entry_async);
-
- if (g_simple_async_result_propagate_error (result, error) == TRUE)
- return NULL;
-
- entry = g_simple_async_result_get_op_res_gpointer (result);
- g_assert (entry != NULL);
+ g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), NULL);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result, gdata_service_update_entry_async),
NULL);
- return g_object_ref (entry);
+ return g_task_propagate_pointer (G_TASK (async_result), error);
}
/**
@@ -1731,22 +1685,17 @@ delete_entry_async_data_free (DeleteEntryAsyncData *data)
}
static void
-delete_entry_thread (GSimpleAsyncResult *result, GDataService *service, GCancellable *cancellable)
+delete_entry_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
- gboolean success;
- GError *error = NULL;
- DeleteEntryAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
+ GDataService *service = GDATA_SERVICE (source_object);
+ g_autoptr(GError) error = NULL;
+ DeleteEntryAsyncData *data = task_data;
/* Delete the entry and return */
- success = gdata_service_delete_entry (service, data->domain, data->entry, cancellable, &error);
- if (success == FALSE) {
- g_simple_async_result_set_from_error (result, error);
- g_error_free (error);
- return;
- }
-
- /* Replace the entry with the success value */
- g_simple_async_result_set_op_res_gboolean (result, success);
+ if (!gdata_service_delete_entry (service, data->domain, data->entry, cancellable, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
}
/**
@@ -1772,7 +1721,7 @@ void
gdata_service_delete_entry_async (GDataService *self, GDataAuthorizationDomain *domain, GDataEntry *entry,
GCancellable *cancellable, GAsyncReadyCallback callback, gpointer
user_data)
{
- GSimpleAsyncResult *result;
+ g_autoptr(GTask) task = NULL;
DeleteEntryAsyncData *data;
g_return_if_fail (GDATA_IS_SERVICE (self));
@@ -1784,10 +1733,10 @@ gdata_service_delete_entry_async (GDataService *self, GDataAuthorizationDomain *
data->domain = (domain != NULL) ? g_object_ref (domain) : NULL;
data->entry = g_object_ref (entry);
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
gdata_service_delete_entry_async);
- g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify)
delete_entry_async_data_free);
- g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) delete_entry_thread,
G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gdata_service_delete_entry_async);
+ g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) delete_entry_async_data_free);
+ g_task_run_in_thread (task, delete_entry_thread);
}
/**
@@ -1805,18 +1754,13 @@ gdata_service_delete_entry_async (GDataService *self, GDataAuthorizationDomain *
gboolean
gdata_service_delete_entry_finish (GDataService *self, GAsyncResult *async_result, GError **error)
{
- GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT (async_result);
-
g_return_val_if_fail (GDATA_IS_SERVICE (self), FALSE);
g_return_val_if_fail (G_IS_ASYNC_RESULT (async_result), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+ g_return_val_if_fail (g_task_is_valid (async_result, self), FALSE);
+ g_return_val_if_fail (g_async_result_is_tagged (async_result, gdata_service_delete_entry_async),
FALSE);
- g_warn_if_fail (g_simple_async_result_get_source_tag (result) == gdata_service_delete_entry_async);
-
- if (g_simple_async_result_propagate_error (result, error) == TRUE)
- return FALSE;
-
- return g_simple_async_result_get_op_res_gboolean (result);
+ return g_task_propagate_boolean (G_TASK (async_result), error);
}
/**
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
