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