static void avatar_cache_close_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GiggleAvatarCacheLoader *loader = user_data; GInputStream *stream = G_INPUT_STREAM (object); GError *error = NULL; if (g_input_stream_close_finish (stream, result, &error) && gdk_pixbuf_loader_close (loader->pixbuf_loader, &error)) { loader->pixbuf = gdk_pixbuf_loader_get_pixbuf (loader->pixbuf_loader); avatar_cache_insert (loader->cache, loader->uri, loader->pixbuf); g_object_unref (loader->pixbuf_loader); loader->pixbuf_loader = NULL; } if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("%s: %s", G_STRFUNC, error->message); avatar_cache_loader_finish (loader, error); }
static gboolean g_tls_output_stream_gnutls_write_ready (GIOStreamAdapter *adapter, gpointer user_data) { GTlsOutputStreamGnutls *tls_stream; GSimpleAsyncResult *simple = user_data; gssize nwrote; GError *error = NULL; tls_stream = G_TLS_OUTPUT_STREAM_GNUTLS (g_async_result_get_source_object (G_ASYNC_RESULT (simple))); g_object_unref (tls_stream); nwrote = g_tls_connection_gnutls_write (tls_stream->priv->conn, tls_stream->priv->buffer, tls_stream->priv->count, FALSE, tls_stream->priv->cancellable, &error); if (nwrote == -1 && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_error_free (error); return TRUE; } if (error) { g_simple_async_result_set_from_error (simple, error); g_error_free (error); } else g_simple_async_result_set_op_res_gssize (simple, nwrote); if (tls_stream->priv->cancellable) g_object_unref (tls_stream->priv->cancellable); g_simple_async_result_complete (simple); g_object_unref (simple); return FALSE; }
static void modem_secrets_cb (NMActRequest *req, NMActRequestGetSecretsCallId call_id, NMSettingsConnection *connection, GError *error, gpointer user_data) { NMModem *self = NM_MODEM (user_data); NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self); g_return_if_fail (call_id == priv->secrets_id); priv->secrets_id = NULL; if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; if (error) nm_log_warn (LOGD_MB, "(%s): %s", nm_modem_get_uid (self), error->message); g_signal_emit (self, signals[AUTH_RESULT], 0, error); }
static void rb_removable_media_manager_unmount_cb (GObject *object, GAsyncResult *result, RBRemovableMediaManager *mgr) { GMount *mount = G_MOUNT (object); GError *error = NULL; rb_debug ("finishing unmount of mount"); g_mount_unmount_finish (mount, result, &error); if (error != NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED)) { rb_error_dialog (NULL, _("Unable to unmount"), "%s", error->message); } else { rb_debug ("unmount failure has already been handled"); } g_error_free (error); } else { rb_removable_media_manager_remove_mount (mgr, mount); } g_object_unref (mgr); }
static GBookmarkFile * ide_recent_projects_get_bookmarks (IdeRecentProjects *self, GError **error) { g_autoptr(GBookmarkFile) bookmarks = NULL; g_autoptr(GError) local_error = NULL; g_assert (IDE_IS_RECENT_PROJECTS (self)); bookmarks = g_bookmark_file_new (); if (!g_bookmark_file_load_from_file (bookmarks, self->file_uri, &local_error)) { if (!g_error_matches (local_error, G_FILE_ERROR, G_FILE_ERROR_NOENT)) { g_propagate_error (error, g_steal_pointer (&local_error)); return NULL; } } return g_steal_pointer (&bookmarks); }
static void stop_network_ready (QmiClientWds *client, GAsyncResult *res, DisconnectContext *ctx) { GError *error = NULL; QmiMessageWdsStopNetworkOutput *output; output = qmi_client_wds_stop_network_finish (client, res, &error); if (output && !qmi_message_wds_stop_network_output_get_result (output, &error)) { /* No effect error, we're already disconnected */ if (g_error_matches (error, QMI_PROTOCOL_ERROR, QMI_PROTOCOL_ERROR_NO_EFFECT)) { g_error_free (error); error = NULL; } } if (error) { if (ctx->running_ipv4) ctx->error_ipv4 = error; else ctx->error_ipv6 = error; } else { /* Clear internal status */ reset_bearer_connection (ctx->self, ctx->running_ipv4, ctx->running_ipv6); } if (output) qmi_message_wds_stop_network_output_unref (output); /* Keep on */ ctx->step++; disconnect_context_step (ctx); }
static void pixbuf_task_completed_cb (GthTask *task, GError *error, gpointer user_data) { GthPixbufListTask *self = user_data; if (g_error_matches (error, GTH_TASK_ERROR, GTH_TASK_ERROR_SKIP_TO_NEXT_FILE)) { process_next_file (self); return; } if (error != NULL) { gth_task_completed (GTH_TASK (self), error); return; } set_current_destination_file (self); pixbuf_task_save_current_pixbuf (self, NULL, (self->priv->overwrite_mode == GTH_OVERWRITE_OVERWRITE)); }
static void picture_opened_for_read (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source; CcBackgroundItem *item; GFileInputStream *stream; GError *error = NULL; item = g_object_get_data (source_object, "item"); stream = g_file_read_finish (G_FILE (source_object), res, &error); if (stream == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { char *filename = g_file_get_path (G_FILE (source_object)); g_warning ("Failed to load picture '%s': %s", filename, error->message); g_free (filename); } g_error_free (error); g_object_unref (item); return; } /* since we were not cancelled, we can now cast user_data * back to BgPicturesSource. */ bg_source = BG_PICTURES_SOURCE (user_data); g_object_set_data (G_OBJECT (stream), "item", item); gdk_pixbuf_new_from_stream_at_scale_async (G_INPUT_STREAM (stream), THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, TRUE, bg_source->priv->cancellable, picture_scaled, bg_source); g_object_unref (stream); }
static void album_art_received (GObject *object, GAsyncResult *result, gpointer user_data) { IdoMediaPlayerMenuItem *self = user_data; GdkPixbuf *pixbuf; GError *error = NULL; pixbuf = gdk_pixbuf_new_from_stream_finish (result, &error); if (pixbuf == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("unable to fetch album art: %s", error->message); g_error_free (error); return; } gtk_image_set_from_pixbuf (GTK_IMAGE (self->album_art), pixbuf); g_object_unref (pixbuf); }
static void tunnel_read_cb (GObject *object, GAsyncResult *result, gpointer user_data) { Tunnel *tunnel = user_data; TunnelEnd *read_end, *write_end; GError *error = NULL; gssize nread; nread = g_input_stream_read_finish (G_INPUT_STREAM (object), result, &error); if (nread <= 0) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_error_free (error); return; } else if (error) { g_print ("Tunnel read failed: %s\n", error->message); g_error_free (error); } tunnel_close (tunnel); return; } if (object == (GObject *)tunnel->client.istream) { read_end = &tunnel->client; write_end = &tunnel->server; } else { read_end = &tunnel->server; write_end = &tunnel->client; } read_end->nread = nread; write_end->nwrote = 0; g_output_stream_write_async (write_end->ostream, read_end->buffer, read_end->nread, G_PRIORITY_DEFAULT, tunnel->cancellable, tunnel_wrote_cb, tunnel); }
static void do_cancel_while_reading_req_test_for_session (SoupSession *session) { SoupRequest *req; SoupURI *uri; GCancellable *cancellable; GError *error = NULL; uri = soup_uri_new_with_base (base_uri, "/slow"); req = soup_session_request_uri (session, uri, NULL); soup_uri_free (uri); cancellable = g_cancellable_new (); if (SOUP_IS_SESSION_ASYNC (soup_request_get_session (req))) { g_timeout_add (100, cancel_request_timeout, cancellable); soup_test_request_send (req, cancellable, &error); } else { GThread *thread; thread = g_thread_new ("cancel_request_thread", cancel_request_thread, g_object_ref (cancellable)); soup_test_request_send (req, cancellable, &error); g_thread_unref (thread); } if (!error) { debug_printf (1, " Request succeeded?\n"); errors++; } else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { debug_printf (1, " Unexpected error: %s\n", error->message); errors++; } g_clear_error (&error); g_object_unref (req); g_object_unref (cancellable); }
static void on_poke_proxy (GObject *source_object, GAsyncResult *result, gpointer user_data) { PokeContext *poke = user_data; CockpitFakeManager *self = poke->manager; GError *error = NULL; GDBusProxy *proxy; g_assert (poke->outstanding > 0); poke->outstanding--; proxy = g_dbus_proxy_new_finish (result, &error); /* Bail fast if cancelled */ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { if (poke->outstanding == 0) poke_context_finish (self, poke); return; } if (error) { g_warning ("Couldn't create proxy: %s", error->message); g_error_free (error); } else { g_debug ("fakemanager: proxy created: %s %s", poke->object_path, g_dbus_proxy_get_interface_name (proxy)); poke->added = g_list_prepend (poke->added, proxy); } if (poke->outstanding == 0) poke_apply_changes_and_finish (self, poke); }
GFile * fetch_archive (const gchar *url, const gchar *sha, const gchar *module_name, GFile *destination, guint strip_components, GError **error) { g_autoptr(GFile) archive_file = NULL; g_autoptr(GFile) source_dir = NULL; g_autoptr(SoupURI) uri = NULL; g_autofree char *archive_name = NULL; GError *local_error = NULL; source_dir = g_file_get_child (destination, module_name); if (!g_file_make_directory_with_parents (source_dir, NULL, &local_error)) { if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_EXISTS)) { g_propagate_error (error, local_error); return NULL; } g_error_free (local_error); } uri = soup_uri_new (url); archive_name = g_path_get_basename (soup_uri_get_path (uri)); archive_file = g_file_get_child (source_dir, archive_name); if (!download_archive (uri, sha, archive_file, error)) return NULL; if (!extract_archive (source_dir, archive_file, strip_components, error)) return NULL; return g_steal_pointer (&source_dir); }
static void on_bss_proxy_acquired (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data) { NMSupplicantInterface *self; NMSupplicantInterfacePrivate *priv; gs_free_error GError *error = NULL; gs_strfreev char **properties = NULL; gs_unref_variant GVariant *props = NULL; GVariantBuilder builder; char **iter; if (!g_async_initable_init_finish (G_ASYNC_INITABLE (proxy), result, &error)) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { nm_log_dbg (LOGD_SUPPLICANT, "Failed to acquire BSS proxy: (%s)", error->message); g_hash_table_remove (NM_SUPPLICANT_INTERFACE_GET_PRIVATE (user_data)->bss_proxies, g_dbus_proxy_get_object_path (proxy)); } return; } self = NM_SUPPLICANT_INTERFACE (user_data); priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); iter = properties = g_dbus_proxy_get_cached_property_names (proxy); while (iter && *iter) { GVariant *copy = g_dbus_proxy_get_cached_property (proxy, *iter); g_variant_builder_add (&builder, "{sv}", *iter++, copy); g_variant_unref (copy); } props = g_variant_builder_end (&builder); g_signal_emit (self, signals[NEW_BSS], 0, g_dbus_proxy_get_object_path (proxy), g_variant_ref_sink (props)); }
static void on_enumerator_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GError *error = NULL; GFileEnumerator *enumerator; JsonObject *options; const gchar *problem; enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, &error); if (enumerator == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { CockpitFslist *self = COCKPIT_FSLIST (user_data); problem = error_to_problem (error); if (problem) g_debug ("%s: couldn't list directory: %s", self->path, error->message); else g_warning ("%s: couldn't list directory: %s", self->path, error->message); options = cockpit_channel_close_options (COCKPIT_CHANNEL (self)); json_object_set_string_member (options, "message", error->message); cockpit_channel_close (COCKPIT_CHANNEL (self), problem ? problem : "internal-error"); } g_clear_error (&error); return; } CockpitFslist *self = COCKPIT_FSLIST (user_data); g_file_enumerator_next_files_async (enumerator, 10, G_PRIORITY_DEFAULT, self->cancellable, on_files_listed, self); }
/** * seahorse_util_handle_error: * @error: The #GError to print, and clear * @desc: The heading of the box * @...: Parameters to insert into the format string desc. * * Displays an error box. The message is the error message. * Won't display cancel errors. */ void seahorse_util_handle_error (GError **error, gpointer parent, const char* description, ...) { gchar *text = NULL; GtkWidget *widget = NULL; va_list ap; if (!error || !(*error) || g_error_matches (*error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_clear_error (error); return; } va_start (ap, description); if (description) text = g_strdup_vprintf (description, ap); va_end (ap); if (parent == NULL) widget = NULL; else if (GTK_IS_WIDGET (parent)) widget = GTK_WIDGET (parent); else if (GTK_IS_WINDOW (parent)) widget = GTK_WIDGET (parent); else if (SEAHORSE_IS_WIDGET (parent)) widget = seahorse_widget_get_toplevel (parent); else g_warning ("unsupported 'parent' argument passed to seahorse_util_handle_error() "); g_dbus_error_strip_remote_error (*error); seahorse_util_show_error (widget, text, (*error)->message ? (*error)->message : ""); g_free (text); g_clear_error (error); }
static void photos_source_manager_goa_client (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosSourceManager *self; PhotosSourceManagerPrivate *priv; GError *error; GoaClient *client; error = NULL; client = goa_client_new_finish (res, &error); if (error != NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Unable to create GoaClient: %s", error->message); g_error_free (error); return; } self = PHOTOS_SOURCE_MANAGER (user_data); priv = self->priv; priv->client = client; g_signal_connect_swapped (priv->client, "account-added", G_CALLBACK (photos_source_manager_refresh_accounts), self); g_signal_connect_swapped (priv->client, "account-changed", G_CALLBACK (photos_source_manager_refresh_accounts), self); g_signal_connect_swapped (priv->client, "account-removed", G_CALLBACK (photos_source_manager_refresh_accounts), self); photos_source_manager_refresh_accounts (self); }
static void set_problem_from_error (CockpitStream *self, const gchar *summary, GError *error) { const gchar *problem; if (g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_MISC)) { g_message ("%s: %s: %s", self->priv->name, summary, error->message); if (self->priv->received) problem = "disconnected"; else problem = "protocol-error"; } else { problem = cockpit_stream_problem (error, self->priv->name, summary, self->priv->io); } g_free (self->priv->problem); self->priv->problem = g_strdup (problem); }
static gchar * get_service_description (const gchar *file) { GError *error = NULL; GKeyFile *kf = g_key_file_new (); g_key_file_load_from_file (kf, file, 0, &error); if (error) goto out; gchar *description = g_key_file_get_string (kf, "Unit", "Description", &error); if (error) goto out; g_key_file_free (kf); return description; out: if (g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND)) g_warning ("Failed to load '%s': %s", file, error->message); g_error_free (error); g_key_file_free (kf); return g_strdup ("Unknown"); }
int SocketStreamHandle::platformSend(const char* data, int length) { LOG(Network, "SocketStreamHandle %p platformSend", this); if (!m_outputStream || !data) return 0; GOwnPtr<GError> error; gssize written = g_pollable_output_stream_write_nonblocking(m_outputStream.get(), data, length, 0, &error.outPtr()); if (error) { if (g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) beginWaitingForSocketWritability(); else m_client->didFailSocketStream(this, SocketStreamError(error->code, error->message)); return 0; } // If we did not send all the bytes we were given, we know that // SocketStreamHandleBase will need to send more in the future. if (written < length) beginWaitingForSocketWritability(); return written; }
static void encoder_completed_cb (RBEncoder *encoder, guint64 dest_size, const char *mediatype, GError *error, RBTrackTransferBatch *batch) { g_object_unref (batch->priv->current_encoder); batch->priv->current_encoder = NULL; if (error == NULL) { rb_debug ("encoder finished (size %" G_GUINT64_FORMAT ")", dest_size); } else if (g_error_matches (error, RB_ENCODER_ERROR, RB_ENCODER_ERROR_DEST_EXISTS)) { rb_debug ("encoder stopped because destination %s already exists", batch->priv->current_dest_uri); g_signal_emit (batch, signals[OVERWRITE_PROMPT], 0, batch->priv->current_dest_uri); return; } else { rb_debug ("encoder finished (error: %s)", error->message); } track_transfer_completed (batch, dest_size, mediatype, FALSE, error); }
/** * fu_util_install_with_fallback: **/ static gboolean fu_util_install_with_fallback (FuUtilPrivate *priv, const gchar *id, const gchar *filename, GError **error) { _cleanup_error_free_ GError *error_local = NULL; /* install with flags chosen by the user */ if (fu_util_install_internal (priv, id, filename, &error_local)) return TRUE; /* some other failure */ if ((priv->flags & FU_PROVIDER_UPDATE_FLAG_OFFLINE) > 0 || !g_error_matches (error_local, FWUPD_ERROR, FWUPD_ERROR_NOT_SUPPORTED)) { g_propagate_error (error, error_local); error_local = NULL; return FALSE; } /* TRANSLATOR: the provider only supports offline */ g_print ("%s...\n", _("Retrying as an offline update")); priv->flags |= FU_PROVIDER_UPDATE_FLAG_OFFLINE; return fu_util_install_internal (priv, id, filename, error); }
static void on_ipclient_search_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GClueIpclient *ipclient = GCLUE_IPCLIENT (source_object); GClueLocator *locator = GCLUE_LOCATOR (user_data); GClueLocationInfo *location; GError *error = NULL; location = gclue_ipclient_search_finish (ipclient, res, &error); if (location == NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Error fetching location from geoip server: %s", error->message); g_error_free (error); return; } g_debug ("New location available"); gclue_locator_update_location (locator, location); g_object_unref (location); }
static void photos_properties_dialog_pipeline_is_edited (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosPropertiesDialog *self; PhotosBaseItem *item = PHOTOS_BASE_ITEM (source_object); gboolean is_edited; { g_autoptr (GError) error = NULL; is_edited = photos_base_item_pipeline_is_edited_finish (item, res, &error); if (error != NULL) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Unable to check if item has been edited or not: %s", error->message); return; } } self = PHOTOS_PROPERTIES_DIALOG (user_data); photos_properties_dialog_modified_updated (self, is_edited); }
static void gbp_git_buffer_change_monitor_wait_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IpcGitChangeMonitor *proxy = (IpcGitChangeMonitor *)object; g_autoptr(GVariant) changes = NULL; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; GbpGitBufferChangeMonitor *self; g_assert (IDE_IS_MAIN_THREAD ()); g_assert (IPC_IS_GIT_CHANGE_MONITOR (proxy)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_TASK (task)); self = ide_task_get_source_object (task); if (!ipc_git_change_monitor_call_list_changes_finish (proxy, &changes, result, &error)) { g_clear_pointer (&self->cache, line_cache_free); self->not_found = TRUE; if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_FILE_NOT_FOUND)) ide_task_return_boolean (task, TRUE); else ide_task_return_error (task, g_steal_pointer (&error)); } else { g_clear_pointer (&self->cache, line_cache_free); self->not_found = FALSE; self->cache = line_cache_new_from_variant (changes); ide_buffer_change_monitor_emit_changed (IDE_BUFFER_CHANGE_MONITOR (self)); ide_task_return_boolean (task, TRUE); } }
static void select_area_done (GObject *source_object, GAsyncResult *res, gpointer user_data) { CallbackData *cb_data = user_data; GError *error = NULL; GVariant *ret; ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object), res, &error); if (error != NULL) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_error_free (error); cb_data->aborted = TRUE; g_idle_add (emit_select_callback_in_idle, cb_data); return; } g_message ("Unable to select area using GNOME Shell's builtin screenshot " "interface, resorting to fallback X11."); g_error_free (error); screenshot_select_area_x11_async (cb_data); return; } g_variant_get (ret, "(iiii)", &cb_data->rectangle.x, &cb_data->rectangle.y, &cb_data->rectangle.width, &cb_data->rectangle.height); g_variant_unref (ret); g_idle_add (emit_select_callback_in_idle, cb_data); }
static void ep_forget_passwords_keyfile (EPassMsg *msg) { gchar **groups; gsize length = 0, ii; if (!check_key_file (G_STRFUNC)) return; groups = g_key_file_get_groups (key_file, &length); if (!groups) return; for (ii = 0; ii < length; ii++) { GError *error = NULL; if (!g_str_has_prefix (groups[ii], KEY_FILE_GROUP_PREFIX)) continue; g_key_file_remove_group (key_file, groups[ii], &error); /* Not finding the requested group is acceptable, but we still * want to leave an informational message on the terminal. */ if (g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND)) { g_message ("%s", error->message); g_error_free (error); /* Issue a warning if anything else goes wrong. */ } else if (error != NULL) { g_warning ("%s", error->message); g_error_free (error); } } ep_key_file_save (); g_strfreev (groups); }
static void ide_git_buffer_change_monitor__calculate_cb (GObject *object, GAsyncResult *result, gpointer user_data_unused) { IdeGitBufferChangeMonitor *self = (IdeGitBufferChangeMonitor *)object; g_autoptr(GHashTable) ret = NULL; g_autoptr(GError) error = NULL; g_assert (IDE_IS_GIT_BUFFER_CHANGE_MONITOR (self)); self->in_calculation = FALSE; ret = ide_git_buffer_change_monitor_calculate_finish (self, result, &error); if (!ret) { if (!g_error_matches (error, GGIT_ERROR, GGIT_ERROR_NOTFOUND)) g_message ("%s", error->message); } else { g_clear_pointer (&self->state, g_hash_table_unref); self->state = g_hash_table_ref (ret); } ide_buffer_change_monitor_emit_changed (IDE_BUFFER_CHANGE_MONITOR (self)); /* * Recalculate the state if the buffer has changed since we submitted our request. */ if (self->state_dirty) ide_git_buffer_change_monitor_calculate_async (self, NULL, ide_git_buffer_change_monitor__calculate_cb, NULL); }
/*static*/ void uGlobalMenuService::RegisterWindowCallback(GObject *object, GAsyncResult *res, gpointer userdata) { GError *error = NULL; GVariant *result = g_dbus_proxy_call_finish(G_DBUS_PROXY(object), res, &error); if (result) { g_variant_unref(result); } RegisterWindowCbData *data = static_cast<RegisterWindowCbData *>(userdata); if (error && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { // If the request was cancelled, then the menubar has definitely been // deleted already g_error_free(error); delete data; return; } uGlobalMenuBar *menu = data->GetMenuBar(); // We don't assume that GDbus cancellation is reliable // see https://launchpad.net/bugs/953562 if (menu && !error) { menu->NotifyMenuBarRegistered(); } else if (menu && sService) { sService->mMenus.RemoveElement(menu); } if (error) { g_error_free(error); } delete data; }
static void avatar_cache_read_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GiggleAvatarCacheLoader *loader = user_data; GInputStream *stream = G_INPUT_STREAM (object); GError *error = NULL; gssize len; len = g_input_stream_read_finish (stream, result, &error); if (len > 0) { if (gdk_pixbuf_loader_write (loader->pixbuf_loader, (gpointer) loader->buffer, len, &error)) { g_input_stream_read_async (stream, loader->buffer, sizeof loader->buffer, G_PRIORITY_DEFAULT, loader->cancellable, avatar_cache_read_cb, loader); } else { len = -2; } } if (0 >= len) { g_input_stream_close_async (stream, G_PRIORITY_DEFAULT, loader->cancellable, avatar_cache_close_cb, loader); } if (error) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("%s: %s", G_STRFUNC, error->message); g_error_free (error); } }