static void input_stream_ready_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { GnomeGdkPixbufAsyncHandle *handle = user_data; handle->file_input_stream = g_file_read_finish (G_FILE (source_object), res, NULL); if (handle->file_input_stream == NULL) { /* TODO: could map the GError more precisely to the GnomeVFSError */ load_done (handle, GNOME_VFS_ERROR_GENERIC, NULL); return; } handle->loader = gdk_pixbuf_loader_new (); g_input_stream_read_async (G_INPUT_STREAM (handle->file_input_stream), handle->buffer, sizeof (handle->buffer), G_PRIORITY_DEFAULT, handle->cancellable, input_stream_read_callback, handle); }
static void album_art_file_opened (GObject *object, GAsyncResult *result, gpointer user_data) { IdoMediaPlayerMenuItem *self = user_data; GFileInputStream *input; GError *error = NULL; input = g_file_read_finish (G_FILE (object), result, &error); if (input == 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; } gdk_pixbuf_new_from_stream_at_scale_async (G_INPUT_STREAM (input), ALBUM_ART_SIZE, ALBUM_ART_SIZE, TRUE, self->cancellable, album_art_received, self); g_object_unref (input); }
static void picture_opened_for_read (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source = BG_PICTURES_SOURCE (user_data); 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) { char *filename; 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; } 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, NULL, picture_scaled, bg_source); g_object_unref (stream); }
static void file_read_async_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GValue nothing = { 0 }; EmpathyTpFile *self = user_data; GFileInputStream *in_stream; GError *error = NULL; in_stream = g_file_read_finish (G_FILE (source), res, &error); if (error != NULL && !self->priv->is_closing) { ft_operation_close_with_error (self, error); g_clear_error (&error); return; } self->priv->in_stream = G_INPUT_STREAM (in_stream); /* we don't impose specific interface/port requirements even * if we're not using UNIX sockets. */ initialize_empty_ac_variant (self->priv->socket_access_control, ¬hing); tp_cli_channel_type_file_transfer_call_provide_file ( self->priv->channel, -1, self->priv->socket_address_type, self->priv->socket_access_control, ¬hing, ft_operation_provide_or_accept_file_cb, NULL, NULL, G_OBJECT (self)); }
static void read_async_ready_cb (GObject *source, GAsyncResult *res, gpointer user_data) { NemoPreviewCoverArtFetcher *self = user_data; NemoPreviewCoverArtFetcherPrivate *priv = NEMO_PREVIEW_COVER_ART_FETCHER_GET_PRIVATE (self); GFileInputStream *stream; GError *error = NULL; GFile *file; stream = g_file_read_finish (G_FILE (source), res, &error); if (error != NULL) { if (!self->priv->tried_cache) { self->priv->tried_cache = TRUE; file = get_gfile_for_amazon (self); try_read_from_file (self, file); g_object_unref (file); } else { g_print ("Unable to fetch Amazon cover art: %s\n", error->message); } g_error_free (error); return; } priv->input_stream = G_INPUT_STREAM (stream); gdk_pixbuf_new_from_stream_async (priv->input_stream, NULL, pixbuf_from_stream_async_cb, self); }
static void photos_glib_file_copy_read (GObject *source_object, GAsyncResult *res, gpointer user_data) { GCancellable *cancellable; GFile *source = G_FILE (source_object); g_autoptr (GFileInputStream) istream = NULL; g_autoptr (GTask) task = G_TASK (user_data); PhotosGLibFileCopyData *data; cancellable = g_task_get_cancellable (task); data = (PhotosGLibFileCopyData *) g_task_get_task_data (task); { g_autoptr (GError) error = NULL; istream = g_file_read_finish (source, res, &error); if (error != NULL) { g_task_return_error (task, g_steal_pointer (&error)); goto out; } } g_output_stream_splice_async (G_OUTPUT_STREAM (data->ostream), G_INPUT_STREAM (istream), G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, data->io_priority, cancellable, photos_glib_file_copy_splice, g_object_ref (task)); out: return; }
static void www_fileRead_cb (GFile *file, GAsyncResult *res, struct rom_romItem *item) { GError *error = NULL; gboolean keepratio = cfg_keyBool ("TILE_KEEP_ASPECT_RATIO"); GFileInputStream *input = g_file_read_finish (file, res, &error); g_object_unref (file); file = NULL; if (!error) { gdk_pixbuf_new_from_stream_at_scale_async ((GInputStream*) input, ui_tileSize_W, ui_tileSize_H, keepratio, NULL, (GAsyncReadyCallback) www_pixbufRead_cb, item); } else { g_print ("stream error [%s]: %s " FAIL_MSG "\n", item->name, error->message); g_error_free (error); item->tile = NULL; item->tileLoaded = TRUE; item->tileLoading = FALSE; if (ui_tileIsVisible (item)) { ui_invalidateDrawingArea (); } www_downloadingItm--; } }
static void openCallback(GObject* source, GAsyncResult* res, gpointer data) { ResourceHandle* handle = static_cast<ResourceHandle*>(data); ResourceHandleInternal* d = handle->getInternal(); ResourceHandleClient* client = handle->client(); if (d->m_cancelled || !client) { cleanupGioOperation(handle); return; } GFileInputStream* in; GError *error = NULL; in = g_file_read_finish(G_FILE(source), res, &error); if (error) { cleanupGioOperation(handle); // FIXME: error client->didFinishLoading(handle); return; } d->m_input_stream = G_INPUT_STREAM(in); d->m_bufsize = 8192; d->m_buffer = static_cast<char*>(g_malloc(d->m_bufsize)); d->m_total = 0; g_input_stream_read_async(d->m_input_stream, d->m_buffer, d->m_bufsize, G_PRIORITY_DEFAULT, d->m_cancellable, readCallback, handle); }
static void photos_base_item_refresh_thumb_path_read (GObject *source_object, GAsyncResult *res, gpointer user_data) { PhotosBaseItem *self = PHOTOS_BASE_ITEM (user_data); PhotosBaseItemPrivate *priv = self->priv; GError *error = NULL; GFile *file = G_FILE (source_object); GFileInputStream *stream; stream = g_file_read_finish (file, res, &error); if (error != NULL) { gchar *uri; uri = g_file_get_uri (file); g_warning ("Unable to read file at %s: %s", uri, error->message); priv->failed_thumbnailing = TRUE; priv->thumb_path = NULL; g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, NULL, NULL); photos_base_item_set_failed_icon (self); g_free (uri); g_error_free (error); goto out; } g_object_set_data_full (G_OBJECT (stream), "file", g_object_ref (file), g_object_unref); gdk_pixbuf_new_from_stream_async (G_INPUT_STREAM (stream), NULL, photos_base_item_refresh_thumb_path_pixbuf, g_object_ref (self)); g_object_unref (stream); out: g_object_unref (self); }
static void thumbnail_opened_cb (GObject *source_object, GAsyncResult *result, ThumbnailData *data) { GFile *thumbnail_file; GFileInputStream *input_stream; GError *error = NULL; /* Finish opening the thumbnail */ thumbnail_file = G_FILE (source_object); input_stream = g_file_read_finish (thumbnail_file, result, &error); if (input_stream == NULL) { /* Don't display an error message, since this isn't really meant to happen */ g_warning ("Error loading video thumbnail: %s", error->message); g_error_free (error); return; } /* NOTE: There's no need to reset the cancellable before using it again, as we'll have bailed before now if it was ever cancelled. */ g_debug ("Creating thumbnail from stream"); totem_gdk_pixbuf_new_from_stream_at_scale_async (G_INPUT_STREAM (input_stream), THUMBNAIL_WIDTH, -1, TRUE, data->cancellable, (GAsyncReadyCallback) thumbnail_loaded_cb, data); g_object_unref (input_stream); }
static void on_file_read_ready (GObject * object, GAsyncResult * res, gpointer data) { GError *error = NULL; GDownloadable *download = G_DOWNLOADABLE (data); GioDownload *gio_download = GIO_DOWNLOAD (data); g_assert (download != NULL); gio_download->priv->input = g_file_read_finish (G_FILE(object), res, &error); handle_critical_error (error); if (gio_download->priv->input == NULL) { // TODO: Error details g_downloadable_set_status (download, G_DOWNLOADABLE_NETWORK_ERROR); } else { if (g_seekable_can_seek(G_SEEKABLE(gio_download->priv->input)) && g_file_query_exists (download->priv->local_file, NULL)) { //g_message ("appeding file ...\n"); g_file_append_to_async (download->priv->local_file, 0,G_PRIORITY_DEFAULT, NULL, on_file_append_to_ready, download); } else { //g_message ("replacing file ...\n"); g_file_replace_async (download->priv->local_file, NULL, FALSE, 0, G_PRIORITY_DEFAULT, NULL, on_file_replace_ready, download); } g_downloadable_set_status (download, G_DOWNLOADABLE_DOWNLOADING); } }
static void file_open_callback (GObject *object, GAsyncResult *res, gpointer user_data) { FileOpenData *data = user_data; NemoImagePropertiesPage *page = data->page; GFile *file; GFileInputStream *stream; GError *error; char *uri; file = G_FILE (object); uri = g_file_get_uri (file); error = NULL; stream = g_file_read_finish (file, res, &error); if (stream) { char *mime_type; mime_type = nemo_file_info_get_mime_type (data->info); page->details->loader = gdk_pixbuf_loader_new_with_mime_type (mime_type, &error); if (error != NULL) { g_warning ("Error creating loader for %s: %s", uri, error->message); g_clear_error (&error); } page->details->pixbuf_still_loading = TRUE; page->details->width = 0; page->details->height = 0; #ifdef HAVE_EXIF page->details->exifldr = exif_loader_new (); #endif /*HAVE_EXIF*/ g_free (mime_type); g_signal_connect (page->details->loader, "size_prepared", G_CALLBACK (size_prepared_callback), page); g_input_stream_read_async (G_INPUT_STREAM (stream), page->details->buffer, sizeof (page->details->buffer), 0, page->details->cancellable, file_read_callback, page); g_object_unref (stream); } else { g_warning ("Error reading %s: %s", uri, error->message); g_clear_error (&error); load_finished (page); } g_free (uri); g_free (data); }
static void picture_opened_for_read (GObject *source_object, GAsyncResult *res, gpointer user_data) { BgPicturesSource *bg_source; CcBackgroundItem *item; GFileInputStream *stream; GError *error = NULL; gint thumbnail_height; gint thumbnail_width; 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); remove_placeholder (BG_PICTURES_SOURCE (user_data), item); g_free (filename); } g_error_free (error); return; } /* since we were not cancelled, we can now cast user_data * back to BgPicturesSource. */ bg_source = BG_PICTURES_SOURCE (user_data); thumbnail_height = bg_source_get_thumbnail_height (BG_SOURCE (bg_source)); thumbnail_width = bg_source_get_thumbnail_width (BG_SOURCE (bg_source)); g_object_set_data_full (G_OBJECT (stream), "item", g_object_ref (item), g_object_unref); 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 ft_handler_read_async_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GFileInputStream *stream; GError *error = NULL; HashingData *hash_data; EmpathyFTHandler *handler = user_data; EmpathyFTHandlerPriv *priv = handler->priv; (void)source; /* suppress unused-parameter warning */ DEBUG ("GFile read async CB."); stream = g_file_read_finish (priv->gfile, res, &error); if (error != NULL) { emit_error_signal (handler, error); g_clear_error (&error); return; } hash_data = g_slice_new0 (HashingData); hash_data->stream = G_INPUT_STREAM (stream); hash_data->total_bytes = priv->total_bytes; hash_data->handler = g_object_ref (handler); /* FIXME: MD5 is the only ContentHashType supported right now */ hash_data->checksum = g_checksum_new (G_CHECKSUM_MD5); tp_asv_set_uint32 (priv->request, TP_PROP_CHANNEL_TYPE_FILE_TRANSFER_CONTENT_HASH_TYPE, TP_FILE_HASH_TYPE_MD5); g_signal_emit (handler, signals[HASHING_STARTED], 0); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wdeprecated-declarations" g_io_scheduler_push_job (do_hash_job, hash_data, NULL, G_PRIORITY_DEFAULT, priv->cancellable); #pragma GCC diagnostic pop }
static void image_file_read_cb (GObject *file, GAsyncResult *result, RBPodcastAddDialog *dialog) { GFileInputStream *stream; GdkPixbuf *pixbuf; GError *error = NULL; stream = g_file_read_finish (G_FILE (file), result, &error); if (error != NULL) { rb_debug ("podcast image read failed: %s", error->message); g_clear_error (&error); g_object_unref (dialog); return; } pixbuf = gdk_pixbuf_new_from_stream_at_scale (G_INPUT_STREAM (stream), PODCAST_IMAGE_SIZE, PODCAST_IMAGE_SIZE, TRUE, NULL, &error); if (error != NULL) { rb_debug ("podcast image load failed: %s", error->message); g_clear_error (&error); } else { GtkTreeIter iter; if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (dialog->priv->feed_model), &iter)) { do { GFile *feedfile; gtk_tree_model_get (GTK_TREE_MODEL (dialog->priv->feed_model), &iter, FEED_COLUMN_IMAGE_FILE, &feedfile, -1); if (feedfile == G_FILE (file)) { gtk_list_store_set (dialog->priv->feed_model, &iter, FEED_COLUMN_IMAGE, g_object_ref (pixbuf), -1); break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (dialog->priv->feed_model), &iter)); } g_object_unref (pixbuf); } g_object_unref (dialog); g_object_unref (stream); }
/* Called when a file open completes */ static void vfs_data_open_done (GObject *source, GAsyncResult *res, gpointer callback_data) { VfsAsyncHandle* ah = (VfsAsyncHandle*)callback_data; if(ah->state == VFS_ASYNC_PROCESSING) { g_assert (ah->operation == VFS_OP_OPENING); g_clear_error (&ah->error); if (ah->writer) ah->ostream = G_OUTPUT_STREAM (g_file_replace_finish (ah->file, res, &ah->error)); else ah->istream = G_INPUT_STREAM (g_file_read_finish (ah->file, res, &ah->error)); ah->state = VFS_ASYNC_READY; ah->total = 0; ah->last = 0; } }
static void file_open_callback (GObject *object, GAsyncResult *res, gpointer data) { CajaImagePropertiesPage *page; GFile *file; GFileInputStream *stream; GError *error; page = CAJA_IMAGE_PROPERTIES_PAGE (data); file = G_FILE (object); error = NULL; stream = g_file_read_finish (file, res, &error); if (stream) { page->details->loader = gdk_pixbuf_loader_new (); page->details->pixbuf_still_loading = TRUE; page->details->width = 0; page->details->height = 0; #ifdef HAVE_EXIF page->details->exifldr = exif_loader_new (); #endif /*HAVE_EXIF*/ g_signal_connect (page->details->loader, "size_prepared", G_CALLBACK (size_prepared_callback), page); g_input_stream_read_async (G_INPUT_STREAM (stream), page->details->buffer, sizeof (page->details->buffer), 0, page->details->cancellable, file_read_callback, page); g_object_unref (stream); } }
static void gtkhash_hash_file_open_finish( G_GNUC_UNUSED GObject *source, GAsyncResult *res, struct hash_file_s *data) { data->stream = g_file_read_finish(data->file, res, NULL); if (G_UNLIKELY(!data->stream && !g_cancellable_is_cancelled(data->cancellable))) { g_warning("failed to open file (%s)", data->uri); g_cancellable_cancel(data->cancellable); } if (G_UNLIKELY(g_cancellable_is_cancelled(data->cancellable))) { if (data->stream) gtkhash_hash_file_set_state(data, HASH_FILE_STATE_CLOSE); else gtkhash_hash_file_set_state(data, HASH_FILE_STATE_FINISH); } else gtkhash_hash_file_set_state(data, HASH_FILE_STATE_GET_SIZE); gtkhash_hash_file_add_source(data); }
static void image_file_opened (GFile *file, GAsyncResult *result, GtkWidget *popover) { dg_lerr GError *gerror = NULL; dg_lobj GFileInputStream *stream = g_file_read_finish (file, result, &gerror); if (!stream || gerror) { dg_lmem gchar *uri = g_file_get_uri (file); g_printerr ("Could not open URL '%s': %s", uri, gerror->message); return; } gdk_pixbuf_new_from_stream_at_scale_async (G_INPUT_STREAM (stream), 500, 500, TRUE, NULL, (GAsyncReadyCallback) image_pixbuf_loaded, popover); }
static void file_read_async_cb (GObject *obj, GAsyncResult *res, gpointer data) { RBChunkLoader *loader = RB_CHUNK_LOADER (data); loader->priv->stream = g_file_read_finish (G_FILE (obj), res, &loader->priv->error); if (loader->priv->error != NULL) { loader->priv->callback (loader, NULL, 0, loader->priv->callback_data); return; } g_file_input_stream_query_info_async (loader->priv->stream, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_PRIORITY_DEFAULT, loader->priv->cancel, stream_info_async_cb, loader); }
static void file_opened_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { EelPixbufLoadHandle *handle; GFileInputStream *stream; GError *error; handle = user_data; if (g_cancellable_is_cancelled (handle->cancellable)) { free_pixbuf_load_handle (handle); return; } error = NULL; stream = g_file_read_finish (G_FILE (source_object), res, &error); if (stream == NULL) { load_done (handle, error, FALSE); g_error_free (error); return; } handle->stream = G_INPUT_STREAM (stream); handle->loader = gdk_pixbuf_loader_new (); g_input_stream_read_async (handle->stream, handle->buffer, sizeof (handle->buffer), 0, handle->cancellable, file_read_callback, handle); }
static void user_style_seet_read_cb (GFile *file, GAsyncResult *result, gpointer user_data) { GFileInputStream *input_stream; GOutputStream *output_stream; input_stream = g_file_read_finish (file, result, NULL); if (!input_stream) return; output_stream = g_memory_output_stream_new_resizable (); g_output_stream_splice_async (output_stream, G_INPUT_STREAM (input_stream), G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, G_PRIORITY_DEFAULT, NULL, (GAsyncReadyCallback)user_style_sheet_output_stream_splice_cb, NULL); g_object_unref (input_stream); g_object_unref (output_stream); }
static void avatar_cache_open_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GiggleAvatarCacheLoader *loader = user_data; GError *error = NULL; GFileInputStream *stream; stream = g_file_read_finish (G_FILE (object), result, &error); if (stream) { g_input_stream_read_async (G_INPUT_STREAM (stream), loader->buffer, sizeof loader->buffer, G_PRIORITY_DEFAULT, loader->cancellable, avatar_cache_read_cb, loader); } else { 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); } }
GInputStream * gitg_platform_support_http_get_finish (GAsyncResult *result, GError **error) { return G_INPUT_STREAM (g_file_read_finish (g_async_result_get_source_object (result), result, error)); }
static void rygel_seekable_response_on_file_read (RygelSeekableResponse* self, GObject* source_object, GAsyncResult* _result_) { GError * _inner_error_; g_return_if_fail (self != NULL); g_return_if_fail (source_object != NULL); g_return_if_fail (_result_ != NULL); _inner_error_ = NULL; { GFileInputStream* _tmp0_; GFileInputStream* _tmp1_; _tmp0_ = g_file_read_finish (self->priv->file, _result_, &_inner_error_); if (_inner_error_ != NULL) { goto __catch12_g_error; goto __finally12; } _tmp1_ = NULL; self->priv->input_stream = (_tmp1_ = _tmp0_, (self->priv->input_stream == NULL) ? NULL : (self->priv->input_stream = (g_object_unref (self->priv->input_stream), NULL)), _tmp1_); } goto __finally12; __catch12_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { char* _tmp2_; _tmp2_ = NULL; g_warning ("rygel-seekable-response.vala:74: Failed to read from URI: %s: %s\n", _tmp2_ = g_file_get_uri (self->priv->file), err->message); _tmp2_ = (g_free (_tmp2_), NULL); rygel_http_response_end ((RygelHTTPResponse*) self, FALSE, (guint) SOUP_STATUS_NOT_FOUND); (err == NULL) ? NULL : (err = (g_error_free (err), NULL)); return; } } __finally12: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message); g_clear_error (&_inner_error_); return; } if (self->priv->seek != NULL) { { G_FILE_INPUT_STREAM_GET_CLASS (self->priv->input_stream)->seek (self->priv->input_stream, rygel_seek_get_start (self->priv->seek), G_SEEK_SET, ((RygelHTTPResponse*) self)->cancellable, &_inner_error_); if (_inner_error_ != NULL) { goto __catch13_g_error; goto __finally13; } } goto __finally13; __catch13_g_error: { GError * err; err = _inner_error_; _inner_error_ = NULL; { char* _tmp5_; char* _tmp4_; char* _tmp3_; _tmp5_ = NULL; _tmp4_ = NULL; _tmp3_ = NULL; g_warning ("rygel-seekable-response.vala:87: Failed to seek to %s-%s on URI %s: %s\n", _tmp3_ = g_strdup_printf ("%lli", rygel_seek_get_start (self->priv->seek)), _tmp4_ = g_strdup_printf ("%lli", rygel_seek_get_stop (self->priv->seek)), _tmp5_ = g_file_get_uri (self->priv->file), err->message); _tmp5_ = (g_free (_tmp5_), NULL); _tmp4_ = (g_free (_tmp4_), NULL); _tmp3_ = (g_free (_tmp3_), NULL); rygel_http_response_end ((RygelHTTPResponse*) self, FALSE, (guint) SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE); (err == NULL) ? NULL : (err = (g_error_free (err), NULL)); return; } } __finally13: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message); g_clear_error (&_inner_error_); return; } } g_input_stream_read_async ((GInputStream*) self->priv->input_stream, self->priv->buffer, RYGEL_SEEKABLE_RESPONSE_BUFFER_LENGTH, self->priv->priority, ((RygelHTTPResponse*) self)->cancellable, _rygel_seekable_response_on_contents_read_gasync_ready_callback, self); }
static gboolean rygel_seekable_response_real_run_co (RygelSeekableResponseRunData* data) { switch (data->_state_) { case 0: goto _state_0; case 13: goto _state_13; case 14: goto _state_14; default: g_assert_not_reached (); } _state_0: { { data->_state_ = 13; g_file_read_async (data->self->priv->file, data->self->priv->priority, rygel_state_machine_get_cancellable ((RygelStateMachine*) data->self), rygel_seekable_response_run_ready, data); return FALSE; _state_13: data->_tmp0_ = g_file_read_finish (data->self->priv->file, data->_res_, &data->_inner_error_); if (data->_inner_error_ != NULL) { goto __catch35_g_error; } #line 59 "rygel-seekable-response.vala" data->self->priv->input_stream = (data->_tmp1_ = data->_tmp0_, _g_object_unref0 (data->self->priv->input_stream), data->_tmp1_); #line 350 "rygel-seekable-response.c" } goto __finally35; __catch35_g_error: { data->err = data->_inner_error_; data->_inner_error_ = NULL; { #line 62 "rygel-seekable-response.vala" g_warning (_ ("Failed to read from URI: %s: %s"), data->_tmp2_ = g_file_get_uri (data->self->priv->file), data->err->message); #line 360 "rygel-seekable-response.c" _g_free0 (data->_tmp2_); #line 65 "rygel-seekable-response.vala" rygel_http_response_end ((RygelHTTPResponse*) data->self, FALSE, (guint) SOUP_STATUS_NOT_FOUND); #line 364 "rygel-seekable-response.c" _g_error_free0 (data->err); { if (data->_state_ == 0) { g_simple_async_result_complete_in_idle (data->_async_result); } else { g_simple_async_result_complete (data->_async_result); } g_object_unref (data->_async_result); return FALSE; } _g_error_free0 (data->err); } } __finally35: if (data->_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code); g_clear_error (&data->_inner_error_); return FALSE; } data->_state_ = 14; rygel_seekable_response_perform_seek (data->self, rygel_seekable_response_run_ready, data); return FALSE; _state_14: #line 70 "rygel-seekable-response.vala" rygel_seekable_response_perform_seek_finish (data->self, data->_res_); #line 390 "rygel-seekable-response.c" } { if (data->_state_ == 0) { g_simple_async_result_complete_in_idle (data->_async_result); } else { g_simple_async_result_complete (data->_async_result); } g_object_unref (data->_async_result); return FALSE; } }