static void cockpit_auth_none_login_async (CockpitAuth *self, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *task; task = g_simple_async_result_new (G_OBJECT (self), callback, user_data, cockpit_auth_none_login_async); g_simple_async_result_set_error (task, COCKPIT_ERROR, COCKPIT_ERROR_AUTHENTICATION_FAILED, "Authentication disabled"); g_simple_async_result_complete_in_idle (task); g_object_unref (task); }
static void abort_verification (EmpathyTLSVerifier *self, EmpTLSCertificateRejectReason reason) { EmpathyTLSVerifierPriv *priv = GET_PRIV (self); DEBUG ("Verification error %u, aborting...", reason); g_simple_async_result_set_error (priv->verify_result, G_IO_ERROR, reason, "TLS verification failed with reason %u", reason); g_simple_async_result_complete_in_idle (priv->verify_result); tp_clear_object (&priv->verify_result); }
static void connect_3gpp_context_complete_and_free (Connect3gppContext *ctx) { g_simple_async_result_complete_in_idle (ctx->result); g_object_unref (ctx->cancellable); g_object_unref (ctx->result); g_object_unref (ctx->modem); g_object_unref (ctx->self); g_clear_object (&ctx->data); g_clear_object (&ctx->primary); g_slice_free (Connect3gppContext, ctx); }
static gboolean guess_content_job(GIOSchedulerJob *job, GCancellable* cancellable, gpointer user_data) { GuessContentData* data = (GuessContentData*)user_data; char** content_types; GSimpleAsyncResult* res; content_types = g_content_type_guess_for_tree(data->root); res = g_simple_async_result_new(data->mnt, data->callback, data->user_data, NULL); g_simple_async_result_set_op_res_gpointer(res, content_types, g_strfreev); g_simple_async_result_complete_in_idle(res); g_object_unref(res); return FALSE; }
/* This function can be called in any thread */ void tracker_extract_file (TrackerExtract *extract, const gchar *file, const gchar *mimetype, const gchar *graph, GCancellable *cancellable, GAsyncReadyCallback cb, gpointer user_data) { GSimpleAsyncResult *res; GError *error = NULL; TrackerExtractTask *task; g_return_if_fail (TRACKER_IS_EXTRACT (extract)); g_return_if_fail (file != NULL); g_return_if_fail (cb != NULL); #ifdef THREAD_ENABLE_TRACE g_debug ("Thread:%p <-- '%s': Processing file\n", g_thread_self (), file); #endif /* THREAD_ENABLE_TRACE */ res = g_simple_async_result_new (G_OBJECT (extract), cb, user_data, NULL); task = extract_task_new (extract, file, mimetype, graph, cancellable, G_ASYNC_RESULT (res), &error); if (error) { g_warning ("Could not get mimetype, %s", error->message); g_simple_async_result_set_from_error (res, error); g_simple_async_result_complete_in_idle (res); g_error_free (error); } else { TrackerExtractPrivate *priv; priv = TRACKER_EXTRACT_GET_PRIVATE (task->extract); g_mutex_lock (&priv->task_mutex); priv->running_tasks = g_list_prepend (priv->running_tasks, task); g_mutex_unlock (&priv->task_mutex); g_idle_add ((GSourceFunc) dispatch_task_cb, task); } /* Task takes a ref and if this fails, we want to unref anyway */ g_object_unref (res); }
static void on_status_advertise_status_returned (TpYtsStatus *self, const GError *error, gpointer user_data, GObject *weak_object) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); if (error != NULL) { DEBUG ("Status.AdvertiseStatus failed: %s", error->message); g_simple_async_result_set_from_error (res, error); } g_simple_async_result_complete_in_idle (res); }
static void abort_verification(HevImpathyTLSVerifier *self, TpTLSCertificateRejectReason reason) { HevImpathyTLSVerifierPrivate *priv = HEV_IMPATHY_TLS_VERIFIER_GET_PRIVATE(self); g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); g_simple_async_result_set_error(priv->verify_result, G_IO_ERROR, reason, "TLS verification failed with reason %u", reason); g_simple_async_result_complete_in_idle(priv->verify_result); tp_clear_object(&priv->verify_result); }
static gboolean timeout_cb (gpointer user_data) { SpawnData *data = user_data; data->timed_out = TRUE; /* ok, timeout is history, make sure we don't free it in spawn_data_free() */ data->timeout_source = NULL; /* we're done */ g_simple_async_result_complete_in_idle (data->simple); g_object_unref (data->simple); return FALSE; /* remove source */ }
static void _pp_new_printer_add_async_cb (gboolean success, PpNewPrinter *printer) { PpNewPrinterPrivate *priv = printer->priv; if (!success) { g_simple_async_result_set_error (priv->res, G_IO_ERROR, G_IO_ERROR_FAILED, "Installation of the new printer failed."); } g_simple_async_result_set_op_res_gboolean (priv->res, success); g_simple_async_result_complete_in_idle (priv->res); }
static void find_file_insensitive_exists_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { GFileInfo *info; InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data); /* The file exists and can be found with the given path, no need to search. */ if ((info = g_file_query_info_finish (G_FILE (source_object), res, NULL))) { GSimpleAsyncResult *simple; simple = g_simple_async_result_new (G_OBJECT (data->root), data->callback, data->user_data, _g_find_file_insensitive_async); g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (source_object), g_object_unref); g_simple_async_result_complete_in_idle (simple); g_object_unref (simple); clear_find_file_insensitive_state (data); g_object_unref (info); } else { data->split_path = g_strsplit (data->original_path, G_DIR_SEPARATOR_S, -1); data->index = 0; data->enumerator = NULL; data->current_file = g_object_ref (data->root); /* Skip any empty components due to multiple slashes */ while (data->split_path[data->index] != NULL && *data->split_path[data->index] == 0) data->index++; g_file_enumerate_children_async (data->current_file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, G_PRIORITY_DEFAULT, data->cancellable, enumerated_children_callback, data); } g_object_unref (source_object); }
static gboolean pdp_qmi_real_statusUpdate_co (pdp_qmi_statusUpdateData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; default: g_assert_not_reached (); } _state_0: g_assert_not_reached (); if (_data_->_state_ == 0) { g_simple_async_result_complete_in_idle (_data_->_async_result); } else { g_simple_async_result_complete (_data_->_async_result); } g_object_unref (_data_->_async_result); return FALSE; }
static void disconnect_context_complete_and_free (DisconnectContext *ctx) { g_simple_async_result_complete_in_idle (ctx->result); g_object_unref (ctx->result); if (ctx->error_ipv4) g_error_free (ctx->error_ipv4); if (ctx->error_ipv6) g_error_free (ctx->error_ipv6); if (ctx->client_ipv4) g_object_unref (ctx->client_ipv4); if (ctx->client_ipv6) g_object_unref (ctx->client_ipv6); g_object_unref (ctx->data); g_object_unref (ctx->self); g_slice_free (DisconnectContext, ctx); }
static void g_unix_resolver_request_complete (GUnixResolverRequest *req) { if (req->cancellable) { g_signal_handlers_disconnect_by_func (req->cancellable, request_cancelled, req); g_object_unref (req->cancellable); req->cancellable = NULL; } /* We always complete_in_idle, even if we were called from * g_unix_resolver_watch(), since we might have been started under a * non-default g_main_context_get_thread_default(). */ g_simple_async_result_complete_in_idle (req->async_result); g_object_unref (req->async_result); }
static void mail_config_page_submit (EMailConfigPage *page, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; simple = g_simple_async_result_new ( G_OBJECT (page), callback, user_data, mail_config_page_submit); g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_complete_in_idle (simple); g_object_unref (simple); }
static gboolean pdp_qmi_real_sc_deactivate_co (PdpQmiScDeactivateData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; default: g_assert_not_reached (); } _state_0: _data_->_tmp0_ = _data_->self->fd; write (_data_->_tmp0_, "down", (gsize) 5); if (_data_->_state_ == 0) { g_simple_async_result_complete_in_idle (_data_->_async_result); } else { g_simple_async_result_complete (_data_->_async_result); } g_object_unref (_data_->_async_result); return FALSE; }
static gboolean vibrator_timed_outputclass_real_stop_co (VibratorTimedOutputclassStopData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; default: g_assert_not_reached (); } _state_0: vibrator_timed_outputclass_cleanTimeouts (_data_->self); vibrator_timed_outputclass_set_enable (_data_->self, 0); if (_data_->_state_ == 0) { g_simple_async_result_complete_in_idle (_data_->_async_result); } else { g_simple_async_result_complete (_data_->_async_result); } g_object_unref (_data_->_async_result); return FALSE; }
static void _upload_file_progress_cb (DBusGProxy *proxy, gint opid, gint progress, const char *error_message, gpointer userdata) { SwClientServiceCallClosure *closure = (SwClientServiceCallClosure *) userdata; if (opid != closure->opid) { /* Ignore, that's not our upload */ return; } if (progress == -1) { g_simple_async_report_error_in_idle (G_OBJECT (closure->service), (GAsyncReadyCallback) closure->cb, closure->userdata, SW_CLIENT_SERVICE_ERROR, 0, error_message); g_object_unref (closure->service); g_slice_free (SwClientServiceCallClosure, closure); return; } (closure->progress_cb) ((float) progress * closure->filesize, closure->filesize, closure->progress_cb_data); if (progress == 100) { GSimpleAsyncResult *res; res = g_simple_async_result_new (G_OBJECT (closure->service), (GAsyncReadyCallback) closure->cb, closure->userdata, closure->iface == PHOTO_UPLOAD_IFACE ? sw_client_service_upload_photo : sw_client_service_upload_video); g_simple_async_result_set_op_res_gboolean (res, TRUE); g_simple_async_result_complete_in_idle (res); g_object_unref (res); g_object_unref (closure->service); g_slice_free (SwClientServiceCallClosure, closure); } }
void nemo_connect_server_dialog_display_location_async (NemoConnectServerDialog *self, GFile *location, GAsyncReadyCallback callback, gpointer user_data) { GError *error; GdkAppLaunchContext *launch_context; gchar *uri; display_location_res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, nemo_connect_server_dialog_display_location_async); error = NULL; uri = g_file_get_uri (location); if (just_print_uri) { g_print ("%s\n", uri); } else { launch_context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (self))); gdk_app_launch_context_set_screen (launch_context, gtk_widget_get_screen (GTK_WIDGET (self))); g_app_info_launch_default_for_uri (uri, G_APP_LAUNCH_CONTEXT (launch_context), &error); g_object_unref (launch_context); } if (error != NULL) { g_simple_async_result_set_from_error (display_location_res, error); g_error_free (error); } g_simple_async_result_complete_in_idle (display_location_res); g_free (uri); g_object_unref (display_location_res); display_location_res = NULL; }
static void tls_certificate_prepared_cb (GObject *source, GAsyncResult *result, gpointer user_data) { TpTLSCertificate *certificate = TP_TLS_CERTIFICATE (source); EmpathyServerTLSHandler *self = user_data; GError *error = NULL; EmpathyServerTLSHandlerPriv *priv = GET_PRIV (self); if (!tp_proxy_prepare_finish (certificate, result, &error)) { g_simple_async_result_set_from_error (priv->async_init_res, error); g_error_free (error); } g_simple_async_result_complete_in_idle (priv->async_init_res); tp_clear_object (&priv->async_init_res); }
static void on_ca_play_full_finished(ca_context *ca, guint32 id, int error_code, gpointer user_data) { GSimpleAsyncResult *result = user_data; if (error_code != CA_SUCCESS) { g_simple_async_result_set_error(result, GSOUND_ERROR, error_code, ca_strerror(error_code)); } g_simple_async_result_complete_in_idle (result); g_object_unref(result); }
static gboolean deja_dup_backend_real_get_envp_co (DejaDupBackendGetEnvpData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; default: g_assert_not_reached (); } _state_0: _data_->_tmp0_ = NULL; g_signal_emit_by_name (_data_->self, "envp-ready", TRUE, _data_->_tmp0_, NULL); __g_list_free__g_free0_0 (_data_->_tmp0_); if (_data_->_state_ == 0) { g_simple_async_result_complete_in_idle (_data_->_async_result); } else { g_simple_async_result_complete (_data_->_async_result); } g_object_unref (_data_->_async_result); return FALSE; }
void empathy_account_set_enabled_async (EmpathyAccount *account, gboolean enabled, GAsyncReadyCallback callback, gpointer user_data) { EmpathyAccountPriv *priv = GET_PRIV (account); EmpathyAccountManager *acc_manager; GValue value = {0, }; GSimpleAsyncResult *result = g_simple_async_result_new (G_OBJECT (account), callback, user_data, empathy_account_set_enabled_finish); char *status = NULL; char *status_message = NULL; TpConnectionPresenceType presence; if (priv->enabled == enabled) { g_simple_async_result_complete_in_idle (result); return; } if (enabled) { acc_manager = empathy_account_manager_dup_singleton (); presence = empathy_account_manager_get_requested_global_presence (acc_manager, &status, &status_message); if (presence != TP_CONNECTION_PRESENCE_TYPE_UNSET) empathy_account_request_presence (account, presence, status, status_message); g_object_unref (acc_manager); g_free (status); g_free (status_message); } g_value_init (&value, G_TYPE_BOOLEAN); g_value_set_boolean (&value, enabled); tp_cli_dbus_properties_call_set (TP_PROXY (priv->account), -1, TP_IFACE_ACCOUNT, "Enabled", &value, account_enabled_set_cb, result, NULL, G_OBJECT (account)); }
static void gb_project_format_real_open_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GSimpleAsyncResult *simple = user_data; const gchar *directory; JsonParser *parser = (JsonParser *)object; JsonNode *root; GObject *project; GError *error = NULL; ENTRY; g_assert(JSON_IS_PARSER(parser)); g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple)); if (!json_parser_load_from_stream_finish(parser, result, &error)) { g_simple_async_result_take_error(simple, error); GOTO(failure); } root = json_parser_get_root(parser); g_assert(root); if (!(project = json_gobject_deserialize(GB_TYPE_PROJECT, root))) { g_simple_async_result_set_error(simple, GB_PROJECT_FORMAT_ERROR, GB_PROJECT_FORMAT_ERROR_INVALID_JSON, _("Failed to deserialize from JSON.")); GOTO(failure); } directory = g_object_get_data(G_OBJECT(simple), "directory"); g_object_set(project, "directory", directory, NULL); g_simple_async_result_set_op_res_gpointer(simple, project, g_object_unref); failure: g_simple_async_result_complete_in_idle(simple); g_object_unref(simple); EXIT; }
static void on_export_message_complete (SoupSession *session, SoupMessage *message, gpointer user_data) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); ExportClosure *closure = g_simple_async_result_get_op_res_gpointer (res); GError *error = NULL; const gchar *start; const gchar *end; const gchar *text; guint len; seahorse_progress_end (closure->cancellable, message); if (hkp_message_propagate_error (closure->source, message, &error)) { g_simple_async_result_take_error (res, error); } else { end = text = message->response_body->data; len = message->response_body->length; for (;;) { len -= end - text; text = end; if (!detect_key (text, len, &start, &end)) break; g_string_append_len (closure->data, start, end - start); g_string_append_c (closure->data, '\n'); } } g_assert (closure->requests > 0); closure->requests--; if (closure->requests == 0) g_simple_async_result_complete_in_idle (res); g_object_unref (res); }
void gclue_locator_stop (GClueLocator *locator, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; g_return_if_fail (GCLUE_IS_LOCATOR (locator)); gclue_locator_stop_sync (locator); simple = g_simple_async_result_new (G_OBJECT (locator), callback, user_data, gclue_locator_stop); g_simple_async_result_complete_in_idle (simple); g_object_unref (simple); }
/** * pk_package_sack_merge_bool_state_finish: **/ static void pk_package_sack_merge_bool_state_finish (PkPackageSackState *state, const GError *error) { /* get result */ if (state->ret) { g_simple_async_result_set_op_res_gboolean (state->res, state->ret); } else { g_simple_async_result_set_from_error (state->res, error); } /* complete */ g_simple_async_result_complete_in_idle (state->res); /* deallocate */ if (state->cancellable != NULL) g_object_unref (state->cancellable); g_object_unref (state->res); g_object_unref (state->sack); g_slice_free (PkPackageSackState, state); }
static void port_probe_run_task_complete (PortProbeRunTask *task, gboolean result, GError *error) { /* As soon as we have the task completed, disable the buffer-full signal * handling, so that we do not get unwanted errors reported */ if (task->buffer_full_id) { g_source_remove (task->buffer_full_id); task->buffer_full_id = 0; } if (error) g_simple_async_result_take_error (task->result, error); else g_simple_async_result_set_op_res_gboolean (task->result, result); /* Always complete in idle */ g_simple_async_result_complete_in_idle (task->result); }
static gboolean http_client_check_data_free (gpointer user_data) { CheckData *data = user_data; g_simple_async_result_complete_in_idle (data->res); if (data->cancellable_id > 0) { g_cancellable_disconnect (data->cancellable, data->cancellable_id); g_object_unref (data->cancellable); } /* soup_session_queue_message stole the references to data->msg */ g_object_unref (data->res); g_object_unref (data->session); g_slice_free (CheckData, data); return G_SOURCE_REMOVE; }
static void _get_properties_cb (GObject *obj, GAsyncResult *res, gpointer user_data) { MtnConnman *connman; GError *error; GVariant *var; InitData *data; connman = MTN_CONNMAN (obj); data = (InitData*)user_data; error = NULL; var = g_dbus_proxy_call_finish (G_DBUS_PROXY (obj), res, &error); if (!var) { g_warning ("Initial Service.GetProperties() failed: %s\n", error->message); g_error_free (error); } else { GVariant *value; char *key; GVariantIter *iter; g_variant_get (var, "(a{sv})", &iter); while (g_variant_iter_next (iter, "{sv}", &key, &value)) { g_hash_table_insert (connman->priv->properties, key, value); } g_variant_iter_free (iter); g_variant_unref (var); } if (data->done_services) { g_simple_async_result_complete_in_idle (data->res); g_object_unref (data->res); g_free (data); } else { data->done_props = TRUE; } }
static void execute_cancelled_cb (GCancellable *cancellable, gpointer user_data) { ExecuteData *exec_data = user_data; FrProcess *process = exec_data->process; if (! process->priv->running) return; if (process->priv->stopping) return; process->priv->stopping = TRUE; exec_data->error = fr_error_new (FR_ERROR_STOPPED, 0, NULL); if (command_is_sticky (process, process->priv->current_command)) allow_sticky_processes_only (exec_data); else if (process->priv->command_pid > 0) killpg (process->priv->command_pid, SIGTERM); else { if (process->priv->check_timeout != 0) { g_source_remove (process->priv->check_timeout); process->priv->check_timeout = 0; } process->priv->command_pid = 0; fr_channel_data_close_source (&process->out); fr_channel_data_close_source (&process->err); process->priv->running = FALSE; if (exec_data->cancel_id != 0) { g_signal_handler_disconnect (exec_data->cancellable, exec_data->cancel_id); exec_data->cancel_id = 0; } g_simple_async_result_complete_in_idle (exec_data->result); } }