[libsoup] Modernize GObject usage of various classes



commit ff57297571549d4db2237b3885e3e413d86ab43c
Author: Patrick Griffis <pgriffis igalia com>
Date:   Tue Oct 27 17:13:16 2020 -0500

    Modernize GObject usage of various classes

 libsoup/cache/soup-cache-client-input-stream.c |   4 +
 libsoup/cache/soup-cache-client-input-stream.h |  23 +----
 libsoup/cache/soup-cache-input-stream.c        |  37 +++++----
 libsoup/cache/soup-cache-input-stream.h        |  32 +------
 libsoup/soup-body-input-stream.c               | 111 ++++++++++++++-----------
 libsoup/soup-body-input-stream.h               |  30 +------
 libsoup/soup-body-output-stream.c              |  89 +++++++++++---------
 libsoup/soup-body-output-stream.h              |  31 +------
 libsoup/soup-client-input-stream.c             |  35 +++++---
 libsoup/soup-client-input-stream.h             |  30 +------
 libsoup/soup-filter-input-stream.c             |  72 ++++++++--------
 libsoup/soup-filter-input-stream.h             |  26 +-----
 libsoup/soup-io-stream.c                       |  60 ++++++++-----
 libsoup/soup-io-stream.h                       |  26 +-----
 libsoup/soup-socket.c                          |  12 ++-
 libsoup/soup-socket.h                          |  35 +-------
 16 files changed, 263 insertions(+), 390 deletions(-)
---
diff --git a/libsoup/cache/soup-cache-client-input-stream.c b/libsoup/cache/soup-cache-client-input-stream.c
index 11bb2602..4838e3fa 100644
--- a/libsoup/cache/soup-cache-client-input-stream.c
+++ b/libsoup/cache/soup-cache-client-input-stream.c
@@ -21,6 +21,10 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
+struct _SoupCacheClientInputStream {
+       GFilterInputStream parent_instance;
+};
+
 G_DEFINE_TYPE (SoupCacheClientInputStream, soup_cache_client_input_stream, G_TYPE_FILTER_INPUT_STREAM)
 
 static void
diff --git a/libsoup/cache/soup-cache-client-input-stream.h b/libsoup/cache/soup-cache-client-input-stream.h
index 2c9da06e..b986ed9e 100644
--- a/libsoup/cache/soup-cache-client-input-stream.h
+++ b/libsoup/cache/soup-cache-client-input-stream.h
@@ -3,34 +3,15 @@
  * Copyright 2015 Igalia S.L.
  */
 
-#ifndef __SOUP_CACHE_CLIENT_INPUT_STREAM_H__
-#define __SOUP_CACHE_CLIENT_INPUT_STREAM_H__ 1
+#pragma once
 
 #include "soup-types.h"
 
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_CACHE_CLIENT_INPUT_STREAM            (soup_cache_client_input_stream_get_type ())
-#define SOUP_CACHE_CLIENT_INPUT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
SOUP_TYPE_CACHE_CLIENT_INPUT_STREAM, SoupCacheClientInputStream))
-#define SOUP_CACHE_CLIENT_INPUT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), 
SOUP_TYPE_CACHE_CLIENT_INPUT_STREAM, SoupCacheClientInputStreamClass))
-#define SOUP_IS_CACHE_CLIENT_INPUT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
SOUP_TYPE_CACHE_CLIENT_INPUT_STREAM))
-#define SOUP_IS_CACHE_CLIENT_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), 
SOUP_TYPE_CACHE_CLIENT_INPUT_STREAM))
-#define SOUP_CACHE_CLIENT_INPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), 
SOUP_TYPE_CACHE_CLIENT_INPUT_STREAM, SoupCacheClientInputStreamClass))
-
-typedef struct _SoupCacheClientInputStreamPrivate SoupCacheClientInputStreamPrivate;
-
-typedef struct {
-       GFilterInputStream parent;
-} SoupCacheClientInputStream;
-
-typedef struct {
-       GFilterInputStreamClass parent_class;
-} SoupCacheClientInputStreamClass;
-
-GType soup_cache_client_input_stream_get_type (void);
+G_DECLARE_FINAL_TYPE (SoupCacheClientInputStream, soup_cache_client_input_stream, SOUP, 
CACHE_CLIENT_INPUT_STREAM, GFilterInputStream)
 
 GInputStream *soup_cache_client_input_stream_new (GInputStream *base_stream);
 
 G_END_DECLS
-
-#endif /* __SOUP_CACHE_CLIENT_INPUT_STREAM_H__ */
diff --git a/libsoup/cache/soup-cache-input-stream.c b/libsoup/cache/soup-cache-input-stream.c
index 649d23fc..799c75e3 100644
--- a/libsoup/cache/soup-cache-input-stream.c
+++ b/libsoup/cache/soup-cache-input-stream.c
@@ -28,8 +28,11 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
-struct _SoupCacheInputStreamPrivate
-{
+struct _SoupCacheInputStream {
+       SoupFilterInputStream parent_instance;
+};
+
+typedef struct {
        GOutputStream *output_stream;
        GCancellable *cancellable;
        gsize bytes_written;
@@ -37,7 +40,7 @@ struct _SoupCacheInputStreamPrivate
        gboolean read_finished;
        GBytes *current_writing_buffer;
        GQueue *buffer_queue;
-};
+} SoupCacheInputStreamPrivate;
 
 static void soup_cache_input_stream_pollable_init (GPollableInputStreamInterface *pollable_interface, 
gpointer interface_data);
 
