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 ide_autotools_build_system_discover_file_worker (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { GFile *file = task_data; GFile *parent; g_assert (G_IS_TASK (task)); g_assert (G_IS_FILE (file)); g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); if (is_configure (file) && g_file_query_exists (file, cancellable)) { g_task_return_pointer (task, g_object_ref (file), g_object_unref); return; } parent = g_object_ref (file); while (parent != NULL) { GFile *child; GFile *tmp; child = g_file_get_child (parent, "configure.ac"); if (g_file_query_exists (child, cancellable)) { g_task_return_pointer (task, g_object_ref (child), g_object_unref); g_clear_object (&child); g_clear_object (&parent); return; } child = g_file_get_child (parent, "configure.in"); if (g_file_query_exists (child, cancellable)) { g_task_return_pointer (task, g_object_ref (child), g_object_unref); g_clear_object (&child); g_clear_object (&parent); return; } g_clear_object (&child); tmp = parent; parent = g_file_get_parent (parent); g_clear_object (&tmp); } g_clear_object (&parent); g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Failed to locate configure.ac")); }
void ide_file_load_settings_async (IdeFile *self, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_autoptr(GTask) task = NULL; g_autoptr(IdeFileSettings) file_settings = NULL; IDE_ENTRY; g_return_if_fail (IDE_IS_FILE (self)); g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable)); task = g_task_new (self, cancellable, callback, user_data); /* Use shared instance if available */ if (self->file_settings != NULL) { g_task_return_pointer (task, g_object_ref (self->file_settings), g_object_unref); IDE_EXIT; } /* Create our new settings instance, races are okay */ file_settings = ide_file_settings_new (self); /* If this is settled immediately (not using editorconfig), then we can use this now * and cache the result for later */ if (ide_file_settings_get_settled (file_settings)) { self->file_settings = g_steal_pointer (&file_settings); g_task_return_pointer (task, g_object_ref (self->file_settings), g_object_unref); IDE_EXIT; } /* * We need to wait until the settings have settled. editorconfig may need to * background load a bunch of .editorconfig files off of disk/sshfs/etc to * determine the settings. */ g_signal_connect (file_settings, "notify::settled", G_CALLBACK (ide_file__file_settings_settled_cb), g_object_ref (task)); g_task_set_task_data (task, g_steal_pointer (&file_settings), g_object_unref); IDE_EXIT; }
static void do_lookup_by_name (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { const char *hostname = task_data; struct addrinfo *res = NULL; GList *addresses; gint retval; retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res); if (retval == 0) { struct addrinfo *ai; GSocketAddress *sockaddr; GInetAddress *addr; addresses = NULL; for (ai = res; ai; ai = ai->ai_next) { sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen); if (!sockaddr || !G_IS_INET_SOCKET_ADDRESS (sockaddr)) continue; addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr)); addresses = g_list_prepend (addresses, addr); g_object_unref (sockaddr); } if (addresses != NULL) { addresses = g_list_reverse (addresses); g_task_return_pointer (task, addresses, (GDestroyNotify)g_resolver_free_addresses); } else { /* All addresses failed to be converted to GSocketAddresses. */ g_task_return_new_error (task, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, _("Error resolving '%s': %s"), hostname, _("No valid addresses were found")); } } else { g_task_return_new_error (task, G_RESOLVER_ERROR, g_resolver_error_from_addrinfo_error (retval), _("Error resolving '%s': %s"), hostname, gai_strerror (retval)); } if (res) freeaddrinfo (res); }
static void do_sparql_query_async_cursor_cb (GObject *const object, GAsyncResult *const result, GTask *const task) { g_autoptr(GError) error = NULL; SparqlQueryWork *const work = sparql_query_work_get (task); TrackerSparqlConnection *const conn = work->connection; TrackerSparqlCursor *const cur = tracker_sparql_connection_query_finish ( conn, result, &error ); if (error) { g_task_return_error (task, g_error_copy (error)); return; } g_task_return_pointer (task, cur, g_object_unref); }
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_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 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 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 gpointer ide_git_buffer_change_monitor_worker (gpointer data) { GAsyncQueue *queue = data; GTask *task; g_assert (queue); while ((task = g_async_queue_pop (queue))) { IdeGitBufferChangeMonitor *self; DiffTask *diff; GError *error = NULL; self = g_task_get_source_object (task); diff = g_task_get_task_data (task); if (!ide_git_buffer_change_monitor_calculate_threaded (self, diff, &error)) g_task_return_error (task, error); else g_task_return_pointer (task, g_hash_table_ref (diff->state), (GDestroyNotify)g_hash_table_unref); g_object_unref (task); } return NULL; }
static gboolean cd_sensor_get_sample_wait_cb (GTask *task) { CdSensor *sensor = CD_SENSOR (g_task_get_source_object (task)); CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (sensor); CdColorXYZ *sample = NULL; g_autoptr(GError) error = NULL; /* never setup */ if (priv->transform_fake == NULL) { g_task_return_new_error (task, CD_SENSOR_ERROR, CD_SENSOR_ERROR_NO_SUPPORT, "no fake transfor set up"); return G_SOURCE_REMOVE; } /* run the sample through the profile */ sample = cd_color_xyz_new (); cmsDoTransform (priv->transform_fake, &priv->sample_fake, sample, 1); /* emulate */ cd_sensor_button_pressed (sensor); /* just return without a problem */ g_task_return_pointer (task, sample, (GDestroyNotify) cd_color_xyz_free); return G_SOURCE_REMOVE; }
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 photos_single_item_job_cursor_next (GObject *source_object, GAsyncResult *res, gpointer user_data) { GTask *task = G_TASK (user_data); TrackerSparqlCursor *cursor = TRACKER_SPARQL_CURSOR (source_object); GDestroyNotify result_destroy = NULL; GError *error; gboolean success; gpointer result = NULL; error = NULL; /* Note that tracker_sparql_cursor_next_finish can return FALSE even * without an error. */ success = tracker_sparql_cursor_next_finish (cursor, res, &error); if (error != NULL) { g_task_return_error (task, error); goto out; } if (success) { result = g_object_ref (cursor); result_destroy = g_object_unref; } g_task_return_pointer (task, result, result_destroy); out: g_object_unref (task); }
static void realm_samba_provider_discover_async (RealmProvider *provider, const gchar *string, GVariant *options, GDBusMethodInvocation *invocation, GAsyncReadyCallback callback, gpointer user_data) { GTask *task; task = g_task_new (provider, NULL, callback, user_data); if (!realm_provider_match_software (options, REALM_DBUS_IDENTIFIER_ACTIVE_DIRECTORY, REALM_DBUS_IDENTIFIER_WINBIND, REALM_DBUS_IDENTIFIER_SAMBA)) { g_task_return_pointer (task, NULL, NULL); } else { realm_disco_domain_async (string, invocation, on_ad_discover, g_object_ref (task)); } g_object_unref (task); }
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 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 egg_task_cache_propagate_pointer (EggTaskCache *self, gconstpointer key, gpointer value) { GPtrArray *queued = NULL; g_assert (EGG_IS_TASK_CACHE (self)); if ((queued = g_hash_table_lookup (self->queued, key))) { gint64 count = queued->len; gsize i; 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_pointer (task, self->value_copy_func (value), self->value_destroy_func); } g_ptr_array_unref (queued); EGG_COUNTER_SUB (queued, count); } }
static void load_operator_identifier_ready (QmiClientNas *client, GAsyncResult *res, GTask *task) { guint16 mcc, mnc; gboolean mnc_with_pcs; GError *error = NULL; GString *aux; if (!get_home_network (client, res, &mcc, &mnc, &mnc_with_pcs, NULL, &error)) { g_task_return_error (task, error); g_object_unref (task); return; } aux = g_string_new (""); /* MCC always 3 digits */ g_string_append_printf (aux, "%.3" G_GUINT16_FORMAT, mcc); /* Guess about MNC, if < 100 assume it's 2 digits, no PCS info here */ if (mnc >= 100 || mnc_with_pcs) g_string_append_printf (aux, "%.3" G_GUINT16_FORMAT, mnc); else g_string_append_printf (aux, "%.2" G_GUINT16_FORMAT, mnc); g_task_return_pointer (task, g_string_free (aux, FALSE), (GDestroyNotify) g_free); g_object_unref (task); }
static void parse_xml_worker (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { DspyIntrospectionModel *self = source_object; GBytes *bytes = task_data; g_autoptr(GError) error = NULL; DspyNodeInfo *info; const gchar *xml; g_assert (G_IS_TASK (task)); g_assert (DSPY_IS_INTROSPECTION_MODEL (source_object)); g_assert (bytes != NULL); g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); xml = (const gchar *)g_bytes_get_data (bytes, NULL); g_mutex_lock (&self->chunks_mutex); info = _dspy_node_parse (xml, self->chunks, &error); g_mutex_unlock (&self->chunks_mutex); if (info != NULL) g_task_return_pointer (task, info, (GDestroyNotify) _dspy_node_free); else g_task_return_error (task, g_steal_pointer (&error)); }
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); }
void WebSoupRequestManager::didHandleURIRequest(const IPC::DataReference& requestData, uint64_t contentLength, const String& mimeType, uint64_t requestID) { WebSoupRequestAsyncData* data = m_requestMap.get(requestID); ASSERT(data); GRefPtr<GTask> task = data->releaseTask(); ASSERT(task.get()); WebKitSoupRequestGeneric* request = WEBKIT_SOUP_REQUEST_GENERIC(g_task_get_source_object(task.get())); webkitSoupRequestGenericSetContentLength(request, contentLength ? contentLength : -1); webkitSoupRequestGenericSetContentType(request, !mimeType.isEmpty() ? mimeType.utf8().data() : 0); GInputStream* dataStream; if (!requestData.size()) { // Empty reply, just create and empty GMemoryInputStream. dataStream = g_memory_input_stream_new(); m_requestMap.remove(requestID); } else if (requestData.size() == contentLength) { // We don't expect more data, so we can just create a GMemoryInputStream with all the data. dataStream = g_memory_input_stream_new_from_data(g_memdup(requestData.data(), requestData.size()), contentLength, g_free); m_requestMap.remove(requestID); } else { // We expect more data chunks from the UI process. dataStream = webkitSoupRequestInputStreamNew(contentLength); data->stream = dataStream; webkitSoupRequestInputStreamAddData(WEBKIT_SOUP_REQUEST_INPUT_STREAM(dataStream), requestData.data(), requestData.size()); } g_task_return_pointer(task.get(), dataStream, g_object_unref); }
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 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 gdav_propfind_request_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { SoupRequestHTTP *request; GTask *task = G_TASK (user_data); SoupURI *base_uri; gpointer parsable; guint status_code; AsyncContext *async_context; GError *local_error = NULL; request = SOUP_REQUEST_HTTP (source_object); async_context = g_task_get_task_data (task); status_code = async_context->message->status_code; gdav_request_send_finish (request, result, &local_error); if (local_error != NULL) goto exit; if (status_code != SOUP_STATUS_MULTI_STATUS) { g_task_return_new_error ( task, GDAV_PARSABLE_ERROR, GDAV_PARSABLE_ERROR_INTERNAL, _("Expected status %u (%s), but got (%u) (%s)"), SOUP_STATUS_MULTI_STATUS, soup_status_get_phrase (SOUP_STATUS_MULTI_STATUS), async_context->message->status_code, async_context->message->reason_phrase); goto exit; } base_uri = soup_message_get_uri (async_context->message); parsable = gdav_parsable_new_from_data ( GDAV_TYPE_MULTI_STATUS, base_uri, async_context->message->response_body->data, async_context->message->response_body->length, &local_error); /* Sanity check */ g_warn_if_fail ( ((parsable != NULL) && (local_error == NULL)) || ((parsable == NULL) && (local_error != NULL))); if (parsable != NULL) { g_warn_if_fail (GDAV_IS_MULTI_STATUS (parsable)); g_task_return_pointer (task, parsable, g_object_unref); } exit: if (local_error != NULL) g_task_return_error (task, local_error); g_object_unref (task); }
static void gdk_clipboard_read_local_async (GdkClipboard *clipboard, GdkContentFormats *formats, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GdkClipboardPrivate *priv = gdk_clipboard_get_instance_private (clipboard); GdkContentFormats *content_formats; const char *mime_type; GTask *task; task = g_task_new (clipboard, cancellable, callback, user_data); g_task_set_priority (task, io_priority); g_task_set_source_tag (task, gdk_clipboard_read_local_async); if (priv->content == NULL) { g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Cannot read from empty clipboard.")); g_object_unref (task); return; } content_formats = gdk_content_provider_ref_formats (priv->content); content_formats = gdk_content_formats_union_serialize_mime_types (content_formats); mime_type = gdk_content_formats_match_mime_type (content_formats, formats); if (mime_type != NULL) { GOutputStream *output_stream; GIOStream *stream; stream = gdk_pipe_io_stream_new (); output_stream = g_io_stream_get_output_stream (stream); gdk_clipboard_write_async (clipboard, mime_type, output_stream, io_priority, cancellable, gdk_clipboard_read_local_write_done, g_object_ref (output_stream)); g_task_set_task_data (task, (gpointer) mime_type, NULL); g_task_return_pointer (task, g_object_ref (g_io_stream_get_input_stream (stream)), g_object_unref); g_object_unref (stream); } else { g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, _("No compatible formats to transfer clipboard contents.")); } gdk_content_formats_unref (content_formats); g_object_unref (task); }
/** * ide_clang_service_get_translation_unit_async: * * This function is used to asynchronously retrieve the translation unit for * a particular file. * * If the translation unit is up to date, then no parsing will occur and the * existing translation unit will be used. * * If the translation unit is out of date, then the source file(s) will be * parsed via clang_parseTranslationUnit() asynchronously. */ void ide_clang_service_get_translation_unit_async (IdeClangService *self, IdeFile *file, gint64 min_serial, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { IdeClangTranslationUnit *cached; g_autoptr(GTask) task = NULL; g_return_if_fail (IDE_IS_CLANG_SERVICE (self)); g_return_if_fail (IDE_IS_FILE (file)); g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable)); task = g_task_new (self, cancellable, callback, user_data); /* * Clang likes to crash on our temporary files. */ if (ide_file_get_is_temporary (file)) { g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "File does not yet exist, ignoring translation unit request."); return; } if (min_serial == 0) { IdeContext *context; IdeUnsavedFiles *unsaved_files; context = ide_object_get_context (IDE_OBJECT (self)); unsaved_files = ide_context_get_unsaved_files (context); min_serial = ide_unsaved_files_get_sequence (unsaved_files); } /* * If we have a cached unit, and it is new enough, then re-use it. */ if ((cached = egg_task_cache_peek (self->units_cache, file)) && (ide_clang_translation_unit_get_serial (cached) >= min_serial)) { g_task_return_pointer (task, g_object_ref (cached), g_object_unref); return; } egg_task_cache_get_async (self->units_cache, file, TRUE, cancellable, ide_clang_service_get_translation_unit_cb, g_object_ref (task)); }
static void do_lookup_records (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { LookupRecordsData *lrd = task_data; GList *records; GError *error = NULL; #if defined(G_OS_UNIX) gint len = 512; gint herr; GByteArray *answer; gint rrtype; rrtype = g_resolver_record_type_to_rrtype (lrd->record_type); answer = g_byte_array_new (); for (;;) { g_byte_array_set_size (answer, len * 2); len = res_query (lrd->rrname, C_IN, rrtype, answer->data, answer->len); /* If answer fit in the buffer then we're done */ if (len < 0 || len < (gint)answer->len) break; /* * On overflow some res_query's return the length needed, others * return the full length entered. This code works in either case. */ } herr = h_errno; records = g_resolver_records_from_res_query (lrd->rrname, rrtype, answer->data, len, herr, &error); g_byte_array_free (answer, TRUE); #else DNS_STATUS status; DNS_RECORD *results = NULL; WORD dnstype; dnstype = g_resolver_record_type_to_dnstype (lrd->record_type); status = DnsQuery_A (lrd->rrname, dnstype, DNS_QUERY_STANDARD, NULL, &results, NULL); records = g_resolver_records_from_DnsQuery (lrd->rrname, dnstype, status, results, &error); if (results != NULL) DnsRecordListFree (results, DnsFreeRecordList); #endif if (records) g_task_return_pointer (task, records, (GDestroyNotify) free_records); else g_task_return_error (task, error); }
static void ide_mingw_device_provider_discover_worker (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { IdeMingwDeviceProvider *self = source_object; GPtrArray *devices; IdeContext *context; g_assert (G_IS_TASK (task)); g_assert (IDE_IS_MINGW_DEVICE_PROVIDER (self)); devices = g_ptr_array_new_with_free_func (g_object_unref); context = ide_object_get_context (IDE_OBJECT (self)); g_assert (IDE_IS_CONTEXT (context)); /* * FIXME: * * I'm almost certain this is not the proper way to check for mingw support. * Someone that knows how this works, please fix this up! */ if (g_file_test ("/usr/bin/x86_64-w64-mingw32-gcc", G_FILE_TEST_EXISTS)) { IdeDevice *device; /* add 64-bit mingw device */ device = ide_mingw_device_new (context, _("MinGW 64-bit"), "local-x86_64-w64-mingw32", "x86_64-w64-mingw32"); g_ptr_array_add (devices, device); } if (g_file_test ("/usr/bin/i686-w64-mingw32-gcc", G_FILE_TEST_EXISTS)) { IdeDevice *device; /* add 32-bit mingw device */ device = ide_mingw_device_new (context, _("MinGW 32-bit"), "local-i686-w64-mingw32", "i686-w64-mingw32"); g_ptr_array_add (devices, device); } g_task_return_pointer (task, devices, (GDestroyNotify)g_ptr_array_unref); ide_object_release (IDE_OBJECT (self)); }
static void photos_glib_file_create_create (GObject *source_object, GAsyncResult *res, gpointer user_data) { GCancellable *cancellable; GFile *file = G_FILE (source_object); g_autoptr (GFileOutputStream) stream = NULL; g_autoptr (GTask) task = G_TASK (user_data); PhotosGLibFileCreateData *data; cancellable = g_task_get_cancellable (task); data = (PhotosGLibFileCreateData *) g_task_get_task_data (task); { g_autoptr (GError) error = NULL; stream = g_file_create_finish (file, res, &error); if (error != NULL) { g_autoptr (GFile) unique_file = NULL; g_autofree gchar *filename = NULL; if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) { g_task_return_error (task, g_steal_pointer (&error)); goto out; } if (data->count == G_MAXUINT) { g_task_return_new_error (task, PHOTOS_ERROR, 0, "Exceeded number of copies of a file"); goto out; } data->count++; filename = photos_glib_file_create_data_get_filename (data); unique_file = g_file_get_child (data->dir, filename); g_file_create_async (unique_file, data->flags, data->io_priority, cancellable, photos_glib_file_create_create, g_object_ref (task)); goto out; } } g_task_return_pointer (task, g_object_ref (stream), g_object_unref); out: return; }