gboolean
soup_test_request_close_stream (SoupRequest *req,
GInputStream *stream,
GCancellable *cancellable,
GError **error)
{
AsyncAsSyncData data;
gboolean ok;
if (SOUP_IS_SESSION_SYNC (soup_request_get_session (req)))
return g_input_stream_close (stream, cancellable, error);
data.loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE);
g_input_stream_close_async (stream, G_PRIORITY_DEFAULT, cancellable,
async_as_sync_callback, &data);
g_main_loop_run (data.loop);
ok = g_input_stream_close_finish (stream, data.result, error);
g_main_loop_unref (data.loop);
g_object_unref (data.result);
return ok;
}
/* *** read_close () *** */
static void
close_read_ready (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
GInputStream *stream;
GVfsJob *job;
GError *error = NULL;
gboolean res;
job = G_VFS_JOB (user_data);
stream = G_INPUT_STREAM (source_object);
res = g_input_stream_close_finish (stream,
result,
&error);
if (res == FALSE)
{
g_vfs_job_failed_literal (G_VFS_JOB (job),
error->domain,
error->code,
error->message);
g_error_free (error);
}
else
g_vfs_job_succeeded (job);
g_object_unref (stream);
}
static void closeCallback(GObject* source, GAsyncResult* res, gpointer data)
{
ResourceHandle* handle = static_cast<ResourceHandle*>(data);
ResourceHandleInternal* d = handle->getInternal();
g_input_stream_close_finish(d->m_input_stream, res, NULL);
cleanupGioOperation(handle);
}
static void
multipart_close_part_cb (GObject *source, GAsyncResult *res, gpointer data)
{
GInputStream *in = G_INPUT_STREAM (source);
GError *error = NULL;
g_input_stream_close_finish (in, res, &error);
if (error) {
debug_printf (1, " error closing stream: %s\n", error->message);
errors++;
}
}
static void
stream_close_cb (GObject *obj, GAsyncResult *res, gpointer data)
{
GError *error = NULL;
g_input_stream_close_finish (G_INPUT_STREAM (obj), res, &error);
if (error != NULL) {
rb_debug ("unable to close input stream: %s", error->message);
g_clear_error (&error);
}
}
static void
close_cb (GObject *source,
GAsyncResult *async_result,
gpointer user_data)
{
GError *error = NULL;
g_input_stream_close_finish (G_INPUT_STREAM (source), async_result, &error);
if (error) {
g_printerr("close_cb: %s [%s, %d]\n", error->message,
g_quark_to_string(error->domain),
error->code);
g_error_free (error);
}
}
static void gtkhash_hash_file_close_finish(
G_GNUC_UNUSED GObject *source, GAsyncResult *res, struct hash_file_s *data)
{
if (G_UNLIKELY(!g_input_stream_close_finish(G_INPUT_STREAM(data->stream), res, NULL) &&
!g_cancellable_is_cancelled(data->cancellable)))
{
g_warning("failed to close file (%s)", data->uri);
}
g_object_unref(data->stream);
gtkhash_hash_file_remove_report_source(data);
gtkhash_hash_file_set_state(data, HASH_FILE_STATE_FINISH);
gtkhash_hash_file_add_source(data);
}
static void
file_close_callback (GObject *object,
GAsyncResult *res,
gpointer data)
{
CajaImagePropertiesPage *page;
GInputStream *stream;
page = CAJA_IMAGE_PROPERTIES_PAGE (data);
stream = G_INPUT_STREAM (object);
g_input_stream_close_finish (stream, res, NULL);
g_object_unref (page->details->cancellable);
page->details->cancellable = NULL;
}
static gboolean
g_filter_input_stream_close_finish (GInputStream *stream,
GAsyncResult *result,
GError **error)
{
GFilterInputStream *filter_stream;
GInputStream *base_stream;
gboolean res;
filter_stream = G_FILTER_INPUT_STREAM (stream);
base_stream = filter_stream->base_stream;
res = g_input_stream_close_finish (stream,
result,
error);
return res;
}
static void rygel_seekable_response_on_input_stream_closed (RygelSeekableResponse* self, GObject* source_object, GAsyncResult* _result_) {
GError * _inner_error_;
GFileInputStream* _tmp0_;
GFileInputStream* input_stream;
g_return_if_fail (self != NULL);
g_return_if_fail (source_object != NULL);
g_return_if_fail (_result_ != NULL);
_inner_error_ = NULL;
_tmp0_ = NULL;
input_stream = (_tmp0_ = G_FILE_INPUT_STREAM (source_object), (_tmp0_ == NULL) ? NULL : g_object_ref (_tmp0_));
{
g_input_stream_close_finish ((GInputStream*) input_stream, _result_, &_inner_error_);
if (_inner_error_ != NULL) {
goto __catch15_g_error;
goto __finally15;
}
}
goto __finally15;
__catch15_g_error:
{
GError * err;
err = _inner_error_;
_inner_error_ = NULL;
{
char* _tmp1_;
_tmp1_ = NULL;
g_warning ("rygel-seekable-response.vala:136: Failed to close stream to URI %s: %s\n", _tmp1_ = g_file_get_uri (self->priv->file), err->message);
_tmp1_ = (g_free (_tmp1_), NULL);
(err == NULL) ? NULL : (err = (g_error_free (err), NULL));
}
}
__finally15:
if (_inner_error_ != NULL) {
(input_stream == NULL) ? NULL : (input_stream = (g_object_unref (input_stream), NULL));
g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, _inner_error_->message);
g_clear_error (&_inner_error_);
return;
}
rygel_http_response_end ((RygelHTTPResponse*) self, FALSE, (guint) SOUP_STATUS_NONE);
(input_stream == NULL) ? NULL : (input_stream = (g_object_unref (input_stream), NULL));
}
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 void on_input_stream_close_ready (GObject * object, GAsyncResult * res, gpointer data)
{
GError * error = NULL;
g_input_stream_close_finish (G_INPUT_STREAM(object), res, &error);
handle_critical_error (error);
}
inline static void
www_closeStream_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
g_input_stream_close_finish (G_INPUT_STREAM (source_object), res, NULL);
g_object_unref (G_INPUT_STREAM (source_object));
}
static gboolean rygel_seekable_response_close_stream_co (RygelSeekableResponseCloseStreamData* data) {
switch (data->_state_) {
case 0:
goto _state_0;
case 21:
goto _state_21;
default:
g_assert_not_reached ();
}
_state_0:
{
{
data->_state_ = 21;
g_input_stream_close_async ((GInputStream*) data->self->priv->input_stream, data->self->priv->priority, rygel_state_machine_get_cancellable ((RygelStateMachine*) data->self), rygel_seekable_response_close_stream_ready, data);
return FALSE;
_state_21:
#line 151 "rygel-seekable-response.vala"
g_input_stream_close_finish ((GInputStream*) data->self->priv->input_stream, data->_res_, &data->_inner_error_);
#line 863 "rygel-seekable-response.c"
if (data->_inner_error_ != NULL) {
goto __catch38_g_error;
}
}
goto __finally38;
__catch38_g_error:
{
data->err = data->_inner_error_;
data->_inner_error_ = NULL;
{
#line 154 "rygel-seekable-response.vala"
g_warning (_ ("Failed to close stream to URI %s: %s"), data->_tmp0_ = g_file_get_uri (data->self->priv->file), data->err->message);
#line 876 "rygel-seekable-response.c"
_g_free0 (data->_tmp0_);
_g_error_free0 (data->err);
}
}
__finally38:
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;
}
#line 159 "rygel-seekable-response.vala"
if (rygel_state_machine_get_cancellable ((RygelStateMachine*) data->self) == NULL) {
#line 159 "rygel-seekable-response.vala"
data->_tmp1_ = TRUE;
#line 891 "rygel-seekable-response.c"
} else {
#line 159 "rygel-seekable-response.vala"
data->_tmp1_ = !g_cancellable_is_cancelled (rygel_state_machine_get_cancellable ((RygelStateMachine*) data->self));
#line 895 "rygel-seekable-response.c"
}
#line 159 "rygel-seekable-response.vala"
if (data->_tmp1_) {
#line 160 "rygel-seekable-response.vala"
rygel_http_response_end ((RygelHTTPResponse*) data->self, FALSE, (guint) SOUP_STATUS_NONE);
#line 901 "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;
}
}
