static void
read_cb (GObject *source, GAsyncResult *asyncResult, gpointer data)
{
GMainLoop *loop = (GMainLoop*)data;
GInputStream *stream = G_INPUT_STREAM (source);
GError *error = NULL;
gssize bytes_read = g_input_stream_read_finish (stream, asyncResult, &error);
if (error) {
debug_printf (1, " failed read: %s\n", error->message);
errors++;
g_object_unref (stream);
g_main_loop_quit (loop);
return;
}
if (!bytes_read) {
g_input_stream_close (stream, NULL, &error);
g_object_unref (stream);
if (error) {
debug_printf (1, " failed close: %s\n", error->message);
errors++;
}
g_main_loop_quit (loop);
return;
}
g_input_stream_read_async (stream, buffer, READ_BUFFER_SIZE,
G_PRIORITY_DEFAULT, NULL,
read_cb, data);
}
static void inputStreamReadReadyCallback(GInputStream* stream, GAsyncResult* result, gpointer userData)
{
std::unique_ptr<ReadAsyncData> asyncData(static_cast<ReadAsyncData*>(userData));
gssize bytesRead = g_input_stream_read_finish(stream, result, nullptr);
if (bytesRead == -1) {
asyncData->completionHandler(asyncData->data, -1);
return;
}
if (!bytesRead) {
asyncData->completionHandler(asyncData->data, 0);
return;
}
ASSERT(bytesRead > 0);
fillDataFromReadBuffer(asyncData->buffer.get(), static_cast<size_t>(bytesRead), asyncData->data);
size_t pendingBytesToRead = asyncData->bytesToRead - asyncData->data.size();
if (!pendingBytesToRead) {
asyncData->completionHandler(asyncData->data, 0);
return;
}
size_t bytesToRead = std::min(pendingBytesToRead, asyncData->buffer->length);
// Use a local variable for the data buffer to pass it to g_input_stream_read_async(), because ReadAsyncData is released.
auto data = const_cast<char*>(asyncData->buffer->data);
g_input_stream_read_async(stream, data, bytesToRead, G_PRIORITY_DEFAULT, nullptr,
reinterpret_cast<GAsyncReadyCallback>(inputStreamReadReadyCallback), asyncData.release());
}
/* Called by gpgme to read data */
static ssize_t
vfs_data_read (void *handle, void *buffer, size_t size)
{
VfsAsyncHandle* ah = (VfsAsyncHandle*)handle;
ssize_t sz = 0;
/* Just in case we have an operation, like open */
if (!vfs_data_wait_results(ah, TRUE))
return -1;
g_assert (ah->state == VFS_ASYNC_READY);
/* Start async operation */
ah->buffer = buffer;
ah->state = VFS_ASYNC_PROCESSING;
ah->operation = VFS_OP_READING;
g_input_stream_read_async (ah->istream, buffer, size, G_PRIORITY_DEFAULT, ah->cancellable, vfs_data_read_done, ah);
/* Wait for it */
if (!vfs_data_wait_results (ah, TRUE))
return -1;
/* Return results */
sz = (ssize_t)ah->processed;
ah->state = VFS_ASYNC_READY;
ah->buffer = NULL;
ah->processed = 0;
return sz;
}
static void readCallback(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;
}
gssize nread;
GError *error = 0;
nread = g_input_stream_read_finish(d->m_input_stream, res, &error);
if (error) {
cleanupGioOperation(handle);
// FIXME: error
client->didFinishLoading(handle);
return;
} else if (!nread) {
client->didFinishLoading(handle);
g_input_stream_close_async(d->m_input_stream, G_PRIORITY_DEFAULT,
NULL, closeCallback, handle);
return;
}
d->m_total += nread;
client->didReceiveData(handle, d->m_buffer, nread, d->m_total);
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 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
read_all_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GInputStream *stream = G_INPUT_STREAM (source_object);
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
gsize bytes_read;
GError *err = NULL;
ReadAllData *read_data;
bytes_read = g_input_stream_read_finish (stream, res, &err);
if (bytes_read == -1)
{
g_simple_async_result_take_error (simple, err);
goto done;
}
read_data = g_simple_async_result_get_op_res_gpointer (simple);
read_data->bytes_read += bytes_read;
if (read_data->bytes_read < read_data->count)
{
g_input_stream_read_async (stream,
(guint8 *)read_data->buffer + read_data->bytes_read,
read_data->count - read_data->bytes_read, 0,
read_data->cancellable, read_all_cb, simple);
return;
}
done:
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
static void
read_all_async (GInputStream *stream,
void *buffer,
gsize count,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
ReadAllData *read_data;
GSimpleAsyncResult *simple;
read_data = g_slice_new0 (ReadAllData);
read_data->buffer = buffer;
read_data->count = count;
read_data->io_priority = io_priority;
if (cancellable)
read_data->cancellable = g_object_ref (cancellable);
simple = g_simple_async_result_new (G_OBJECT (stream), callback, user_data,
read_all_async);
g_simple_async_result_set_op_res_gpointer (simple, read_data,
(GDestroyNotify)free_read_all_data);
g_input_stream_read_async (stream, buffer, count, io_priority, cancellable,
read_all_cb, simple);
}
static void
stream_read_async_cb (GObject *obj, GAsyncResult *res, gpointer data)
{
RBChunkLoader *loader = RB_CHUNK_LOADER (data);
gssize done;
done = g_input_stream_read_finish (G_INPUT_STREAM (obj),
res,
&loader->priv->error);
if (done == -1) {
rb_debug ("error reading from stream: %s", loader->priv->error->message);
loader->priv->callback (loader, NULL, 0, loader->priv->callback_data);
cleanup (loader);
} else if (done == 0) {
rb_debug ("reached end up input stream");
loader->priv->callback (loader, NULL, 0, loader->priv->callback_data);
cleanup (loader);
} else {
loader->priv->chunk_string.len = done;
loader->priv->callback (loader, &loader->priv->chunk_string, loader->priv->total, loader->priv->callback_data);
g_input_stream_read_async (G_INPUT_STREAM (loader->priv->stream),
loader->priv->chunk,
loader->priv->chunk_size,
G_PRIORITY_DEFAULT,
loader->priv->cancel,
stream_read_async_cb,
loader);
}
}
static void sendIncompleteRequest(InspectorServerTest* test, gconstpointer)
{
GOwnPtr<GError> error;
// Connect to the inspector server.
GRefPtr<GSocketClient> client = adoptGRef(g_socket_client_new());
GRefPtr<GSocketConnection> connection = adoptGRef(g_socket_client_connect_to_host(client.get(), "127.0.0.1", 2999, 0, &error.outPtr()));
g_assert_no_error(error.get());
// Send incomplete request (missing blank line after headers) and check if inspector server
// replies. The server should not reply to an incomplete request and the test should timeout
// on read.
GOutputStream* ostream = g_io_stream_get_output_stream(G_IO_STREAM(connection.get()));
// Request missing blank line after headers.
const gchar* incompleteRequest = "GET /devtools/page/1 HTTP/1.1\r\nHost: Localhost\r\n";
g_output_stream_write(ostream, incompleteRequest, strlen(incompleteRequest), 0, &error.outPtr());
g_assert_no_error(error.get());
GInputStream* istream = g_io_stream_get_input_stream(G_IO_STREAM(connection.get()));
char response[16];
memset(response, 0, sizeof(response));
GRefPtr<GCancellable> cancel = adoptGRef(g_cancellable_new());
g_input_stream_read_async(istream, response, sizeof(response) - 1, G_PRIORITY_DEFAULT, cancel.get(), 0, 0);
// Give a chance for the server to reply.
test->wait(1);
g_cancellable_cancel(cancel.get());
// If we got any answer it means the server replied to an incomplete request, lets fail.
g_assert(response[0] == '\0');
}
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
state_read_buffer (GcrImporter *self, gboolean async)
{
GError *error = NULL;
gssize count;
gsize at;
g_assert (GCR_IS_IMPORTER (self));
g_assert (G_IS_INPUT_STREAM (self->pv->input));
if (!self->pv->buffer)
self->pv->buffer = g_byte_array_sized_new (BLOCK);
at = self->pv->buffer->len;
g_byte_array_set_size (self->pv->buffer, at + BLOCK);
if (async) {
g_input_stream_read_async (self->pv->input, self->pv->buffer->data + at,
BLOCK, G_PRIORITY_DEFAULT, self->pv->cancel,
on_read_buffer, self);
} else {
count = g_input_stream_read (self->pv->input, self->pv->buffer->data + at,
BLOCK, self->pv->cancel, &error);
complete_read_buffer (self, count, error);
}
}
void
sourceview_io_open (SourceviewIO* sio, GFile* file)
{
GFileInputStream* input_stream;
GError* err = NULL;
g_return_if_fail (file != NULL);
if (sio->file)
g_object_unref (sio->file);
sio->file = file;
g_object_ref (sio->file);
set_display_name(sio);
input_stream = g_file_read (file, NULL, &err);
if (!input_stream)
{
g_signal_emit_by_name (sio, "open-failed", err);
g_error_free (err);
return;
}
sio->read_buffer = g_realloc (sio->read_buffer, READ_SIZE);
g_input_stream_read_async (G_INPUT_STREAM (input_stream),
sio->read_buffer,
READ_SIZE,
G_PRIORITY_LOW,
sio->cancel,
on_read_finished,
sio);
}
static void
update_system_bookmark_list_ready (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
UpdateBookmarksData *data = user_data;
gssize size;
size = g_input_stream_read_finish (data->stream, result, NULL);
if (size < 0) {
update_bookmakrs_data_free (data);
return;
}
if (size > 0) {
data->buffer[size + 1] = '\0';
g_string_append (data->file_content, data->buffer);
g_input_stream_read_async (data->stream,
data->buffer,
BUFFER_SIZE - 1,
G_PRIORITY_DEFAULT,
NULL,
update_system_bookmark_list_ready,
data);
return;
}
update_system_bookmark_list_from_content (data->browser, data->file_content->str);
update_bookmakrs_data_free (data);
}
/**
* json_parser_load_from_stream_async:
* @parser: a #JsonParser
* @stream: a #GInputStream
* @cancellable: (allow-none): a #GCancellable, or %NULL
* @callback: a #GAsyncReadyCallback to call when the request is satisfied
* @user_data: the data to pass to @callback
*
* Asynchronously reads the contents of @stream.
*
* For more details, see json_parser_load_from_stream() which is the
* synchronous version of this call.
*
* When the operation is finished, @callback will be called. You should
* then call json_parser_load_from_stream_finish() to get the result
* of the operation.
*
* Since: 0.12
*/
void
json_parser_load_from_stream_async (JsonParser *parser,
GInputStream *stream,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
LoadStreamData *data;
g_return_if_fail (JSON_IS_PARSER (parser));
g_return_if_fail (G_IS_INPUT_STREAM (stream));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
data = g_new0 (LoadStreamData, 1);
if (cancellable != NULL)
data->cancellable = g_object_ref (cancellable);
data->callback = callback;
data->user_data = user_data;
data->content = g_byte_array_new ();
data->parser = g_object_ref (parser);
g_byte_array_set_size (data->content, data->pos + GET_DATA_BLOCK_SIZE);
g_input_stream_read_async (stream, data->content->data + data->pos,
GET_DATA_BLOCK_SIZE, 0,
data->cancellable,
load_stream_data_read_callback,
data);
}
/*
* * Read from g_input_stream until we get 0 bytes read. Then process
* * using the value of stream_type. Finally try and read another multipart.
* */
static void
read_cb (GObject *source, GAsyncResult *async_result, gpointer user_data)
{
//g_print ("read_cb: Enter\n");
GInputStream *in = G_INPUT_STREAM (source);
MultiPartData *multipart_data = (MultiPartData *) user_data;
SoupMultipartInputStream *multipart = SOUP_MULTIPART_INPUT_STREAM (multipart_data->multipart);
gssize bytes_read;
bytes_read = g_input_stream_read_finish (in, async_result, &multipart_data->error);
/* Read 0 bytes - try to start reading another part. */
if (bytes_read <= 0) {
g_input_stream_close_async (in,
G_PRIORITY_DEFAULT,
multipart_data->cancellable,
close_cb,
user_data);
if (multipart_data->callback) {
SoupBuffer *soup_buffer;
//g_print ("callback\n");
soup_buffer = soup_buffer_new(SOUP_MEMORY_TEMPORARY,
(guchar *) multipart_data->buffer->str,
multipart_data->buffer->len);
multipart_data->callback (multipart_data->method,
multipart_data->path,
multipart_data->cancellable,
multipart_data->error,
multipart_data->headers,
soup_buffer,
multipart_data->user_data);
soup_buffer_free(soup_buffer);
}
g_string_free (multipart_data->buffer, TRUE);
if (multipart_data->error) {
g_input_stream_close_async (G_INPUT_STREAM (multipart),
G_PRIORITY_DEFAULT,
multipart_data->cancellable,
close_base_cb,
user_data);
return;
}
soup_multipart_input_stream_next_part_async (multipart_data->multipart,
G_PRIORITY_DEFAULT,
multipart_data->cancellable,
next_part_cb,
user_data);
return;
}
multipart_data->buffer = g_string_append_len (multipart_data->buffer, buffer, bytes_read);
g_input_stream_read_async (in,
buffer,
READ_BUFFER_SIZE,
G_PRIORITY_DEFAULT,
multipart_data->cancellable,
read_cb,
user_data);
//g_print ("read_cb: Exit\n");
}
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
load_stream_data_read_callback (GObject *object,
GAsyncResult *read_res,
gpointer user_data)
{
GInputStream *stream = G_INPUT_STREAM (object);
LoadStreamData *data = user_data;
GError *error = NULL;
gssize read_size;
read_size = g_input_stream_read_finish (stream, read_res, &error);
if (read_size < 0)
{
if (error != NULL)
data->error = error;
else
{
GSimpleAsyncResult *res;
/* EOF */
res = g_simple_async_result_new (G_OBJECT (data->parser),
data->callback,
data->user_data,
json_parser_load_from_stream_async);
g_simple_async_result_set_op_res_gpointer (res, data, load_stream_data_free);
g_simple_async_result_complete (res);
g_object_unref (res);
}
}
else if (read_size > 0)
{
data->pos += read_size;
g_byte_array_set_size (data->content, data->pos + GET_DATA_BLOCK_SIZE);
g_input_stream_read_async (stream, data->content->data + data->pos,
GET_DATA_BLOCK_SIZE,
0,
data->cancellable,
load_stream_data_read_callback,
data);
}
else
{
GSimpleAsyncResult *res;
res = g_simple_async_result_new (G_OBJECT (data->parser),
data->callback,
data->user_data,
json_parser_load_from_stream_async);
g_simple_async_result_set_op_res_gpointer (res, data, load_stream_data_free);
g_simple_async_result_complete (res);
g_object_unref (res);
}
}
static void
read_stream (LatexilaPostProcessor *pp)
{
g_input_stream_read_async (pp->priv->stream,
&pp->priv->buffer,
BUFFER_SIZE,
G_PRIORITY_DEFAULT,
g_task_get_cancellable (pp->priv->task),
(GAsyncReadyCallback) read_stream_cb,
pp);
}
static void
do_read (GAsyncReadyCallback callback, GTask *task, ConnectAsyncData *data)
{
GInputStream *in;
in = g_io_stream_get_input_stream (data->io_stream);
g_input_stream_read_async (in,
data->buffer + data->offset,
data->length - data->offset,
g_task_get_priority (task),
g_task_get_cancellable (task),
callback, task);
}
static GByteArray *
do_single_coding_req_test (SoupRequest *req,
const char *expected_encoding,
const char *expected_content_type,
MessageContentStatus status)
{
GInputStream *stream;
SoupMessage *msg;
GByteArray *data;
guchar buf[1024];
gssize nread;
GError *error = NULL;
data = g_byte_array_new ();
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
stream = soup_test_request_send (req, NULL, &error);
if (error) {
debug_printf (1, " Error sending request: %s\n",
error->message);
g_error_free (error);
errors++;
return data;
}
do {
nread = -2;
g_input_stream_read_async (stream, buf, sizeof (buf),
G_PRIORITY_DEFAULT,
NULL, read_finished, &nread);
while (nread == -2)
g_main_context_iteration (NULL, TRUE);
if (nread > 0)
g_byte_array_append (data, buf, nread);
} while (nread > 0);
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " error closing stream: %s\n",
error->message);
g_error_free (error);
errors++;
}
g_object_unref (stream);
check_response (msg, expected_encoding, expected_content_type, status);
g_object_unref (msg);
return data;
}
static void gtkhash_hash_file_read(struct hash_file_s *data)
{
if (G_UNLIKELY(g_cancellable_is_cancelled(data->cancellable))) {
gtkhash_hash_file_set_state(data, HASH_FILE_STATE_CLOSE);
return;
}
gtkhash_hash_file_remove_source(data);
g_input_stream_read_async(G_INPUT_STREAM(data->stream),
data->buffer, HASH_FILE_BUFFER_SIZE, G_PRIORITY_DEFAULT,
data->cancellable, (GAsyncReadyCallback)gtkhash_hash_file_read_finish,
data);
}
void IOChannel::read(size_t offset, size_t size, WorkQueue*, std::function<void (Data&, int error)> completionHandler)
{
ASSERT(m_inputStream);
size_t bufferSize = std::min(size, gDefaultReadBufferSize);
uint8_t* bufferData = static_cast<uint8_t*>(fastMalloc(bufferSize));
GRefPtr<SoupBuffer> buffer = adoptGRef(soup_buffer_new_with_owner(bufferData, bufferSize, bufferData, fastFree));
ReadAsyncData* asyncData = new ReadAsyncData { this, buffer.get(), size, completionHandler, { } };
// FIXME: implement offset.
g_input_stream_read_async(m_inputStream.get(), const_cast<char*>(buffer->data), bufferSize, G_PRIORITY_DEFAULT, nullptr,
reinterpret_cast<GAsyncReadyCallback>(inputStreamReadReadyCallback), asyncData);
}
static void
connect_cb(GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSocketConnection *socket_conn;
PnNode *conn;
GError *error = NULL;
conn = PN_NODE(user_data);
socket_conn = g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(source), res, &error);
g_object_unref(source);
if (error) {
g_error_free(error);
return;
}
g_object_ref(conn);
if (socket_conn) {
GSocket *socket;
GInputStream *input;
conn->socket_conn = socket_conn;
socket = g_socket_connection_get_socket(socket_conn);
conn->status = PN_NODE_STATUS_OPEN;
input = g_io_stream_get_input_stream (G_IO_STREAM (conn->socket_conn));
g_object_ref (conn);
g_input_stream_read_async (input, conn->input_buffer, PN_BUF_LEN,
G_PRIORITY_DEFAULT, NULL,
read_cb, conn);
}
else {
conn->error = g_error_new_literal(PN_NODE_ERROR, PN_NODE_ERROR_OPEN,
"Unable to connect");
pn_node_error(conn);
}
{
PnNodeClass *class;
class = g_type_class_peek(PN_NODE_TYPE);
g_signal_emit(G_OBJECT(conn), class->open_sig, 0, conn);
}
g_object_unref(conn);
}
static void
start_tunnel (SoupMessage *msg, gpointer user_data)
{
Tunnel *tunnel = user_data;
tunnel->client.iostream = soup_client_context_steal_connection (tunnel->context);
tunnel->client.istream = g_io_stream_get_input_stream (tunnel->client.iostream);
tunnel->client.ostream = g_io_stream_get_output_stream (tunnel->client.iostream);
tunnel->client.buffer = g_malloc (BUFSIZE);
tunnel->server.buffer = g_malloc (BUFSIZE);
tunnel->cancellable = g_cancellable_new ();
g_input_stream_read_async (tunnel->client.istream,
tunnel->client.buffer, BUFSIZE,
G_PRIORITY_DEFAULT, tunnel->cancellable,
tunnel_read_cb, tunnel);
g_input_stream_read_async (tunnel->server.istream,
tunnel->server.buffer, BUFSIZE,
G_PRIORITY_DEFAULT, tunnel->cancellable,
tunnel_read_cb, tunnel);
}
void SocketStreamHandle::connected(GRefPtr<GSocketConnection>&& socketConnection)
{
m_socketConnection = WTFMove(socketConnection);
m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(G_IO_STREAM(m_socketConnection.get())));
m_inputStream = g_io_stream_get_input_stream(G_IO_STREAM(m_socketConnection.get()));
m_readBuffer = std::make_unique<char[]>(READ_BUFFER_SIZE);
RefPtr<SocketStreamHandle> protectedThis(this);
g_input_stream_read_async(m_inputStream.get(), m_readBuffer.get(), READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, m_cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(readReadyCallback), protectedThis.leakRef());
m_state = Open;
m_client.didOpenSocketStream(*this);
}
static void read_input_stream (GDownloadable * download)
{
//g_message ("reading input stream ...\n");
g_assert (download != NULL);
if (download->priv->status != G_DOWNLOADABLE_DOWNLOADING)
return;
GioDownload *gio_download = GIO_DOWNLOAD (download);
g_input_stream_read_async (G_INPUT_STREAM(gio_download->priv->input), gio_download->priv->chunk_buff, CHUNK_BUFF_SIZE,
G_PRIORITY_DEFAULT, NULL, on_input_stream_read_ready, download);
//g_message ("reading input stream ...\n");
}
static void
file_read_callback (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
EelPixbufLoadHandle *handle;
gssize bytes_read;
GError *error;
handle = user_data;
if (g_cancellable_is_cancelled (handle->cancellable))
{
free_pixbuf_load_handle (handle);
return;
}
error = NULL;
bytes_read = g_input_stream_read_finish (G_INPUT_STREAM (source_object),
res, &error);
if (bytes_read > 0)
{
if (!gdk_pixbuf_loader_write (handle->loader,
handle->buffer,
bytes_read,
&error))
{
bytes_read = -1;
}
else
{
g_input_stream_read_async (handle->stream,
handle->buffer,
sizeof (handle->buffer),
0,
handle->cancellable,
file_read_callback, handle);
return;
}
}
load_done (handle, error, bytes_read == 0);
if (error != NULL)
{
g_error_free (error);
}
}
void SocketStreamHandle::readBytes(gssize bytesRead)
{
if (!bytesRead) {
close();
return;
}
// The client can close the handle, potentially removing the last reference.
RefPtr<SocketStreamHandle> protectedThis(this);
m_client.didReceiveSocketStreamData(*this, m_readBuffer.get(), bytesRead);
if (m_inputStream) {
g_input_stream_read_async(m_inputStream.get(), m_readBuffer.get(), READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, m_cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(readReadyCallback), protectedThis.leakRef());
}
}
static gboolean
on_incoming_connection (GSocketService * service,
GSocketConnection * connection,
GObject * source_object,
gpointer user_data)
{
GInputStream * input;
void * buf;
input = g_io_stream_get_input_stream (G_IO_STREAM (connection));
buf = g_malloc (1);
g_input_stream_read_async (input, buf, 1, G_PRIORITY_DEFAULT, NULL,
on_read_ready, NULL);
return TRUE;
}
static void
_gth_browser_update_system_bookmark_list (GthBrowser *browser)
{
BrowserData *browser_data;
GFile *bookmark_file;
GFileInputStream *input_stream;
UpdateBookmarksData *data;
browser_data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
g_return_if_fail (browser_data != NULL);
g_menu_remove_all (browser_data->system_bookmarks_menu);
/* give priority to XDG_CONFIG_HOME/gtk-3.0/bookmarks if not found
* try the old ~/.gtk-bookmarks */
bookmark_file = gth_user_dir_get_file_for_read (GTH_DIR_CONFIG, "gtk-3.0", "bookmarks", NULL);
if (! g_file_query_exists (bookmark_file, NULL)) {
char *path;
g_object_unref (bookmark_file);
path = g_build_filename (g_get_home_dir (), ".gtk-bookmarks", NULL);
bookmark_file = g_file_new_for_path (path);
g_free (path);
}
input_stream = g_file_read (bookmark_file, NULL, NULL);
g_object_unref (bookmark_file);
if (input_stream == NULL)
return;
data = g_new0 (UpdateBookmarksData, 1);
data->browser = g_object_ref (browser);
data->stream = (GInputStream*) input_stream;
data->file_content = g_string_new ("");
g_input_stream_read_async (data->stream,
data->buffer,
BUFFER_SIZE - 1,
G_PRIORITY_DEFAULT,
NULL,
update_system_bookmark_list_ready,
data);
}
