Modernize GObject usage of various classes

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__ */