static void
photos_thumbnailer_generate_thumbnail_save_to_stream (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GCancellable *cancellable;
g_autoptr (GTask) task = G_TASK (user_data);
PhotosThumbnailerGenerateData *data;
cancellable = g_task_get_cancellable (task);
data = g_task_get_task_data (task);
{
g_autoptr (GError) error = NULL;
if (!gdk_pixbuf_save_to_stream_finish (res, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
goto out;
}
}
g_output_stream_close_async (G_OUTPUT_STREAM (data->stream),
G_PRIORITY_DEFAULT,
cancellable,
photos_thumbnailer_generate_thumbnail_stream_close,
g_object_ref (task));
out:
return;
}
/* Called to cancel the current operation.
* Puts the async handle into a cancelled state. */
static void
vfs_data_cancel (VfsAsyncHandle *ah)
{
switch (ah->state) {
case VFS_ASYNC_CANCELLED:
break;
case VFS_ASYNC_PROCESSING:
g_cancellable_cancel (ah->cancellable);
break;
case VFS_ASYNC_READY:
break;
}
if (ah->ostream)
g_output_stream_close_async (ah->ostream, G_PRIORITY_DEFAULT, NULL, vfs_data_close_done, ah);
else if (ah->istream)
g_input_stream_close_async (ah->istream, G_PRIORITY_DEFAULT, NULL, vfs_data_close_done, ah);
else
return;
vfs_data_wait_results (ah, FALSE);
ah->state = VFS_ASYNC_CANCELLED;
}
static void
g_filter_output_stream_close_async (GOutputStream *stream,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer data)
{
GFilterOutputStream *filter_stream;
filter_stream = G_FILTER_OUTPUT_STREAM (stream);
g_output_stream_close_async (filter_stream->base_stream,
io_priority,
cancellable,
callback,
data);
}
static void
close_output (CockpitStream *self)
{
if (self->priv->out_closed)
return;
g_debug ("%s: end of output", self->priv->name);
self->priv->out_closed = TRUE;
if (!self->priv->io)
{
close_maybe (self);
return;
}
g_output_stream_close_async (g_io_stream_get_output_stream (self->priv->io),
G_PRIORITY_DEFAULT, NULL, on_output_closed, g_object_ref (self));
}
static VALUE
rg_close_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbio_priority, rbcancellable, block;
int io_priority;
GCancellable *cancellable;
rb_scan_args(argc, argv, "02&", &rbio_priority, &rbcancellable, &block);
io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_output_stream_close_async(_SELF(self),
io_priority,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void on_input_stream_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);
gssize size = g_input_stream_read_finish (G_INPUT_STREAM(object), res, &error);
handle_critical_error (error);
if (size < 0) {
g_downloadable_set_status (download, G_DOWNLOADABLE_NETWORK_ERROR);
return;
}
if (size == 0 && download->priv->size == download->priv->downloaded_size) {
/* Download Completed */
write_chunks_to_output_stream (gio_download);
g_input_stream_close_async (G_INPUT_STREAM(gio_download->priv->input), G_PRIORITY_DEFAULT,
NULL, on_input_stream_close_ready, NULL);
g_output_stream_close_async (G_OUTPUT_STREAM(gio_download->priv->output), G_PRIORITY_DEFAULT,
NULL, on_output_stream_close_ready, NULL);
g_downloadable_set_status (download, G_DOWNLOADABLE_COMPLETED);
g_signal_emit_by_name (download, "download-completed");
return;
}
if (gio_download->priv->num_chunks == NUM_OF_CHUNKS) {
write_chunks_to_output_stream (gio_download);
gio_download->priv->num_chunks = 0;
}
MemChunk *chunk = mem_chunk_new_from_buffer (size, gio_download->priv->chunk_buff);
gio_download->priv->chunks = g_slist_prepend (gio_download->priv->chunks, chunk);
gio_download->priv->num_chunks++;
g_signal_emit_by_name (data, "download-progressed", size);
read_input_stream (download);
}
static void
write_to_outputstream (GcrCertificateExporter *self, GOutputStream *os)
{
gtk_widget_hide (GTK_WIDGET (self->pv->chooser_dialog));
g_assert (GTK_IS_WIDGET (self->pv->chooser_dialog));
/* Are we all done? */
g_assert (self->pv->buffer_at <= self->pv->buffer->len);
if (self->pv->buffer_at == self->pv->buffer->len) {
g_output_stream_close_async (os, G_PRIORITY_DEFAULT,
self->pv->cancellable,
on_outputstream_closed, self);
return;
}
g_output_stream_write_async (os, self->pv->buffer->data + self->pv->buffer_at,
self->pv->buffer->len - self->pv->buffer_at,
G_PRIORITY_DEFAULT, self->pv->cancellable,
on_outputstream_write_ready, self);
}
/* Attempts to push forward the writing side of @msg's I/O. Returns
* %TRUE if it manages to make some progress, and it is likely that
* further progress can be made. Returns %FALSE if it has reached a
* stopping point of some sort (need input from the application,
* socket not writable, write is complete, etc).
*/
static gboolean
io_write (SoupMessage *msg, gboolean blocking,
GCancellable *cancellable, GError **error)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io = priv->io_data;
SoupBuffer *chunk;
gssize nwrote;
if (io->async_close_error) {
g_propagate_error (error, io->async_close_error);
io->async_close_error = NULL;
return FALSE;
} else if (io->async_close_wait) {
g_set_error_literal (error, G_IO_ERROR,
G_IO_ERROR_WOULD_BLOCK,
_("Operation would block"));
return FALSE;
}
switch (io->write_state) {
case SOUP_MESSAGE_IO_STATE_HEADERS:
if (io->mode == SOUP_MESSAGE_IO_SERVER &&
io->read_state == SOUP_MESSAGE_IO_STATE_BLOCKING &&
msg->status_code == 0) {
/* Client requested "Expect: 100-continue", and
* server did not set an error.
*/
soup_message_set_status (msg, SOUP_STATUS_CONTINUE);
}
if (!io->write_buf->len) {
io->get_headers_cb (msg, io->write_buf,
&io->write_encoding,
io->header_data);
}
while (io->written < io->write_buf->len) {
nwrote = g_pollable_stream_write (io->ostream,
io->write_buf->str + io->written,
io->write_buf->len - io->written,
blocking,
cancellable, error);
if (nwrote == -1)
return FALSE;
io->written += nwrote;
}
io->written = 0;
g_string_truncate (io->write_buf, 0);
if (io->mode == SOUP_MESSAGE_IO_SERVER &&
SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) {
if (msg->status_code == SOUP_STATUS_CONTINUE) {
/* Stop and wait for the body now */
io->write_state =
SOUP_MESSAGE_IO_STATE_BLOCKING;
io->read_state = SOUP_MESSAGE_IO_STATE_BODY_START;
} else {
/* We just wrote a 1xx response
* header, so stay in STATE_HEADERS.
* (The caller will pause us from the
* wrote_informational callback if he
* is not ready to send the final
* response.)
*/
}
soup_message_wrote_informational (msg);
/* If this was "101 Switching Protocols", then
* the server probably stole the connection...
*/
if (io != priv->io_data)
return FALSE;
soup_message_cleanup_response (msg);
break;
}
if (io->write_encoding == SOUP_ENCODING_CONTENT_LENGTH) {
SoupMessageHeaders *hdrs =
(io->mode == SOUP_MESSAGE_IO_CLIENT) ?
msg->request_headers : msg->response_headers;
io->write_length = soup_message_headers_get_content_length (hdrs);
}
if (io->mode == SOUP_MESSAGE_IO_CLIENT &&
soup_message_headers_get_expectations (msg->request_headers) & SOUP_EXPECTATION_CONTINUE) {
/* Need to wait for the Continue response */
io->write_state = SOUP_MESSAGE_IO_STATE_BLOCKING;
io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
} else {
io->write_state = SOUP_MESSAGE_IO_STATE_BODY_START;
/* If the client was waiting for a Continue
* but we sent something else, then they're
* now done writing.
*/
if (io->mode == SOUP_MESSAGE_IO_SERVER &&
io->read_state == SOUP_MESSAGE_IO_STATE_BLOCKING)
io->read_state = SOUP_MESSAGE_IO_STATE_DONE;
}
soup_message_wrote_headers (msg);
break;
case SOUP_MESSAGE_IO_STATE_BODY_START:
io->body_ostream = soup_body_output_stream_new (io->ostream,
io->write_encoding,
io->write_length);
io->write_state = SOUP_MESSAGE_IO_STATE_BODY;
break;
case SOUP_MESSAGE_IO_STATE_BODY:
if (!io->write_length &&
io->write_encoding != SOUP_ENCODING_EOF &&
io->write_encoding != SOUP_ENCODING_CHUNKED) {
io->write_state = SOUP_MESSAGE_IO_STATE_BODY_FLUSH;
break;
}
if (!io->write_chunk) {
io->write_chunk = soup_message_body_get_chunk (io->write_body, io->write_body_offset);
if (!io->write_chunk) {
g_return_val_if_fail (!io->item || !io->item->new_api, FALSE);
soup_message_io_pause (msg);
return FALSE;
}
if (!io->write_chunk->length) {
io->write_state = SOUP_MESSAGE_IO_STATE_BODY_FLUSH;
break;
}
}
nwrote = g_pollable_stream_write (io->body_ostream,
io->write_chunk->data + io->written,
io->write_chunk->length - io->written,
blocking,
cancellable, error);
if (nwrote == -1)
return FALSE;
chunk = soup_buffer_new_subbuffer (io->write_chunk,
io->written, nwrote);
io->written += nwrote;
if (io->write_length)
io->write_length -= nwrote;
if (io->written == io->write_chunk->length)
io->write_state = SOUP_MESSAGE_IO_STATE_BODY_DATA;
soup_message_wrote_body_data (msg, chunk);
soup_buffer_free (chunk);
break;
case SOUP_MESSAGE_IO_STATE_BODY_DATA:
io->written = 0;
if (io->write_chunk->length == 0) {
io->write_state = SOUP_MESSAGE_IO_STATE_BODY_FLUSH;
break;
}
if (io->mode == SOUP_MESSAGE_IO_SERVER ||
priv->msg_flags & SOUP_MESSAGE_CAN_REBUILD)
soup_message_body_wrote_chunk (io->write_body, io->write_chunk);
io->write_body_offset += io->write_chunk->length;
soup_buffer_free (io->write_chunk);
io->write_chunk = NULL;
io->write_state = SOUP_MESSAGE_IO_STATE_BODY;
soup_message_wrote_chunk (msg);
break;
case SOUP_MESSAGE_IO_STATE_BODY_FLUSH:
if (io->body_ostream) {
if (blocking || io->write_encoding != SOUP_ENCODING_CHUNKED) {
if (!g_output_stream_close (io->body_ostream, cancellable, error))
return FALSE;
g_clear_object (&io->body_ostream);
} else {
io->async_close_wait = g_cancellable_new ();
if (io->async_context)
g_main_context_push_thread_default (io->async_context);
g_output_stream_close_async (io->body_ostream,
G_PRIORITY_DEFAULT, cancellable,
closed_async, g_object_ref (msg));
if (io->async_context)
g_main_context_pop_thread_default (io->async_context);
}
}
io->write_state = SOUP_MESSAGE_IO_STATE_BODY_DONE;
break;
case SOUP_MESSAGE_IO_STATE_BODY_DONE:
io->write_state = SOUP_MESSAGE_IO_STATE_FINISHING;
soup_message_wrote_body (msg);
break;
case SOUP_MESSAGE_IO_STATE_FINISHING:
io->write_state = SOUP_MESSAGE_IO_STATE_DONE;
if (io->mode == SOUP_MESSAGE_IO_CLIENT)
io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
break;
default:
g_return_val_if_reached (FALSE);
}
return TRUE;
}
/* Save app data lists to file */
static gboolean
idle_save_application_usage (gpointer data)
{
ShellAppUsage *self = SHELL_APP_USAGE (data);
UsageIterator iter;
const char *current_context;
const char *context;
const char *id;
UsageData *usage;
GFileOutputStream *output;
GOutputStream *buffered_output;
GDataOutputStream *data_output;
GError *error = NULL;
self->save_id = 0;
/* Parent directory is already created by shell-global */
output = g_file_replace (self->configfile, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error);
if (!output)
{
g_debug ("Could not save applications usage data: %s", error->message);
g_error_free (error);
return FALSE;
}
buffered_output = g_buffered_output_stream_new (G_OUTPUT_STREAM (output));
g_object_unref (output);
data_output = g_data_output_stream_new (G_OUTPUT_STREAM (buffered_output));
g_object_unref (buffered_output);
if (!g_data_output_stream_put_string (data_output, "<?xml version=\"1.0\"?>\n<application-state>\n", NULL, &error))
goto out;
usage_iterator_init (self, &iter);
current_context = NULL;
while (usage_iterator_next (self, &iter, &context, &id, &usage))
{
ShellApp *app;
app = shell_app_system_lookup_app (shell_app_system_get_default(), id);
if (!app)
continue;
if (context != current_context)
{
if (current_context != NULL)
{
if (!g_data_output_stream_put_string (data_output, " </context>", NULL, &error))
goto out;
}
current_context = context;
if (!g_data_output_stream_put_string (data_output, " <context", NULL, &error))
goto out;
if (!write_attribute_string (data_output, "id", context, &error))
goto out;
if (!g_data_output_stream_put_string (data_output, ">\n", NULL, &error))
goto out;
}
if (!g_data_output_stream_put_string (data_output, " <application", NULL, &error))
goto out;
if (!write_attribute_string (data_output, "id", id, &error))
goto out;
if (!write_attribute_uint (data_output, "open-window-count", shell_app_get_n_windows (app), &error))
goto out;
if (!write_attribute_double (data_output, "score", usage->score, &error))
goto out;
if (!write_attribute_uint (data_output, "last-seen", usage->last_seen, &error))
goto out;
if (!g_data_output_stream_put_string (data_output, "/>\n", NULL, &error))
goto out;
}
if (current_context != NULL)
{
if (!g_data_output_stream_put_string (data_output, " </context>\n", NULL, &error))
goto out;
}
if (!g_data_output_stream_put_string (data_output, "</application-state>\n", NULL, &error))
goto out;
out:
if (!error)
g_output_stream_close_async (G_OUTPUT_STREAM (data_output), 0, NULL, NULL, NULL);
g_object_unref (data_output);
if (error)
{
g_debug ("Could not save applications usage data: %s", error->message);
g_error_free (error);
}
return FALSE;
}
