summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorNiels De Graef <nielsdegraef@gmail.com>2021-01-12 22:19:43 +0000
committerNiels De Graef <nielsdegraef@gmail.com>2021-01-12 22:19:43 +0000
commitabd46ef6ca57ebba6ae78361fd095fbc2b42a77c (patch)
treea145d5c2821b270e5e14a81792ebfafe481ee8b5
parent1d645eb64503baec7ebd07cac2d468161227646d (diff)
parent9aa308b47a8c6cf34fe286e468090d7d79d25e3d (diff)
downloadgcr-abd46ef6ca57ebba6ae78361fd095fbc2b42a77c.tar.gz
Merge branch 'wip/nielsdg/initial-gtask' into 'master'
Get rid of most GSimpleAsyncResult uages See merge request GNOME/gcr!29
Diffstat
-rw-r--r--.gitlab-ci.yml18
-rw-r--r--gck/gck-object-cache.c53
-rw-r--r--gck/gck-slot.c32
-rw-r--r--gcr/console-interaction.c55
-rw-r--r--gcr/gcr-certificate-chain.c31
-rw-r--r--gcr/gcr-certificate-request.c72
-rw-r--r--gcr/gcr-gnupg-collection.c75
-rw-r--r--gcr/gcr-gnupg-importer.c37
-rw-r--r--gcr/gcr-library.c52
-rw-r--r--gcr/gcr-memory-icon.c15
-rw-r--r--gcr/gcr-pkcs11-certificate.c66
-rw-r--r--gcr/gcr-pkcs11-importer.c166
-rw-r--r--gcr/gcr-subject-public-key.c37
-rw-r--r--gcr/gcr-trust.c223
-rw-r--r--ui/frob-import-button.c12
-rw-r--r--ui/gcr-dialog-util.c59
-rw-r--r--ui/gcr-pkcs11-import-interaction.c34
17 files changed, 456 insertions, 581 deletions
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 3d56cad..db8f059 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -42,6 +42,12 @@ fedora:asan:
- meson _build -Dsanitize=address
- eval `dbus-launch --sh-syntax`
- meson test -C _build
+ artifacts:
+ name: "gcr-asan-${CI_JOB_NAME}-${CI_COMMIT_REF_NAME}"
+ when: always
+ paths:
+ - "_build/config.h"
+ - "_build/meson-logs"
fedora:ubsan:
image: fedora:latest
@@ -55,6 +61,12 @@ fedora:ubsan:
- meson _build -Dsanitize=undefined
- eval `dbus-launch --sh-syntax`
- meson test -C _build
+ artifacts:
+ name: "gcr-ubsan-${CI_JOB_NAME}-${CI_COMMIT_REF_NAME}"
+ when: always
+ paths:
+ - "_build/config.h"
+ - "_build/meson-logs"
fedora:coverage:
image: fedora:latest
@@ -74,6 +86,12 @@ fedora:coverage:
name: "gcr-${CI_JOB_NAME}-${CI_COMMIT_REF_NAME}"
paths:
- _build/meson-logs/coveragereport/
+ artifacts:
+ name: "gcr-coverage-${CI_JOB_NAME}-${CI_COMMIT_REF_NAME}"
+ when: always
+ paths:
+ - "_build/config.h"
+ - "_build/meson-logs"
pages:
stage: deploy
diff --git a/gck/gck-object-cache.c b/gck/gck-object-cache.c
index e6f93e7..4db51b3 100644
--- a/gck/gck-object-cache.c
+++ b/gck/gck-object-cache.c
@@ -209,7 +209,7 @@ on_cache_object_get (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
+ GTask *task = G_TASK (user_data);
GckAttributes *attrs;
GError *error = NULL;
@@ -217,12 +217,12 @@ on_cache_object_get (GObject *source,
if (error == NULL) {
gck_object_cache_fill (GCK_OBJECT_CACHE (source), attrs);
gck_attributes_unref (attrs);
+ g_task_return_boolean (task, TRUE);
} else {
- g_simple_async_result_take_error (res, error);
+ g_task_return_error (task, g_steal_pointer (&error));
}
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -248,7 +248,7 @@ gck_object_cache_update_async (GckObjectCache *object,
gpointer user_data)
{
GckObjectCacheIface *iface;
- GSimpleAsyncResult *res;
+ GTask *task;
g_return_if_fail (GCK_IS_OBJECT_CACHE (object));
g_return_if_fail (attr_types != NULL || n_attr_types == 0);
@@ -267,13 +267,13 @@ gck_object_cache_update_async (GckObjectCache *object,
}
}
- res = g_simple_async_result_new (G_OBJECT (object), callback, user_data,
- gck_object_cache_update_async);
+ task = g_task_new (object, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gck_object_cache_update_async);
gck_object_get_async (GCK_OBJECT (object), attr_types, n_attr_types,
- cancellable, on_cache_object_get, g_object_ref (res));
+ cancellable, on_cache_object_get, g_steal_pointer (&task));
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -293,14 +293,10 @@ gck_object_cache_update_finish (GckObjectCache *object,
GError **error)
{
g_return_val_if_fail (GCK_IS_OBJECT_CACHE (object), FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (object),
- gck_object_cache_update_async), FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, object), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
static gboolean
@@ -404,26 +400,27 @@ gck_object_cache_lookup_async (GckObject *object,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
- GckAttributes *attrs;
- GckObjectCache *cache;
- gboolean have;
-
g_return_if_fail (GCK_IS_OBJECT (object));
g_return_if_fail (attr_types != NULL || n_attr_types == 0);
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
if (GCK_IS_OBJECT_CACHE (object)) {
+ GckObjectCache *cache;
+ GckAttributes *attrs;
+ gboolean have;
+
cache = GCK_OBJECT_CACHE (object);
attrs = gck_object_cache_get_attributes (cache);
have = check_have_attributes (attrs, attr_types, n_attr_types);
gck_attributes_unref (attrs);
if (have) {
- res = g_simple_async_result_new (G_OBJECT (cache), callback, user_data,
- gck_object_cache_lookup_async);
- g_simple_async_result_complete_in_idle (res);
- g_object_unref (res);
+ GTask *task;
+
+ task = g_task_new (cache, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gck_object_cache_lookup_async);
+ g_task_return_boolean (task, TRUE);
+ g_clear_object (&task);
} else {
gck_object_cache_update_async (cache, attr_types, n_attr_types,
cancellable, callback, user_data);
@@ -457,13 +454,11 @@ gck_object_cache_lookup_finish (GckObject *object,
if (GCK_IS_OBJECT_CACHE (object)) {
cache = GCK_OBJECT_CACHE (object);
- if (!g_simple_async_result_is_valid (result, G_OBJECT (object),
- gck_object_cache_lookup_async))
+ if (!g_task_is_valid (result, object))
if (!gck_object_cache_update_finish (cache, result, error))
return NULL;
return gck_object_cache_get_attributes (cache);
- } else {
-
- return gck_object_get_finish (object, result, error);
}
+
+ return gck_object_get_finish (object, result, error);
}
diff --git a/gck/gck-slot.c b/gck/gck-slot.c
index f42c3ee..435fe61 100644
--- a/gck/gck-slot.c
+++ b/gck/gck-slot.c
@@ -1037,18 +1037,17 @@ on_open_session_complete (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
+ GTask *task = G_TASK (user_data);
GError *error = NULL;
GObject *session;
session = g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, &error);
if (session != NULL)
- g_simple_async_result_set_op_res_gpointer (res, session, g_object_unref);
+ g_task_return_pointer (task, session, g_object_unref);
else
- g_simple_async_result_take_error (res, error);
+ g_task_return_error (task, g_steal_pointer (&error));
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -1058,7 +1057,7 @@ on_open_session_complete (GObject *source,
* @pkcs11_flags: Additional raw PKCS\#11 flags.
* @app_data: Application data for notification callback.
* @notify: PKCS\#11 notification callback.
- * @cancellable: Optional cancellation object, or %NULL.
+ * @cancellable: (nullable): Optional cancellation object, or %NULL.
* @callback: Called when the operation completes.
* @user_data: Data to pass to the callback.
*
@@ -1077,24 +1076,24 @@ gck_slot_open_session_full_async (GckSlot *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
g_return_if_fail (GCK_IS_SLOT (self));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
- res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
- gck_slot_open_session_full_async);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gck_slot_open_session_full_async);
g_async_initable_new_async (GCK_TYPE_SESSION, G_PRIORITY_DEFAULT,
cancellable, on_open_session_complete,
- g_object_ref (res),
+ g_steal_pointer (&task),
"options", options,
"slot", self,
"opening-flags", pkcs11_flags,
"app-data", app_data,
NULL);
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -1111,18 +1110,11 @@ gck_slot_open_session_full_async (GckSlot *self,
GckSession *
gck_slot_open_session_finish (GckSlot *self, GAsyncResult *result, GError **error)
{
- GSimpleAsyncResult *res;
-
g_return_val_if_fail (GCK_IS_SLOT (self), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
- gck_slot_open_session_full_async), NULL);
-
- res = G_SIMPLE_ASYNC_RESULT (result);
- if (g_simple_async_result_propagate_error (res, error))
- return NULL;
+ g_return_val_if_fail (g_task_is_valid (result, self), NULL);
- return g_object_ref (g_simple_async_result_get_op_res_gpointer (res));
+ return g_task_propagate_pointer (G_TASK (result), error);
}
/**
diff --git a/gcr/console-interaction.c b/gcr/console-interaction.c
index bc3b7dc..47c2cb4 100644
--- a/gcr/console-interaction.c
+++ b/gcr/console-interaction.c
@@ -108,46 +108,49 @@ console_interaction_ask_password (GTlsInteraction *interaction,
}
static void
-ask_password_with_getpass (GSimpleAsyncResult *res,
- GObject *object,
- GCancellable *cancellable)
+ask_password_with_getpass (GTask *task,
+ gpointer src_object,
+ gpointer task_data,
+ GCancellable *cancellable)
{
GTlsPassword *password;
GError *error = NULL;
- password = g_simple_async_result_get_op_res_gpointer (res);
- console_interaction_ask_password (G_TLS_INTERACTION (object), password,
- cancellable, &error);
- if (error != NULL)
- g_simple_async_result_take_error (res, error);
+ password = g_task_get_task_data (task);
+ console_interaction_ask_password (G_TLS_INTERACTION (src_object), password,
+ cancellable, &error);
+ if (error == NULL)
+ g_task_return_boolean (task, TRUE);
+ else
+ g_task_return_error (task, g_steal_pointer (&error));
}
static void
console_interaction_ask_password_async (GTlsInteraction *interaction,
- GTlsPassword *password,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
+ GTlsPassword *password,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
- GSimpleAsyncResult *res;
-
- res = g_simple_async_result_new (G_OBJECT (interaction), callback, user_data,
- console_interaction_ask_password);
- g_simple_async_result_set_op_res_gpointer (res, g_object_ref (password), g_object_unref);
- g_simple_async_result_run_in_thread (res, ask_password_with_getpass,
- G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (res);
+ GTask *task;
+
+ task = g_task_new (interaction, cancellable, callback, user_data);
+ g_task_set_source_tag (task, console_interaction_ask_password);
+ g_task_set_task_data (task, g_object_ref (password), g_object_unref);
+
+ g_task_run_in_thread (task, ask_password_with_getpass);
+ g_clear_object (&task);
}
static GTlsInteractionResult
-console_interaction_ask_password_finish (GTlsInteraction *interaction,
- GAsyncResult *result,
- GError **error)
+console_interaction_ask_password_finish (GTlsInteraction *interaction,
+ GAsyncResult *result,
+ GError **error)
{
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (interaction),
- console_interaction_ask_password), G_TLS_INTERACTION_FAILED);
+ g_return_val_if_fail (g_task_is_valid (result, interaction),
+ G_TLS_INTERACTION_FAILED);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+ if (!g_task_propagate_boolean (G_TASK (result), error))
return G_TLS_INTERACTION_FAILED;
return G_TLS_INTERACTION_HANDLED;
diff --git a/gcr/gcr-certificate-chain.c b/gcr/gcr-certificate-chain.c
index 1eb1af2..1793869 100644
--- a/gcr/gcr-certificate-chain.c
+++ b/gcr/gcr-certificate-chain.c
@@ -372,19 +372,21 @@ perform_build_chain (GcrCertificateChainPrivate *pv, GCancellable *cancellable,
}
static void
-thread_build_chain (GSimpleAsyncResult *result, GObject *object,
+thread_build_chain (GTask *task, gpointer src_object, gpointer task_data,
GCancellable *cancellable)
{
GcrCertificateChainPrivate *pv;
GError *error = NULL;
- pv = g_object_get_qdata (G_OBJECT (result), Q_OPERATION_DATA);
+ pv = g_object_get_qdata (G_OBJECT (task), Q_OPERATION_DATA);
g_assert (pv);
g_debug ("building asynchronously in another thread");
- if (!perform_build_chain (pv, cancellable, &error)) {
- g_simple_async_result_set_from_error (result, error);
+ if (perform_build_chain (pv, cancellable, &error)) {
+ g_task_return_boolean (task, TRUE);
+ } else {
+ g_task_return_error (task, g_steal_pointer (&error));
g_clear_error (&error);
}
}
@@ -784,22 +786,19 @@ gcr_certificate_chain_build_async (GcrCertificateChain *self,
gpointer user_data)
{
GcrCertificateChainPrivate *pv;
- GSimpleAsyncResult *result;
-
- g_return_if_fail (GCR_IS_CERTIFICATE_CHAIN (self));
+ GTask *task;
g_return_if_fail (GCR_IS_CERTIFICATE_CHAIN (self));
g_return_if_fail (purpose);
pv = prep_chain_private_thread_safe (self->pv, purpose, peer, flags);
- result = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
- gcr_certificate_chain_build_async);
- g_object_set_qdata_full (G_OBJECT (result), Q_OPERATION_DATA, pv, free_chain_private);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_certificate_chain_build_async);
+ g_object_set_qdata_full (G_OBJECT (task), Q_OPERATION_DATA, pv, free_chain_private);
- g_simple_async_result_run_in_thread (result, thread_build_chain,
- G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (result);
+ g_task_run_in_thread (task, thread_build_chain);
+ g_clear_object (&task);
}
/**
@@ -820,11 +819,9 @@ gcr_certificate_chain_build_finish (GcrCertificateChain *self, GAsyncResult *res
GcrCertificateChainPrivate *pv;
g_return_val_if_fail (GCR_IS_CERTIFICATE_CHAIN (self), FALSE);
- g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
- gcr_certificate_chain_build_async), FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+ if (!g_task_propagate_boolean (G_TASK (result), error))
return FALSE;
pv = g_object_steal_qdata (G_OBJECT (result), Q_OPERATION_DATA);
diff --git a/gcr/gcr-certificate-request.c b/gcr/gcr-certificate-request.c
index 9a663aa..9736ce8 100644
--- a/gcr/gcr-certificate-request.c
+++ b/gcr/gcr-certificate-request.c
@@ -516,7 +516,6 @@ gcr_certificate_request_complete (GcrCertificateRequest *self,
typedef struct {
GcrCertificateRequest *request;
- GCancellable *cancellable;
GQuark algorithm;
GNode *subject_public_key;
GckMechanism mechanism;
@@ -530,7 +529,6 @@ complete_closure_free (gpointer data)
CompleteClosure *closure = data;
egg_asn1x_destroy (closure->subject_public_key);
g_clear_object (&closure->request);
- g_clear_object (&closure->cancellable);
g_clear_object (&closure->session);
if (closure->tbs)
g_bytes_unref (closure->tbs);
@@ -542,8 +540,8 @@ on_certificate_request_signed (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- CompleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ CompleteClosure *closure = g_task_get_task_data (task);
GError *error = NULL;
guchar *signature;
gsize n_signature;
@@ -555,12 +553,12 @@ on_certificate_request_signed (GObject *source,
closure->subject_public_key,
signature, n_signature);
+ g_task_return_boolean (task, TRUE);
} else {
- g_simple_async_result_take_error (res, error);
+ g_task_return_error (task, g_steal_pointer (&error));
}
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_clear_object (&task);
}
static void
@@ -568,15 +566,15 @@ on_mechanism_check (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- CompleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ CompleteClosure *closure = g_task_get_task_data (task);
+ GCancellable *cancellable = g_task_get_cancellable (task);
closure->mechanism.type = _gcr_key_mechanisms_check_finish (closure->request->private_key,
result, NULL);
if (closure->mechanism.type == GCK_INVALID) {
- g_simple_async_result_set_error (res, GCK_ERROR, CKR_KEY_TYPE_INCONSISTENT,
- _("The key cannot be used to sign the request"));
- g_simple_async_result_complete (res);
+ g_task_return_new_error (task, GCK_ERROR, CKR_KEY_TYPE_INCONSISTENT,
+ _("The key cannot be used to sign the request"));
} else {
closure->tbs = prepare_to_be_signed (closure->request, &closure->mechanism);
@@ -585,12 +583,12 @@ on_mechanism_check (GObject *source,
&closure->mechanism,
g_bytes_get_data (closure->tbs, NULL),
g_bytes_get_size (closure->tbs),
- closure->cancellable,
+ cancellable,
on_certificate_request_signed,
- g_object_ref (res));
+ g_steal_pointer (&task));
}
- g_object_unref (res);
+ g_clear_object (&task);
}
static void
@@ -598,8 +596,9 @@ on_subject_public_key_loaded (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- CompleteClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ CompleteClosure *closure = g_task_get_task_data (task);
+ GCancellable *cancellable = g_task_get_cancellable (task);
const gulong *mechanisms;
gsize n_mechanisms;
GError *error = NULL;
@@ -615,23 +614,21 @@ on_subject_public_key_loaded (GObject *source,
}
if (error != NULL) {
- g_simple_async_result_take_error (res, error);
- g_simple_async_result_complete (res);
-
- } else {
- _gcr_key_mechanisms_check_async (closure->request->private_key,
- mechanisms, n_mechanisms, CKA_SIGN,
- closure->cancellable, on_mechanism_check,
- g_object_ref (res));
+ g_task_return_error (task, g_steal_pointer (&error));
+ g_clear_object (&task);
+ return;
}
- g_object_unref (res);
+ _gcr_key_mechanisms_check_async (closure->request->private_key,
+ mechanisms, n_mechanisms, CKA_SIGN,
+ cancellable, on_mechanism_check,
+ g_steal_pointer (&task));
}
/**
* gcr_certificate_request_complete_async:
* @self: a certificate request
- * @cancellable: a cancellation object
+ * @cancellable: (nullable): a cancellation object
* @callback: called when the operation completes
* @user_data: data to pass to the callback
*
@@ -646,25 +643,24 @@ gcr_certificate_request_complete_async (GcrCertificateRequest *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
CompleteClosure *closure;
g_return_if_fail (GCR_IS_CERTIFICATE_REQUEST (self));
g_return_if_fail (cancellable == NULL || G_CANCELLABLE (cancellable));
- res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
- gcr_certificate_request_complete_async);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_certificate_request_complete_async);
closure = g_new0 (CompleteClosure, 1);
- closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
closure->session = gck_object_get_session (self->private_key);
closure->request = g_object_ref (self);
- g_simple_async_result_set_op_res_gpointer (res, closure, complete_closure_free);
+ g_task_set_task_data (task, closure, complete_closure_free);
_gcr_subject_public_key_load_async (self->private_key, cancellable,
on_subject_public_key_loaded,
- g_object_ref (res));
+ g_steal_pointer (&task));
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -685,13 +681,9 @@ gcr_certificate_request_complete_finish (GcrCertificateRequest *self,
{
g_return_val_if_fail (GCR_IS_CERTIFICATE_REQUEST (self), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
- gcr_certificate_request_complete_async), FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
/**
diff --git a/gcr/gcr-gnupg-collection.c b/gcr/gcr-gnupg-collection.c
index c47ead8..d2f90bf 100644
--- a/gcr/gcr-gnupg-collection.c
+++ b/gcr/gcr-gnupg-collection.c
@@ -233,7 +233,6 @@ typedef struct {
GcrLoadingPhase loading_phase; /* Whether loading public or private */
GPtrArray *records; /* GcrRecord* not yet made into a key */
GcrGnupgProcess *process; /* The gnupg process itself */
- GCancellable *cancel; /* Cancellation for process */
GString *out_data; /* Pending output not yet parsed into colons */
GHashTable *difference; /* Hashset gchar *keyid -> gchar *keyid */
@@ -248,7 +247,7 @@ typedef struct {
} GcrGnupgCollectionLoad;
/* Forward declarations */
-static void spawn_gnupg_list_process (GcrGnupgCollectionLoad *load, GSimpleAsyncResult *res);
+static void spawn_gnupg_list_process (GcrGnupgCollectionLoad *load, GTask *task);
static void
_gcr_gnupg_collection_load_free (gpointer data)
@@ -274,9 +273,6 @@ _gcr_gnupg_collection_load_free (gpointer data)
g_output_stream_close (load->outattr, NULL, NULL);
g_object_unref (load->outattr);
- if (load->cancel)
- g_object_unref (load->cancel);
-
if (load->attribute_queue) {
while (!g_queue_is_empty (load->attribute_queue))
_gcr_record_free (g_queue_pop_head (load->attribute_queue));
@@ -517,8 +513,8 @@ on_gnupg_process_output_data (gconstpointer buffer,
gpointer user_data,
GError **error)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GcrGnupgCollectionLoad *load = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ GcrGnupgCollectionLoad *load = g_task_get_task_data (task);
g_string_append_len (load->out_data, buffer, count);
_gcr_util_parse_lines (load->out_data, FALSE, on_line_parse_output, load);
@@ -536,8 +532,8 @@ static void
on_gnupg_process_status_record (GcrGnupgProcess *process, GcrRecord *record,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GcrGnupgCollectionLoad *load = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ GcrGnupgCollectionLoad *load = g_task_get_task_data (task);
if (GCR_RECORD_SCHEMA_ATTRIBUTE != _gcr_record_get_schema (record))
return;
@@ -556,8 +552,8 @@ on_gnupg_process_attribute_data (gconstpointer buffer,
gpointer user_data,
GError **error)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GcrGnupgCollectionLoad *load = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ GcrGnupgCollectionLoad *load = g_task_get_task_data (task);
/* If we don't have a buffer, just claim this one */
if (!load->attribute_buf)
@@ -572,18 +568,16 @@ on_gnupg_process_attribute_data (gconstpointer buffer,
static void
on_gnupg_process_completed (GObject *source, GAsyncResult *result, gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GcrGnupgCollectionLoad *load = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ GcrGnupgCollectionLoad *load = g_task_get_task_data (task);
GHashTableIter iter;
GError *error = NULL;
GObject *object;
gpointer keyid;
if (!_gcr_gnupg_process_run_finish (GCR_GNUPG_PROCESS (source), result, &error)) {
- g_simple_async_result_set_from_error (res, error);
- g_simple_async_result_complete (res);
- g_object_unref (res);
- g_clear_error (&error);
+ g_task_return_error (task, g_steal_pointer (&error));
+ g_clear_object (&task);
return;
}
@@ -599,8 +593,8 @@ on_gnupg_process_completed (GObject *source, GAsyncResult *result, gpointer user
case GCR_LOADING_PHASE_PUBLIC:
g_debug ("public load phase completed");
load->loading_phase = GCR_LOADING_PHASE_SECRET;
- spawn_gnupg_list_process (load, res);
- g_object_unref (res);
+ spawn_gnupg_list_process (load, task);
+ g_clear_object (&task);
return;
case GCR_LOADING_PHASE_SECRET:
g_debug ("secret load phase completed");
@@ -623,13 +617,14 @@ on_gnupg_process_completed (GObject *source, GAsyncResult *result, gpointer user
}
}
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_task_return_boolean (task, TRUE);
+ g_clear_object (&task);
}
static void
-spawn_gnupg_list_process (GcrGnupgCollectionLoad *load, GSimpleAsyncResult *res)
+spawn_gnupg_list_process (GcrGnupgCollectionLoad *load, GTask *task)
{
+ GCancellable *cancellable = g_task_get_cancellable (task);
GcrGnupgProcessFlags flags = 0;
GPtrArray *argv;
@@ -658,8 +653,8 @@ spawn_gnupg_list_process (GcrGnupgCollectionLoad *load, GSimpleAsyncResult *res)
/* res is unreffed in on_gnupg_process_completed */
_gcr_gnupg_process_run_async (load->process, (const gchar**)argv->pdata, NULL, flags,
- load->cancel, on_gnupg_process_completed,
- g_object_ref (res));
+ cancellable, on_gnupg_process_completed,
+ g_object_ref (task));
g_ptr_array_unref (argv);
}
@@ -667,7 +662,7 @@ spawn_gnupg_list_process (GcrGnupgCollectionLoad *load, GSimpleAsyncResult *res)
/**
* _gcr_gnupg_collection_load_async:
* @self: The collection
- * @cancellable: Cancellation object or %NULL
+ * @cancellable: (nullable): Cancellation object or %NULL
* @callback: Callback to call when result is ready
* @user_data: Data for callback
*
@@ -678,7 +673,7 @@ void
_gcr_gnupg_collection_load_async (GcrGnupgCollection *self, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
GcrGnupgCollectionLoad *load;
GHashTableIter iter;
gpointer keyid;
@@ -687,23 +682,22 @@ _gcr_gnupg_collection_load_async (GcrGnupgCollection *self, GCancellable *cancel
/* TODO: Cancellation not yet implemented */
- res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
- _gcr_gnupg_collection_load_async);
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_gnupg_collection_load_async);
load = g_slice_new0 (GcrGnupgCollectionLoad);
load->records = g_ptr_array_new_with_free_func (_gcr_record_free);
load->out_data = g_string_sized_new (1024);
load->collection = g_object_ref (self);
- load->cancel = cancellable ? g_object_ref (cancellable) : cancellable;
- load->output = _gcr_callback_output_stream_new (on_gnupg_process_output_data, res, NULL);
- load->outattr = _gcr_callback_output_stream_new (on_gnupg_process_attribute_data, res, NULL);
+ load->output = _gcr_callback_output_stream_new (on_gnupg_process_output_data, task, NULL);
+ load->outattr = _gcr_callback_output_stream_new (on_gnupg_process_attribute_data, task, NULL);
load->process = _gcr_gnupg_process_new (self->pv->directory, NULL);
_gcr_gnupg_process_set_output_stream (load->process, load->output);
_gcr_gnupg_process_set_attribute_stream (load->process, load->outattr);
- load->error_sig = g_signal_connect (load->process, "error-line", G_CALLBACK (on_gnupg_process_error_line), res);
- load->status_sig = g_signal_connect (load->process, "status-record", G_CALLBACK (on_gnupg_process_status_record), res);
+ load->error_sig = g_signal_connect (load->process, "error-line", G_CALLBACK (on_gnupg_process_error_line), task);
+ load->status_sig = g_signal_connect (load->process, "status-record", G_CALLBACK (on_gnupg_process_status_record), task);
/*
* Track all the keys we currently have, at end remove those that
@@ -714,13 +708,12 @@ _gcr_gnupg_collection_load_async (GcrGnupgCollection *self, GCancellable *cancel
while (g_hash_table_iter_next (&iter, &keyid, NULL))
g_hash_table_insert (load->difference, keyid, keyid);
- g_simple_async_result_set_op_res_gpointer (res, load,
- _gcr_gnupg_collection_load_free);
+ g_task_set_task_data (task, load, _gcr_gnupg_collection_load_free);
load->loading_phase = GCR_LOADING_PHASE_PUBLIC;
- spawn_gnupg_list_process (load, res);
+ spawn_gnupg_list_process (load, task);
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -739,11 +732,7 @@ _gcr_gnupg_collection_load_finish (GcrGnupgCollection *self, GAsyncResult *resul
g_return_val_if_fail (GCR_IS_GNUPG_COLLECTION (self), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (self),
- _gcr_gnupg_collection_load_async), FALSE);
-
- 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);
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
diff --git a/gcr/gcr-gnupg-importer.c b/gcr/gcr-gnupg-importer.c
index 439a90a..79fa043 100644
--- a/gcr/gcr-gnupg-importer.c
+++ b/gcr/gcr-gnupg-importer.c
@@ -295,23 +295,23 @@ on_process_run_complete (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GcrGnupgImporter *self = GCR_GNUPG_IMPORTER (g_async_result_get_source_object (user_data));
+ GTask *task = G_TASK (user_data);
+ GcrGnupgImporter *self = GCR_GNUPG_IMPORTER (g_task_get_source_object (task));
GError *error = NULL;
if (!_gcr_gnupg_process_run_finish (GCR_GNUPG_PROCESS (source), result, &error)) {
if (g_error_matches (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED) && self->pv->first_error) {
- g_simple_async_result_set_error (res, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
- "%s", self->pv->first_error);
+ g_task_return_new_error (task, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
+ "%s", self->pv->first_error);
g_error_free (error);
} else {
- g_simple_async_result_take_error (res, error);
+ g_task_return_error (task, g_steal_pointer (&error));
}
+ } else {
+ g_task_return_boolean (task, TRUE);
}
- g_simple_async_result_complete (res);
- g_object_unref (self);
- g_object_unref (res);
+ g_clear_object (&task);
}
static void
@@ -321,21 +321,20 @@ _gcr_gnupg_importer_import_async (GcrImporter *importer,
gpointer user_data)
{
GcrGnupgImporter *self = GCR_GNUPG_IMPORTER (importer);
- GSimpleAsyncResult *res;
+ GTask *task;
const gchar *argv[] = { "--import", NULL };
- g_free (self->pv->first_error);
- self->pv->first_error = NULL;
+ g_clear_pointer (&self->pv->first_error, g_free);
- res = g_simple_async_result_new (G_OBJECT (importer), callback, user_data,
- _gcr_gnupg_importer_import_async);
+ task = g_task_new (importer, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_gnupg_importer_import_async);
_gcr_gnupg_process_run_async (self->pv->process, argv, NULL,
GCR_GNUPG_PROCESS_WITH_STATUS,
cancellable, on_process_run_complete,
- g_object_ref (res));
+ g_steal_pointer (&task));
- g_object_unref (res);
+ g_clear_object (&task);
}
static gboolean
@@ -343,13 +342,9 @@ _gcr_gnupg_importer_import_finish (GcrImporter *importer,
GAsyncResult *result,
GError **error)
{
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (importer),
- _gcr_gnupg_importer_import_async), FALSE);
-
- 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, importer), FALSE);
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
static void
diff --git a/gcr/gcr-library.c b/gcr/gcr-library.c
index bbce13f..399c7e2 100644
--- a/gcr/gcr-library.c
+++ b/gcr/gcr-library.c
@@ -239,38 +239,36 @@ on_initialize_registered (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
+ GTask *task = G_TASK (user_data);
GError *error = NULL;
GList *results;
results = gck_modules_initialize_registered_finish (result, &error);
if (error != NULL) {
g_debug ("failed %s", error->message);
- g_simple_async_result_take_error (res, error);
-
- } else {
-
- G_LOCK (modules);
-
- if (!initialized_modules) {
- all_modules = g_list_concat(all_modules, results);
- results = NULL;
- initialized_modules = TRUE;
- }
+ g_task_return_error (task, g_steal_pointer (&error));
+ g_clear_object (&task);
+ return;
+ }
- G_UNLOCK (modules);
+ G_LOCK (modules);
+ if (!initialized_modules) {
+ all_modules = g_list_concat (all_modules, results);
+ results = NULL;
+ initialized_modules = TRUE;
}
+ G_UNLOCK (modules);
gck_list_unref_free (results);
g_debug ("completed initialize of registered modules");
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_task_return_boolean (task, TRUE);
+ g_clear_object (&task);
}
/**
* gcr_pkcs11_initialize_async:
- * @cancellable: optional cancellable used to cancel the operation
+ * @cancellable: (nullable): optional cancellable used to cancel the operation
* @callback: callback which will be called when the operation completes
* @user_data: data passed to the callback
*
@@ -281,22 +279,24 @@ gcr_pkcs11_initialize_async (GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
+
+ g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
- res = g_simple_async_result_new (NULL, callback, user_data,
- gcr_pkcs11_initialize_async);
+ task = g_task_new (NULL, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_pkcs11_initialize_async);
if (initialized_modules) {
g_debug ("already initialized, no need to async");
- g_simple_async_result_complete_in_idle (res);
+ g_task_return_boolean (task, TRUE);
} else {
gck_modules_initialize_registered_async (cancellable,
on_initialize_registered,
- g_object_ref (res));
+ g_steal_pointer (&task));
g_debug ("starting initialize of registered modules");
}
- g_object_unref (res);
+ g_clear_object (&task);
}
/**
@@ -313,13 +313,9 @@ gboolean
gcr_pkcs11_initialize_finish (GAsyncResult *result,
GError **error)
{
- g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
- gcr_pkcs11_initialize_async), FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
/**
diff --git a/gcr/gcr-memory-icon.c b/gcr/gcr-memory-icon.c
index 27edefc..40a4527 100644
--- a/gcr/gcr-memory-icon.c
+++ b/gcr/gcr-memory-icon.c
@@ -138,21 +138,22 @@ static void
_gcr_memory_icon_load_async (GLoadableIcon *icon, int size, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
- res = g_simple_async_result_new (G_OBJECT (icon), callback, user_data,
- _gcr_memory_icon_load_async);
+ task = g_task_new (icon, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_memory_icon_load_async);
- g_simple_async_result_complete_in_idle (res);
- g_object_unref (res);
+ /* We don't do anything with the task value, so just return a bogus value */
+ g_task_return_pointer (task, NULL, NULL);
+ g_object_unref (task);
}
static GInputStream*
_gcr_memory_icon_finish (GLoadableIcon *icon, GAsyncResult *res, char **type,
GError **error)
{
- g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (icon),
- _gcr_memory_icon_load_async), NULL);
+ g_return_val_if_fail (g_task_is_valid (res, icon), NULL);
+
return _gcr_memory_icon_load (icon, 0, type, NULL, error);
}
diff --git a/gcr/gcr-pkcs11-certificate.c b/gcr/gcr-pkcs11-certificate.c
index ce55a18..ea87961 100644
--- a/gcr/gcr-pkcs11-certificate.c
+++ b/gcr/gcr-pkcs11-certificate.c
@@ -74,20 +74,6 @@ G_DEFINE_TYPE_WITH_CODE (GcrPkcs11Certificate, gcr_pkcs11_certificate, GCK_TYPE_
G_IMPLEMENT_INTERFACE (GCR_TYPE_CERTIFICATE, gcr_certificate_iface);
);
-typedef struct {
- GckAttributes *search;
- GcrCertificate *result;
-} lookup_issuer_closure;
-
-static void
-lookup_issuer_free (gpointer data)
-{
- lookup_issuer_closure *closure = data;
- gck_attributes_unref (closure->search);
- g_clear_object (&closure->result);
- g_free (closure);
-}
-
static GckAttributes *
prepare_lookup_certificate_issuer (GcrCertificate *cert)
{
@@ -168,17 +154,19 @@ perform_lookup_certificate (GckAttributes *search,
}
static void
-thread_lookup_certificate (GSimpleAsyncResult *res, GObject *object, GCancellable *cancel)
+thread_lookup_certificate (GTask *task, gpointer src_object, gpointer task_data,
+ GCancellable *cancellable)
{
- lookup_issuer_closure *closure;
+ GckAttributes *search = (GckAttributes *) task_data;
+ GcrCertificate *result;
GError *error = NULL;
- closure = g_simple_async_result_get_op_res_gpointer (res);
- closure->result = perform_lookup_certificate (closure->search, cancel, &error);
-
+ result = perform_lookup_certificate (search, cancellable, &error);
if (error != NULL) {
- g_simple_async_result_set_from_error (res, error);
+ g_task_return_error (task, g_steal_pointer (&error));
g_clear_error (&error);
+ } else{
+ g_task_return_pointer (task, result, g_object_unref);
}
}
@@ -394,22 +382,21 @@ void
gcr_pkcs11_certificate_lookup_issuer_async (GcrCertificate *certificate, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *async;
- lookup_issuer_closure *closure;
+ GTask *task;
+ GckAttributes *search;
g_return_if_fail (GCR_IS_CERTIFICATE (certificate));
- async = g_simple_async_result_new (G_OBJECT (certificate), callback, user_data,
- gcr_pkcs11_certificate_lookup_issuer_async);
- closure = g_new0 (lookup_issuer_closure, 1);
- closure->search = prepare_lookup_certificate_issuer (certificate);
- g_return_if_fail (closure->search);
- g_simple_async_result_set_op_res_gpointer (async, closure, lookup_issuer_free);
+ task = g_task_new (certificate, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_pkcs11_certificate_lookup_issuer_async);
- g_simple_async_result_run_in_thread (async, thread_lookup_certificate,
- G_PRIORITY_DEFAULT, cancellable);
+ search = prepare_lookup_certificate_issuer (certificate);
+ g_return_if_fail (search);
+ g_task_set_task_data (task, search, gck_attributes_unref);
- g_object_unref (async);
+ g_task_run_in_thread (task, thread_lookup_certificate);
+
+ g_object_unref (task);
}
/**
@@ -428,21 +415,12 @@ gcr_pkcs11_certificate_lookup_issuer_async (GcrCertificate *certificate, GCancel
GcrCertificate *
gcr_pkcs11_certificate_lookup_issuer_finish (GAsyncResult *result, GError **error)
{
- lookup_issuer_closure *closure;
GObject *source;
- g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL);
-
- source = g_async_result_get_source_object (result);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, source,
- gcr_pkcs11_certificate_lookup_issuer_async), NULL);
- g_object_unref (source);
+ g_return_val_if_fail (G_IS_TASK (result), NULL);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return NULL;
+ source = g_task_get_source_object (G_TASK (result));
+ g_return_val_if_fail (g_task_is_valid (result, source), NULL);
- closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
- if (closure->result != NULL)
- g_object_ref (closure->result);
- return closure->result;
+ return g_task_propagate_pointer (G_TASK (result), error);
}
diff --git a/gcr/gcr-pkcs11-importer.c b/gcr/gcr-pkcs11-importer.c
index 7a7cc3b..302eb72 100644
--- a/gcr/gcr-pkcs11-importer.c
+++ b/gcr/gcr-pkcs11-importer.c
@@ -62,28 +62,16 @@ struct _GcrPkcs11Importer {
typedef struct {
GcrPkcs11Importer *importer;
- GCancellable *cancellable;
gboolean prompted;
gboolean async;
GckBuilder *supplement;
} GcrImporterData;
-/* State forward declarations */
-static void state_cancelled (GSimpleAsyncResult *res,
+/* frward declarations */
+static void state_cancelled (GTask *task,
gboolean async);
-
-static void state_complete (GSimpleAsyncResult *res,
- gboolean async);
-
-static void state_create_object (GSimpleAsyncResult *res,
- gboolean async);
-
-static void state_supplement (GSimpleAsyncResult *res,
- gboolean async);
-
-static void state_open_session (GSimpleAsyncResult *res,
+static void state_create_object (GTask *task,
gboolean async);
-
static void _gcr_pkcs11_importer_init_iface (GcrImporterIface *iface);
G_DEFINE_TYPE_WITH_CODE (GcrPkcs11Importer, _gcr_pkcs11_importer, G_TYPE_OBJECT,
@@ -97,24 +85,23 @@ gcr_importer_data_free (gpointer data)
{
GcrImporterData *state = data;
- g_clear_object (&state->cancellable);
g_clear_object (&state->importer);
gck_builder_unref (state->supplement);
g_free (state);
}
static void
-next_state (GSimpleAsyncResult *res,
- void (*state) (GSimpleAsyncResult *, gboolean))
+next_state (GTask *task,
+ void (*state) (GTask *, gboolean))
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
g_assert (state);
- if (g_cancellable_is_cancelled (data->cancellable))
+ if (g_cancellable_is_cancelled (g_task_get_cancellable (task)))
state = state_cancelled;
- (state) (res, data->async);
+ (state) (task, data->async);
}
/* ---------------------------------------------------------------------------------
@@ -122,25 +109,17 @@ next_state (GSimpleAsyncResult *res,
*/
static void
-state_complete (GSimpleAsyncResult *res,
- gboolean async)
-{
- g_simple_async_result_complete (res);
-}
-
-static void
-state_cancelled (GSimpleAsyncResult *res,
+state_cancelled (GTask *task,
gboolean async)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GCancellable *cancellable = g_task_get_cancellable (task);
GError *error = NULL;
- if (data->cancellable && !g_cancellable_is_cancelled (data->cancellable))
- g_cancellable_cancel (data->cancellable);
+ if (cancellable && !g_cancellable_is_cancelled (cancellable))
+ g_cancellable_cancel (cancellable);
- g_cancellable_set_error_if_cancelled (data->cancellable, &error);
- g_simple_async_result_take_error (res, error);
- next_state (res, state_complete);
+ g_cancellable_set_error_if_cancelled (cancellable, &error);
+ g_task_return_error (task, g_steal_pointer (&error));
}
/* ---------------------------------------------------------------------------------
@@ -148,20 +127,19 @@ state_cancelled (GSimpleAsyncResult *res,
*/
static void
-complete_create_object (GSimpleAsyncResult *res,
+complete_create_object (GTask *task,
GckObject *object,
GError *error)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
GcrPkcs11Importer *self = data->importer;
if (object == NULL) {
- g_simple_async_result_take_error (res, error);
- next_state (res, state_complete);
+ g_task_return_error (task, g_steal_pointer (&error));
} else {
self->objects = g_list_append (self->objects, object);
- next_state (res, state_create_object);
+ next_state (task, state_create_object);
}
}
@@ -170,20 +148,21 @@ on_create_object (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
+ GTask *task = G_TASK (user_data);
GError *error = NULL;
GckObject *object;
object = gck_session_create_object_finish (GCK_SESSION (source), result, &error);
- complete_create_object (res, object, error);
- g_object_unref (res);
+ complete_create_object (task, object, error);
+ g_clear_object (&task);
}
static void
-state_create_object (GSimpleAsyncResult *res,
+state_create_object (GTask *task,
gboolean async)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
+ GCancellable *cancellable = g_task_get_cancellable (task);
GcrPkcs11Importer *self = data->importer;
GckAttributes *attrs;
GckObject *object;
@@ -191,7 +170,7 @@ state_create_object (GSimpleAsyncResult *res,
/* No more objects */
if (g_queue_is_empty (self->queue)) {
- next_state (res, state_complete);
+ g_task_return_boolean (task, TRUE);
} else {
@@ -201,12 +180,12 @@ state_create_object (GSimpleAsyncResult *res,
if (async) {
gck_session_create_object_async (self->session, attrs,
- data->cancellable, on_create_object,
- g_object_ref (res));
+ cancellable, on_create_object,
+ g_object_ref (task));
} else {
object = gck_session_create_object (self->session, attrs,
- data->cancellable, &error);
- complete_create_object (res, object, error);
+ cancellable, &error);
+ complete_create_object (task, object, error);
}
gck_attributes_unref (attrs);
@@ -406,10 +385,10 @@ supplement_attributes (GcrPkcs11Importer *self,
}
static void
-complete_supplement (GSimpleAsyncResult *res,
+complete_supplement (GTask *task,
GError *error)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
GckAttributes *attributes;
if (error == NULL) {
@@ -417,10 +396,9 @@ complete_supplement (GSimpleAsyncResult *res,
supplement_attributes (data->importer, attributes);
gck_attributes_unref (attributes);
- next_state (res, state_create_object);
+ next_state (task, state_create_object);
} else {
- g_simple_async_result_take_error (res, error);
- next_state (res, state_complete);
+ g_task_return_error (task, g_steal_pointer (&error));
}
}
@@ -429,44 +407,46 @@ on_supplement_done (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ GcrImporterData *data = g_task_get_task_data (task);
GcrPkcs11Importer *self = data->importer;
GError *error = NULL;
gcr_import_interaction_supplement_finish (GCR_IMPORT_INTERACTION (self->interaction),
result, &error);
- complete_supplement (res, error);
- g_object_unref (res);
+ complete_supplement (task, error);
+ g_clear_object (&task);
}
static void
-state_supplement (GSimpleAsyncResult *res,
+state_supplement (GTask *task,
gboolean async)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
+ GCancellable *cancellable = g_task_get_cancellable (task);
GcrPkcs11Importer *self = data->importer;
GError *error = NULL;
if (self->interaction == NULL || !GCR_IS_IMPORT_INTERACTION (self->interaction)) {
- complete_supplement (res, NULL);
+ complete_supplement (task, NULL);
} else if (async) {
gcr_import_interaction_supplement_async (GCR_IMPORT_INTERACTION (self->interaction),
- data->supplement, data->cancellable,
- on_supplement_done, g_object_ref (res));
+ data->supplement, cancellable,
+ on_supplement_done,
+ g_object_ref (task));
} else {
gcr_import_interaction_supplement (GCR_IMPORT_INTERACTION (self->interaction),
- data->supplement, data->cancellable, &error);
- complete_supplement (res, error);
+ data->supplement, cancellable, &error);
+ complete_supplement (task, error);
}
}
static void
-supplement_prep (GSimpleAsyncResult *res)
+supplement_prep (GTask *task)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
GcrPkcs11Importer *self = data->importer;
const GckAttribute *the_label = NULL;
const GckAttribute *attr;
@@ -503,21 +483,20 @@ supplement_prep (GSimpleAsyncResult *res)
*/
static void
-complete_open_session (GSimpleAsyncResult *res,
+complete_open_session (GTask *task,
GckSession *session,
GError *error)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
GcrPkcs11Importer *self = data->importer;
if (!session) {
- g_simple_async_result_take_error (res, error);
- next_state (res, state_complete);
+ g_task_return_error (task, g_steal_pointer (&error));
} else {
g_clear_object (&self->session);
self->session = session;
- next_state (res, state_supplement);
+ next_state (task, state_supplement);
}
}
@@ -526,20 +505,21 @@ on_open_session (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
+ GTask *task = G_TASK (user_data);
GError *error = NULL;
GckSession *session;
session = gck_session_open_finish (result, &error);
- complete_open_session (res, session, error);
- g_object_unref (res);
+ complete_open_session (task, session, error);
+ g_clear_object (&task);
}
static void
-state_open_session (GSimpleAsyncResult *res,
+state_open_session (GTask *task,
gboolean async)
{
- GcrImporterData *data = g_simple_async_result_get_op_res_gpointer (res);
+ GcrImporterData *data = g_task_get_task_data (task);
+ GCancellable *cancellable = g_task_get_cancellable (task);
GcrPkcs11Importer *self = data->importer;
guint options = GCK_SESSION_READ_WRITE | GCK_SESSION_LOGIN_USER;
GckSession *session;
@@ -547,11 +527,11 @@ state_open_session (GSimpleAsyncResult *res,
if (async) {
gck_session_open_async (self->slot, options, self->interaction,
- data->cancellable, on_open_session, g_object_ref (res));
+ cancellable, on_open_session, g_object_ref (task));
} else {
session = gck_session_open (self->slot, options, self->interaction,
- data->cancellable, &error);
- complete_open_session (res, session, error);
+ cancellable, &error);
+ complete_open_session (task, session, error);
}
}
@@ -843,21 +823,21 @@ _gcr_pkcs11_importer_import_async (GcrImporter *importer,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
GcrImporterData *data;
- res = g_simple_async_result_new (G_OBJECT (importer), callback, user_data,
- _gcr_pkcs11_importer_import_async);
+ task = g_task_new (importer, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_pkcs11_importer_import_async);
+
data = g_new0 (GcrImporterData, 1);
data->async = TRUE;
data->importer = GCR_PKCS11_IMPORTER (g_object_ref (importer));
- data->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
- g_simple_async_result_set_op_res_gpointer (res, data, gcr_importer_data_free);
+ g_task_set_task_data (task, data, gcr_importer_data_free);
- supplement_prep (res);
+ supplement_prep (task);
- next_state (res, state_open_session);
- g_object_unref (res);
+ next_state (task, state_open_session);
+ g_clear_object (&task);
}
static gboolean
@@ -865,13 +845,9 @@ _gcr_pkcs11_importer_import_finish (GcrImporter *importer,
GAsyncResult *result,
GError **error)
{
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (importer),
- _gcr_pkcs11_importer_import_async), FALSE);
-
- 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, importer), FALSE);
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
static void
diff --git a/gcr/gcr-subject-public-key.c b/gcr/gcr-subject-public-key.c
index bc07de4..7ff78f4 100644
--- a/gcr/gcr-subject-public-key.c
+++ b/gcr/gcr-subject-public-key.c
@@ -510,15 +510,16 @@ load_closure_free (gpointer data)
}
static void
-thread_key_attributes (GSimpleAsyncResult *res,
- GObject *object,
+thread_key_attributes (GTask *task, gpointer src_object, gpointer task_data,
GCancellable *cancellable)
{
- LoadClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
+ LoadClosure *closure = task_data;
GError *error = NULL;
- if (!load_attributes (closure->object, &closure->builder, cancellable, &error))
- g_simple_async_result_take_error (res, error);
+ if (load_attributes (closure->object, &closure->builder, cancellable, &error))
+ g_task_return_boolean (task, TRUE);
+ else
+ g_task_return_error (task, g_steal_pointer (&error));
}
void
@@ -527,29 +528,28 @@ _gcr_subject_public_key_load_async (GckObject *key,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
LoadClosure *closure;
g_return_if_fail (GCK_IS_OBJECT (key));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
- res = g_simple_async_result_new (NULL, callback, user_data,
- _gcr_subject_public_key_load_async);
+ task = g_task_new (NULL, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_subject_public_key_load_async);
closure = g_slice_new0 (LoadClosure);
closure->object = g_object_ref (key);
lookup_attributes (key, &closure->builder);
- g_simple_async_result_set_op_res_gpointer (res, closure, load_closure_free);
+ g_task_set_task_data (task, closure, load_closure_free);
if (check_attributes (&closure->builder)) {
- g_simple_async_result_complete_in_idle (res);
- g_object_unref (res);
+ g_task_return_boolean (task, TRUE);
+ g_clear_object (&task);
return;
}
- g_simple_async_result_run_in_thread (res, thread_key_attributes,
- G_PRIORITY_DEFAULT, cancellable);
- g_object_unref (res);
+ g_task_run_in_thread (task, thread_key_attributes);
+ g_clear_object (&task);
}
GNode *
@@ -557,19 +557,16 @@ _gcr_subject_public_key_load_finish (GAsyncResult *result,
GError **error)
{
GckAttributes *attributes;
- GSimpleAsyncResult *res;
LoadClosure *closure;
GNode *asn;
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
- _gcr_subject_public_key_load_async), NULL);
+ g_return_val_if_fail (g_task_is_valid (result, NULL), NULL);
- res = G_SIMPLE_ASYNC_RESULT (result);
- if (g_simple_async_result_propagate_error (res, error))
+ if (!g_task_propagate_boolean (G_TASK (result), error))
return NULL;
- closure = g_simple_async_result_get_op_res_gpointer (res);
+ closure = g_task_get_task_data (G_TASK (result));
attributes = gck_attributes_ref_sink (gck_builder_end (&closure->builder));
asn = _gcr_subject_public_key_for_attributes (attributes);
if (asn == NULL) {
diff --git a/gcr/gcr-trust.c b/gcr/gcr-trust.c
index 2a74b59..af41d02 100644
--- a/gcr/gcr-trust.c
+++ b/gcr/gcr-trust.c
@@ -97,19 +97,6 @@
* HELPERS
*/
-typedef struct {
- GckAttributes *attrs;
- gboolean found;
-} trust_closure;
-
-static void
-trust_closure_free (gpointer data)
-{
- trust_closure *closure = data;
- gck_attributes_unref (closure->attrs);
- g_free (closure);
-}
-
static void
prepare_trust_attrs (GcrCertificate *certificate,
CK_X_ASSERTION_TYPE type,
@@ -211,18 +198,18 @@ gcr_trust_is_certificate_pinned (GcrCertificate *certificate, const gchar *purpo
}
static void
-thread_is_certificate_pinned (GSimpleAsyncResult *result, GObject *object, GCancellable *cancel)
+thread_is_certificate_pinned (GTask *task, gpointer object,
+ gpointer task_data, GCancellable *cancellable)
{
+ GckAttributes *attrs = task_data;
GError *error = NULL;
- trust_closure *closure;
-
- closure = g_simple_async_result_get_op_res_gpointer (result);
- closure->found = perform_is_certificate_pinned (closure->attrs, cancel, &error);
+ gboolean found;
- if (error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_clear_error (&error);
- }
+ found = perform_is_certificate_pinned (attrs, cancellable, &error);
+ if (error == NULL)
+ g_task_return_boolean (task, found);
+ else
+ g_task_return_error (task, g_steal_pointer (&error));
}
/**
@@ -246,24 +233,23 @@ gcr_trust_is_certificate_pinned_async (GcrCertificate *certificate, const gchar
const gchar *peer, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *async;
- trust_closure *closure;
+ GTask *task;
+ GckAttributes *attrs;
- g_return_if_fail (GCR_CERTIFICATE (certificate));
+ g_return_if_fail (GCR_IS_CERTIFICATE (certificate));
g_return_if_fail (purpose);
g_return_if_fail (peer);
- async = g_simple_async_result_new (NULL, callback, user_data,
- gcr_trust_is_certificate_pinned_async);
- closure = g_new0 (trust_closure, 1);
- closure->attrs = prepare_is_certificate_pinned (certificate, purpose, peer);
- g_return_if_fail (closure->attrs);
- g_simple_async_result_set_op_res_gpointer (async, closure, trust_closure_free);
+ task = g_task_new (NULL, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_trust_is_certificate_pinned_async);
+
+ attrs = prepare_is_certificate_pinned (certificate, purpose, peer);
+ g_return_if_fail (attrs);
+ g_task_set_task_data (task, attrs, gck_attributes_unref);
- g_simple_async_result_run_in_thread (async, thread_is_certificate_pinned,
- G_PRIORITY_DEFAULT, cancellable);
+ g_task_run_in_thread (task, thread_is_certificate_pinned);
- g_object_unref (async);
+ g_clear_object (&task);
}
/**
@@ -282,19 +268,10 @@ gcr_trust_is_certificate_pinned_async (GcrCertificate *certificate, const gchar
gboolean
gcr_trust_is_certificate_pinned_finish (GAsyncResult *result, GError **error)
{
- trust_closure *closure;
-
- g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
- gcr_trust_is_certificate_pinned_async), FALSE);
-
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
- return closure->found;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
/* ----------------------------------------------------------------------------------
@@ -428,18 +405,17 @@ gcr_trust_add_pinned_certificate (GcrCertificate *certificate, const gchar *purp
}
static void
-thread_add_pinned_certificate (GSimpleAsyncResult *result, GObject *object, GCancellable *cancel)
+thread_add_pinned_certificate (GTask *task, gpointer object,
+ gpointer task_data, GCancellable *cancellable)
{
+ GckAttributes *attrs = task_data;
GError *error = NULL;
- trust_closure *closure;
-
- closure = g_simple_async_result_get_op_res_gpointer (result);
- perform_add_pinned_certificate (closure->attrs, cancel, &error);
- if (error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_clear_error (&error);
- }
+ perform_add_pinned_certificate (attrs, cancellable, &error);
+ if (error == NULL)
+ g_task_return_boolean (task, TRUE);
+ else
+ g_task_return_error (task, g_steal_pointer (&error));
}
/**
@@ -467,24 +443,23 @@ gcr_trust_add_pinned_certificate_async (GcrCertificate *certificate, const gchar
const gchar *peer, GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- GSimpleAsyncResult *async;
- trust_closure *closure;
+ GTask *task;
+ GckAttributes *attrs;
g_return_if_fail (GCR_IS_CERTIFICATE (certificate));
g_return_if_fail (purpose);
g_return_if_fail (peer);
- async = g_simple_async_result_new (NULL, callback, user_data,
- gcr_trust_add_pinned_certificate_async);
- closure = g_new0 (trust_closure, 1);
- closure->attrs = prepare_add_pinned_certificate (certificate, purpose, peer);
- g_return_if_fail (closure->attrs);
- g_simple_async_result_set_op_res_gpointer (async, closure, trust_closure_free);
+ task = g_task_new (NULL, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_trust_add_pinned_certificate_async);
+
+ attrs = prepare_add_pinned_certificate (certificate, purpose, peer);
+ g_return_if_fail (attrs);
+ g_task_set_task_data (task, attrs, gck_attributes_unref);
- g_simple_async_result_run_in_thread (async, thread_add_pinned_certificate,
- G_PRIORITY_DEFAULT, cancellable);
+ g_task_run_in_thread (task, thread_add_pinned_certificate);
- g_object_unref (async);
+ g_clear_object (&task);
}
/**
@@ -500,16 +475,10 @@ gcr_trust_add_pinned_certificate_async (GcrCertificate *certificate, const gchar
gboolean
gcr_trust_add_pinned_certificate_finish (GAsyncResult *result, GError **error)
{
- g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
- gcr_trust_add_pinned_certificate_async), FALSE);
-
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
/* -----------------------------------------------------------------------
@@ -613,18 +582,18 @@ gcr_trust_remove_pinned_certificate (GcrCertificate *certificate, const gchar *p
}
static void
-thread_remove_pinned_certificate (GSimpleAsyncResult *result, GObject *object, GCancellable *cancel)
+thread_remove_pinned_certificate (GTask *task, gpointer object,
+ gpointer task_data, GCancellable *cancellable)
{
+ GckAttributes *attrs = task_data;
GError *error = NULL;
- trust_closure *closure;
- closure = g_simple_async_result_get_op_res_gpointer (result);
- perform_remove_pinned_certificate (closure->attrs, cancel, &error);
+ perform_remove_pinned_certificate (attrs, cancellable, &error);
- if (error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_clear_error (&error);
- }
+ if (error == NULL)
+ g_task_return_boolean (task, TRUE);
+ else
+ g_task_return_error (task, g_steal_pointer (&error));
}
/**
@@ -646,28 +615,30 @@ thread_remove_pinned_certificate (GSimpleAsyncResult *result, GObject *object, G
* operation.
*/
void
-gcr_trust_remove_pinned_certificate_async (GcrCertificate *certificate, const gchar *purpose,
- const gchar *peer, GCancellable *cancellable,
- GAsyncReadyCallback callback, gpointer user_data)
+gcr_trust_remove_pinned_certificate_async (GcrCertificate *certificate,
+ const gchar *purpose,
+ const gchar *peer,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
- GSimpleAsyncResult *async;
- trust_closure *closure;
+ GTask *task;
+ GckAttributes *attrs;
g_return_if_fail (GCR_IS_CERTIFICATE (certificate));
g_return_if_fail (purpose);
g_return_if_fail (peer);
- async = g_simple_async_result_new (NULL, callback, user_data,
- gcr_trust_remove_pinned_certificate_async);
- closure = g_new0 (trust_closure, 1);
- closure->attrs = prepare_remove_pinned_certificate (certificate, purpose, peer);
- g_return_if_fail (closure->attrs);
- g_simple_async_result_set_op_res_gpointer (async, closure, trust_closure_free);
+ task = g_task_new (NULL, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_trust_remove_pinned_certificate_async);
+
+ attrs = prepare_remove_pinned_certificate (certificate, purpose, peer);
+ g_return_if_fail (attrs);
+ g_task_set_task_data (task, attrs, gck_attributes_unref);
- g_simple_async_result_run_in_thread (async, thread_remove_pinned_certificate,
- G_PRIORITY_DEFAULT, cancellable);
+ g_task_run_in_thread (task, thread_remove_pinned_certificate);
- g_object_unref (async);
+ g_clear_object (&task);
}
/**
@@ -683,16 +654,10 @@ gcr_trust_remove_pinned_certificate_async (GcrCertificate *certificate, const gc
gboolean
gcr_trust_remove_pinned_certificate_finish (GAsyncResult *result, GError **error)
{
- g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
- gcr_trust_remove_pinned_certificate_async), FALSE);
-
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- return TRUE;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
/* ----------------------------------------------------------------------------------
@@ -777,18 +742,18 @@ gcr_trust_is_certificate_anchored (GcrCertificate *certificate, const gchar *pur
}
static void
-thread_is_certificate_anchored (GSimpleAsyncResult *result, GObject *object, GCancellable *cancel)
+thread_is_certificate_anchored (GTask *task, gpointer object,
+ gpointer task_data, GCancellable *cancellable)
{
+ GckAttributes *attrs = task_data;
GError *error = NULL;
- trust_closure *closure;
-
- closure = g_simple_async_result_get_op_res_gpointer (result);
- closure->found = perform_is_certificate_anchored (closure->attrs, cancel, &error);
+ gboolean found;
- if (error != NULL) {
- g_simple_async_result_set_from_error (result, error);
- g_clear_error (&error);
- }
+ found = perform_is_certificate_anchored (attrs, cancellable, &error);
+ if (error == NULL)
+ g_task_return_boolean (task, found);
+ else
+ g_task_return_error (task, g_steal_pointer (&error));
}
/**
@@ -811,23 +776,22 @@ gcr_trust_is_certificate_anchored_async (GcrCertificate *certificate, const gcha
GCancellable *cancellable, GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *async;
- trust_closure *closure;
+ GTask *task;
+ GckAttributes *attrs;
g_return_if_fail (GCR_IS_CERTIFICATE (certificate));
g_return_if_fail (purpose);
- async = g_simple_async_result_new (NULL, callback, user_data,
- gcr_trust_is_certificate_anchored_async);
- closure = g_new0 (trust_closure, 1);
- closure->attrs = prepare_is_certificate_anchored (certificate, purpose);
- g_return_if_fail (closure->attrs);
- g_simple_async_result_set_op_res_gpointer (async, closure, trust_closure_free);
+ task = g_task_new (NULL, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gcr_trust_is_certificate_anchored_async);
- g_simple_async_result_run_in_thread (async, thread_is_certificate_anchored,
- G_PRIORITY_DEFAULT, cancellable);
+ attrs = prepare_is_certificate_anchored (certificate, purpose);
+ g_return_if_fail (attrs);
+ g_task_set_task_data (task, attrs, gck_attributes_unref);
- g_object_unref (async);
+ g_task_run_in_thread (task, thread_is_certificate_anchored);
+
+ g_clear_object (&task);
}
/**
@@ -846,17 +810,8 @@ gcr_trust_is_certificate_anchored_async (GcrCertificate *certificate, const gcha
gboolean
gcr_trust_is_certificate_anchored_finish (GAsyncResult *result, GError **error)
{
- trust_closure *closure;
-
- g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE);
g_return_val_if_fail (!error || !*error, FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, NULL), FALSE);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, NULL,
- gcr_trust_is_certificate_anchored_async), FALSE);
-
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
- return FALSE;
-
- closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
- return closure->found;
+ return g_task_propagate_boolean (G_TASK (result), error);
}
diff --git a/ui/frob-import-button.c b/ui/frob-import-button.c
index 7b386a8..d876d81 100644
--- a/ui/frob-import-button.c
+++ b/ui/frob-import-button.c
@@ -70,14 +70,14 @@ mock_importer_import_async (GcrImporter *importer,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
- res = g_simple_async_result_new (G_OBJECT (importer), callback, user_data,
- mock_importer_import_async);
+ task = g_task_new (importer, cancellable, callback, user_data);
+ g_task_set_source_tag (task, mock_importer_import_async);
g_printerr ("Import %p\n", importer);
- g_simple_async_result_complete_in_idle (res);
- g_object_unref (res);
+ g_task_return_boolean (task, TRUE);
+ g_clear_object (&task);
}
@@ -86,7 +86,7 @@ mock_importer_import_finish (GcrImporter *importer,
GAsyncResult *result,
GError **error)
{
- return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error);
+ return g_task_propagate_boolean (G_TASK (result), error);
}
diff --git a/ui/gcr-dialog-util.c b/ui/gcr-dialog-util.c
index b37aa63..e9c7fa0 100644
--- a/ui/gcr-dialog-util.c
+++ b/ui/gcr-dialog-util.c
@@ -27,7 +27,6 @@
typedef struct {
GtkDialog *dialog;
- gint response_id;
gboolean was_modal;
gboolean destroyed;
gulong response_sig;
@@ -49,11 +48,11 @@ dialog_run_closure_free (gpointer data)
}
static void
-complete_async_result (GSimpleAsyncResult *res)
+complete_task (GTask *task, int response_id)
{
- DialogRunClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
+ DialogRunClosure *closure = g_task_get_task_data (task);
- g_object_ref (res);
+ g_object_ref (task);
if (!closure->destroyed) {
if (!closure->was_modal)
@@ -69,17 +68,17 @@ complete_async_result (GSimpleAsyncResult *res)
closure->destroy_sig = 0;
}
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_task_return_int (task, response_id);
+ g_clear_object (&task);
}
static void
on_dialog_unmap (GtkDialog *dialog,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
+ GTask *task = G_TASK (user_data);
- complete_async_result (res);
+ complete_task (task, GTK_RESPONSE_NONE);
}
static void
@@ -87,11 +86,8 @@ on_dialog_response (GtkDialog *dialog,
gint response_id,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- DialogRunClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
-
- closure->response_id = response_id;
- complete_async_result (res);
+ GTask *task = G_TASK (user_data);
+ complete_task (task, response_id);
}
static gint
@@ -99,8 +95,8 @@ on_dialog_delete (GtkDialog *dialog,
GdkEventAny *event,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- complete_async_result (res);
+ GTask *task = G_TASK (user_data);
+ complete_task (task, GTK_RESPONSE_NONE);
return TRUE; /* Do not destroy */
}
@@ -108,8 +104,8 @@ static void
on_dialog_destroy (GtkDialog *dialog,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- DialogRunClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ DialogRunClosure *closure = g_task_get_task_data (task);
/* complete will be called by run_unmap_handler */
closure->destroyed = TRUE;
@@ -121,18 +117,17 @@ _gcr_dialog_util_run_async (GtkDialog *dialog,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *res;
+ GTask *task;
DialogRunClosure *closure;
g_return_if_fail (GTK_IS_DIALOG (dialog));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
- res = g_simple_async_result_new (G_OBJECT (dialog), callback, user_data,
- _gcr_dialog_util_run_async);
- closure = g_new0 (DialogRunClosure, 1);
+ task = g_task_new (dialog, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_dialog_util_run_async);
+ closure = g_new0 (DialogRunClosure, 1);
closure->dialog = g_object_ref (dialog);
- closure->response_id = GTK_RESPONSE_NONE;
closure->was_modal = gtk_window_get_modal (GTK_WINDOW (dialog));
if (!closure->was_modal)
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
@@ -140,29 +135,29 @@ _gcr_dialog_util_run_async (GtkDialog *dialog,
if (!gtk_widget_get_visible (GTK_WIDGET (dialog)))
gtk_widget_show (GTK_WIDGET (dialog));
- g_simple_async_result_set_op_res_gpointer (res, closure, dialog_run_closure_free);
+ g_task_set_task_data (task, closure, dialog_run_closure_free);
closure->response_sig = g_signal_connect_data (dialog, "response",
G_CALLBACK (on_dialog_response),
- g_object_ref (res),
+ g_object_ref (task),
(GClosureNotify)g_object_unref, 0);
closure->unmap_sig = g_signal_connect_data (dialog, "unmap",
G_CALLBACK (on_dialog_unmap),
- g_object_ref (res),
+ g_object_ref (task),
(GClosureNotify)g_object_unref, 0);
closure->delete_sig = g_signal_connect_data (dialog, "delete-event",
G_CALLBACK (on_dialog_delete),
- g_object_ref (res),
+ g_object_ref (task),
(GClosureNotify)g_object_unref, 0);
closure->destroy_sig = g_signal_connect_data (dialog, "destroy",
G_CALLBACK (on_dialog_destroy),
- g_object_ref (res),
+ g_object_ref (task),
(GClosureNotify)g_object_unref, 0);
- g_object_unref (res);
+ g_clear_object (&task);
}
@@ -170,11 +165,7 @@ gint
_gcr_dialog_util_run_finish (GtkDialog *dialog,
GAsyncResult *result)
{
- DialogRunClosure *closure;
-
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (dialog),
- _gcr_dialog_util_run_async), GTK_RESPONSE_NONE);
+ g_return_val_if_fail (g_task_is_valid (result, dialog), GTK_RESPONSE_NONE);
- closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
- return closure->response_id;
+ return g_task_propagate_int (G_TASK (result), NULL);
}
diff --git a/ui/gcr-pkcs11-import-interaction.c b/ui/gcr-pkcs11-import-interaction.c
index ecdc8f3..bb0dc5d 100644
--- a/ui/gcr-pkcs11-import-interaction.c
+++ b/ui/gcr-pkcs11-import-interaction.c
@@ -149,19 +149,19 @@ on_dialog_run_async (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
- GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
- GckBuilder *builder = g_simple_async_result_get_op_res_gpointer (res);
+ GTask *task = G_TASK (user_data);
+ GckBuilder *builder = g_task_get_task_data (task);
if (_gcr_pkcs11_import_dialog_run_finish (GCR_PKCS11_IMPORT_DIALOG (source), result)) {
_gcr_pkcs11_import_dialog_get_supplements (GCR_PKCS11_IMPORT_DIALOG (source), builder);
+ g_task_return_boolean (task, TRUE);
} else {
- g_simple_async_result_set_error (res, G_IO_ERROR, G_IO_ERROR_CANCELLED,
- _("The user cancelled the operation"));
+ g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_CANCELLED,
+ _("The user cancelled the operation"));
}
- g_simple_async_result_complete (res);
- g_object_unref (res);
+ g_clear_object (&task);
}
static void
@@ -172,26 +172,27 @@ _gcr_pkcs11_import_interaction_supplement_async (GcrImportInteraction *interacti
gpointer user_data)
{
GcrPkcs11ImportInteraction *self = GCR_PKCS11_IMPORT_INTERACTION (interaction);
- GSimpleAsyncResult *res;
+ GTask *task;
g_return_if_fail (self->dialog != NULL);
- res = g_simple_async_result_new (G_OBJECT (interaction), callback, user_data,
- _gcr_pkcs11_import_interaction_supplement_async);
+ task = g_task_new (interaction, cancellable, callback, user_data);
+ g_task_set_source_tag (task, _gcr_pkcs11_import_interaction_supplement_async);
/* If dialog was already shown, then short circuit */
if (self->supplemented) {
- g_simple_async_result_complete_in_idle (res);
+ g_task_return_boolean (task, TRUE);
} else {
self->supplemented = TRUE;
- g_simple_async_result_set_op_res_gpointer (res, gck_builder_ref (builder),
- (GDestroyNotify)gck_builder_unref);
+ g_task_set_task_data (task, gck_builder_ref (builder),
+ (GDestroyNotify) gck_builder_unref);
_gcr_pkcs11_import_dialog_run_async (self->dialog, cancellable,
- on_dialog_run_async, g_object_ref (res));
+ on_dialog_run_async,
+ g_object_ref (task));
}
- g_object_unref (res);
+ g_clear_object (&task);
}
static GTlsInteractionResult
@@ -202,10 +203,9 @@ _gcr_pkcs11_import_interaction_supplement_finish (GcrImportInteraction *interact
GcrPkcs11ImportInteraction *self = GCR_PKCS11_IMPORT_INTERACTION (interaction);
g_return_val_if_fail (self->dialog != NULL, G_TLS_INTERACTION_UNHANDLED);
- g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (interaction),
- _gcr_pkcs11_import_interaction_supplement_async), G_TLS_INTERACTION_UNHANDLED);
+ g_return_val_if_fail (g_task_is_valid (result, interaction), G_TLS_INTERACTION_UNHANDLED);
- if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
+ if (!g_task_propagate_boolean (G_TASK (result), error))
return G_TLS_INTERACTION_FAILED;
return G_TLS_INTERACTION_HANDLED;
View Lorry Controller Status