static void
on_replace_file_ready (GObject *source, GAsyncResult *res, gpointer user_data)
{
GcrCertificateExporter *self = GCR_CERTIFICATE_EXPORTER (user_data);
GFile *file = G_FILE (source);
GFileOutputStream *os;
os = g_file_replace_finish (file, res, &self->pv->error);
if (self->pv->error) {
complete_async_result (self);
return;
}
write_to_outputstream (self, G_OUTPUT_STREAM (os));
}
void didReceiveData(ResourceHandle*, const char* data, int length, int /*encodedDataLength*/)
{
if (m_handleResponseLaterID) {
g_source_remove(m_handleResponseLaterID);
handleResponse();
}
gsize bytesWritten;
GOwnPtr<GError> error;
g_output_stream_write_all(G_OUTPUT_STREAM(m_outputStream.get()), data, length, &bytesWritten, 0, &error.outPtr());
if (error) {
downloadFailed(platformDownloadDestinationError(ResourceResponse(m_response.get()), error->message));
return;
}
m_download->didReceiveData(bytesWritten);
}
static gssize
g_pollable_output_stream_default_write_nonblocking (GPollableOutputStream *stream,
const void *buffer,
gsize count,
GError **error)
{
if (!g_pollable_output_stream_is_writable (stream))
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK,
g_strerror (EAGAIN));
return -1;
}
return G_OUTPUT_STREAM_GET_CLASS (stream)->
write_fn (G_OUTPUT_STREAM (stream), buffer, count, NULL, error);
}
/* called in an I/O thread */
static GOutputStream *
get_stream_for_unique_path (const gchar *path,
const gchar *filename,
gchar **filename_used)
{
GOutputStream *stream;
GFile *file;
gchar *real_path, *real_filename, *name, *ptr;
gint idx;
ptr = g_strrstr (filename, ".png");
if (ptr != NULL)
real_filename = g_strndup (filename, ptr - filename);
else
real_filename = g_strdup (filename);
idx = 0;
real_path = NULL;
do
{
if (idx == 0)
name = g_strdup_printf ("%s.png", real_filename);
else
name = g_strdup_printf ("%s - %d.png", real_filename, idx);
real_path = g_build_filename (path, name, NULL);
g_free (name);
file = g_file_new_for_path (real_path);
stream = G_OUTPUT_STREAM (g_file_create (file, G_FILE_CREATE_NONE, NULL, NULL));
g_object_unref (file);
if (stream != NULL)
*filename_used = real_path;
else
g_free (real_path);
idx++;
}
while (stream == NULL);
g_free (real_filename);
return stream;
}
static tsize_t
write_to_stream(thandle_t handle,
tdata_t buffer,
tsize_t size)
{
Priv *p = (Priv*) handle;
GError *error = NULL;
gchar *new_buffer;
gsize new_size;
gssize written = -1;
g_assert(p->stream);
if (p->can_seek)
{
written = g_output_stream_write(G_OUTPUT_STREAM(p->stream),
(void *) buffer, (gsize) size,
NULL, &error);
if (written < 0)
{
g_warning("%s", error->message);
g_error_free(error);
}
}
else
{
if (p->position + size > p->allocated)
{
new_size = p->position + size;
new_buffer = g_try_realloc(p->buffer, new_size);
if (!new_buffer)
return -1;
p->allocated = new_size;
p->buffer = new_buffer;
}
g_assert(p->position + size >= p->allocated);
memcpy(p->buffer + p->position, buffer, size);
p->position += size;
written = size;
}
return (tsize_t) written;
}
static void
cache_splice_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
g_output_stream_splice_finish (G_OUTPUT_STREAM (source),
res, &error);
if (error != NULL) {
g_warning ("Can't save the cover art image in the cache: %s\n", error->message);
g_error_free (error);
return;
}
}
static gboolean
debug_dialog_store_filter_foreach (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer user_data)
{
GFileOutputStream *output_stream = (GFileOutputStream *) user_data;
gchar *domain, *category, *message, *level_str, *level_upper;
gdouble timestamp;
gchar *line;
GError *error = NULL;
gboolean out = FALSE;
gtk_tree_model_get (model, iter,
COL_DEBUG_TIMESTAMP, ×tamp,
COL_DEBUG_DOMAIN, &domain,
COL_DEBUG_CATEGORY, &category,
COL_DEBUG_LEVEL_STRING, &level_str,
COL_DEBUG_MESSAGE, &message,
-1);
level_upper = g_ascii_strup (level_str, -1);
line = g_strdup_printf ("%s%s%s-%s: %e: %s\n",
domain, EMP_STR_EMPTY (category) ? "" : "/",
category, level_upper, timestamp, message);
g_output_stream_write (G_OUTPUT_STREAM (output_stream), line,
strlen (line), NULL, &error);
if (error != NULL)
{
DEBUG ("Failed to write to file: %s", error->message);
g_error_free (error);
out = TRUE;
}
g_free (line);
g_free (level_upper);
g_free (level_str);
g_free (domain);
g_free (category);
g_free (message);
return out;
}
static void
os_splice_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GError *error = NULL;
PdfLoadJob *job = user_data;
g_output_stream_splice_finish (G_OUTPUT_STREAM (source), res, &error);
if (error != NULL) {
pdf_load_job_complete_error (job, error);
return;
}
pdf_load_job_cache_set_attributes (job);
}
static gboolean
nice_output_stream_is_writable (GPollableOutputStream *stream)
{
NiceOutputStreamPrivate *priv = NICE_OUTPUT_STREAM (stream)->priv;
NiceComponent *component = NULL;
NiceStream *_stream = NULL;
gboolean retval = FALSE;
NiceAgent *agent; /* owned */
/* Closed streams are not writeable. */
if (g_output_stream_is_closed (G_OUTPUT_STREAM (stream)))
return FALSE;
/* Has the agent disappeared? */
agent = g_weak_ref_get (&priv->agent_ref);
if (agent == NULL)
return FALSE;
agent_lock ();
if (!agent_find_component (agent, priv->stream_id, priv->component_id,
&_stream, &component)) {
g_warning ("Could not find component %u in stream %u", priv->component_id,
priv->stream_id);
goto done;
}
if (component->selected_pair.local != NULL) {
NiceSocket *sockptr = component->selected_pair.local->sockptr;
/* If it’s a reliable agent, see if there’s any space in the pseudo-TCP
* output buffer. */
if (!nice_socket_is_reliable (sockptr)) {
retval = pseudo_tcp_socket_can_send (component->tcp);
} else {
retval = (g_socket_condition_check (sockptr->fileno, G_IO_OUT) != 0);
}
}
done:
agent_unlock ();
g_object_unref (agent);
return retval;
}
static GFile *
create_file (GFile *base_dir)
{
GFile *scratch_file;
gchar *scratch_name;
GOutputStream *output_stream;
gint pid;
GError *error = NULL;
gchar buffer [BUFFER_SIZE];
gint i;
pid = getpid ();
scratch_name = g_strdup_printf ("gvfs-benchmark-scratch-%d", pid);
scratch_file = g_file_resolve_relative_path (base_dir, scratch_name);
g_free (scratch_name);
if (!scratch_file)
return NULL;
output_stream = G_OUTPUT_STREAM (g_file_replace (scratch_file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error));
if (!output_stream)
{
g_printerr ("Failed to create scratch file: %s\n", error->message);
g_object_unref (scratch_file);
return NULL;
}
memset (buffer, 0xaa, BUFFER_SIZE);
for (i = 0; i < FILE_SIZE; i += BUFFER_SIZE)
{
if (g_output_stream_write (output_stream, buffer, BUFFER_SIZE, NULL, &error) < BUFFER_SIZE)
{
g_printerr ("Failed to populate scratch file: %s\n", error->message);
g_output_stream_close (output_stream, NULL, NULL);
g_object_unref (output_stream);
g_object_unref (scratch_file);
return NULL;
}
}
g_output_stream_close (output_stream, NULL, NULL);
g_object_unref (output_stream);
return scratch_file;
}
static void
tunnel_wrote_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
Tunnel *tunnel = user_data;
TunnelEnd *write_end, *read_end;
GError *error = NULL;
gssize nwrote;
nwrote = g_output_stream_write_finish (G_OUTPUT_STREAM (object), result, &error);
if (nwrote <= 0) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_error_free (error);
return;
} else if (error) {
g_print ("Tunnel write failed: %s\n", error->message);
g_error_free (error);
}
tunnel_close (tunnel);
return;
}
if (object == (GObject *)tunnel->client.ostream) {
write_end = &tunnel->client;
read_end = &tunnel->server;
} else {
write_end = &tunnel->server;
read_end = &tunnel->client;
}
write_end->nwrote += nwrote;
if (write_end->nwrote < read_end->nread) {
g_output_stream_write_async (write_end->ostream,
read_end->buffer + write_end->nwrote,
read_end->nread - write_end->nwrote,
G_PRIORITY_DEFAULT, tunnel->cancellable,
tunnel_wrote_cb, tunnel);
} else {
g_input_stream_read_async (read_end->istream,
read_end->buffer, BUFSIZE,
G_PRIORITY_DEFAULT, tunnel->cancellable,
tunnel_read_cb, tunnel);
}
}
static ssize_t
stream_write (CamelStream *stream, const char *buffer, size_t n)
{
gssize nwritten;
GError *error = NULL;
CamelStreamVFS *stream_vfs = CAMEL_STREAM_VFS (stream);
g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream_vfs->stream), 0);
nwritten = g_output_stream_write (G_OUTPUT_STREAM (stream_vfs->stream), buffer, n, NULL, &error);
if (error) {
g_warning ("%s", error->message);
g_error_free (error);
}
return nwritten;
}
static void ekg_connection_remove(struct ekg_connection *c) {
if (g_input_stream_has_pending(G_INPUT_STREAM(c->instream))) {
debug_warn("ekg_connection_remove(%x) input stream has pending!\n", c);
g_input_stream_clear_pending(G_INPUT_STREAM(c->instream));
}
#if 0 /* XXX */
g_assert(!g_output_stream_has_pending(
G_OUTPUT_STREAM(c->outstream)));
#endif
connections = g_slist_remove(connections, c);
g_string_free(c->wr_buffer, TRUE);
g_object_unref(c->cancellable);
g_object_unref(c->instream);
g_object_unref(c->outstream);
g_slice_free(struct ekg_connection, c);
}
static void
on_output_closed (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
CockpitStream *self = COCKPIT_STREAM (user_data);
GError *error = NULL;
g_output_stream_close_finish (G_OUTPUT_STREAM (object), result, &error);
if (error)
{
g_warning ("%s: couldn't close output stream: %s", self->priv->name, error->message);
close_immediately (self, "internal-error");
}
close_maybe (self);
g_object_unref (self);
}
/**
* soup_output_stream_new:
* @session: the #SoupSession to use
* @msg: the #SoupMessage whose request will be streamed
* @size: the total size of the request body, or -1 if not known
*
* Prepares to send @msg over @session, and returns a #GOutputStream
* that can be used to write the response. The server's response will
* be available in @msg after calling soup_output_stream_close()
* (which will return a %SOUP_OUTPUT_STREAM_HTTP_ERROR #GError if the
* status is not 2xx).
*
* If you know the total number of bytes that will be written, pass
* that in @size. Otherwise, pass -1. (If you pass a size, you MUST
* write that many bytes to the stream; Trying to write more than
* that, or closing the stream without having written enough, will
* result in an error.
*
* In some situations, the request will not actually be sent until you
* call g_output_stream_close(). (In fact, currently this is *always*
* true.)
*
* Internally, #SoupOutputStream is implemented using asynchronous
* I/O, so if you are using the synchronous API (eg,
* g_output_stream_write()), you should create a new #GMainContext and
* set it as the %SOUP_SESSION_ASYNC_CONTEXT property on @session. (If
* you don't, then synchronous #GOutputStream calls will cause the
* main loop to be run recursively.) The async #GOutputStream API
* works fine with %SOUP_SESSION_ASYNC_CONTEXT either set or unset.
*
* Returns: a new #GOutputStream.
**/
GOutputStream *
soup_output_stream_new (SoupSession *session, SoupMessage *msg, goffset size)
{
SoupOutputStream *stream;
SoupOutputStreamPrivate *priv;
g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
stream = g_object_new (SOUP_TYPE_OUTPUT_STREAM, NULL);
priv = SOUP_OUTPUT_STREAM_GET_PRIVATE (stream);
priv->session = g_object_ref (session);
priv->async_context = soup_session_get_async_context (session);
priv->msg = g_object_ref (msg);
priv->size = size;
return G_OUTPUT_STREAM (stream);
}
static void
splice_stream_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
EmpathyTpFile *self = user_data;
GError *error = NULL;
g_output_stream_splice_finish (G_OUTPUT_STREAM (source), res, &error);
DEBUG ("Splice stream ready cb, error %p", error);
if (error != NULL && !self->priv->is_closing)
{
ft_operation_close_with_error (self, error);
g_clear_error (&error);
return;
}
}
static void
write_buf_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
GOutputStream *output = G_OUTPUT_STREAM (object);
RequestData *req_data = user_data;
GVfsAfpConnection *afp_conn = req_data->conn;
GVfsAfpConnectionPrivate *priv = afp_conn->priv;
HANDLE_RES ();
g_hash_table_insert (priv->request_hash,
GUINT_TO_POINTER ((guint)GUINT16_FROM_BE (priv->write_dsi_header.requestID)),
req_data);
g_mutex_lock (&priv->mutex);
send_request_unlocked (afp_conn);
g_mutex_unlock (&priv->mutex);
}
static void
gdav_request_splice_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupMessage *message;
GTask *task = G_TASK (user_data);
GError *local_error = NULL;
message = g_task_get_task_data (task);
g_output_stream_splice_finish (
G_OUTPUT_STREAM (source_object), result, &local_error);
if (local_error != NULL) {
g_task_return_error (task, local_error);
/* XXX That the input stream's content is not automatically
* copied to the SoupMessage's response_body is a known
* libsoup bug which may be fixed in a future release.
* Check that the response body is empty so we don't
* accidentally duplicate the body. */
} else if (message->response_body->data == NULL) {
GMemoryOutputStream *output_stream;
gpointer data;
gsize size;
output_stream = G_MEMORY_OUTPUT_STREAM (source_object);
size = g_memory_output_stream_get_data_size (output_stream);
data = g_memory_output_stream_steal_data (output_stream);
soup_message_body_append_take (
message->response_body, data, size);
soup_message_body_flatten (message->response_body);
soup_message_finished (message);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_boolean (task, TRUE);
}
g_object_unref (task);
}
/* 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 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 int
stream_flush (CamelStream *stream)
{
CamelStreamVFS *stream_vfs = CAMEL_STREAM_VFS (stream);
GError *error = NULL;
g_return_val_if_fail (CAMEL_IS_STREAM_VFS (stream) && stream_vfs != NULL, -1);
g_return_val_if_fail (stream_vfs->stream != NULL, -1);
g_return_val_if_fail (G_IS_OUTPUT_STREAM (stream_vfs->stream), -1);
g_output_stream_flush (G_OUTPUT_STREAM (stream_vfs->stream), NULL, &error);
if (error) {
g_warning ("%s", error->message);
g_error_free (error);
return -1;
}
return 0;
}
static void
write_buf_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
GOutputStream *output = G_OUTPUT_STREAM (object);
GVfsAfpConnection *afp_conn = G_VFS_AFP_CONNECTION (user_data);
GVfsAfpConnectionPrivate *priv = afp_conn->priv;
RequestData *req_data;
req_data = g_queue_peek_head (priv->request_queue);
HANDLE_RES ();
g_hash_table_insert (priv->request_hash,
GUINT_TO_POINTER ((guint)GUINT16_FROM_BE (priv->write_dsi_header.requestID)),
req_data);
g_queue_pop_head (priv->request_queue);
send_request (afp_conn);
}
static void
cleanup(GeglOperation *operation)
{
GeglProperties *o = GEGL_PROPERTIES(operation);
Priv *p = (Priv*) o->user_data;
if (p != NULL)
{
if (p->tiff != NULL)
TIFFClose(p->tiff);
else if (p->stream != NULL)
g_output_stream_close(G_OUTPUT_STREAM(p->stream), NULL, NULL);
if (p->stream != NULL)
g_clear_object(&p->stream);
p->tiff = NULL;
if (p->file != NULL)
g_clear_object(&p->file);
}
}
static gssize
nice_output_stream_write_nonblocking (GPollableOutputStream *stream,
const void *buffer, gsize count, GError **error)
{
NiceOutputStreamPrivate *priv = NICE_OUTPUT_STREAM (stream)->priv;
NiceAgent *agent; /* owned */
gint n_sent;
/* Closed streams are not writeable. */
if (g_output_stream_is_closed (G_OUTPUT_STREAM (stream))) {
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
"Stream is closed.");
return -1;
}
/* Has the agent disappeared? */
agent = g_weak_ref_get (&priv->agent_ref);
if (agent == NULL) {
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED,
"Stream is closed due to the NiceAgent being finalised.");
return -1;
}
if (count == 0) {
n_sent = 0;
goto done;
}
n_sent = nice_agent_send (agent, priv->stream_id, priv->component_id,
count, buffer);
if (n_sent == -1)
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK,
g_strerror (EAGAIN));
done:
g_object_unref (agent);
return n_sent;
}
static void
on_outputstream_write_ready (GObject *source, GAsyncResult *res, gpointer user_data)
{
GcrCertificateExporter *self = GCR_CERTIFICATE_EXPORTER (user_data);
GOutputStream *os = G_OUTPUT_STREAM (source);
gssize written;
written = g_output_stream_write_finish (os, res, &self->pv->error);
if (self->pv->error) {
complete_async_result (self);
return;
}
g_return_if_fail (written >= 0);
g_return_if_fail (written <= self->pv->buffer->len - self->pv->buffer_at);
self->pv->buffer_at += written;
/* Write next bit, or finished */
write_to_outputstream (self, os);
}
static GOutputStream *
prepare_write_stream (const gchar *filename,
gchar **filename_used)
{
GOutputStream *stream;
GFile *file;
if (g_path_is_absolute (filename))
{
file = g_file_new_for_path (filename);
*filename_used = g_strdup (filename);
stream = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL));
g_object_unref (file);
}
else
{
stream = get_stream_for_filename (filename, filename_used);
}
return stream;
}
static void
on_create_file_ready (GObject *source, GAsyncResult *res, gpointer user_data)
{
GcrCertificateExporter *self = GCR_CERTIFICATE_EXPORTER (user_data);
GFileOutputStream *os;
GtkWidget *dialog;
os = g_file_create_finish (self->pv->output_file, res, &self->pv->error);
/* Try again this time replacing the file */
if (g_error_matches (self->pv->error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
g_clear_error (&self->pv->error);
dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (self->pv->chooser_dialog),
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE, "<b>%s</b>\n\n%s",
_("A file already exists with this name."),
_("Do you want to replace it with a new file?"));
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Replace"), GTK_RESPONSE_ACCEPT, NULL);
g_signal_connect (dialog, "response",
G_CALLBACK (on_replace_dialog_response), self);
if (self->pv->cancellable)
g_cancellable_connect (self->pv->cancellable,
G_CALLBACK (on_cancel_replace_dialog),
g_object_ref (dialog), g_object_unref);
gtk_widget_show (dialog);
return;
}
if (self->pv->error) {
complete_async_result (self);
return;
}
write_to_outputstream (self, G_OUTPUT_STREAM (os));
}
static void
disabled_repos_free (GHashTable *disabled)
{
GHashTableIter iter;
GFile *file;
GFileOutputStream *file_stream;
GDataOutputStream *data_stream;
const gchar *line = PACMAN_REPO_LIST_HEADER "\n";
g_return_if_fail (disabled != NULL);
g_debug ("pacman: storing disabled repos in %s", PACMAN_REPO_LIST);
file = g_file_new_for_path (PACMAN_REPO_LIST);
file_stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, NULL);
if (file_stream == NULL) {
g_object_unref (file);
g_hash_table_unref (disabled);
return;
}
g_hash_table_iter_init (&iter, disabled);
data_stream = g_data_output_stream_new (G_OUTPUT_STREAM (file_stream));
/* write header, then all disabled repos line by line */
if (g_data_output_stream_put_string (data_stream, line, NULL, NULL)) {
while (g_hash_table_iter_next (&iter, (gpointer *) &line, NULL) &&
g_data_output_stream_put_string (data_stream, line, NULL, NULL) &&
g_data_output_stream_put_string (data_stream, "\n", NULL, NULL));
}
g_object_unref (data_stream);
g_object_unref (file_stream);
g_object_unref (file);
g_hash_table_unref (disabled);
}
void
arv_dom_document_save_to_url (ArvDomDocument *document, const char *path, GError **error)
{
GFile *file;
GFileOutputStream *stream;
g_return_if_fail (path != NULL);
file = g_file_new_for_uri (path);
stream = g_file_create (file, G_FILE_CREATE_REPLACE_DESTINATION, NULL, error);
if (stream != NULL) {
arv_dom_document_save_to_stream (document, G_OUTPUT_STREAM (stream), error);
g_object_unref (stream);
}
g_object_unref (file);
}
void didReceiveData(ResourceHandle*, const char* data, unsigned length, int /*encodedDataLength*/)
{
if (m_handleResponseLater.isScheduled()) {
m_handleResponseLater.cancel();
handleResponse();
}
gsize bytesWritten;
GUniqueOutPtr<GError> error;
g_output_stream_write_all(G_OUTPUT_STREAM(m_outputStream.get()), data, length, &bytesWritten, 0, &error.outPtr());
if (error) {
downloadFailed(platformDownloadDestinationError(m_response, error->message));
return;
}
m_download->didReceiveData(bytesWritten);
}
