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;
}