@@ -52,7 +55,7 @@ static void soup_cache_input_stream_write_next_buffer (SoupCacheInputStream *ist
 static inline void
 notify_and_clear (SoupCacheInputStream *istream, GError *error)
 {
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
 
        g_signal_emit (istream, signals[CACHING_FINISHED], 0, priv->bytes_written, error);
 
@@ -64,7 +67,7 @@ notify_and_clear (SoupCacheInputStream *istream, GError *error)
 static inline void
 try_write_next_buffer (SoupCacheInputStream *istream)
 {
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
 
        if (priv->current_writing_buffer == NULL && priv->buffer_queue->length)
                soup_cache_input_stream_write_next_buffer (istream);
@@ -84,7 +87,7 @@ file_replaced_cb (GObject      *source,
                  gpointer      user_data)
 {
        SoupCacheInputStream *istream = SOUP_CACHE_INPUT_STREAM (user_data);
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
        GError *error = NULL;
 
        priv->output_stream = (GOutputStream *) g_file_replace_finish (G_FILE (source), res, &error);
@@ -103,7 +106,6 @@ soup_cache_input_stream_init (SoupCacheInputStream *self)
        SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (self);
 
        priv->buffer_queue = g_queue_new ();
-       self->priv = priv;
 }
 
 static void
@@ -111,7 +113,7 @@ soup_cache_input_stream_get_property (GObject *object,
                                      guint property_id, GValue *value, GParamSpec *pspec)
 {
        SoupCacheInputStream *self = SOUP_CACHE_INPUT_STREAM (object);
-       SoupCacheInputStreamPrivate *priv = self->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (self);
 
        switch (property_id) {
        case PROP_OUTPUT_STREAM:
@@ -128,7 +130,7 @@ soup_cache_input_stream_set_property (GObject *object,
                                      guint property_id, const GValue *value, GParamSpec *pspec)
 {
        SoupCacheInputStream *self = SOUP_CACHE_INPUT_STREAM (object);
-       SoupCacheInputStreamPrivate *priv = self->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (self);
 
        switch (property_id) {
        case PROP_OUTPUT_STREAM:
@@ -144,7 +146,7 @@ static void
 soup_cache_input_stream_finalize (GObject *object)
 {
        SoupCacheInputStream *self = (SoupCacheInputStream *)object;
-       SoupCacheInputStreamPrivate *priv = self->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (self);
 
        g_clear_object (&priv->cancellable);
        g_clear_object (&priv->output_stream);
@@ -158,7 +160,7 @@ static void
 write_ready_cb (GObject *source, GAsyncResult *result, SoupCacheInputStream *istream)
 {
        GOutputStream *ostream = G_OUTPUT_STREAM (source);
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
        gssize write_size;
        gsize pending;
        GError *error = NULL;
@@ -188,7 +190,7 @@ write_ready_cb (GObject *source, GAsyncResult *result, SoupCacheInputStream *ist
 static void
 soup_cache_input_stream_write_next_buffer (SoupCacheInputStream *istream)
 {
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
        GBytes *buffer = g_queue_pop_head (priv->buffer_queue);
        int priority;
 
@@ -219,7 +221,7 @@ read_internal (GInputStream  *stream,
               GError       **error)
 {
        SoupCacheInputStream *istream = SOUP_CACHE_INPUT_STREAM (stream);
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
        GInputStream *base_stream;
        gssize nread;
 
@@ -280,7 +282,7 @@ soup_cache_input_stream_close_fn (GInputStream  *stream,
                                  GError       **error)
 {
        SoupCacheInputStream *istream = SOUP_CACHE_INPUT_STREAM (stream);
-       SoupCacheInputStreamPrivate *priv = istream->priv;
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
 
        if (!priv->read_finished) {
                if (priv->output_stream) {
@@ -326,7 +328,7 @@ soup_cache_input_stream_class_init (SoupCacheInputStreamClass *klass)
                g_signal_new ("caching-finished",
                              G_OBJECT_CLASS_TYPE (gobject_class),
                              G_SIGNAL_RUN_FIRST,
-                             G_STRUCT_OFFSET (SoupCacheInputStreamClass, caching_finished),
+                             0,
                              NULL, NULL,
                              NULL,
                              G_TYPE_NONE, 2,
@@ -341,11 +343,12 @@ soup_cache_input_stream_new (GInputStream *base_stream,
                                              "base-stream", base_stream,
                                              "close-base-stream", FALSE,
                                              NULL);
+       SoupCacheInputStreamPrivate *priv = soup_cache_input_stream_get_instance_private (istream);
 
-       istream->priv->cancellable = g_cancellable_new ();
+       priv->cancellable = g_cancellable_new ();
        g_file_replace_async (file, NULL, FALSE,
                              G_FILE_CREATE_PRIVATE | G_FILE_CREATE_REPLACE_DESTINATION,
-                             G_PRIORITY_DEFAULT, istream->priv->cancellable,
+                             G_PRIORITY_DEFAULT, priv->cancellable,
                              file_replaced_cb, g_object_ref (istream));
 
        return (GInputStream *) istream;
diff --git a/libsoup/cache/soup-cache-input-stream.h b/libsoup/cache/soup-cache-input-stream.h
index 92b1d7b6..fe9e1470 100644
--- a/libsoup/cache/soup-cache-input-stream.h
+++ b/libsoup/cache/soup-cache-input-stream.h
@@ -3,44 +3,16 @@
  * soup-cache-input-stream.h - Header for SoupCacheInputStream
  */
 
-#ifndef __SOUP_CACHE_INPUT_STREAM_H__
-#define __SOUP_CACHE_INPUT_STREAM_H__
+#pragma once
 
 #include "soup-filter-input-stream.h"
 
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_CACHE_INPUT_STREAM           (soup_cache_input_stream_get_type())
-#define SOUP_CACHE_INPUT_STREAM(obj)           (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
SOUP_TYPE_CACHE_INPUT_STREAM, SoupCacheInputStream))
-#define SOUP_CACHE_INPUT_STREAM_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST ((klass), 
SOUP_TYPE_CACHE_INPUT_STREAM, SoupCacheInputStreamClass))
-#define SOUP_IS_CACHE_INPUT_STREAM(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
SOUP_TYPE_CACHE_INPUT_STREAM))
-#define SOUP_IS_CACHE_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), 
SOUP_TYPE_CACHE_INPUT_STREAM))
-#define SOUP_CACHE_INPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), 
SOUP_TYPE_CACHE_INPUT_STREAM, SoupCacheInputStreamClass))
-
-typedef struct _SoupCacheInputStream      SoupCacheInputStream;
-typedef struct _SoupCacheInputStreamClass SoupCacheInputStreamClass;
-typedef struct _SoupCacheInputStreamPrivate SoupCacheInputStreamPrivate;
-
-struct _SoupCacheInputStreamClass
-{
-       SoupFilterInputStreamClass parent_class;
-
-       /* signals */
-       void     (*caching_finished) (SoupCacheInputStream *istream, gsize bytes_written, GError *error);
-};
-
-struct _SoupCacheInputStream
-{
-       SoupFilterInputStream parent;
-
-       SoupCacheInputStreamPrivate *priv;
-};
-
-GType soup_cache_input_stream_get_type (void) G_GNUC_CONST;
+G_DECLARE_FINAL_TYPE (SoupCacheInputStream, soup_cache_input_stream, SOUP, CACHE_INPUT_STREAM, 
SoupFilterInputStream)
 
 GInputStream *soup_cache_input_stream_new (GInputStream *base_stream,
                                           GFile        *file);
 
 G_END_DECLS
-
-#endif /* __SOUP_CACHE_INPUT_STREAM_H__ */
diff --git a/libsoup/soup-body-input-stream.c b/libsoup/soup-body-input-stream.c
index 6b958847..88ccd2ed 100644
--- a/libsoup/soup-body-input-stream.c
+++ b/libsoup/soup-body-input-stream.c
@@ -25,7 +25,11 @@ typedef enum {
        SOUP_BODY_INPUT_STREAM_STATE_DONE
 } SoupBodyInputStreamState;
 
-struct _SoupBodyInputStreamPrivate {
+struct _SoupBodyInputStream {
+       GFilterInputStream parent_instance;
+};
+
+typedef struct {
        GInputStream *base_stream;
 
        SoupEncoding  encoding;
@@ -34,7 +38,7 @@ struct _SoupBodyInputStreamPrivate {
        gboolean      eof;
 
        goffset       pos;
-};
+} SoupBodyInputStreamPrivate;
 
 enum {
        CLOSED,
@@ -63,21 +67,22 @@ G_DEFINE_TYPE_WITH_CODE (SoupBodyInputStream, soup_body_input_stream, G_TYPE_FIL
 static void
 soup_body_input_stream_init (SoupBodyInputStream *bistream)
 {
-       bistream->priv = soup_body_input_stream_get_instance_private (bistream);
-       bistream->priv->encoding = SOUP_ENCODING_NONE;
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
+       priv->encoding = SOUP_ENCODING_NONE;
 }
 
 static void
 soup_body_input_stream_constructed (GObject *object)
 {
        SoupBodyInputStream *bistream = SOUP_BODY_INPUT_STREAM (object);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
 
-       bistream->priv->base_stream = g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM 
(bistream));
+       priv->base_stream = g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (bistream));
 
-       if (bistream->priv->encoding == SOUP_ENCODING_NONE ||
-           (bistream->priv->encoding == SOUP_ENCODING_CONTENT_LENGTH &&
-            bistream->priv->read_length == 0))
-               bistream->priv->eof = TRUE;
+       if (priv->encoding == SOUP_ENCODING_NONE ||
+           (priv->encoding == SOUP_ENCODING_CONTENT_LENGTH &&
+            priv->read_length == 0))
+               priv->eof = TRUE;
 }
 
 static void
@@ -85,15 +90,16 @@ soup_body_input_stream_set_property (GObject *object, guint prop_id,
                                     const GValue *value, GParamSpec *pspec)
 {
        SoupBodyInputStream *bistream = SOUP_BODY_INPUT_STREAM (object);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
 
        switch (prop_id) {
        case PROP_ENCODING:
-               bistream->priv->encoding = g_value_get_enum (value);
-               if (bistream->priv->encoding == SOUP_ENCODING_CHUNKED)
-                       bistream->priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK_SIZE;
+               priv->encoding = g_value_get_enum (value);
+               if (priv->encoding == SOUP_ENCODING_CHUNKED)
+                       priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK_SIZE;
                break;
        case PROP_CONTENT_LENGTH:
-               bistream->priv->read_length = g_value_get_int64 (value);
+               priv->read_length = g_value_get_int64 (value);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -106,10 +112,12 @@ soup_body_input_stream_get_property (GObject *object, guint prop_id,
                                     GValue *value, GParamSpec *pspec)
 {
        SoupBodyInputStream *bistream = SOUP_BODY_INPUT_STREAM (object);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
+
 
        switch (prop_id) {
        case PROP_ENCODING:
-               g_value_set_enum (value, bistream->priv->encoding);
+               g_value_set_enum (value, priv->encoding);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -125,15 +133,16 @@ soup_body_input_stream_read_raw (SoupBodyInputStream  *bistream,
                                 GCancellable         *cancellable,
                                 GError              **error)
 {
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
        gssize nread;
 
-       nread = g_pollable_stream_read (bistream->priv->base_stream,
+       nread = g_pollable_stream_read (priv->base_stream,
                                        buffer, count,
                                        blocking,
                                        cancellable, error);
        if (nread == 0) {
-               bistream->priv->eof = TRUE;
-               if (bistream->priv->encoding != SOUP_ENCODING_EOF) {
+               priv->eof = TRUE;
+               if (priv->encoding != SOUP_ENCODING_EOF) {
                        g_set_error_literal (error, G_IO_ERROR,
                                             G_IO_ERROR_PARTIAL_INPUT,
                                             _("Connection terminated unexpectedly"));
@@ -151,13 +160,14 @@ soup_body_input_stream_read_chunked (SoupBodyInputStream  *bistream,
                                     GCancellable         *cancellable,
                                     GError              **error)
 {
-       SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (bistream->priv->base_stream);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
+       SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (priv->base_stream);
        char metabuf[128];
        gssize nread;
        gboolean got_line;
 
 again:
-       switch (bistream->priv->chunked_state) {
+       switch (priv->chunked_state) {
        case SOUP_BODY_INPUT_STREAM_STATE_CHUNK_SIZE:
                nread = soup_filter_input_stream_read_line (
                        fstream, metabuf, sizeof (metabuf), blocking,
@@ -171,28 +181,28 @@ again:
                        return -1;
                }
 
-               bistream->priv->read_length = strtoul (metabuf, NULL, 16);
-               if (bistream->priv->read_length > 0)
-                       bistream->priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK;
+               priv->read_length = strtoul (metabuf, NULL, 16);
+               if (priv->read_length > 0)
+                       priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK;
                else
-                       bistream->priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_TRAILERS;
+                       priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_TRAILERS;
                break;
 
        case SOUP_BODY_INPUT_STREAM_STATE_CHUNK:
                nread = soup_body_input_stream_read_raw (
                        bistream, buffer,
-                       MIN (count, bistream->priv->read_length),
+                       MIN (count, priv->read_length),
                        blocking, cancellable, error);
                if (nread > 0) {
-                       bistream->priv->read_length -= nread;
-                       if (bistream->priv->read_length == 0)
-                               bistream->priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK_END;
+                       priv->read_length -= nread;
+                       if (priv->read_length == 0)
+                               priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK_END;
                }
                return nread;
 
        case SOUP_BODY_INPUT_STREAM_STATE_CHUNK_END:
                nread = soup_filter_input_stream_read_line (
-                       SOUP_FILTER_INPUT_STREAM (bistream->priv->base_stream),
+                       SOUP_FILTER_INPUT_STREAM (priv->base_stream),
                        metabuf, sizeof (metabuf), blocking,
                        &got_line, cancellable, error);
                if (nread <= 0)
@@ -204,7 +214,7 @@ again:
                        return -1;
                }
 
-               bistream->priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK_SIZE;
+               priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_CHUNK_SIZE;
                break;
 
        case SOUP_BODY_INPUT_STREAM_STATE_TRAILERS:
@@ -215,8 +225,8 @@ again:
                        return nread;
 
                if (strncmp (buffer, "\r\n", nread) || strncmp (buffer, "\n", nread)) {
-                       bistream->priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_DONE;
-                       bistream->priv->eof = TRUE;
+                       priv->chunked_state = SOUP_BODY_INPUT_STREAM_STATE_DONE;
+                       priv->eof = TRUE;
                }
                break;
 
@@ -236,12 +246,13 @@ read_internal (GInputStream  *stream,
               GError       **error)
 {
        SoupBodyInputStream *bistream = SOUP_BODY_INPUT_STREAM (stream);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
        gssize nread;
 
-       if (bistream->priv->eof)
+       if (priv->eof)
                return 0;
 
-       switch (bistream->priv->encoding) {
+       switch (priv->encoding) {
        case SOUP_ENCODING_NONE:
                return 0;
 
@@ -251,19 +262,19 @@ read_internal (GInputStream  *stream,
 
        case SOUP_ENCODING_CONTENT_LENGTH:
        case SOUP_ENCODING_EOF:
-               if (bistream->priv->read_length != -1) {
-                       count = MIN (count, bistream->priv->read_length);
+               if (priv->read_length != -1) {
+                       count = MIN (count, priv->read_length);
                        if (count == 0)
                                return 0;
                }
 
                nread = soup_body_input_stream_read_raw (bistream, buffer, count,
                                                         blocking, cancellable, error);
-               if (bistream->priv->read_length != -1 && nread > 0)
-                       bistream->priv->read_length -= nread;
+               if (priv->read_length != -1 && nread > 0)
+                       priv->read_length -= nread;
 
-               if (bistream->priv->encoding == SOUP_ENCODING_CONTENT_LENGTH)
-                       bistream->priv->pos += nread;
+               if (priv->encoding == SOUP_ENCODING_CONTENT_LENGTH)
+                       priv->pos += nread;
                return nread;
 
        default:
@@ -277,7 +288,7 @@ soup_body_input_stream_skip (GInputStream *stream,
                             GCancellable *cancellable,
                             GError      **error)
 {
-       SoupBodyInputStreamPrivate *priv = SOUP_BODY_INPUT_STREAM(stream)->priv;
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private 
(SOUP_BODY_INPUT_STREAM(stream));
        gssize skipped;
 
        skipped = g_input_stream_skip (G_FILTER_INPUT_STREAM (stream)->base_stream,
@@ -317,15 +328,17 @@ static gboolean
 soup_body_input_stream_is_readable (GPollableInputStream *stream)
 {
        SoupBodyInputStream *bistream = SOUP_BODY_INPUT_STREAM (stream);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
 
-       return bistream->priv->eof ||
-               g_pollable_input_stream_is_readable (G_POLLABLE_INPUT_STREAM (bistream->priv->base_stream));
+       return priv->eof ||
+               g_pollable_input_stream_is_readable (G_POLLABLE_INPUT_STREAM (priv->base_stream));
 }
 
 static gboolean
 soup_body_input_stream_can_poll (GPollableInputStream *pollable)
 {
-       GInputStream *base_stream = SOUP_BODY_INPUT_STREAM (pollable)->priv->base_stream;
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private 
(SOUP_BODY_INPUT_STREAM (pollable));
+       GInputStream *base_stream = priv->base_stream;
 
        return G_IS_POLLABLE_INPUT_STREAM (base_stream) &&
                g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (base_stream));
@@ -346,12 +359,13 @@ soup_body_input_stream_create_source (GPollableInputStream *stream,
                                      GCancellable *cancellable)
 {
        SoupBodyInputStream *bistream = SOUP_BODY_INPUT_STREAM (stream);
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private (bistream);
        GSource *base_source, *pollable_source;
 
-       if (bistream->priv->eof)
+       if (priv->eof)
                base_source = g_timeout_source_new (0);
        else
-               base_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM 
(bistream->priv->base_stream), cancellable);
+               base_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM 
(priv->base_stream), cancellable);
        g_source_set_dummy_callback (base_source);
 
        pollable_source = g_pollable_source_new (G_OBJECT (stream));
@@ -414,13 +428,14 @@ soup_body_input_stream_pollable_init (GPollableInputStreamInterface *pollable_in
 static goffset
 soup_body_input_stream_tell (GSeekable *seekable)
 {
-       return SOUP_BODY_INPUT_STREAM (seekable)->priv->pos;
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private 
(SOUP_BODY_INPUT_STREAM (seekable));
+       return priv->pos;
 }
 
 static gboolean
 soup_body_input_stream_can_seek (GSeekable *seekable)
 {
-       SoupBodyInputStreamPrivate *priv = SOUP_BODY_INPUT_STREAM (seekable)->priv;
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private 
(SOUP_BODY_INPUT_STREAM (seekable));
 
        return priv->encoding == SOUP_ENCODING_CONTENT_LENGTH
                && G_IS_SEEKABLE (priv->base_stream)
@@ -434,7 +449,7 @@ soup_body_input_stream_seek (GSeekable     *seekable,
                             GCancellable  *cancellable,
                             GError       **error)
 {
-       SoupBodyInputStreamPrivate *priv = SOUP_BODY_INPUT_STREAM (seekable)->priv;
+        SoupBodyInputStreamPrivate *priv = soup_body_input_stream_get_instance_private 
(SOUP_BODY_INPUT_STREAM (seekable));
        goffset position, end_position;
 
        end_position = priv->pos + priv->read_length;
diff --git a/libsoup/soup-body-input-stream.h b/libsoup/soup-body-input-stream.h
index bd04e5fe..f210574d 100644
--- a/libsoup/soup-body-input-stream.h
+++ b/libsoup/soup-body-input-stream.h
@@ -3,8 +3,7 @@
  * Copyright 2012 Red Hat, Inc.
  */
 
-#ifndef __SOUP_BODY_INPUT_STREAM_H__
-#define __SOUP_BODY_INPUT_STREAM_H__ 1
+#pragma once
 
 #include "soup-types.h"
 #include "soup-filter-input-stream.h"
@@ -13,36 +12,11 @@
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_BODY_INPUT_STREAM            (soup_body_input_stream_get_type ())
-#define SOUP_BODY_INPUT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
SOUP_TYPE_BODY_INPUT_STREAM, SoupBodyInputStream))
-#define SOUP_BODY_INPUT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), 
SOUP_TYPE_BODY_INPUT_STREAM, SoupBodyInputStreamClass))
-#define SOUP_IS_BODY_INPUT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
SOUP_TYPE_BODY_INPUT_STREAM))
-#define SOUP_IS_BODY_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_BODY_INPUT_STREAM))
-#define SOUP_BODY_INPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), 
SOUP_TYPE_BODY_INPUT_STREAM, SoupBodyInputStreamClass))
+G_DECLARE_FINAL_TYPE (SoupBodyInputStream, soup_body_input_stream, SOUP, BODY_INPUT_STREAM, 
GFilterInputStream)
 
-typedef struct _SoupBodyInputStreamPrivate SoupBodyInputStreamPrivate;
-
-typedef struct {
-       GFilterInputStream parent;
-
-       SoupBodyInputStreamPrivate *priv;
-} SoupBodyInputStream;
-
-typedef struct {
-       GFilterInputStreamClass parent_class;
-
-       /* Padding for future expansion */
-       void (*_libsoup_reserved1) (void);
-       void (*_libsoup_reserved2) (void);
-       void (*_libsoup_reserved3) (void);
-       void (*_libsoup_reserved4) (void);
-} SoupBodyInputStreamClass;
-
-GType soup_body_input_stream_get_type (void);
 
 GInputStream *soup_body_input_stream_new (GInputStream *base_stream,
                                          SoupEncoding  encoding,
                                          goffset       content_length);
 
 G_END_DECLS
-
-#endif /* __SOUP_BODY_INPUT_STREAM_H__ */
diff --git a/libsoup/soup-body-output-stream.c b/libsoup/soup-body-output-stream.c
index 94fe2811..a390ed83 100644
--- a/libsoup/soup-body-output-stream.c
+++ b/libsoup/soup-body-output-stream.c
@@ -22,7 +22,11 @@ typedef enum {
        SOUP_BODY_OUTPUT_STREAM_STATE_DONE
 } SoupBodyOutputStreamState;
 
-struct _SoupBodyOutputStreamPrivate {
+struct _SoupBodyOutputStream {
+       GFilterOutputStream parent_instance;
+};
+
+typedef struct {
        GOutputStream *base_stream;
        char           buf[20];
 
@@ -31,7 +35,7 @@ struct _SoupBodyOutputStreamPrivate {
        goffset        written;
        SoupBodyOutputStreamState chunked_state;
        gboolean       eof;
-};
+} SoupBodyOutputStreamPrivate;
 
 enum {
        PROP_0,
@@ -59,15 +63,15 @@ G_DEFINE_TYPE_WITH_CODE (SoupBodyOutputStream, soup_body_output_stream, G_TYPE_F
 static void
 soup_body_output_stream_init (SoupBodyOutputStream *stream)
 {
-       stream->priv = soup_body_output_stream_get_instance_private (stream);
 }
 
 static void
 soup_body_output_stream_constructed (GObject *object)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (object);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
-       bostream->priv->base_stream = g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM 
(bostream));
+       priv->base_stream = g_filter_output_stream_get_base_stream (G_FILTER_OUTPUT_STREAM (bostream));
 }
 
 static void
@@ -75,15 +79,16 @@ soup_body_output_stream_set_property (GObject *object, guint prop_id,
                                      const GValue *value, GParamSpec *pspec)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (object);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
        switch (prop_id) {
        case PROP_ENCODING:
-               bostream->priv->encoding = g_value_get_enum (value);
-               if (bostream->priv->encoding == SOUP_ENCODING_CHUNKED)
-                       bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE;
+               priv->encoding = g_value_get_enum (value);
+               if (priv->encoding == SOUP_ENCODING_CHUNKED)
+                       priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE;
                break;
        case PROP_CONTENT_LENGTH:
-               bostream->priv->write_length = g_value_get_uint64 (value);
+               priv->write_length = g_value_get_uint64 (value);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -96,10 +101,11 @@ soup_body_output_stream_get_property (GObject *object, guint prop_id,
                                      GValue *value, GParamSpec *pspec)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (object);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
        switch (prop_id) {
        case PROP_ENCODING:
-               g_value_set_enum (value, bostream->priv->encoding);
+               g_value_set_enum (value, priv->encoding);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -122,27 +128,28 @@ soup_body_output_stream_write_raw (SoupBodyOutputStream  *bostream,
                                   GCancellable          *cancellable,
                                   GError               **error)
 {
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
        gssize nwrote, my_count;
 
        /* If the caller tries to write too much to a Content-Length
         * encoded stream, we truncate at the right point, but keep
         * accepting additional data until they stop.
         */
-       if (bostream->priv->write_length) {
-               my_count = MIN (count, bostream->priv->write_length - bostream->priv->written);
+       if (priv->write_length) {
+               my_count = MIN (count, priv->write_length - priv->written);
                if (my_count == 0) {
-                       bostream->priv->eof = TRUE;
+                       priv->eof = TRUE;
                        return count;
                }
        } else
                my_count = count;
 
-       nwrote = g_pollable_stream_write (bostream->priv->base_stream,
+       nwrote = g_pollable_stream_write (priv->base_stream,
                                          buffer, my_count,
                                          blocking, cancellable, error);
 
-       if (nwrote > 0 && bostream->priv->write_length) {
-               bostream->priv->written += nwrote;
+       if (nwrote > 0 && priv->write_length) {
+               priv->written += nwrote;
                soup_body_output_stream_wrote_data (bostream, nwrote);
        }
 
@@ -160,13 +167,14 @@ soup_body_output_stream_write_chunked (SoupBodyOutputStream  *bostream,
                                       GCancellable          *cancellable,
                                       GError               **error)
 {
-       char *buf = bostream->priv->buf;
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
+       char *buf = priv->buf;
        gssize nwrote, len;
 
 again:
        len = strlen (buf);
        if (len) {
-               nwrote = g_pollable_stream_write (bostream->priv->base_stream,
+               nwrote = g_pollable_stream_write (priv->base_stream,
                                                  buf, len, blocking,
                                                  cancellable, error);
                if (nwrote < 0)
@@ -175,19 +183,19 @@ again:
                goto again;
        }
 
-       switch (bostream->priv->chunked_state) {
+       switch (priv->chunked_state) {
        case SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE:
-               g_snprintf (buf, sizeof (bostream->priv->buf),
+               g_snprintf (buf, sizeof (priv->buf),
                            "%lx\r\n", (gulong)count);
 
                if (count > 0)
-                       bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK;
+                       priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK;
                else
-                       bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_TRAILERS;
+                       priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_TRAILERS;
                break;
 
        case SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK:
-               nwrote = g_pollable_stream_write (bostream->priv->base_stream,
+               nwrote = g_pollable_stream_write (priv->base_stream,
                                                  buffer, count, blocking,
                                                  cancellable, error);
                if (nwrote > 0)
@@ -196,21 +204,21 @@ again:
                if (nwrote < (gssize)count)
                        return nwrote;
 
-               bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_END;
+               priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_END;
                break;
 
        case SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_END:
-               strncpy (buf, "\r\n", sizeof (bostream->priv->buf));
-               bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_DONE;
+               strncpy (buf, "\r\n", sizeof (priv->buf));
+               priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_DONE;
                break;
 
        case SOUP_BODY_OUTPUT_STREAM_STATE_TRAILERS:
-               strncpy (buf, "\r\n", sizeof (bostream->priv->buf));
-               bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_DONE;
+               strncpy (buf, "\r\n", sizeof (priv->buf));
+               priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_DONE;
                break;
 
        case SOUP_BODY_OUTPUT_STREAM_STATE_DONE:
-               bostream->priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE;
+               priv->chunked_state = SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE;
                return count;
        }
 
@@ -225,11 +233,12 @@ soup_body_output_stream_write_fn (GOutputStream  *stream,
                                  GError        **error)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (stream);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
-       if (bostream->priv->eof)
+       if (priv->eof)
                return count;
 
-       switch (bostream->priv->encoding) {
+       switch (priv->encoding) {
        case SOUP_ENCODING_CHUNKED:
                return soup_body_output_stream_write_chunked (bostream, buffer, count,
                                                              TRUE, cancellable, error);
@@ -246,9 +255,10 @@ soup_body_output_stream_close_fn (GOutputStream  *stream,
                                  GError        **error)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (stream);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
-       if (bostream->priv->encoding == SOUP_ENCODING_CHUNKED &&
-           bostream->priv->chunked_state == SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE) {
+       if (priv->encoding == SOUP_ENCODING_CHUNKED &&
+           priv->chunked_state == SOUP_BODY_OUTPUT_STREAM_STATE_CHUNK_SIZE) {
                if (soup_body_output_stream_write_chunked (bostream, NULL, 0, TRUE, cancellable, error) == -1)
                        return FALSE;
        }
@@ -260,9 +270,10 @@ static gboolean
 soup_body_output_stream_is_writable (GPollableOutputStream *stream)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (stream);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
-       return bostream->priv->eof ||
-               g_pollable_output_stream_is_writable (G_POLLABLE_OUTPUT_STREAM (bostream->priv->base_stream));
+       return priv->eof ||
+               g_pollable_output_stream_is_writable (G_POLLABLE_OUTPUT_STREAM (priv->base_stream));
 }
 
 static gssize
@@ -272,11 +283,12 @@ soup_body_output_stream_write_nonblocking (GPollableOutputStream  *stream,
                                           GError                **error)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (stream);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
 
-       if (bostream->priv->eof)
+       if (priv->eof)
                return count;
 
-       switch (bostream->priv->encoding) {
+       switch (priv->encoding) {
        case SOUP_ENCODING_CHUNKED:
                return soup_body_output_stream_write_chunked (bostream, buffer, count,
                                                              FALSE, NULL, error);
@@ -292,12 +304,13 @@ soup_body_output_stream_create_source (GPollableOutputStream *stream,
                                       GCancellable *cancellable)
 {
        SoupBodyOutputStream *bostream = SOUP_BODY_OUTPUT_STREAM (stream);
+        SoupBodyOutputStreamPrivate *priv = soup_body_output_stream_get_instance_private (bostream);
        GSource *base_source, *pollable_source;
 
-       if (bostream->priv->eof)
+       if (priv->eof)
                base_source = g_timeout_source_new (0);
        else
-               base_source = g_pollable_output_stream_create_source (G_POLLABLE_OUTPUT_STREAM 
(bostream->priv->base_stream), cancellable);
+               base_source = g_pollable_output_stream_create_source (G_POLLABLE_OUTPUT_STREAM 
(priv->base_stream), cancellable);
        g_source_set_dummy_callback (base_source);
 
        pollable_source = g_pollable_source_new (G_OBJECT (stream));
diff --git a/libsoup/soup-body-output-stream.h b/libsoup/soup-body-output-stream.h
index c817cc74..b4fb1308 100644
--- a/libsoup/soup-body-output-stream.h
+++ b/libsoup/soup-body-output-stream.h
@@ -3,8 +3,7 @@
  * Copyright 2012 Red Hat, Inc.
  */
 
-#ifndef __SOUP_BODY_OUTPUT_STREAM_H__
-#define __SOUP_BODY_OUTPUT_STREAM_H__ 1
+#pragma once
 
 #include "soup-types.h"
 #include "soup-message-headers.h"
@@ -12,36 +11,10 @@
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_BODY_OUTPUT_STREAM            (soup_body_output_stream_get_type ())
-#define SOUP_BODY_OUTPUT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
SOUP_TYPE_BODY_OUTPUT_STREAM, SoupBodyOutputStream))
-#define SOUP_BODY_OUTPUT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), 
SOUP_TYPE_BODY_OUTPUT_STREAM, SoupBodyOutputStreamClass))
-#define SOUP_IS_BODY_OUTPUT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
SOUP_TYPE_BODY_OUTPUT_STREAM))
-#define SOUP_IS_BODY_OUTPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), 
SOUP_TYPE_BODY_OUTPUT_STREAM))
-#define SOUP_BODY_OUTPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), 
SOUP_TYPE_BODY_OUTPUT_STREAM, SoupBodyOutputStreamClass))
-
-typedef struct _SoupBodyOutputStreamPrivate SoupBodyOutputStreamPrivate;
-
-typedef struct {
-       GFilterOutputStream parent;
-
-       SoupBodyOutputStreamPrivate *priv;
-} SoupBodyOutputStream;
-
-typedef struct {
-       GFilterOutputStreamClass parent_class;
-
-       /* Padding for future expansion */
-       void (*_libsoup_reserved1) (void);
-       void (*_libsoup_reserved2) (void);
-       void (*_libsoup_reserved3) (void);
-       void (*_libsoup_reserved4) (void);
-} SoupBodyOutputStreamClass;
-
-GType soup_body_output_stream_get_type (void);
+G_DECLARE_FINAL_TYPE (SoupBodyOutputStream, soup_body_output_stream, SOUP, BODY_OUTPUT_STREAM, 
GFilterOutputStream)
 
 GOutputStream *soup_body_output_stream_new (GOutputStream *base_stream,
                                            SoupEncoding   encoding,
                                            goffset        content_length);
 
 G_END_DECLS
-
-#endif /* __SOUP_BODY_OUTPUT_STREAM_H__ */
diff --git a/libsoup/soup-client-input-stream.c b/libsoup/soup-client-input-stream.c
index 8fa28c0b..1d698fa6 100644
--- a/libsoup/soup-client-input-stream.c
+++ b/libsoup/soup-client-input-stream.c
@@ -14,10 +14,14 @@
 #include "soup-message-private.h"
 #include "soup-misc.h"
 
-struct _SoupClientInputStreamPrivate {
-       SoupMessage  *msg;
+struct _SoupClientInputStream {
+       SoupFilterInputStream parent_instance;
 };
 
+typedef struct {
+       SoupMessage  *msg;
+} SoupClientInputStreamPrivate;
+
 enum {
        SIGNAL_EOF,
        LAST_SIGNAL
@@ -42,15 +46,15 @@ G_DEFINE_TYPE_WITH_CODE (SoupClientInputStream, soup_client_input_stream, SOUP_T
 static void
 soup_client_input_stream_init (SoupClientInputStream *stream)
 {
-       stream->priv = soup_client_input_stream_get_instance_private (stream);
 }
 
 static void
 soup_client_input_stream_finalize (GObject *object)
 {
        SoupClientInputStream *cistream = SOUP_CLIENT_INPUT_STREAM (object);
+        SoupClientInputStreamPrivate *priv = soup_client_input_stream_get_instance_private (cistream);
 
-       g_clear_object (&cistream->priv->msg);
+       g_clear_object (&priv->msg);
 
        G_OBJECT_CLASS (soup_client_input_stream_parent_class)->finalize (object);
 }
@@ -60,10 +64,11 @@ soup_client_input_stream_set_property (GObject *object, guint prop_id,
                                       const GValue *value, GParamSpec *pspec)
 {
        SoupClientInputStream *cistream = SOUP_CLIENT_INPUT_STREAM (object);
+        SoupClientInputStreamPrivate *priv = soup_client_input_stream_get_instance_private (cistream);
 
        switch (prop_id) {
        case PROP_MESSAGE:
-               cistream->priv->msg = g_value_dup_object (value);
+               priv->msg = g_value_dup_object (value);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -76,10 +81,11 @@ soup_client_input_stream_get_property (GObject *object, guint prop_id,
                                       GValue *value, GParamSpec *pspec)
 {
        SoupClientInputStream *cistream = SOUP_CLIENT_INPUT_STREAM (object);
+        SoupClientInputStreamPrivate *priv = soup_client_input_stream_get_instance_private (cistream);
 
        switch (prop_id) {
        case PROP_MESSAGE:
-               g_value_set_object (value, cistream->priv->msg);
+               g_value_set_object (value, priv->msg);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -128,11 +134,12 @@ soup_client_input_stream_close_fn (GInputStream  *stream,
                                   GError       **error)
 {
        SoupClientInputStream *cistream = SOUP_CLIENT_INPUT_STREAM (stream);
+        SoupClientInputStreamPrivate *priv = soup_client_input_stream_get_instance_private (cistream);
        gboolean success;
 
-       success = soup_message_io_run_until_finish (cistream->priv->msg, TRUE,
+       success = soup_message_io_run_until_finish (priv->msg, TRUE,
                                                    NULL, error);
-       soup_message_io_finished (cistream->priv->msg);
+       soup_message_io_finished (priv->msg);
        return success;
 }
 
@@ -151,9 +158,10 @@ close_async_ready (SoupMessage *msg, gpointer user_data)
 {
        GTask *task = user_data;
        SoupClientInputStream *cistream = g_task_get_source_object (task);
+        SoupClientInputStreamPrivate *priv = soup_client_input_stream_get_instance_private (cistream);
        GError *error = NULL;
 
-       if (!soup_message_io_run_until_finish (cistream->priv->msg, FALSE,
+       if (!soup_message_io_run_until_finish (priv->msg, FALSE,
                                               g_task_get_cancellable (task),
                                               &error) &&
            g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
@@ -161,7 +169,7 @@ close_async_ready (SoupMessage *msg, gpointer user_data)
                return TRUE;
        }
 
-       soup_message_io_finished (cistream->priv->msg);
+       soup_message_io_finished (priv->msg);
 
        if (error) {
                g_task_return_error (task, error);
@@ -186,15 +194,16 @@ soup_client_input_stream_close_async (GInputStream        *stream,
                                      gpointer             user_data)
 {
        SoupClientInputStream *cistream = SOUP_CLIENT_INPUT_STREAM (stream);
+        SoupClientInputStreamPrivate *priv = soup_client_input_stream_get_instance_private (cistream);
        GTask *task;
        GSource *source;
 
        task = g_task_new (stream, cancellable, callback, user_data);
        g_task_set_priority (task, priority);
 
-       if (close_async_ready (cistream->priv->msg, task) == G_SOURCE_CONTINUE) {
-               source = soup_message_io_data_get_source ((SoupMessageIOData *)soup_message_get_io_data 
(cistream->priv->msg),
-                                                         G_OBJECT (cistream->priv->msg),
+       if (close_async_ready (priv->msg, task) == G_SOURCE_CONTINUE) {
+               source = soup_message_io_data_get_source ((SoupMessageIOData *)soup_message_get_io_data 
(priv->msg),
+                                                         G_OBJECT (priv->msg),
                                                          cancellable, NULL, NULL);
 
                g_task_attach_source (task, source, (GSourceFunc) close_async_ready);
diff --git a/libsoup/soup-client-input-stream.h b/libsoup/soup-client-input-stream.h
index c007047a..b8334138 100644
--- a/libsoup/soup-client-input-stream.h
+++ b/libsoup/soup-client-input-stream.h
@@ -3,8 +3,7 @@
  * Copyright 2010-2012 Red Hat, Inc.
  */
 
-#ifndef __SOUP_CLIENT_INPUT_STREAM_H__
-#define __SOUP_CLIENT_INPUT_STREAM_H__ 1
+#pragma once
 
 #include "soup-types.h"
 #include "soup-filter-input-stream.h"
@@ -12,35 +11,10 @@
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_CLIENT_INPUT_STREAM            (soup_client_input_stream_get_type ())
-#define SOUP_CLIENT_INPUT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
SOUP_TYPE_CLIENT_INPUT_STREAM, SoupClientInputStream))
-#define SOUP_CLIENT_INPUT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), 
SOUP_TYPE_CLIENT_INPUT_STREAM, SoupClientInputStreamClass))
-#define SOUP_IS_CLIENT_INPUT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
SOUP_TYPE_CLIENT_INPUT_STREAM))
-#define SOUP_IS_CLIENT_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), 
SOUP_TYPE_CLIENT_INPUT_STREAM))
-#define SOUP_CLIENT_INPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), 
SOUP_TYPE_CLIENT_INPUT_STREAM, SoupClientInputStreamClass))
-
-typedef struct _SoupClientInputStreamPrivate SoupClientInputStreamPrivate;
-
-typedef struct {
-       SoupFilterInputStream parent;
-
-       SoupClientInputStreamPrivate *priv;
-} SoupClientInputStream;
-
-typedef struct {
-       SoupFilterInputStreamClass parent_class;
-
-       /* Padding for future expansion */
-       void (*_libsoup_reserved1) (void);
-       void (*_libsoup_reserved2) (void);
-       void (*_libsoup_reserved3) (void);
-       void (*_libsoup_reserved4) (void);
-} SoupClientInputStreamClass;
-
-GType soup_client_input_stream_get_type (void);
+G_DECLARE_FINAL_TYPE (SoupClientInputStream, soup_client_input_stream, SOUP, CLIENT_INPUT_STREAM, 
SoupFilterInputStream)
 
 GInputStream *soup_client_input_stream_new (GInputStream *base_stream,
                                            SoupMessage  *msg);
 
 G_END_DECLS
 
-#endif /* __SOUP_CLIENT_INPUT_STREAM_H__ */
diff --git a/libsoup/soup-filter-input-stream.c b/libsoup/soup-filter-input-stream.c
index 2c30bf98..fd4466f1 100644
--- a/libsoup/soup-filter-input-stream.c
+++ b/libsoup/soup-filter-input-stream.c
@@ -20,11 +20,11 @@
  * via fill_async(), but that would be more work...)
  */
 
-struct _SoupFilterInputStreamPrivate {
+typedef struct {
        GByteArray *buf;
        gboolean need_more;
        gboolean in_read_until;
-};
+} SoupFilterInputStreamPrivate;
 
 static void soup_filter_input_stream_pollable_init (GPollableInputStreamInterface *pollable_interface, 
gpointer interface_data);
 
@@ -36,15 +36,15 @@ G_DEFINE_TYPE_WITH_CODE (SoupFilterInputStream, soup_filter_input_stream, G_TYPE
 static void
 soup_filter_input_stream_init (SoupFilterInputStream *stream)
 {
-       stream->priv = soup_filter_input_stream_get_instance_private (stream);
 }
 
 static void
 soup_filter_input_stream_finalize (GObject *object)
 {
        SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (object);
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
 
-       g_clear_pointer (&fstream->priv->buf, g_byte_array_unref);
+       g_clear_pointer (&priv->buf, g_byte_array_unref);
 
        G_OBJECT_CLASS (soup_filter_input_stream_parent_class)->finalize (object);
 }
@@ -52,7 +52,8 @@ soup_filter_input_stream_finalize (GObject *object)
 static gssize
 read_from_buf (SoupFilterInputStream *fstream, gpointer buffer, gsize count)
 {
-       GByteArray *buf = fstream->priv->buf;
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
+       GByteArray *buf = priv->buf;
 
        if (buf->len < count)
                count = buf->len;
@@ -60,7 +61,7 @@ read_from_buf (SoupFilterInputStream *fstream, gpointer buffer, gsize count)
 
        if (count == buf->len) {
                g_byte_array_free (buf, TRUE);
-               fstream->priv->buf = NULL;
+               priv->buf = NULL;
        } else {
                memmove (buf->data, buf->data + count,
                         buf->len - count);
@@ -78,11 +79,12 @@ soup_filter_input_stream_read_fn (GInputStream  *stream,
                                  GError       **error)
 {
        SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (stream);
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
 
-       if (!fstream->priv->in_read_until)
-               fstream->priv->need_more = FALSE;
+       if (!priv->in_read_until)
+               priv->need_more = FALSE;
 
-       if (fstream->priv->buf && !fstream->priv->in_read_until) {
+       if (priv->buf && !priv->in_read_until) {
                return read_from_buf (fstream, buffer, count);
        } else {
                return g_pollable_stream_read (G_FILTER_INPUT_STREAM (fstream)->base_stream,
@@ -95,8 +97,9 @@ static gboolean
 soup_filter_input_stream_is_readable (GPollableInputStream *stream)
 {
        SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (stream);
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
 
-       if (fstream->priv->buf && !fstream->priv->need_more)
+       if (priv->buf && !priv->need_more)
                return TRUE;
        else
                return g_pollable_input_stream_is_readable (G_POLLABLE_INPUT_STREAM (G_FILTER_INPUT_STREAM 
(fstream)->base_stream));
@@ -109,11 +112,12 @@ soup_filter_input_stream_read_nonblocking (GPollableInputStream  *stream,
                                           GError               **error)
 {
        SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (stream);
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
 
-       if (!fstream->priv->in_read_until)
-               fstream->priv->need_more = FALSE;
+       if (!priv->in_read_until)
+               priv->need_more = FALSE;
 
-       if (fstream->priv->buf && !fstream->priv->in_read_until) {
+       if (priv->buf && !priv->in_read_until) {
                return read_from_buf (fstream, buffer, count);
        } else {
                return g_pollable_stream_read (G_FILTER_INPUT_STREAM (fstream)->base_stream,
@@ -127,9 +131,10 @@ soup_filter_input_stream_create_source (GPollableInputStream *stream,
                                        GCancellable         *cancellable)
 {
        SoupFilterInputStream *fstream = SOUP_FILTER_INPUT_STREAM (stream);
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
        GSource *base_source, *pollable_source;
 
-       if (fstream->priv->buf && !fstream->priv->need_more)
+       if (priv->buf && !priv->need_more)
                base_source = g_timeout_source_new (0);
        else
                base_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM 
(G_FILTER_INPUT_STREAM (fstream)->base_stream), cancellable);
@@ -198,6 +203,7 @@ soup_filter_input_stream_read_until (SoupFilterInputStream  *fstream,
                                     GCancellable           *cancellable,
                                     GError                **error)
 {
+        SoupFilterInputStreamPrivate *priv = soup_filter_input_stream_get_instance_private (fstream);
        gssize nread, read_length;
        guint8 *p, *buf, *end;
        gboolean eof = FALSE;
@@ -207,37 +213,37 @@ soup_filter_input_stream_read_until (SoupFilterInputStream  *fstream,
        g_return_val_if_fail (!include_boundary || (boundary_length < length), -1);
 
        *got_boundary = FALSE;
-       fstream->priv->need_more = FALSE;
+       priv->need_more = FALSE;
 
-       if (!fstream->priv->buf || fstream->priv->buf->len < boundary_length) {
+       if (!priv->buf || priv->buf->len < boundary_length) {
                guint prev_len;
 
        fill_buffer:
-               if (!fstream->priv->buf)
-                       fstream->priv->buf = g_byte_array_new ();
-               prev_len = fstream->priv->buf->len;
-               g_byte_array_set_size (fstream->priv->buf, length);
-               buf = fstream->priv->buf->data;
+               if (!priv->buf)
+                       priv->buf = g_byte_array_new ();
+               prev_len = priv->buf->len;
+               g_byte_array_set_size (priv->buf, length);
+               buf = priv->buf->data;
 
-               fstream->priv->in_read_until = TRUE;
+               priv->in_read_until = TRUE;
                nread = g_pollable_stream_read (G_INPUT_STREAM (fstream),
                                                buf + prev_len, length - prev_len,
                                                blocking,
                                                cancellable, &my_error);
-               fstream->priv->in_read_until = FALSE;
+               priv->in_read_until = FALSE;
                if (nread <= 0) {
                        if (prev_len)
-                               fstream->priv->buf->len = prev_len;
+                               priv->buf->len = prev_len;
                        else {
-                               g_byte_array_free (fstream->priv->buf, TRUE);
-                               fstream->priv->buf = NULL;
+                               g_byte_array_free (priv->buf, TRUE);
+                               priv->buf = NULL;
                        }
 
                        if (nread == 0 && prev_len)
                                eof = TRUE;
                        else {
                                if (g_error_matches (my_error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK))
-                                       fstream->priv->need_more = TRUE;
+                                       priv->need_more = TRUE;
                                if (my_error)
                                        g_propagate_error (error, my_error);
 
@@ -247,15 +253,15 @@ soup_filter_input_stream_read_until (SoupFilterInputStream  *fstream,
                        if (my_error)
                                g_propagate_error (error, my_error);
                } else
-                       fstream->priv->buf->len = prev_len + nread;
+                       priv->buf->len = prev_len + nread;
        } else
-               buf = fstream->priv->buf->data;
+               buf = priv->buf->data;
 
        /* Scan for the boundary within the range we can possibly return. */
        if (include_boundary)
-               end = buf + MIN (fstream->priv->buf->len, length) - boundary_length;
+               end = buf + MIN (priv->buf->len, length) - boundary_length;
        else
-               end = buf + MIN (fstream->priv->buf->len - boundary_length, length);
+               end = buf + MIN (priv->buf->len - boundary_length, length);
        for (p = buf; p <= end; p++) {
                if (*p == *(guint8*)boundary &&
                    !memcmp (p, boundary, boundary_length)) {
@@ -266,11 +272,11 @@ soup_filter_input_stream_read_until (SoupFilterInputStream  *fstream,
                }
        }
 
-       if (!*got_boundary && fstream->priv->buf->len < length && !eof)
+       if (!*got_boundary && priv->buf->len < length && !eof)
                goto fill_buffer;
 
        if (eof && !*got_boundary)
-               read_length = MIN (fstream->priv->buf->len, length);
+               read_length = MIN (priv->buf->len, length);
        else
                read_length = p - buf;
        return read_from_buf (fstream, buffer, read_length);
diff --git a/libsoup/soup-filter-input-stream.h b/libsoup/soup-filter-input-stream.h
index fac1efed..4547f91c 100644
--- a/libsoup/soup-filter-input-stream.h
+++ b/libsoup/soup-filter-input-stream.h
@@ -3,34 +3,18 @@
  * Copyright 2012 Red Hat, Inc.
  */
 
-#ifndef __SOUP_FILTER_INPUT_STREAM_H__
-#define __SOUP_FILTER_INPUT_STREAM_H__ 1
+#pragma once
 
 #include "soup-types.h"
 
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_FILTER_INPUT_STREAM            (soup_filter_input_stream_get_type ())
-#define SOUP_FILTER_INPUT_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), 
SOUP_TYPE_FILTER_INPUT_STREAM, SoupFilterInputStream))
-#define SOUP_FILTER_INPUT_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), 
SOUP_TYPE_FILTER_INPUT_STREAM, SoupFilterInputStreamClass))
-#define SOUP_IS_FILTER_INPUT_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), 
SOUP_TYPE_FILTER_INPUT_STREAM))
-#define SOUP_IS_FILTER_INPUT_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), 
SOUP_TYPE_FILTER_INPUT_STREAM))
-#define SOUP_FILTER_INPUT_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), 
SOUP_TYPE_FILTER_INPUT_STREAM, SoupFilterInputStreamClass))
+G_DECLARE_DERIVABLE_TYPE (SoupFilterInputStream, soup_filter_input_stream, SOUP, FILTER_INPUT_STREAM, 
GFilterInputStream)
 
-typedef struct _SoupFilterInputStreamPrivate SoupFilterInputStreamPrivate;
-
-typedef struct {
-       GFilterInputStream parent;
-
-       SoupFilterInputStreamPrivate *priv;
-} SoupFilterInputStream;
-
-typedef struct {
+struct _SoupFilterInputStreamClass {
        GFilterInputStreamClass parent_class;
-
-} SoupFilterInputStreamClass;
-
-GType soup_filter_input_stream_get_type (void);
+};
 
 GInputStream *soup_filter_input_stream_new        (GInputStream           *base_stream);
 
@@ -53,5 +37,3 @@ gssize        soup_filter_input_stream_read_until (SoupFilterInputStream  *fstre
                                                   GError                **error);
 
 G_END_DECLS
-
-#endif /* __SOUP_FILTER_INPUT_STREAM_H__ */
diff --git a/libsoup/soup-io-stream.c b/libsoup/soup-io-stream.c
index 8daca38d..07b35273 100644
--- a/libsoup/soup-io-stream.c
+++ b/libsoup/soup-io-stream.c
@@ -13,14 +13,18 @@
 #include "soup.h"
 #include "soup-filter-input-stream.h"
 
-struct _SoupIOStreamPrivate {
+struct _SoupIOStream {
+       GIOStream parent_instance;
+};
+
+typedef struct {
        GIOStream *base_iostream;
        gboolean close_on_dispose;
 
        GInputStream *istream;
        GOutputStream *ostream;
        gboolean disposing;
-};
+} SoupIOStreamPrivate;
 
 enum {
        PROP_0,
@@ -34,7 +38,6 @@ G_DEFINE_TYPE_WITH_PRIVATE (SoupIOStream, soup_io_stream, G_TYPE_IO_STREAM)
 static void
 soup_io_stream_init (SoupIOStream *stream)
 {
-       stream->priv = soup_io_stream_get_instance_private (stream);
 }
 
 static void
@@ -42,23 +45,24 @@ soup_io_stream_set_property (GObject *object, guint prop_id,
                             const GValue *value, GParamSpec *pspec)
 {
        SoupIOStream *siostream = SOUP_IO_STREAM (object);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
        GIOStream *io;
 
        switch (prop_id) {
        case PROP_BASE_IOSTREAM:
-               io = siostream->priv->base_iostream = g_value_dup_object (value);
+               io = priv->base_iostream = g_value_dup_object (value);
                if (io) {
-                       siostream->priv->istream =
+                       priv->istream =
                                soup_filter_input_stream_new (g_io_stream_get_input_stream (io));
-                       siostream->priv->ostream =
+                       priv->ostream =
                                g_object_ref (g_io_stream_get_output_stream (io));
                } else {
-                       g_clear_object (&siostream->priv->istream);
-                       g_clear_object (&siostream->priv->ostream);
+                       g_clear_object (&priv->istream);
+                       g_clear_object (&priv->ostream);
                }
                break;
        case PROP_CLOSE_ON_DISPOSE:
-               siostream->priv->close_on_dispose = g_value_get_boolean (value);
+               priv->close_on_dispose = g_value_get_boolean (value);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -71,13 +75,14 @@ soup_io_stream_get_property (GObject *object, guint prop_id,
                             GValue *value, GParamSpec *pspec)
 {
        SoupIOStream *siostream = SOUP_IO_STREAM (object);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
 
        switch (prop_id) {
        case PROP_BASE_IOSTREAM:
-               g_value_set_object (value, siostream->priv->base_iostream);
+               g_value_set_object (value, priv->base_iostream);
                break;
        case PROP_CLOSE_ON_DISPOSE:
-               g_value_set_boolean (value, siostream->priv->close_on_dispose);
+               g_value_set_boolean (value, priv->close_on_dispose);
                break;
        default:
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -89,8 +94,9 @@ static void
 soup_io_stream_dispose (GObject *object)
 {
        SoupIOStream *siostream = SOUP_IO_STREAM (object);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
 
-       siostream->priv->disposing = TRUE;
+       priv->disposing = TRUE;
 
        G_OBJECT_CLASS (soup_io_stream_parent_class)->dispose (object);
 }
@@ -99,10 +105,11 @@ static void
 soup_io_stream_finalize (GObject *object)
 {
        SoupIOStream *siostream = SOUP_IO_STREAM (object);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
 
-       g_clear_object (&siostream->priv->base_iostream);
-       g_clear_object (&siostream->priv->istream);
-       g_clear_object (&siostream->priv->ostream);
+       g_clear_object (&priv->base_iostream);
+       g_clear_object (&priv->istream);
+       g_clear_object (&priv->ostream);
 
        G_OBJECT_CLASS (soup_io_stream_parent_class)->finalize (object);
 }
@@ -110,13 +117,17 @@ soup_io_stream_finalize (GObject *object)
 static GInputStream *
 soup_io_stream_get_input_stream (GIOStream *stream)
 {
-       return SOUP_IO_STREAM (stream)->priv->istream;
+        SoupIOStream *siostream = SOUP_IO_STREAM (stream);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
+       return priv->istream;
 }
 
 static GOutputStream *
 soup_io_stream_get_output_stream (GIOStream *stream)
 {
-       return SOUP_IO_STREAM (stream)->priv->ostream;
+        SoupIOStream *siostream = SOUP_IO_STREAM (stream);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
+       return priv->ostream;
 }
 
 
@@ -126,12 +137,13 @@ soup_io_stream_close (GIOStream     *stream,
                      GError       **error)
 {
        SoupIOStream *siostream = SOUP_IO_STREAM (stream);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
 
-       if (siostream->priv->disposing &&
-           !siostream->priv->close_on_dispose)
+       if (priv->disposing &&
+           !priv->close_on_dispose)
                return TRUE;
 
-       return g_io_stream_close (siostream->priv->base_iostream,
+       return g_io_stream_close (priv->base_iostream,
                                  cancellable, error);
 }
 
@@ -158,9 +170,11 @@ soup_io_stream_close_async (GIOStream           *stream,
                            gpointer             user_data)
 {
        GTask *task;
+        SoupIOStream *siostream = SOUP_IO_STREAM (stream);
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (siostream);
 
        task = g_task_new (stream, cancellable, callback, user_data);
-       g_io_stream_close_async (SOUP_IO_STREAM (stream)->priv->base_iostream,
+       g_io_stream_close_async (priv->base_iostream,
                                 io_priority, cancellable,
                                 close_async_complete, task);
 }
@@ -223,7 +237,9 @@ soup_io_stream_new (GIOStream *base_iostream,
 GIOStream *
 soup_io_stream_get_base_iostream (SoupIOStream *stream)
 {
+        SoupIOStreamPrivate *priv = soup_io_stream_get_instance_private (stream);
+
        g_return_val_if_fail (SOUP_IS_IO_STREAM (stream), NULL);
 
-       return stream->priv->base_iostream;
+       return priv->base_iostream;
 }
diff --git a/libsoup/soup-io-stream.h b/libsoup/soup-io-stream.h
index b5169c04..e8684d30 100644
--- a/libsoup/soup-io-stream.h
+++ b/libsoup/soup-io-stream.h
@@ -3,34 +3,14 @@
  * Copyright 2012 Red Hat, Inc.
  */
 
-#ifndef __SOUP_IO_STREAM_H__
-#define __SOUP_IO_STREAM_H__ 1
+#pragma once
 
 #include "soup-types.h"
 
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_IO_STREAM            (soup_io_stream_get_type ())
-#define SOUP_IO_STREAM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_IO_STREAM, 
SoupIOStream))
-#define SOUP_IO_STREAM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_IO_STREAM, 
SoupIOStreamClass))
-#define SOUP_IS_IO_STREAM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_IO_STREAM))
-#define SOUP_IS_IO_STREAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_IO_STREAM))
-#define SOUP_IO_STREAM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_IO_STREAM, 
SoupIOStreamClass))
-
-typedef struct _SoupIOStreamPrivate SoupIOStreamPrivate;
-
-typedef struct {
-       GIOStream parent;
-
-       SoupIOStreamPrivate *priv;
-} SoupIOStream;
-
-typedef struct {
-       GIOStreamClass parent_class;
-
-} SoupIOStreamClass;
-
-GType soup_io_stream_get_type (void);
+G_DECLARE_FINAL_TYPE (SoupIOStream, soup_io_stream, SOUP, IO_STREAM, GIOStream)
 
 GIOStream *soup_io_stream_new (GIOStream *base_iostream,
                               gboolean   close_on_dispose);
@@ -38,5 +18,3 @@ GIOStream *soup_io_stream_new (GIOStream *base_iostream,
 GIOStream *soup_io_stream_get_base_iostream (SoupIOStream *stream);
 
 G_END_DECLS
-
-#endif /* __SOUP_IO_STREAM_H__ */
diff --git a/libsoup/soup-socket.c b/libsoup/soup-socket.c
index 5b0c604c..3f974ff3 100644
--- a/libsoup/soup-socket.c
+++ b/libsoup/soup-socket.c
@@ -64,6 +64,10 @@ enum {
        LAST_PROP
 };
 
+struct _SoupSocket {
+       GObject parent_instance;
+};
+
 typedef struct {
        GInetSocketAddress *local_addr, *remote_addr;
     GSocketConnectable *remote_connectable;
@@ -406,7 +410,7 @@ soup_socket_class_init (SoupSocketClass *socket_class)
                g_signal_new ("readable",
                              G_OBJECT_CLASS_TYPE (object_class),
                              G_SIGNAL_RUN_LAST,
-                             G_STRUCT_OFFSET (SoupSocketClass, readable),
+                             0,
                              NULL, NULL,
                              NULL,
                              G_TYPE_NONE, 0);
@@ -422,7 +426,7 @@ soup_socket_class_init (SoupSocketClass *socket_class)
                g_signal_new ("writable",
                              G_OBJECT_CLASS_TYPE (object_class),
                              G_SIGNAL_RUN_LAST,
-                             G_STRUCT_OFFSET (SoupSocketClass, writable),
+                             0,
                              NULL, NULL,
                              NULL,
                              G_TYPE_NONE, 0);
@@ -438,7 +442,7 @@ soup_socket_class_init (SoupSocketClass *socket_class)
                g_signal_new ("disconnected",
                              G_OBJECT_CLASS_TYPE (object_class),
                              G_SIGNAL_RUN_LAST,
-                             G_STRUCT_OFFSET (SoupSocketClass, disconnected),
+                             0,
                              NULL, NULL,
                              NULL,
                              G_TYPE_NONE, 0);
@@ -458,7 +462,7 @@ soup_socket_class_init (SoupSocketClass *socket_class)
                g_signal_new ("new_connection",
                              G_OBJECT_CLASS_TYPE (object_class),
                              G_SIGNAL_RUN_FIRST,
-                             G_STRUCT_OFFSET (SoupSocketClass, new_connection),
+                             0,
                              NULL, NULL,
                              NULL,
                              G_TYPE_NONE, 1,
diff --git a/libsoup/soup-socket.h b/libsoup/soup-socket.h
index 16c289e5..3775e6ad 100644
--- a/libsoup/soup-socket.h
+++ b/libsoup/soup-socket.h
@@ -3,41 +3,14 @@
  * Copyright (C) 2000-2003, Ximian, Inc.
  */
 
-#ifndef __SOUP_SOCKET_H__
-#define __SOUP_SOCKET_H__ 1
+#pragma once
 
 #include "soup-types.h"
 
 G_BEGIN_DECLS
 
 #define SOUP_TYPE_SOCKET            (soup_socket_get_type ())
-#define SOUP_SOCKET(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SOCKET, SoupSocket))
-#define SOUP_SOCKET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SOCKET, SoupSocketClass))
-#define SOUP_IS_SOCKET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SOCKET))
-#define SOUP_IS_SOCKET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SOCKET))
-#define SOUP_SOCKET_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOCKET, SoupSocketClass))
-
-struct _SoupSocket {
-       GObject parent;
-
-};
-
-typedef struct {
-       GObjectClass parent_class;
-
-       /* signals */
-       void (*readable)       (SoupSocket *sock);
-       void (*writable)       (SoupSocket *sock);
-       void (*disconnected)   (SoupSocket *sock);
-
-       void (*new_connection) (SoupSocket *listener, SoupSocket *new_sock);
-
-       /* Padding for future expansion */
-       void (*_libsoup_reserved1) (void);
-       void (*_libsoup_reserved2) (void);
-       void (*_libsoup_reserved3) (void);
-       void (*_libsoup_reserved4) (void);
-} SoupSocketClass;
+G_DECLARE_FINAL_TYPE (SoupSocket, soup_socket, SOUP, SOCKET, GObject)
 
 #define SOUP_SOCKET_LOCAL_ADDRESS       "local-address"
 #define SOUP_SOCKET_REMOTE_ADDRESS      "remote-address"
@@ -56,8 +29,6 @@ typedef void (*SoupSocketCallback)            (SoupSocket         *sock,
                                               guint               status,
                                               gpointer            user_data);
 
-GType soup_socket_get_type (void);
-
 SoupSocket    *soup_socket_new                (const char         *optname1,
                                               ...) G_GNUC_NULL_TERMINATED;
 
@@ -112,5 +83,3 @@ SoupSocketIOStatus  soup_socket_write      (SoupSocket         *sock,
                                            GError            **error);
 
 G_END_DECLS
-
-#endif /* __SOUP_SOCKET_H__ */


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]