static void fetch_items(GTask* task, gpointer source, gpointer task_data, GCancellable* cancel) { g_assert(GT_IS_SEARCH_GAME_CONTAINER(source)); GtSearchGameContainer* self = GT_SEARCH_GAME_CONTAINER(source); GtSearchGameContainerPrivate* priv = gt_search_game_container_get_instance_private(self); g_assert(G_IS_CANCELLABLE(cancel)); g_assert(G_IS_TASK(task)); if (g_task_return_error_if_cancelled(task)) return; if (utils_str_empty(priv->query)) { g_task_return_pointer(task, NULL, NULL); return; } g_assert_nonnull(task_data); FetchItemsData* data = task_data; g_mutex_lock(&priv->mutex); gint64 end_time = g_get_monotonic_time() + SEARCH_DELAY; g_cancellable_connect(cancel, G_CALLBACK(cancelled_cb), self, NULL); while (!g_cancellable_is_cancelled(cancel)) { if (!g_cond_wait_until(&priv->cond, &priv->mutex, end_time)) { /* We weren't cancelled */ g_assert(!utils_str_empty(priv->query)); GError* err = NULL; GList* items = data->offset == 0 ? gt_twitch_search_games(main_app->twitch, priv->query, data->amount, data->offset, &err) : NULL; if (err) g_task_return_error(task, err); else g_task_return_pointer(task, items, (GDestroyNotify) gt_game_list_free); g_mutex_unlock(&priv->mutex); return; } } /* We were cancelled */ g_assert(g_task_return_error_if_cancelled(task)); g_mutex_unlock(&priv->mutex); }
static void taskThread(GTask * task, gpointer source, gpointer taskData, GCancellable * cancellable) { TaskData *td = taskData; gchar *q = g_uri_escape_string(td->src, NULL, TRUE); gchar *target = g_strdup_printf(TARGET_URL, wl_dict_lang_get_phrase(td->from), wl_dict_lang_get_phrase(td->to), q); g_free(q); SoupMessage *msg = soup_message_new("GET", target); if (msg == NULL) { GError *error = g_error_new(G_IO_ERROR, 2, "failed to parse URL %s", target); g_free(target); g_task_return_error(task, error); return; } g_free(target); static SoupSession *session = NULL; if (session == NULL) { session = soup_session_new(); } if (g_task_return_error_if_cancelled(task)) { g_object_unref(msg); return; } guint status = soup_session_send_message(session, msg); if (!SOUP_STATUS_IS_SUCCESSFUL(status)) { g_object_unref(msg); g_task_return_new_error(task, G_IO_ERROR, status, "%s", soup_status_get_phrase(status)); return; } if (g_task_return_error_if_cancelled(task)) { g_object_unref(msg); return; } SoupMessageBody *body = NULL; g_object_get(msg, "response-body", &body, NULL); gchar *responseBody = g_strdup(body->data); g_object_unref(msg); g_task_return_pointer(task, responseBody, g_free); }
static void search_providers_discover_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { GList *providers = NULL; const gchar * const *system_data_dirs; int idx; system_data_dirs = g_get_system_data_dirs (); for (idx = 0; system_data_dirs[idx] != NULL; idx++) { providers = g_list_concat (search_providers_discover_one_directory (system_data_dirs[idx], cancellable), providers); if (g_task_return_error_if_cancelled (task)) { g_list_free_full (providers, g_object_unref); return; } } g_task_return_pointer (task, providers, NULL); }
static void get_libproxy_proxies (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { GLibProxyResolver *resolver = source_object; const gchar *uri = task_data; GError *error = NULL; gchar **proxies; if (g_task_return_error_if_cancelled (task)) return; proxies = px_proxy_factory_get_proxies (resolver->factory, uri); if (proxies) { /* We always copy to be able to translate "socks" entry into * three entries ("socks5", "socks4a", "socks4"). */ g_task_return_pointer (task, copy_proxies (proxies), (GDestroyNotify) g_strfreev); free_libproxy_proxies (proxies); } else { g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Proxy resolver internal error.")); g_task_return_error (task, error); } }
static void create_tmp_file_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GbBeautifierWorkbenchAddin *self = (GbBeautifierWorkbenchAddin *)object; g_autoptr (GTask) task = (GTask *)user_data; g_autoptr(GError) error = NULL; ProcessState *state; GSubprocess *process; GCancellable *cancellable; g_assert (GB_IS_BEAUTIFIER_WORKBENCH_ADDIN (self)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (G_IS_TASK (task)); state = (ProcessState *)g_task_get_task_data (task); if (NULL == (state->src_file = gb_beautifier_helper_create_tmp_file_finish (self, result, &error))) goto fail; if (state->command == GB_BEAUTIFIER_CONFIG_COMMAND_CLANG_FORMAT) process = gb_beautifier_process_create_for_clang_format (self, state, error); else process = gb_beautifier_process_create_generic (self, state, error); if (process != NULL) { if (g_task_return_error_if_cancelled (task)) g_object_unref (process); else { cancellable = g_task_get_cancellable (task); g_subprocess_communicate_utf8_async (process, NULL, cancellable, process_communicate_utf8_cb, g_steal_pointer (&task)); } return; } fail: g_task_return_error (task, g_steal_pointer (&error)); return; }
static void mail_printer_load_changed_cb (WebKitWebView *web_view, WebKitLoadEvent load_event, GTask *task) { AsyncContext *async_context; /* Note: we disregard WEBKIT_LOAD_FAILED and print what we can. */ if (load_event != WEBKIT_LOAD_FINISHED) return; async_context = g_task_get_task_data (task); g_return_if_fail (async_context != NULL); /* WebKit reloads the page once more right before starting to print, * so disconnect this handler after the first time to avoid starting * another print operation. */ g_signal_handler_disconnect ( async_context->web_view, async_context->load_status_handler_id); async_context->load_status_handler_id = 0; /* Check if we've been cancelled. */ if (g_task_return_error_if_cancelled (task)) { return; } else { GSource *timeout_source; /* Give WebKit some time to perform layouting and rendering before * we start printing. 500ms should be enough in most cases. */ timeout_source = g_timeout_source_new (500); g_task_attach_source ( task, timeout_source, (GSourceFunc) mail_printer_print_timeout_cb); g_source_unref (timeout_source); } }
static void watch_smartcards_from_driver (GTask *task, GsdSmartcardManager *self, WatchSmartcardsOperation *operation, GCancellable *cancellable) { g_debug ("watching for smartcard events"); while (!g_cancellable_is_cancelled (cancellable)) { gboolean watch_succeeded; GError *error = NULL; watch_succeeded = watch_one_event_from_driver (self, operation, cancellable, &error); if (g_task_return_error_if_cancelled (task)) { break; } if (!watch_succeeded) { g_task_return_error (task, error); break; } } }
static void process_communicate_utf8_cb (GObject *object, GAsyncResult *result, gpointer user_data) { g_autoptr (GSubprocess) process = (GSubprocess *)object; g_autoptr (GTask) task = (GTask *)user_data; g_autofree gchar *stdout_str = NULL; g_autofree gchar *stderr_str = NULL; g_autoptr(GError) error = NULL; GtkSourceCompletion *completion; GtkTextBuffer *buffer; GtkTextIter begin; GtkTextIter end; ProcessState *state; gboolean status; g_assert (G_IS_SUBPROCESS (process)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (G_IS_TASK (task)); if (!g_subprocess_communicate_utf8_finish (process, result, &stdout_str, &stderr_str, &error)) { g_task_return_error (task, g_steal_pointer (&error)); return; } if (g_task_return_error_if_cancelled (task)) return; state = (ProcessState *)g_task_get_task_data (task); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (state->source_view)); completion = gtk_source_view_get_completion (GTK_SOURCE_VIEW (state->source_view)); if (!ide_str_empty0 (stdout_str)) { gtk_source_completion_block_interactive (completion); gtk_text_buffer_begin_user_action (buffer); gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark); gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark); gtk_text_buffer_delete (buffer, &begin, &end); gtk_text_buffer_insert (buffer, &begin, stdout_str, -1); /* Get valid iters from marks */ gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark); gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark); gtk_text_buffer_select_range (buffer, &begin, &end); g_signal_emit_by_name (state->source_view, "selection-theatric", IDE_SOURCE_VIEW_THEATRIC_EXPAND); gtk_text_buffer_end_user_action (buffer); gtk_source_completion_unblock_interactive (completion); g_task_return_boolean (task, TRUE); } else g_warning ("beautify plugin: output empty"); if (g_subprocess_get_if_exited (process)) { status = g_subprocess_get_exit_status (process); if (status != 0 && stderr_str != NULL && !ide_str_empty0 (stderr_str)) { g_warning ("beautify plugin stderr:\n%s", stderr_str); } } }