static void
ide_subprocess_wait_check_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeSubprocess *self = (IdeSubprocess *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_SUBPROCESS (self));
g_assert (G_IS_TASK (task));
if (!ide_subprocess_wait_finish (self, result, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (!ide_subprocess_check_exit_status (self, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
g_task_return_boolean (task, TRUE);
IDE_EXIT;
}
static void
ide_git_vcs_reload_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
IdeGitVcs *self = source_object;
g_autoptr(GgitRepository) repository1 = NULL;
g_autoptr(GgitRepository) repository2 = NULL;
GError *error = NULL;
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_GIT_VCS (self));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
if (!(repository1 = ide_git_vcs_load (self, &error)) ||
!(repository2 = ide_git_vcs_load (self, &error)))
{
g_task_return_error (task, error);
return;
}
g_set_object (&self->repository, repository1);
g_set_object (&self->change_monitor_repository, repository2);
if (!ide_git_vcs_load_monitor (self, &error))
{
g_task_return_error (task, error);
return;
}
g_task_return_boolean (task, TRUE);
}
static void
dms_uim_set_pin_protection_ready (QmiClientDms *client,
GAsyncResult *res,
GTask *task)
{
QmiMessageDmsUimSetPinProtectionOutput *output = NULL;
GError *error = NULL;
MMSimQmi *self;
self = g_task_get_source_object (task);
output = qmi_client_dms_uim_set_pin_protection_finish (client, res, &error);
if (!output) {
g_prefix_error (&error, "QMI operation failed: ");
g_task_return_error (task, error);
} else if (!qmi_message_dms_uim_set_pin_protection_output_get_result (output, &error)) {
g_prefix_error (&error, "Couldn't enable PIN: ");
g_task_return_error (task, pin_qmi_error_to_mobile_equipment_error (error));
} else
g_task_return_boolean (task, TRUE);
if (output)
qmi_message_dms_uim_set_pin_protection_output_unref (output);
g_object_unref (task);
}
static void
dms_uim_get_imsi_ready (QmiClientDms *client,
GAsyncResult *res,
GTask *task)
{
QmiMessageDmsUimGetImsiOutput *output = NULL;
GError *error = NULL;
output = qmi_client_dms_uim_get_imsi_finish (client, res, &error);
if (!output) {
g_prefix_error (&error, "QMI operation failed: ");
g_task_return_error (task, error);
} else if (!qmi_message_dms_uim_get_imsi_output_get_result (output, &error)) {
g_prefix_error (&error, "Couldn't get UIM IMSI: ");
g_task_return_error (task, error);
} else {
const gchar *str = NULL;
qmi_message_dms_uim_get_imsi_output_get_imsi (output, &str, NULL);
g_task_return_pointer (task, g_strdup (str), (GDestroyNotify) g_free);
}
if (output)
qmi_message_dms_uim_get_imsi_output_unref (output);
g_object_unref (task);
}
static void
handshake_thread_completed (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GTask *caller_task = user_data;
GTlsConnectionBase *tls = g_task_get_source_object (caller_task);
GError *error = NULL;
gboolean need_finish_handshake, success;
g_mutex_lock (&tls->op_mutex);
if (tls->need_finish_handshake)
{
need_finish_handshake = TRUE;
tls->need_finish_handshake = FALSE;
}
else
need_finish_handshake = FALSE;
g_mutex_unlock (&tls->op_mutex);
if (need_finish_handshake)
{
success = finish_handshake (tls, G_TASK (result), &error);
if (success)
g_task_return_boolean (caller_task, TRUE);
else
g_task_return_error (caller_task, error);
}
else if (tls->handshake_error)
g_task_return_error (caller_task, g_error_copy (tls->handshake_error));
else
g_task_return_boolean (caller_task, TRUE);
g_object_unref (caller_task);
}
static void
load_file (GTask *task,
MetaBackgroundImage *image,
gpointer task_data,
GCancellable *cancellable)
{
GError *error = NULL;
GdkPixbuf *pixbuf;
GFileInputStream *stream;
stream = g_file_read (image->file, NULL, &error);
if (stream == NULL)
{
g_task_return_error (task, error);
return;
}
pixbuf = gdk_pixbuf_new_from_stream (G_INPUT_STREAM (stream), NULL, &error);
g_object_unref (stream);
if (pixbuf == NULL)
{
g_task_return_error (task, error);
return;
}
g_task_return_pointer (task, pixbuf, (GDestroyNotify) g_object_unref);
}
static void
ide_git_vcs_list_status_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
ListStatus *state = task_data;
g_autoptr(GListStore) store = NULL;
g_autoptr(GFile) workdir = NULL;
g_autoptr(GgitRepository) repository = NULL;
g_autoptr(GgitStatusOptions) options = NULL;
g_autoptr(GString) pathspec = NULL;
g_autoptr(GError) error = NULL;
g_autofree gchar *relative = NULL;
gchar *strv[] = { NULL, NULL };
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_GIT_VCS (source_object));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (state != NULL);
g_assert (G_IS_FILE (state->repository_location));
if (!(repository = ggit_repository_open (state->repository_location, &error)))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if (!(workdir = ggit_repository_get_workdir (repository)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Failed to locate working directory");
return;
}
g_set_object (&state->workdir, workdir);
if (state->directory_or_file != NULL)
relative = g_file_get_relative_path (workdir, state->directory_or_file);
strv[0] = relative;
options = ggit_status_options_new (GGIT_STATUS_OPTION_DEFAULT,
GGIT_STATUS_SHOW_INDEX_AND_WORKDIR,
(const gchar **)strv);
store = g_list_store_new (IDE_TYPE_VCS_FILE_INFO);
g_set_object (&state->store, store);
if (!ggit_repository_file_status_foreach (repository,
options,
ide_git_vcs_list_status_cb,
state,
&error))
g_task_return_error (task, g_steal_pointer (&error));
else
g_task_return_pointer (task, g_steal_pointer (&store), g_object_unref);
}
static void
check_for_packages_thread (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GDBusProxy *proxy = G_DBUS_PROXY (source_object);
ClientCtx *ctx = (ClientCtx *) task_data;
gboolean satisfied = TRUE;
gint i = 0;
GError *error = NULL;
for (i = 0; i < g_strv_length (ctx->packages); i++) {
GVariant *res = g_dbus_proxy_call_sync (proxy,
"IsInstalled",
g_variant_new ("(ss)", ctx->packages[i], ctx->options),
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, NULL, &error);
if (error != NULL) {
satisfied = FALSE;
break;
}
gboolean is_installed = FALSE;
g_variant_get (res, "(b)", &is_installed);
g_variant_unref (res);
if (!is_installed) {
satisfied = FALSE;
break;
}
}
if (error != NULL) {
g_task_return_error (task, error);
return;
}
if (!satisfied) {
g_task_return_error (task,
g_error_new (g_quark_from_static_string ("GnomeInstaller"),
1,
"%s", ctx->packages[i]));
return;
}
g_task_return_boolean (task, TRUE);
}
static void
on_import_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
source_import_closure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
g_autofree gchar *errmsg = NULL;
g_assert (closure->requests > 0);
seahorse_progress_end (closure->cancellable, GUINT_TO_POINTER (closure->requests));
closure->requests--;
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if ((errmsg = get_send_result (message->response_body->data)) != NULL) {
g_task_return_new_error (task, HKP_ERROR_DOMAIN, message->status_code,
"%s", errmsg);
return;
}
/* A successful status from the server is all we want in this case */
if (closure->requests == 0) {
/* We don't know which keys got imported, so just return NULL */
g_task_return_pointer (task, NULL, NULL);
}
}
static void
on_all_drivers_activated (GsdSmartcardManager *self,
GAsyncResult *result,
GTask *task)
{
GError *error = NULL;
gboolean driver_activated;
PK11SlotInfo *login_token;
driver_activated = activate_all_drivers_async_finish (self, result, &error);
if (!driver_activated) {
g_task_return_error (task, error);
return;
}
login_token = gsd_smartcard_manager_get_login_token (self);
if (login_token || g_getenv ("PKCS11_LOGIN_TOKEN_NAME") != NULL) {
/* The card used to log in was removed before login completed.
* Do removal action immediately
*/
if (!login_token || !PK11_IsPresent (login_token))
gsd_smartcard_manager_do_remove_action (self);
}
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
static void
get_rules_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable)
{
GDataAccessHandler *access_handler = GDATA_ACCESS_HANDLER (source_object);
GDataAccessHandlerIface *iface;
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);
feed = iface->get_rules (access_handler, data->service,
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);
}
}
static void
photos_glib_file_copy_read (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GCancellable *cancellable;
GFile *source = G_FILE (source_object);
g_autoptr (GFileInputStream) istream = NULL;
g_autoptr (GTask) task = G_TASK (user_data);
PhotosGLibFileCopyData *data;
cancellable = g_task_get_cancellable (task);
data = (PhotosGLibFileCopyData *) g_task_get_task_data (task);
{
g_autoptr (GError) error = NULL;
istream = g_file_read_finish (source, res, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_output_stream_splice_async (G_OUTPUT_STREAM (data->ostream),
G_INPUT_STREAM (istream),
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
data->io_priority,
cancellable,
photos_glib_file_copy_splice,
g_object_ref (task));
out:
return;
}
static void
on_driver_registered (GsdSmartcardManager *self,
GAsyncResult *result,
GTask *task)
{
GError *error = NULL;
DriverRegistrationOperation *operation;
GsdSmartcardManagerPrivate *priv = self->priv;
operation = g_task_get_task_data (G_TASK (result));
if (!register_driver_finish (self, result, &error)) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
watch_smartcards_from_driver_async (self,
operation->driver,
priv->cancellable,
(GAsyncReadyCallback) on_smartcards_from_driver_watched,
task);
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
static void
photos_base_item_download_in_thread_func (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemPrivate *priv = self->priv;
GError *error;
gchar *path;
g_mutex_lock (&priv->mutex_download);
error = NULL;
path = photos_base_item_download (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_pointer (task, path, g_free);
out:
g_mutex_unlock (&priv->mutex_download);
}
static void
photos_base_item_load_in_thread_func (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemPrivate *priv = self->priv;
GeglNode *node;
GError *error = NULL;
g_mutex_lock (&priv->mutex);
node = photos_base_item_load (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_pointer (task, node, g_object_unref);
out:
g_mutex_unlock (&priv->mutex);
}
static void
photos_glib_file_copy_splice (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GOutputStream *ostream = G_OUTPUT_STREAM (source_object);
g_autoptr (GTask) task = G_TASK (user_data);
PhotosGLibFileCopyData *data;
data = (PhotosGLibFileCopyData *) g_task_get_task_data (task);
g_assert_true (G_IS_FILE_OUTPUT_STREAM (ostream));
g_assert_true (G_FILE_OUTPUT_STREAM (ostream) == data->ostream);
{
g_autoptr (GError) error = NULL;
g_output_stream_splice_finish (ostream, res, &error);
if (error != NULL)
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_task_return_pointer (task, g_object_ref (data->unique_file), g_object_unref);
out:
return;
}
static void
photos_base_item_create_thumbnail_in_thread_func (gpointer data, gpointer user_data)
{
GTask *task = G_TASK (data);
PhotosBaseItem *self;
GCancellable *cancellable;
GError *error;
gboolean op_res;
self = PHOTOS_BASE_ITEM (g_task_get_source_object (task));
cancellable = g_task_get_cancellable (task);
error = NULL;
op_res = PHOTOS_BASE_ITEM_GET_CLASS (self)->create_thumbnail (self, cancellable, &error);
if (error != NULL)
{
g_task_return_error (task, error);
goto out;
}
g_task_return_boolean (task, op_res);
out:
g_object_unref (task);
}
static void
photos_thumbnailer_generate_thumbnail_save_to_stream (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GCancellable *cancellable;
g_autoptr (GTask) task = G_TASK (user_data);
PhotosThumbnailerGenerateData *data;
cancellable = g_task_get_cancellable (task);
data = g_task_get_task_data (task);
{
g_autoptr (GError) error = NULL;
if (!gdk_pixbuf_save_to_stream_finish (res, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_output_stream_close_async (G_OUTPUT_STREAM (data->stream),
G_PRIORITY_DEFAULT,
cancellable,
photos_thumbnailer_generate_thumbnail_stream_close,
g_object_ref (task));
out:
return;
}
static void
on_get_user_id_ready (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GTask *task = G_TASK (user_data);
gpointer *info = g_task_get_source_object (task);
GClueClientInfoPrivate *priv = GCLUE_CLIENT_INFO (info)->priv;
GError *error = NULL;
GVariant *results = NULL;
results = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),
res,
&error);
if (results == NULL) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
g_assert (g_variant_n_children (results) > 0);
g_variant_get_child (results, 0, "u", &priv->user_id);
g_variant_unref (results);
g_dbus_proxy_call (priv->dbus_proxy,
"GetConnectionUnixProcessID",
g_variant_new ("(s)", priv->bus_name),
G_DBUS_CALL_FLAGS_NONE,
-1,
g_task_get_cancellable (task),
on_get_pid_ready,
task);
}
static void
gdav_options_request_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupRequestHTTP *request;
GTask *task = G_TASK (user_data);
AsyncContext *async_context;
GError *local_error = NULL;
request = SOUP_REQUEST_HTTP (source_object);
async_context = g_task_get_task_data (task);
gdav_request_send_finish (request, result, &local_error);
if (local_error == NULL) {
async_context->allow =
gdav_options_from_headers (
async_context->message->response_headers);
async_context->options =
gdav_options_from_headers (
async_context->message->response_headers);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_error (task, local_error);
}
g_object_unref (task);
}
static void
on_search_message_complete (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
g_autoptr(GTask) task = G_TASK (user_data);
source_search_closure *closure = g_task_get_task_data (task);
g_autoptr(GError) error = NULL;
GList *keys, *l;
seahorse_progress_end (closure->cancellable, message);
if (hkp_message_propagate_error (closure->source, message, &error)) {
g_task_return_error (task, g_steal_pointer (&error));
return;
}
keys = parse_hkp_index (message->response_body->data);
for (l = keys; l; l = g_list_next (l)) {
g_object_set (l->data, "place", closure->source, NULL);
gcr_simple_collection_add (closure->results, l->data);
}
g_list_free_full (keys, g_object_unref);
g_task_return_boolean (task, TRUE);
}
static void
cd_sensor_munki_sample_thread_cb (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
g_autoptr(GError) error = NULL;
CdSensor *sensor = CD_SENSOR (object);
// CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
/* no hardware support */
if (task->current_cap == CD_SENSOR_CAP_PROJECTOR) {
g_set_error_literal (&error, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"MUNKI cannot measure in projector mode");
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
goto out;
}
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
/* save result */
task->sample = cd_color_xyz_new ();
g_task_return_error (task, NULL);
out:
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
}
/**
* g_socket_listener_accept_socket_async:
* @listener: a #GSocketListener
* @cancellable: (allow-none): a #GCancellable, or %NULL
* @callback: (scope async): a #GAsyncReadyCallback
* @user_data: (closure): user data for the callback
*
* This is the asynchronous version of g_socket_listener_accept_socket().
*
* When the operation is finished @callback will be
* called. You can then call g_socket_listener_accept_socket_finish()
* to get the result of the operation.
*
* Since: 2.22
*/
void
g_socket_listener_accept_socket_async (GSocketListener *listener,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
GList *sources;
GError *error = NULL;
task = g_task_new (listener, cancellable, callback, user_data);
if (!check_listener (listener, &error))
{
g_task_return_error (task, error);
g_object_unref (task);
return;
}
sources = add_sources (listener,
accept_ready,
task,
cancellable,
g_main_context_get_thread_default ());
g_task_set_task_data (task, sources, (GDestroyNotify) free_sources);
}
static gboolean
accept_ready (GSocket *accept_socket,
GIOCondition condition,
gpointer user_data)
{
GTask *task = user_data;
GError *error = NULL;
GSocket *socket;
GObject *source_object;
socket = g_socket_accept (accept_socket, g_task_get_cancellable (task), &error);
if (socket)
{
source_object = g_object_get_qdata (G_OBJECT (accept_socket), source_quark);
if (source_object)
g_object_set_qdata_full (G_OBJECT (task),
source_quark,
g_object_ref (source_object), g_object_unref);
g_task_return_pointer (task, socket, g_object_unref);
}
else
{
g_task_return_error (task, error);
}
g_object_unref (task);
return FALSE;
}
static void
photos_fetch_ids_job_query_executed (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GCancellable *cancellable;
GTask *task = G_TASK (user_data);
TrackerSparqlConnection *connection = TRACKER_SPARQL_CONNECTION (source_object);
TrackerSparqlCursor *cursor; /* TODO: Use g_autoptr */
GError *error;
cancellable = g_task_get_cancellable (task);
error = NULL;
cursor = tracker_sparql_connection_query_finish (connection, res, &error);
if (error != NULL)
{
g_task_return_error (task, error);
return;
}
tracker_sparql_cursor_next_async (cursor,
cancellable,
photos_fetch_ids_job_cursor_next,
g_object_ref (task));
g_object_unref (cursor);
}
static void
populate_cache__get_local_makefile_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self = (IdeAutotoolsBuildSystem *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GFile) makefile = NULL;
IdeContext *context;
GError *error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_AUTOTOOLS_BUILD_SYSTEM (self));
g_assert (G_IS_TASK (task));
makefile = ide_autotools_build_system_get_local_makefile_finish (self, result, &error);
if (makefile == NULL)
{
g_task_return_error (task, error);
IDE_EXIT;
}
context = ide_object_get_context (IDE_OBJECT (self));
ide_makecache_new_for_makefile_async (context,
makefile,
g_task_get_cancellable (task),
populate_cache__new_makecache_cb,
g_object_ref (task));
IDE_EXIT;
}
static void
egg_task_cache_propagate_error (EggTaskCache *self,
gconstpointer key,
const GError *error)
{
GPtrArray *queued;
g_assert (EGG_IS_TASK_CACHE (self));
g_assert (error != NULL);
if ((queued = g_hash_table_lookup (self->queued, key)))
{
gint64 count = queued->len;
gsize i;
/* we can't use steal because we want the key freed */
g_ptr_array_ref (queued);
g_hash_table_remove (self->queued, key);
for (i = 0; i < queued->len; i++)
{
GTask *task;
task = g_ptr_array_index (queued, i);
g_task_return_error (task, g_error_copy (error));
}
g_ptr_array_unref (queued);
EGG_COUNTER_SUB (queued, count);
}
}
static void
ide_autotools_build_system_get_build_targets_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self = (IdeAutotoolsBuildSystem *)object;
g_autoptr(IdeMakecache) makecache = NULL;
g_autoptr(GTask) task = user_data;
GError *error = NULL;
g_assert (IDE_IS_AUTOTOOLS_BUILD_SYSTEM (self));
g_assert (G_IS_TASK (task));
makecache = ide_autotools_build_system_get_makecache_finish (self, result, &error);
if (makecache == NULL)
{
g_task_return_error (task, error);
return;
}
ide_makecache_get_build_targets_async (makecache,
g_task_get_cancellable (task),
ide_autotools_build_system_get_build_targets_cb2,
g_object_ref (task));
}
static void
on_dbus_proxy_ready (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GTask *task = G_TASK (user_data);
gpointer *info = g_task_get_source_object (task);
GClueClientInfoPrivate *priv = GCLUE_CLIENT_INFO (info)->priv;
GError *error = NULL;
priv->dbus_proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
if (priv->dbus_proxy == NULL) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
g_dbus_proxy_call (priv->dbus_proxy,
"GetConnectionUnixUser",
g_variant_new ("(s)", priv->bus_name),
G_DBUS_CALL_FLAGS_NONE,
-1,
g_task_get_cancellable (task),
on_get_user_id_ready,
task);
}
static void
discover_file_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self;
g_autoptr(GTask) task = user_data;
g_autoptr(GFile) file = NULL;
GError *error = NULL;
g_return_if_fail (G_IS_TASK (task));
self = g_task_get_source_object (task);
file = ide_autotools_build_system_discover_file_finish (self, result, &error);
if (!file)
{
g_task_return_error (task, error);
return;
}
g_object_set (self, "project-file", file, NULL);
ide_autotools_build_system_parse_async (self,
file,
g_task_get_cancellable (task),
parse_cb,
g_object_ref (task));
}
