/**
* media_art_remove_async:
* @artist: artist the media art belongs to
* @album: (allow-none): album the media art belongs or %NULL
* @source_object: (allow-none): the #GObject this task belongs to,
* can be %NULL.
* @io_priority: the [I/O priority][io-priority] of the request
* @cancellable: (allow-none): optional #GCancellable object, %NULL to
* ignore
* @callback: (scope async): a #GAsyncReadyCallback to call when the
* request is satisfied
* @user_data: (closure): the data to pass to callback function
*
* Removes media art for given album/artist provided. Precisely the
* same operation as media_art_remove() is performing, but
* asynchronously.
*
* When all i/o for the operation is finished the @callback will be
* called.
*
* In case of a partial error the callback will be called with any
* succeeding items and no error, and on the next request the error
* will be reported. If a request is cancelled the callback will be
* called with %G_IO_ERROR_CANCELLED.
*
* During an async request no other sync and async calls are allowed,
* and will result in %G_IO_ERROR_PENDING errors.
*
* Any outstanding i/o request with higher priority (lower numerical
* value) will be executed before an outstanding request with lower
* priority. Default priority is %G_PRIORITY_DEFAULT.
*
* Since: 0.7.0
*/
void
media_art_remove_async (const gchar *artist,
const gchar *album,
gint io_priority,
GObject *source_object,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (source_object, cancellable, callback, user_data);
g_task_set_task_data (task, remove_data_new (artist, album), (GDestroyNotify) remove_data_free);
g_task_set_priority (task, io_priority);
g_task_run_in_thread (task, remove_thread);
g_object_unref (task);
}
static void
g_loadable_icon_real_load_async (GLoadableIcon *icon,
int size,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
LoadData *data;
task = g_task_new (icon, cancellable, callback, user_data);
g_task_set_source_tag (task, g_loadable_icon_real_load_async);
data = g_new0 (LoadData, 1);
g_task_set_task_data (task, data, (GDestroyNotify) load_data_free);
g_task_run_in_thread (task, load_async_thread);
g_object_unref (task);
}
void
cb_media_downloader_load_async (CbMediaDownloader *downloader,
CbMedia *media,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
g_return_if_fail (CB_IS_MEDIA_DOWNLOADER (downloader));
g_return_if_fail (CB_IS_MEDIA (media));
task = g_task_new (downloader, NULL, callback, user_data);
g_task_set_task_data (task, media, g_object_unref);
g_task_run_in_thread (task, load_in_thread);
g_object_unref (task);
}
void
gdav_options (SoupSession *session,
SoupURI *uri,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
SoupRequestHTTP *request;
AsyncContext *async_context;
GError *local_error = NULL;
g_return_if_fail (SOUP_IS_SESSION (session));
g_return_if_fail (uri != NULL);
async_context = g_slice_new0 (AsyncContext);
task = g_task_new (session, cancellable, callback, user_data);
g_task_set_source_tag (task, gdav_options);
g_task_set_task_data (
task, async_context, (GDestroyNotify) async_context_free);
request = gdav_request_options_uri (session, uri, &local_error);
/* Sanity check */
g_return_if_fail (
((request != NULL) && (local_error == NULL)) ||
((request == NULL) && (local_error != NULL)));
if (request != NULL) {
async_context->message =
soup_request_http_get_message (request);
gdav_request_send (
request, cancellable,
gdav_options_request_cb,
g_object_ref (task));
g_object_unref (request);
} else {
g_task_return_error (task, local_error);
}
g_object_unref (task);
}
static void
ide_git_buffer_change_monitor_calculate_async (IdeGitBufferChangeMonitor *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
DiffTask *diff;
IdeFile *file;
GFile *gfile;
g_assert (IDE_IS_GIT_BUFFER_CHANGE_MONITOR (self));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (self->buffer != NULL);
g_assert (self->repository != NULL);
self->state_dirty = FALSE;
task = g_task_new (self, cancellable, callback, user_data);
file = ide_buffer_get_file (self->buffer);
gfile = ide_file_get_file (file);
if (!gfile)
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
_("Cannot provide diff, no backing file provided."));
return;
}
diff = g_slice_new0 (DiffTask);
diff->file = g_object_ref (gfile);
diff->repository = g_object_ref (self->repository);
diff->state = g_hash_table_new (g_direct_hash, g_direct_equal);
diff->content = ide_buffer_get_content (self->buffer);
diff->blob = self->cached_blob ? g_object_ref (self->cached_blob) : NULL;
g_task_set_task_data (task, diff, diff_task_free);
self->in_calculation = TRUE;
g_async_queue_push (gWorkQueue, g_object_ref (task));
}
static gchar *
lookup_by_address (GResolver *resolver,
GInetAddress *address,
GCancellable *cancellable,
GError **error)
{
GTask *task;
gchar *name;
task = g_task_new (resolver, cancellable, NULL, NULL);
g_task_set_task_data (task, g_object_ref (address), g_object_unref);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread_sync (task, do_lookup_by_address);
name = g_task_propagate_pointer (task, error);
g_object_unref (task);
return name;
}
static void
parse_xml_async (DspyIntrospectionModel *self,
GBytes *bytes,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_assert (DSPY_IS_INTROSPECTION_MODEL (self));
g_assert (bytes != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, parse_xml_async);
g_task_set_task_data (task, g_bytes_ref (bytes), (GDestroyNotify) g_bytes_unref);
g_task_run_in_thread (task, parse_xml_worker);
}
static GList *
lookup_by_name (GResolver *resolver,
const gchar *hostname,
GCancellable *cancellable,
GError **error)
{
GTask *task;
GList *addresses;
task = g_task_new (resolver, cancellable, NULL, NULL);
g_task_set_task_data (task, g_strdup (hostname), g_free);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread_sync (task, do_lookup_by_name);
addresses = g_task_propagate_pointer (task, error);
g_object_unref (task);
return addresses;
}
static void
ide_git_vcs_initializer_initialize_async (IdeVcsInitializer *initializer,
GFile *file,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeGitVcsInitializer *self = (IdeGitVcsInitializer *)initializer;
g_autoptr(GTask) task = NULL;
g_return_if_fail (IDE_IS_GIT_VCS_INITIALIZER (self));
g_return_if_fail (G_IS_FILE (file));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, g_object_ref (file), g_object_unref);
g_task_run_in_thread (task, ide_git_vcs_initializer_initialize_worker);
}
void
ide_application_open_async (IdeApplication *self,
GFile **files,
gint n_files,
const gchar *hint,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_autoptr(GPtrArray) ar = NULL;
IdeApplicationOpen *state;
guint i;
g_return_if_fail (IDE_IS_APPLICATION (self));
g_return_if_fail (!n_files || files != NULL);
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_application_open_async);
g_task_set_check_cancellable (task, FALSE);
/*
* We have to open each file one at a time so that we don't race to
* open the same containing project multiple times.
*/
ar = g_ptr_array_new_with_free_func (g_object_unref);
for (i = 0; i < n_files; i++)
{
GFile *file = files [i];
if (!maybe_open_with_existing_workspace (self, file, hint, cancellable))
g_ptr_array_add (ar, g_object_ref (file));
}
state = g_slice_new0 (IdeApplicationOpen);
state->hint = g_strdup (hint);
state->files = g_steal_pointer (&ar);
g_task_set_task_data (task, state, ide_application_open_free);
ide_application_open_tick (task);
}
static void
ide_run_manager_install_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeBuildManager *build_manager = (IdeBuildManager *)object;
g_autoptr(GTask) task = user_data;
IdeRunManager *self;
IdeBuildTarget *build_target;
GCancellable *cancellable;
GError *error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_BUILD_MANAGER (build_manager));
g_assert (G_IS_TASK (task));
if (!ide_build_manager_build_finish (build_manager, result, &error))
{
g_task_return_error (task, error);
IDE_EXIT;
}
self = g_task_get_source_object (task);
g_assert (IDE_IS_RUN_MANAGER (self));
build_target = ide_run_manager_get_build_target (self);
if (build_target == NULL)
{
cancellable = g_task_get_cancellable (task);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
ide_run_manager_discover_default_target_async (self,
cancellable,
ide_run_manager_run_discover_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
g_task_set_task_data (task, g_object_ref (build_target), g_object_unref);
do_run_async (self, g_steal_pointer (&task));
}
static void
activate_all_drivers_async (GsdSmartcardManager *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
SECMODListLock *lock;
SECMODModuleList *driver_list, *node;
ActivateAllDriversOperation *operation;
task = g_task_new (self, cancellable, callback, user_data);
operation = g_new0 (ActivateAllDriversOperation, 1);
g_task_set_task_data (task, operation, (GDestroyNotify) g_free);
lock = SECMOD_GetDefaultModuleListLock ();
g_assert (lock != NULL);
SECMOD_GetReadLock (lock);
driver_list = SECMOD_GetDefaultModuleList ();
for (node = driver_list; node != NULL; node = node->next) {
if (!node->module->loaded)
continue;
if (!SECMOD_HasRemovableSlots (node->module))
continue;
if (node->module->dllName == NULL)
continue;
operation->pending_drivers_count++;
activate_driver (self, node->module,
cancellable,
(GAsyncReadyCallback) on_driver_activated,
task);
}
SECMOD_ReleaseReadLock (lock);
try_to_complete_all_drivers_activation (task);
}
/**
* g_dbus_address_get_stream:
* @address: A valid D-Bus address.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback to call when the request is satisfied.
* @user_data: Data to pass to @callback.
*
* Asynchronously connects to an endpoint specified by @address and
* sets up the connection so it is in a state to run the client-side
* of the D-Bus authentication conversation.
*
* When the operation is finished, @callback will be invoked. You can
* then call g_dbus_address_get_stream_finish() to get the result of
* the operation.
*
* This is an asynchronous failable function. See
* g_dbus_address_get_stream_sync() for the synchronous version.
*
* Since: 2.26
*/
void
g_dbus_address_get_stream (const gchar *address,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
GetStreamData *data;
g_return_if_fail (address != NULL);
data = g_new0 (GetStreamData, 1);
data->address = g_strdup (address);
task = g_task_new (NULL, cancellable, callback, user_data);
g_task_set_task_data (task, data, (GDestroyNotify) get_stream_data_free);
g_task_run_in_thread (task, get_stream_thread_func);
g_object_unref (task);
}
void wl_dict_query_query(WlDictQuery * query, const gchar * src,
WlDictQueryCallback cb, gpointer userData)
{
g_return_if_fail(WL_IS_DICT_QUERY(query) && src != NULL);
TaskData *td = g_malloc(sizeof(TaskData));
td->src = g_strdup(src);
td->from = query->from;
td->to = query->to;
td->cb = cb;
td->cbData = userData;
newQueryCancellable(query);
GTask *task =
g_task_new(query, query->cancel, onTaskReadyCallback, NULL);
g_task_set_task_data(task, td, onTaskDataDestroy);
g_task_run_in_thread(task, taskThread);
g_object_unref(task);
}
static void
ide_git_vcs_list_status_async (IdeVcs *vcs,
GFile *directory_or_file,
gboolean include_descendants,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeGitVcs *self = (IdeGitVcs *)vcs;
g_autoptr(GTask) task = NULL;
ListStatus *state;
IDE_ENTRY;
g_return_if_fail (IDE_IS_GIT_VCS (self));
g_return_if_fail (!directory_or_file || G_IS_FILE (directory_or_file));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
g_mutex_lock (&self->repository_mutex);
state = g_slice_new0 (ListStatus);
state->directory_or_file = g_object_ref (directory_or_file);
state->repository_location = ggit_repository_get_location (self->repository);
state->recursive = !!include_descendants;
g_mutex_unlock (&self->repository_mutex);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_git_vcs_list_status_async);
g_task_set_priority (task, io_priority);
g_task_set_return_on_cancel (task, TRUE);
g_task_set_task_data (task, state, list_status_free);
if (state->repository_location == NULL)
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"No repository loaded");
else
g_task_run_in_thread (task, ide_git_vcs_list_status_worker);
IDE_EXIT;
}
static void
g_proxy_address_enumerator_next_async (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator);
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
g_task_set_task_data (task, priv, NULL);
if (priv->proxies == NULL)
{
GProxyResolver *resolver = g_proxy_resolver_get_default ();
g_proxy_resolver_lookup_async (resolver,
priv->dest_uri,
cancellable,
proxy_lookup_cb,
task);
return;
}
if (priv->addr_enum)
{
if (priv->proxy_address)
{
return_result (task);
return;
}
else
{
g_socket_address_enumerator_next_async (priv->addr_enum,
cancellable,
address_enumerate_cb,
task);
return;
}
}
complete_async (task);
}
static void
register_driver (GsdSmartcardManager *self,
SECMODModule *driver,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
DriverRegistrationOperation *operation;
task = g_task_new (self, cancellable, callback, user_data);
operation = g_new0 (DriverRegistrationOperation, 1);
operation->driver = SECMOD_ReferenceModule (driver);
g_task_set_task_data (task,
operation,
(GDestroyNotify) destroy_driver_registration_operation);
operation->idle_id = g_idle_add ((GSourceFunc) on_main_thread_to_register_driver, task);
g_source_set_name_by_id (operation->idle_id, "[gnome-settings-daemon] on_main_thread_to_register_driver");
}
static void
send_pin (MMBaseSim *_self,
const gchar *pin,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
MMSimQmi *self;
self = MM_SIM_QMI (_self);
task = g_task_new (self, NULL, callback, user_data);
g_task_set_task_data (task, g_strdup (pin), (GDestroyNotify) g_free);
mm_dbg ("Verifying PIN...");
if (!self->priv->dms_uim_deprecated)
dms_uim_verify_pin (self, task);
else
uim_verify_pin (self, task);
}
static void
g_socks4a_proxy_connect_async (GProxy *proxy,
GIOStream *io_stream,
GProxyAddress *proxy_address,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GError *error = NULL;
GTask *task;
ConnectAsyncData *data;
const gchar *hostname;
guint16 port;
const gchar *username;
data = g_slice_new0 (ConnectAsyncData);
data->io_stream = g_object_ref (io_stream);
task = g_task_new (proxy, cancellable, callback, user_data);
g_task_set_task_data (task, data, (GDestroyNotify) free_connect_data);
hostname = g_proxy_address_get_destination_hostname (proxy_address);
port = g_proxy_address_get_destination_port (proxy_address);
username = g_proxy_address_get_username (proxy_address);
data->buffer = g_malloc0 (SOCKS4_CONN_MSG_LEN);
data->length = set_connect_msg (data->buffer,
hostname, port, username,
&error);
data->offset = 0;
if (data->length < 0)
{
g_task_return_error (task, error);
g_object_unref (task);
}
else
{
do_write (connect_msg_write_cb, task, data);
}
}
static void
load_texture_async (StTextureCache *cache,
AsyncTextureLoadData *data)
{
if (data->file)
{
GTask *task = g_task_new (cache, NULL, on_pixbuf_loaded, data);
g_task_set_task_data (task, data, NULL);
g_task_run_in_thread (task, load_pixbuf_thread);
g_object_unref (task);
}
else if (data->icon_info)
{
StIconColors *colors = data->colors;
if (colors)
{
GdkRGBA foreground_color;
GdkRGBA success_color;
GdkRGBA warning_color;
GdkRGBA error_color;
rgba_from_clutter (&foreground_color, &colors->foreground);
rgba_from_clutter (&success_color, &colors->success);
rgba_from_clutter (&warning_color, &colors->warning);
rgba_from_clutter (&error_color, &colors->error);
gtk_icon_info_load_symbolic_async (data->icon_info,
&foreground_color, &success_color,
&warning_color, &error_color,
NULL, on_symbolic_icon_loaded, data);
}
else
{
gtk_icon_info_load_icon_async (data->icon_info, NULL, on_icon_loaded, data);
}
}
else
g_assert_not_reached ();
}
static void
lookup_records_async (GResolver *resolver,
const char *rrname,
GResolverRecordType record_type,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
LookupRecordsData *lrd;
task = g_task_new (resolver, cancellable, callback, user_data);
lrd = g_slice_new (LookupRecordsData);
lrd->rrname = g_strdup (rrname);
lrd->record_type = record_type;
g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread (task, do_lookup_records);
g_object_unref (task);
}
void
photos_glib_file_create_async (GFile *file,
GFileCreateFlags flags,
gint io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr (GTask) task = NULL;
g_autoptr (PhotosGLibFileCreateData) data = NULL;
g_return_if_fail (G_IS_FILE (file));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
task = g_task_new (file, cancellable, callback, user_data);
g_task_set_source_tag (task, photos_glib_file_create_async);
data = photos_glib_file_create_data_new (file, flags, io_priority);
g_task_set_task_data (task, g_steal_pointer (&data), (GDestroyNotify) photos_glib_file_create_data_free);
g_file_create_async (file, flags, io_priority, cancellable, photos_glib_file_create_create, g_object_ref (task));
}
void
nul_sparql_query_util_query_async (gchar const *const sparql,
GCancellable *const cancellable,
GAsyncReadyCallback const callback,
gpointer const user_data)
{
nul_debug ("scheduling query %s", sparql);
GTask *const task = g_task_new (NULL, cancellable, callback, user_data);
SparqlQueryWork *const work = g_new0 (SparqlQueryWork, 1);
work->sparql = g_strdup (sparql);
g_task_set_task_data (task, work, (GDestroyNotify) sparql_query_work_free);
tracker_sparql_connection_get_async (
cancellable,
(GAsyncReadyCallback) do_sparql_query_async_connection_cb,
task
);
}
void
pp_cups_renew_subscription_async (PpCups *cups,
gint subscription_id,
gchar **events,
gint lease_duration,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CRSData *subscription_data;
GTask *task;
subscription_data = g_slice_new (CRSData);
subscription_data->id = subscription_id;
subscription_data->events = g_strdupv (events);
subscription_data->lease_duration = lease_duration;
task = g_task_new (cups, cancellable, callback, user_data);
g_task_set_task_data (task, subscription_data, (GDestroyNotify) crs_data_free);
g_task_run_in_thread (task, renew_subscription_thread);
g_object_unref (task);
}
static void
decorator_pair_tasks (TrackerDecorator *decorator)
{
TrackerDecoratorPrivate *priv = decorator->priv;
TrackerDecoratorInfo *info;
GTask *task;
while (!g_queue_is_empty (&priv->item_cache) &&
!g_queue_is_empty (&priv->next_elem_queue)) {
info = g_queue_pop_head (&priv->item_cache);
task = g_queue_pop_head (&priv->next_elem_queue);
g_task_set_task_data (task, GINT_TO_POINTER (info->id), NULL);
/* Pass ownership of info */
g_task_return_pointer (task, info,
(GDestroyNotify) tracker_decorator_info_unref);
g_object_unref (task);
/* Store the decorator-side task in the active task pool */
g_hash_table_add (priv->tasks, info->task);
}
}
void
tracker_db_backup_save (GFile *destination,
TrackerDBBackupFinished callback,
gpointer user_data,
GDestroyNotify destroy)
{
GTask *task;
BackupInfo *info;
info = g_slice_new0 (BackupInfo);
info->destination = g_object_ref (destination);
info->callback = callback;
info->user_data = user_data;
info->destroy = destroy;
task = g_task_new (NULL, NULL, NULL, NULL);
g_task_set_task_data (task, info, NULL);
g_task_run_in_thread (task, backup_job);
g_object_unref (task);
}
/**
* g_io_scheduler_push_job:
* @job_func: a #GIOSchedulerJobFunc.
* @user_data: data to pass to @job_func
* @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
* @io_priority: the [I/O priority][io-priority]
* of the request.
* @cancellable: optional #GCancellable object, %NULL to ignore.
*
* Schedules the I/O job to run in another thread.
*
* @notify will be called on @user_data after @job_func has returned,
* regardless whether the job was cancelled or has run to completion.
*
* If @cancellable is not %NULL, it can be used to cancel the I/O job
* by calling g_cancellable_cancel() or by calling
* g_io_scheduler_cancel_all_jobs().
*
* Deprecated: use #GThreadPool or g_task_run_in_thread()
**/
void
g_io_scheduler_push_job (GIOSchedulerJobFunc job_func,
gpointer user_data,
GDestroyNotify notify,
gint io_priority,
GCancellable *cancellable)
{
GIOSchedulerJob *job;
GTask *task;
g_return_if_fail (job_func != NULL);
job = g_slice_new0 (GIOSchedulerJob);
job->job_func = job_func;
job->data = user_data;
job->destroy_notify = notify;
if (cancellable)
job->cancellable = g_object_ref (cancellable);
job->context = g_main_context_ref_thread_default ();
G_LOCK (active_jobs);
active_jobs = g_list_prepend (active_jobs, job);
job->active_link = active_jobs;
G_UNLOCK (active_jobs);
task = g_task_new (NULL, cancellable, NULL, NULL);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
g_task_set_source_tag (task, g_io_scheduler_push_job);
G_GNUC_END_IGNORE_DEPRECATIONS
g_task_set_task_data (task, job, (GDestroyNotify)g_io_job_free);
g_task_set_priority (task, io_priority);
g_task_run_in_thread (task, io_job_thread);
g_object_unref (task);
}
void
ide_git_clone_widget_clone_async (IdeGitCloneWidget *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_autoptr(GFile) location = NULL;
g_autoptr(GFile) child = NULL;
CloneRequest *req;
const gchar *uri;
const gchar *child_name;
g_return_if_fail (IDE_IS_GIT_CLONE_WIDGET (self));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
gtk_label_set_label (self->clone_error_label, NULL);
uri = gtk_entry_get_text (self->clone_uri_entry);
child_name = gtk_entry_get_text (self->clone_location_entry);
location = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (self->clone_location_button));
if (child_name != NULL)
{
child = g_file_get_child (location, child_name);
req = clone_request_new (uri, child);
}
else
{
req = clone_request_new (uri, location);
}
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, req, clone_request_free);
g_task_run_in_thread (task, ide_git_clone_widget_worker);
}
static void
watch_smartcards_from_driver_async (GsdSmartcardManager *self,
SECMODModule *driver,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GsdSmartcardManagerPrivate *priv = self->priv;
GTask *task;
WatchSmartcardsOperation *operation;
operation = g_new0 (WatchSmartcardsOperation, 1);
operation->driver = SECMOD_ReferenceModule (driver);
operation->smartcards = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify) PK11_FreeSlot);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task,
operation,
(GDestroyNotify) destroy_watch_smartcards_operation);
G_LOCK (gsd_smartcards_watch_tasks);
priv->smartcards_watch_tasks = g_list_prepend (priv->smartcards_watch_tasks,
task);
g_object_weak_ref (G_OBJECT (task),
(GWeakNotify) on_smartcards_watch_task_destroyed,
self);
G_UNLOCK (gsd_smartcards_watch_tasks);
sync_initial_tokens_from_driver (self, driver, operation->smartcards, cancellable);
g_task_run_in_thread (task, (GTaskThreadFunc) watch_smartcards_from_driver);
}
void
um_realm_login (UmRealmObject *realm,
const gchar *user,
const gchar *password,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
LoginClosure *login;
UmRealmKerberos *kerberos;
g_return_if_fail (UM_REALM_IS_OBJECT (realm));
g_return_if_fail (user != NULL);
g_return_if_fail (password != NULL);
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
kerberos = um_realm_object_get_kerberos (realm);
g_return_if_fail (kerberos != NULL);
task = g_task_new (realm, cancellable, callback, user_data);
login = g_slice_new0 (LoginClosure);
login->domain = g_strdup (um_realm_kerberos_get_domain_name (kerberos));
login->realm = g_strdup (um_realm_kerberos_get_realm_name (kerberos));
login->user = g_strdup (user);
login->password = g_strdup (password);
g_task_set_task_data (task, login, login_closure_free);
g_task_set_check_cancellable (task, TRUE);
g_task_set_return_on_cancel (task, TRUE);
g_task_run_in_thread (task, kinit_thread_func);
g_object_unref (task);
g_object_unref (kerberos);
}
