Make SoupMessage a private and final type

46 files changed, 541 insertions, 454 deletions

diff --git a/docs/reference/server-howto.xml b/docs/reference/server-howto.xml
index 0372a319..712f68c1 100644
--- a/docs/reference/server-howto.xml
+++ b/docs/reference/server-howto.xml
@@ -230,7 +230,7 @@ server_callback (SoupServer        *server,
 	const char *mime_type;
 	GByteArray *body;
 
-	if (msg->method != SOUP_METHOD_GET) {
+	if (soup_message_get_method (msg) != SOUP_METHOD_GET) {
 		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
 		return;
 	}
diff --git a/examples/get.c b/examples/get.c
index 0a429252..48c35f0a 100644
--- a/examples/get.c
+++ b/examples/get.c
@@ -42,19 +42,19 @@ get_url (const char *url)
 	name = soup_message_get_uri (msg)->path;
 
 	if (!debug) {
-		if (msg->status_code == SOUP_STATUS_SSL_FAILED) {
+		if (soup_message_get_status (msg) == SOUP_STATUS_SSL_FAILED) {
 			GTlsCertificateFlags flags;
 
 			if (soup_message_get_https_status (msg, NULL, &flags))
-				g_print ("%s: %d %s (0x%x)\n", name, msg->status_code, msg->reason_phrase, flags);
+				g_print ("%s: %d %s (0x%x)\n", name, soup_message_get_status (msg), soup_message_get_reason_phrase (msg), flags);
 			else
-				g_print ("%s: %d %s (no handshake status)\n", name, msg->status_code, msg->reason_phrase);
-		} else if (!quiet || SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code))
-			g_print ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
+				g_print ("%s: %d %s (no handshake status)\n", name, soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
+		} else if (!quiet || SOUP_STATUS_IS_TRANSPORT_ERROR (soup_message_get_status (msg)))
+			g_print ("%s: %d %s\n", name, soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
 	}
 
-	if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
-		header = soup_message_headers_get_one (msg->response_headers,
+	if (SOUP_STATUS_IS_REDIRECTION (soup_message_get_status (msg))) {
+		header = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 						       "Location");
 		if (header) {
 			SoupURI *uri;
@@ -69,7 +69,7 @@ get_url (const char *url)
 			g_free (uri_string);
 			soup_uri_free (uri);
 		}
-	} else if (!head && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
+	} else if (!head && SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (msg))) {
 		if (output_file_path) {
 			output_file = fopen (output_file_path, "w");
 			if (!output_file)
diff --git a/examples/simple-httpd.c b/examples/simple-httpd.c
index 8cfed4b5..3c5b534b 100644
--- a/examples/simple-httpd.c
+++ b/examples/simple-httpd.c
@@ -117,7 +117,7 @@ do_get (SoupServer *server, SoupMessage *msg, const char *path)
 		return;
 	}
 
-	if (msg->method == SOUP_METHOD_GET) {
+	if (soup_message_get_method (msg) == SOUP_METHOD_GET) {
 		GMappedFile *mapping;
 		GBytes *buffer;
 
@@ -132,7 +132,7 @@ do_get (SoupServer *server, SoupMessage *msg, const char *path)
 						     (GDestroyNotify)g_mapped_file_unref, g_steal_pointer (&mapping));
 		soup_message_body_append_bytes (msg->response_body, buffer);
 		g_bytes_unref (buffer);
-	} else /* msg->method == SOUP_METHOD_HEAD */ {
+	} else /* soup_message_get_method (msg) == SOUP_METHOD_HEAD */ {
 		char *length;
 
 		/* We could just use the same code for both GET and
@@ -140,7 +140,7 @@ do_get (SoupServer *server, SoupMessage *msg, const char *path)
 		 * But we'll optimize and avoid the extra I/O.
 		 */
 		length = g_strdup_printf ("%lu", (gulong)st.st_size);
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (soup_message_get_response_headers (msg),
 					     "Content-Length", length);
 		g_free (length);
 	}
@@ -156,7 +156,7 @@ do_put (SoupServer *server, SoupMessage *msg, const char *path)
 	gboolean created = TRUE;
 
 	if (g_stat (path, &st) != -1) {
-		const char *match = soup_message_headers_get_one (msg->request_headers, "If-None-Match");
+		const char *match = soup_message_headers_get_one (soup_message_get_request_headers (msg), "If-None-Match");
 		if (match && !strcmp (match, "*")) {
 			soup_message_set_status (msg, SOUP_STATUS_CONFLICT);
 			return;
@@ -191,9 +191,9 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	SoupMessageHeadersIter iter;
 	const char *name, *value;
 
-	g_print ("%s %s HTTP/1.%d\n", msg->method, path,
+	g_print ("%s %s HTTP/1.%d\n", soup_message_get_method (msg), path,
 		 soup_message_get_http_version (msg));
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		g_print ("%s: %s\n", name, value);
 	if (msg->request_body->length)
@@ -201,15 +201,15 @@ server_callback (SoupServer *server, SoupMessage *msg,
 
 	file_path = g_strdup_printf (".%s", path);
 
-	if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD)
+	if (soup_message_get_method (msg) == SOUP_METHOD_GET || soup_message_get_method (msg) == SOUP_METHOD_HEAD)
 		do_get (server, msg, file_path);
-	else if (msg->method == SOUP_METHOD_PUT)
+	else if (soup_message_get_method (msg) == SOUP_METHOD_PUT)
 		do_put (server, msg, file_path);
 	else
 		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
 
 	g_free (file_path);
-	g_print ("  -> %d %s\n\n", msg->status_code, msg->reason_phrase);
+	g_print ("  -> %d %s\n\n", soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
 }
 
 static void
diff --git a/examples/simple-proxy.c b/examples/simple-proxy.c
index 4f8f5af3..eb0433bb 100644
--- a/examples/simple-proxy.c
+++ b/examples/simple-proxy.c
@@ -285,16 +285,16 @@ server_callback (SoupServer *server, SoupMessage *msg,
 	char *uristr;
 
 	uristr = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
-	g_print ("[%p] %s %s HTTP/1.%d\n", msg, msg->method, uristr,
+	g_print ("[%p] %s %s HTTP/1.%d\n", msg, soup_message_get_method (msg), uristr,
 		 soup_message_get_http_version (msg));
 
-	if (msg->method == SOUP_METHOD_CONNECT) {
+	if (soup_message_get_method (msg) == SOUP_METHOD_CONNECT) {
 		try_tunnel (server, msg, context);
 		return;
 	}
 
-        msg2 = soup_message_new (msg->method, uristr);
-	soup_message_headers_foreach (msg->request_headers, copy_header,
+        msg2 = soup_message_new (soup_message_get_method (msg), uristr);
+	soup_message_headers_foreach (soup_message_get_request_headers (msg), copy_header,
 				      msg2->request_headers);
 	soup_message_headers_remove (msg2->request_headers, "Host");
 	soup_message_headers_remove (msg2->request_headers, "Connection");
@@ -304,7 +304,7 @@ server_callback (SoupServer *server, SoupMessage *msg,
 		soup_message_body_append_bytes (msg2->request_body, request);
 		g_bytes_unref (request);
 	}
-	soup_message_headers_set_encoding (msg->response_headers,
+	soup_message_headers_set_encoding (soup_message_get_response_headers (msg),
 					   SOUP_ENCODING_CHUNKED);
 
 	g_signal_connect (msg2, "got_headers",
diff --git a/libsoup/auth/soup-auth-digest.c b/libsoup/auth/soup-auth-digest.c
index 06439ea3..f81dfdca 100644
--- a/libsoup/auth/soup-auth-digest.c
+++ b/libsoup/auth/soup-auth-digest.c
@@ -390,7 +390,7 @@ authentication_info_cb (SoupMessage *msg, gpointer data)
 	if (auth != soup_message_get_auth (msg))
 		return;
 
-	header = soup_message_headers_get_one (msg->response_headers,
+	header = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 					       soup_auth_is_for_proxy (auth) ?
 					       "Proxy-Authentication-Info" :
 					       "Authentication-Info");
@@ -423,7 +423,7 @@ soup_auth_digest_get_authorization (SoupAuth *auth, SoupMessage *msg)
 	g_return_val_if_fail (uri != NULL, NULL);
 	url = soup_uri_to_string (uri, TRUE);
 
-	soup_auth_digest_compute_response (msg->method, url, priv->hex_a1,
+	soup_auth_digest_compute_response (soup_message_get_method (msg), url, priv->hex_a1,
 					   priv->qop, priv->nonce,
 					   priv->cnonce, priv->nc,
 					   response);
diff --git a/libsoup/auth/soup-auth-manager.c b/libsoup/auth/soup-auth-manager.c
index afe6be48..3e1000f2 100644
--- a/libsoup/auth/soup-auth-manager.c
+++ b/libsoup/auth/soup-auth-manager.c
@@ -236,11 +236,11 @@ soup_auth_manager_attach (SoupSessionFeature *feature, SoupSession *session)
 static inline const char *
 auth_header_for_message (SoupMessage *msg)
 {
-	if (msg->status_code == SOUP_STATUS_PROXY_UNAUTHORIZED) {
-		return soup_message_headers_get_list (msg->response_headers,
+	if (soup_message_get_status (msg) == SOUP_STATUS_PROXY_UNAUTHORIZED) {
+		return soup_message_headers_get_list (soup_message_get_response_headers (msg),
 						      "Proxy-Authenticate");
 	} else {
-		return soup_message_headers_get_list (msg->response_headers,
+		return soup_message_headers_get_list (soup_message_get_response_headers (msg),
 						      "WWW-Authenticate");
 	}
 }
@@ -441,7 +441,7 @@ update_authorization_header (SoupMessage *msg, SoupAuth *auth, gboolean is_proxy
 	char *token;
 
 	if (soup_message_get_auth (msg))
-		soup_message_headers_remove (msg->request_headers, authorization_header);
+		soup_message_headers_remove (soup_message_get_request_headers (msg), authorization_header);
 
 	if (!auth)
 		return;
@@ -450,7 +450,7 @@ update_authorization_header (SoupMessage *msg, SoupAuth *auth, gboolean is_proxy
 	if (!token)
 		return;
 
-	soup_message_headers_replace (msg->request_headers, authorization_header, token);
+	soup_message_headers_replace (soup_message_get_request_headers (msg), authorization_header, token);
 	g_free (token);
 }
 
@@ -755,7 +755,7 @@ auth_msg_starting (SoupMessage *msg, gpointer manager)
 
 	g_mutex_lock (&priv->lock);
 
-	if (msg->method != SOUP_METHOD_CONNECT) {
+	if (soup_message_get_method (msg) != SOUP_METHOD_CONNECT) {
 		auth = lookup_auth (priv, msg);
 		if (auth) {
 			authenticate_auth (manager, auth, msg, FALSE, FALSE, FALSE);
diff --git a/libsoup/auth/soup-auth-negotiate.c b/libsoup/auth/soup-auth-negotiate.c
index 8c29a759..cf2befcf 100644
--- a/libsoup/auth/soup-auth-negotiate.c
+++ b/libsoup/auth/soup-auth-negotiate.c
@@ -353,11 +353,11 @@ check_server_response (SoupMessage *msg, gpointer auth)
 	if (auth != soup_message_get_auth (msg))
 		return;
 
-	if (msg->status_code == SOUP_STATUS_UNAUTHORIZED)
+	if (soup_message_get_status (msg) == SOUP_STATUS_UNAUTHORIZED)
 		return;
 
 	/* FIXME: need to check for proxy-auth too */
-	auth_headers = soup_message_headers_get_one (msg->response_headers,
+	auth_headers = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 						     "WWW-Authenticate");
 	if (!auth_headers || g_ascii_strncasecmp (auth_headers, "Negotiate ", 10) != 0) {
 		g_warning ("Failed to parse auth header");
@@ -383,7 +383,7 @@ check_server_response (SoupMessage *msg, gpointer auth)
 		 * Try to behave in the right way (pass the token to
 		 * gss_init_sec_context()), show a warning, but don't fail
 		 * if the server returned 200. */
-		if (msg->status_code == SOUP_STATUS_OK)
+		if (soup_message_get_status (msg) == SOUP_STATUS_OK)
 			priv->is_authenticated = TRUE;
 		else
 			conn->state = SOUP_NEGOTIATE_FAILED;
diff --git a/libsoup/auth/soup-auth-ntlm.c b/libsoup/auth/soup-auth-ntlm.c
index d0b9440b..f18678e5 100644
--- a/libsoup/auth/soup-auth-ntlm.c
+++ b/libsoup/auth/soup-auth-ntlm.c
@@ -327,7 +327,7 @@ soup_auth_ntlm_update_connection (SoupConnectionAuth *auth, SoupMessage *msg,
 			 */
 			conn->state = SOUP_NTLM_FAILED;
 			if (soup_message_is_keepalive (msg)) {
-				soup_message_headers_append (msg->response_headers,
+				soup_message_headers_append (soup_message_get_response_headers (msg),
 							     "Connection", "close");
 			}
 			return TRUE;
@@ -494,7 +494,7 @@ got_final_auth_result (SoupMessage *msg, gpointer data)
 	if (auth != soup_message_get_auth (msg))
 		return;
 
-	if (msg->status_code != SOUP_STATUS_UNAUTHORIZED)
+	if (soup_message_get_status (msg) != SOUP_STATUS_UNAUTHORIZED)
 		priv->password_state = SOUP_NTLM_PASSWORD_ACCEPTED;
 }
 
diff --git a/libsoup/auth/soup-auth.c b/libsoup/auth/soup-auth.c
index 62690bb5..c71b7e31 100644
--- a/libsoup/auth/soup-auth.c
+++ b/libsoup/auth/soup-auth.c
@@ -276,7 +276,7 @@ soup_auth_new (GType type, SoupMessage *msg, const char *auth_header)
 
 	authority = g_strdup_printf ("%s:%d", uri->host, uri->port);
 	auth = g_object_new (type,
-			     "is-for-proxy", (msg->status_code == SOUP_STATUS_PROXY_UNAUTHORIZED),
+			     "is-for-proxy", (soup_message_get_status (msg) == SOUP_STATUS_PROXY_UNAUTHORIZED),
 			     "authority", authority,
 			     NULL);
 	g_free (authority);
diff --git a/libsoup/cache/soup-cache.c b/libsoup/cache/soup-cache.c
index 8aa117af..b0c55514 100644
--- a/libsoup/cache/soup-cache.c
+++ b/libsoup/cache/soup-cache.c
@@ -159,20 +159,20 @@ get_cacheability (SoupCache *cache, SoupMessage *msg)
 	gboolean has_max_age = FALSE;
 
 	/* 1. The request method must be cacheable */
-	if (msg->method == SOUP_METHOD_GET)
+	if (soup_message_get_method (msg) == SOUP_METHOD_GET)
 		cacheability = SOUP_CACHE_CACHEABLE;
-	else if (msg->method == SOUP_METHOD_HEAD ||
-		 msg->method == SOUP_METHOD_TRACE ||
-		 msg->method == SOUP_METHOD_CONNECT)
+	else if (soup_message_get_method (msg) == SOUP_METHOD_HEAD ||
+		 soup_message_get_method (msg) == SOUP_METHOD_TRACE ||
+		 soup_message_get_method (msg) == SOUP_METHOD_CONNECT)
 		return SOUP_CACHE_UNCACHEABLE;
 	else
 		return (SOUP_CACHE_UNCACHEABLE | SOUP_CACHE_INVALIDATES);
 
-	content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
+	content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (msg), NULL);
 	if (content_type && !g_ascii_strcasecmp (content_type, "multipart/x-mixed-replace"))
 		return SOUP_CACHE_UNCACHEABLE;
 
-	cache_control = soup_message_headers_get_list (msg->response_headers, "Cache-Control");
+	cache_control = soup_message_headers_get_list (soup_message_get_response_headers (msg), "Cache-Control");
 	if (cache_control && *cache_control) {
 		GHashTable *hash;
 
@@ -210,11 +210,11 @@ get_cacheability (SoupCache *cache, SoupMessage *msg)
 
 	/* Section 13.9 */
 	if ((soup_message_get_uri (msg))->query &&
-	    !soup_message_headers_get_one (msg->response_headers, "Expires") &&
+	    !soup_message_headers_get_one (soup_message_get_response_headers (msg), "Expires") &&
 	    !has_max_age)
 		return SOUP_CACHE_UNCACHEABLE;
 
-	switch (msg->status_code) {
+	switch (soup_message_get_status (msg)) {
 	case SOUP_STATUS_PARTIAL_CONTENT:
 		/* We don't cache partial responses, but they only
 		 * invalidate cached full responses if the headers
@@ -251,18 +251,18 @@ get_cacheability (SoupCache *cache, SoupMessage *msg)
 		/* Any 5xx status or any 4xx status not handled above
 		 * is uncacheable but doesn't break the cache.
 		 */
-		if ((msg->status_code >= SOUP_STATUS_BAD_REQUEST &&
-		     msg->status_code <= SOUP_STATUS_FAILED_DEPENDENCY) ||
-		    msg->status_code >= SOUP_STATUS_INTERNAL_SERVER_ERROR)
+		if ((soup_message_get_status (msg) >= SOUP_STATUS_BAD_REQUEST &&
+		     soup_message_get_status (msg) <= SOUP_STATUS_FAILED_DEPENDENCY) ||
+		    soup_message_get_status (msg) >= SOUP_STATUS_INTERNAL_SERVER_ERROR)
 			return SOUP_CACHE_UNCACHEABLE;
 
 		/* An unrecognized 2xx, 3xx, or 4xx response breaks
 		 * the cache.
 		 */
-		if ((msg->status_code > SOUP_STATUS_PARTIAL_CONTENT &&
-		     msg->status_code < SOUP_STATUS_MULTIPLE_CHOICES) ||
-		    (msg->status_code > SOUP_STATUS_TEMPORARY_REDIRECT &&
-		     msg->status_code < SOUP_STATUS_INTERNAL_SERVER_ERROR))
+		if ((soup_message_get_status (msg) > SOUP_STATUS_PARTIAL_CONTENT &&
+		     soup_message_get_status (msg) < SOUP_STATUS_MULTIPLE_CHOICES) ||
+		    (soup_message_get_status (msg) > SOUP_STATUS_TEMPORARY_REDIRECT &&
+		     soup_message_get_status (msg) < SOUP_STATUS_INTERNAL_SERVER_ERROR))
 			return (SOUP_CACHE_UNCACHEABLE | SOUP_CACHE_INVALIDATES);
 		break;
 	}
@@ -462,13 +462,13 @@ soup_cache_entry_new (SoupCache *cache, SoupMessage *msg, time_t request_time, t
 	entry = g_slice_new0 (SoupCacheEntry);
 	entry->dirty = FALSE;
 	entry->being_validated = FALSE;
-	entry->status_code = msg->status_code;
+	entry->status_code = soup_message_get_status (msg);
 	entry->response_time = response_time;
 	entry->uri = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
 
 	/* Headers */
 	entry->headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
-	copy_end_to_end_headers (msg->response_headers, entry->headers);
+	copy_end_to_end_headers (soup_message_get_response_headers (msg), entry->headers);
 
 	/* LRU list */
 	entry->hits = 0;
@@ -712,7 +712,7 @@ soup_cache_send_response (SoupCache *cache, SoupMessage *msg)
 	soup_message_set_status (msg, entry->status_code);
 
 	/* Headers */
-	copy_end_to_end_headers (entry->headers, msg->response_headers);
+	copy_end_to_end_headers (entry->headers, soup_message_get_response_headers (msg));
 
 	/* Create the cache stream. */
 	soup_message_disable_feature (msg, SOUP_TYPE_CACHE);
@@ -1113,7 +1113,7 @@ soup_cache_has_response (SoupCache *cache, SoupMessage *msg)
 	 * (TODO: although we could return the headers for HEAD
 	 * probably).
 	 */
-	if (msg->method != SOUP_METHOD_GET)
+	if (soup_message_get_method (msg) != SOUP_METHOD_GET)
 		return SOUP_CACHE_RESPONSE_STALE;
 
 	/* 3. Selecting request-headers nominated by the stored
@@ -1124,8 +1124,8 @@ soup_cache_has_response (SoupCache *cache, SoupMessage *msg)
 
 	/* 4. The request is a conditional request issued by the client.
 	 */
-	if (soup_message_headers_get_one (msg->request_headers, "If-Modified-Since") ||
-	    soup_message_headers_get_list (msg->request_headers, "If-None-Match"))
+	if (soup_message_headers_get_one (soup_message_get_request_headers (msg), "If-Modified-Since") ||
+	    soup_message_headers_get_list (soup_message_get_request_headers (msg), "If-None-Match"))
 		return SOUP_CACHE_RESPONSE_STALE;
 
 	/* 5. The presented request and stored response are free from
@@ -1136,10 +1136,10 @@ soup_cache_has_response (SoupCache *cache, SoupMessage *msg)
 
 	/* For HTTP 1.0 compatibility. RFC2616 section 14.9.4
 	 */
-	if (soup_message_headers_header_contains (msg->request_headers, "Pragma", "no-cache"))
+	if (soup_message_headers_header_contains (soup_message_get_request_headers (msg), "Pragma", "no-cache"))
 		return SOUP_CACHE_RESPONSE_STALE;
 
-	cache_control = soup_message_headers_get_list (msg->request_headers, "Cache-Control");
+	cache_control = soup_message_headers_get_list (soup_message_get_request_headers (msg), "Cache-Control");
 	if (cache_control && *cache_control) {
 		GHashTable *hash = soup_header_parse_param_list (cache_control);
 
@@ -1381,13 +1381,13 @@ soup_cache_generate_conditional_request (SoupCache *cache, SoupMessage *original
 
 	/* Copy the data we need from the original message */
 	uri = soup_message_get_uri (original);
-	msg = soup_message_new_from_uri (original->method, uri);
+	msg = soup_message_new_from_uri (soup_message_get_method (original), uri);
 	soup_message_set_flags (msg, soup_message_get_flags (original));
 	soup_message_disable_feature (msg, SOUP_TYPE_CACHE);
 
-	soup_message_headers_foreach (original->request_headers,
+	soup_message_headers_foreach (soup_message_get_request_headers (original),
 				      (SoupMessageHeadersForeachFunc)copy_headers,
-				      msg->request_headers);
+				      soup_message_get_request_headers (msg));
 
 	disabled_features = soup_message_get_disabled_features (original);
 	for (f = disabled_features; f; f = f->next)
@@ -1395,11 +1395,11 @@ soup_cache_generate_conditional_request (SoupCache *cache, SoupMessage *original
 	g_list_free (disabled_features);
 
 	if (last_modified)
-		soup_message_headers_append (msg->request_headers,
+		soup_message_headers_append (soup_message_get_request_headers (msg),
 					     "If-Modified-Since",
 					     last_modified);
 	if (etag)
-		soup_message_headers_append (msg->request_headers,
+		soup_message_headers_append (soup_message_get_request_headers (msg),
 					     "If-None-Match",
 					     etag);
 
@@ -1430,11 +1430,11 @@ soup_cache_update_from_conditional_request (SoupCache   *cache,
 
 	entry->being_validated = FALSE;
 
-	if (msg->status_code == SOUP_STATUS_NOT_MODIFIED) {
-		soup_message_headers_foreach (msg->response_headers,
+	if (soup_message_get_status (msg) == SOUP_STATUS_NOT_MODIFIED) {
+		soup_message_headers_foreach (soup_message_get_response_headers (msg),
 					      (SoupMessageHeadersForeachFunc) remove_headers,
 					      entry->headers);
-		copy_end_to_end_headers (msg->response_headers, entry->headers);
+		copy_end_to_end_headers (soup_message_get_response_headers (msg), entry->headers);
 
 		soup_cache_entry_set_freshness (entry, msg, cache);
 	}
diff --git a/libsoup/content-sniffer/soup-content-decoder.c b/libsoup/content-sniffer/soup-content-decoder.c
index d8d5b5be..2a723b30 100644
--- a/libsoup/content-sniffer/soup-content-decoder.c
+++ b/libsoup/content-sniffer/soup-content-decoder.c
@@ -85,7 +85,7 @@ soup_content_decoder_get_decoders_for_msg (SoupContentDecoder *decoder, SoupMess
 	SoupContentDecoderCreator converter_creator;
 	GConverter *converter;
 
-	header = soup_message_headers_get_list (msg->response_headers,
+	header = soup_message_headers_get_list (soup_message_get_response_headers (msg),
 						"Content-Encoding");
 	if (!header)
 		return NULL;
@@ -93,7 +93,7 @@ soup_content_decoder_get_decoders_for_msg (SoupContentDecoder *decoder, SoupMess
 	/* Workaround for an apache bug (bgo 613361) */
 	if (!g_ascii_strcasecmp (header, "gzip") ||
 	    !g_ascii_strcasecmp (header, "x-gzip")) {
-		const char *content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
+		const char *content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (msg), NULL);
 
 		if (content_type &&
 		    (!g_ascii_strcasecmp (content_type, "application/gzip") ||
@@ -248,9 +248,9 @@ static void
 soup_content_decoder_request_queued (SoupSessionFeature *feature,
 				     SoupMessage        *msg)
 {
-	if (!soup_message_headers_get_one (msg->request_headers,
+	if (!soup_message_headers_get_one (soup_message_get_request_headers (msg),
 					   "Accept-Encoding")) {
-		soup_message_headers_append (msg->request_headers,
+		soup_message_headers_append (soup_message_get_request_headers (msg),
 					     "Accept-Encoding",
 					     ACCEPT_ENCODING_HEADER);
 	}
diff --git a/libsoup/content-sniffer/soup-content-sniffer.c b/libsoup/content-sniffer/soup-content-sniffer.c
index bfb4f541..a4c6b9be 100644
--- a/libsoup/content-sniffer/soup-content-sniffer.c
+++ b/libsoup/content-sniffer/soup-content-sniffer.c
@@ -775,11 +775,11 @@ soup_content_sniffer_real_sniff (SoupContentSniffer *sniffer, SoupMessage *msg,
 	char *sniffed_type = NULL;
 	gboolean no_sniff = FALSE;
 
-	content_type = soup_message_headers_get_content_type (msg->response_headers, params);
+	content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (msg), params);
 
 	/* MIMESNIFF: 7 Determining the sniffed MIME type of a resource. */
 
-	x_content_type_options = soup_message_headers_get_one (msg->response_headers, "X-Content-Type-Options");
+	x_content_type_options = soup_message_headers_get_one (soup_message_get_response_headers (msg), "X-Content-Type-Options");
 	if (!g_strcmp0 (x_content_type_options, "nosniff"))
 		no_sniff = TRUE;
 
diff --git a/libsoup/cookies/soup-cookie-jar.c b/libsoup/cookies/soup-cookie-jar.c
index 850bb38e..7f6d67fd 100644
--- a/libsoup/cookies/soup-cookie-jar.c
+++ b/libsoup/cookies/soup-cookie-jar.c
@@ -798,15 +798,15 @@ msg_starting_cb (SoupMessage *msg, gpointer feature)
 	                                                               soup_message_get_first_party (msg),
 							               soup_message_get_site_for_cookies (msg),
 								       TRUE,
-							               SOUP_METHOD_IS_SAFE (msg->method),
+							               SOUP_METHOD_IS_SAFE (soup_message_get_method (msg)),
 							               soup_message_get_is_top_level_navigation (msg));
 	if (cookies != NULL) {
 		char *cookie_header = soup_cookies_to_cookie_header (cookies);
-		soup_message_headers_replace (msg->request_headers, "Cookie", cookie_header);
+		soup_message_headers_replace (soup_message_get_request_headers (msg), "Cookie", cookie_header);
 		g_free (cookie_header);
 		g_slist_free_full (cookies, (GDestroyNotify)soup_cookie_free);
 	} else {
-		soup_message_headers_remove (msg->request_headers, "Cookie");
+		soup_message_headers_remove (soup_message_get_request_headers (msg), "Cookie");
 	}
 }
 
diff --git a/libsoup/cookies/soup-cookie.c b/libsoup/cookies/soup-cookie.c
index c243d84c..e45ed71e 100644
--- a/libsoup/cookies/soup-cookie.c
+++ b/libsoup/cookies/soup-cookie.c
@@ -912,7 +912,7 @@ soup_cookies_from_response (SoupMessage *msg)
 	 * soup_message_headers_get_list() since Set-Cookie isn't
 	 * properly mergeable/unmergeable.
 	 */
-	soup_message_headers_iter_init (&iter, msg->response_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_response_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value)) {
 		if (g_ascii_strcasecmp (name, "Set-Cookie") != 0)
 			continue;
@@ -951,7 +951,7 @@ soup_cookies_from_request (SoupMessage *msg)
 	gpointer name, value;
 	const char *header;
 
-	header = soup_message_headers_get_one (msg->request_headers, "Cookie");
+	header = soup_message_headers_get_one (soup_message_get_request_headers (msg), "Cookie");
 	if (!header)
 		return NULL;
 
@@ -988,7 +988,7 @@ soup_cookies_to_response (GSList *cookies, SoupMessage *msg)
 	header = g_string_new (NULL);
 	while (cookies) {
 		serialize_cookie (cookies->data, header, TRUE);
-		soup_message_headers_append (msg->response_headers,
+		soup_message_headers_append (soup_message_get_response_headers (msg),
 					     "Set-Cookie", header->str);
 		g_string_truncate (header, 0);
 		cookies = cookies->next;
@@ -1014,13 +1014,13 @@ soup_cookies_to_request (GSList *cookies, SoupMessage *msg)
 {
 	GString *header;
 
-	header = g_string_new (soup_message_headers_get_one (msg->request_headers,
+	header = g_string_new (soup_message_headers_get_one (soup_message_get_request_headers (msg),
 							     "Cookie"));
 	while (cookies) {
 		serialize_cookie (cookies->data, header, FALSE);
 		cookies = cookies->next;
 	}
-	soup_message_headers_replace (msg->request_headers,
+	soup_message_headers_replace (soup_message_get_request_headers (msg),
 				      "Cookie", header->str);
 	g_string_free (header, TRUE);
 }
diff --git a/libsoup/hsts/soup-hsts-policy.c b/libsoup/hsts/soup-hsts-policy.c
index 6a8bceae..b1895981 100644
--- a/libsoup/hsts/soup-hsts-policy.c
+++ b/libsoup/hsts/soup-hsts-policy.c
@@ -269,7 +269,7 @@ soup_hsts_policy_new_from_response (SoupMessage *msg)
 
 	g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
 
-	soup_message_headers_iter_init (&iter, msg->response_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_response_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value)) {
 		SoupURI *uri;
 		GHashTable *params;
diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index dc705e25..3357ebb4 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -258,8 +258,8 @@ current_msg_got_body (SoupMessage *msg, gpointer user_data)
 	priv->unused_timeout = 0;
 
 	if (priv->proxy_uri &&
-	    msg->method == SOUP_METHOD_CONNECT &&
-	    SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
+	    soup_message_get_method (msg) == SOUP_METHOD_CONNECT &&
+	    SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (msg))) {
 		soup_connection_event (conn, G_SOCKET_CLIENT_PROXY_NEGOTIATED, NULL);
 
 		/* We're now effectively no longer proxying */
@@ -292,7 +292,7 @@ set_current_msg (SoupConnection *conn, SoupMessage *msg)
 	g_object_freeze_notify (G_OBJECT (conn));
 
 	if (priv->current_msg) {
-		g_return_if_fail (priv->current_msg->method == SOUP_METHOD_CONNECT);
+		g_return_if_fail (soup_message_get_method (priv->current_msg) == SOUP_METHOD_CONNECT);
 		clear_current_msg (conn);
 	}
 
@@ -304,7 +304,7 @@ set_current_msg (SoupConnection *conn, SoupMessage *msg)
 	g_signal_connect (msg, "got-body",
 			  G_CALLBACK (current_msg_got_body), conn);
 
-	if (priv->proxy_uri && msg->method == SOUP_METHOD_CONNECT)
+	if (priv->proxy_uri && soup_message_get_method (msg) == SOUP_METHOD_CONNECT)
 		soup_connection_event (conn, G_SOCKET_CLIENT_PROXY_NEGOTIATING, NULL);
 
 	g_object_thaw_notify (G_OBJECT (conn));
diff --git a/libsoup/soup-form.c b/libsoup/soup-form.c
index e73cca93..23cd007e 100644
--- a/libsoup/soup-form.c
+++ b/libsoup/soup-form.c
@@ -480,9 +480,9 @@ soup_form_request_new_from_multipart (const char *uri,
 	GBytes *body = NULL;
 
 	msg = soup_message_new ("POST", uri);
-	soup_multipart_to_message (multipart, msg->request_headers, &body);
+	soup_multipart_to_message (multipart, soup_message_get_request_headers (msg), &body);
 	soup_message_set_request_body_from_bytes (msg,
-						  soup_message_headers_get_content_type (msg->request_headers, NULL),
+						  soup_message_headers_get_content_type (soup_message_get_request_headers (msg), NULL),
 						  body);
 	g_bytes_unref (body);
 
diff --git a/libsoup/soup-logger.c b/libsoup/soup-logger.c
index 9aba4b69..399253a9 100644
--- a/libsoup/soup-logger.c
+++ b/libsoup/soup-logger.c
@@ -517,7 +517,7 @@ print_request (SoupLogger *logger, SoupMessage *msg,
 		return;
 
 	uri = soup_message_get_uri (msg);
-	if (msg->method == SOUP_METHOD_CONNECT) {
+	if (soup_message_get_method (msg) == SOUP_METHOD_CONNECT) {
 		soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
 				   "CONNECT %s:%u HTTP/1.%d",
 				   uri->host, uri->port,
@@ -525,7 +525,7 @@ print_request (SoupLogger *logger, SoupMessage *msg,
 	} else {
 		soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
 				   "%s %s%s%s HTTP/1.%d",
-				   msg->method, uri->path,
+				   soup_message_get_method (msg), uri->path,
 				   uri->query ? "?" : "",
 				   uri->query ? uri->query : "",
 				   soup_message_get_http_version (msg));
@@ -554,7 +554,7 @@ print_request (SoupLogger *logger, SoupMessage *msg,
 	if (log_level == SOUP_LOGGER_LOG_MINIMAL)
 		return;
 
-	if (!soup_message_headers_get_one (msg->request_headers, "Host")) {
+	if (!soup_message_headers_get_one (soup_message_get_request_headers (msg), "Host")) {
 		char *uri_host;
 
 		if (strchr (uri->host, ':'))
@@ -572,7 +572,7 @@ print_request (SoupLogger *logger, SoupMessage *msg,
 		if (uri_host != uri->host)
 			g_free (uri_host);
 	}
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value)) {
 		if (!g_ascii_strcasecmp (name, "Authorization") &&
 		    !g_ascii_strncasecmp (value, "Basic ", 6))
@@ -604,7 +604,7 @@ print_response (SoupLogger *logger, SoupMessage *msg)
 	soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<',
 			   "HTTP/1.%d %u %s\n",
 			   soup_message_get_http_version (msg),
-			   msg->status_code, msg->reason_phrase);
+			   soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
 
 	soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<',
 			   "Soup-Debug-Timestamp: %lu",
@@ -617,7 +617,7 @@ print_response (SoupLogger *logger, SoupMessage *msg)
 	if (log_level == SOUP_LOGGER_LOG_MINIMAL)
 		return;
 
-	soup_message_headers_iter_init (&iter, msg->response_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_response_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value)) {
 		soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '<',
 				   "%s: %s", name, value);
@@ -650,7 +650,7 @@ got_informational (SoupMessage *msg, gpointer user_data)
 	print_response (logger, msg);
 	soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, ' ', "\n");
 
-	if (msg->status_code == SOUP_STATUS_CONTINUE && msg->request_body_stream) {
+	if (soup_message_get_status (msg) == SOUP_STATUS_CONTINUE && soup_message_get_request_body_stream (msg)) {
 		soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
 				   "[Now sending request body...]");
 		soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, ' ', "\n");
diff --git a/libsoup/soup-message-io.c b/libsoup/soup-message-io.c
index 667176cb..34d40d00 100644
--- a/libsoup/soup-message-io.c
+++ b/libsoup/soup-message-io.c
@@ -281,7 +281,7 @@ write_headers (SoupMessage          *msg,
 	else
 		uri_host = uri->host;
 
-	if (msg->method == SOUP_METHOD_CONNECT) {
+	if (soup_message_get_method (msg) == SOUP_METHOD_CONNECT) {
 		/* CONNECT URI is hostname:port for tunnel destination */
 		uri_string = g_strdup_printf ("%s:%d", uri_host, uri->port);
 	} else {
@@ -301,10 +301,10 @@ write_headers (SoupMessage          *msg,
 	}
 
 	g_string_append_printf (header, "%s %s HTTP/1.%d\r\n",
-				msg->method, uri_string,
+				soup_message_get_method (msg), uri_string,
 				(soup_message_get_http_version (msg) == SOUP_HTTP_1_0) ? 0 : 1);
 
-	if (!soup_message_headers_get_one (msg->request_headers, "Host")) {
+	if (!soup_message_headers_get_one (soup_message_get_request_headers (msg), "Host")) {
 		if (soup_uri_uses_default_port (uri)) {
 			g_string_append_printf (header, "Host: %s\r\n",
 						uri_host);
@@ -317,9 +317,9 @@ write_headers (SoupMessage          *msg,
 	if (uri_host != uri->host)
 		g_free (uri_host);
 
-	*encoding = soup_message_headers_get_encoding (msg->request_headers);
+	*encoding = soup_message_headers_get_encoding (soup_message_get_request_headers (msg));
 
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		g_string_append_printf (header, "%s: %s\r\n", name, value);
 	g_string_append (header, "\r\n");
@@ -370,9 +370,9 @@ io_write (SoupMessage *msg, gboolean blocking,
 		g_string_truncate (io->write_buf, 0);
 
 		if (io->write_encoding == SOUP_ENCODING_CONTENT_LENGTH)
-			io->write_length = soup_message_headers_get_content_length (msg->request_headers);
+			io->write_length = soup_message_headers_get_content_length (soup_message_get_request_headers (msg));
 
-		if (soup_message_headers_get_expectations (msg->request_headers) & SOUP_EXPECTATION_CONTINUE) {
+		if (soup_message_headers_get_expectations (soup_message_get_request_headers (msg)) & SOUP_EXPECTATION_CONTINUE) {
 			/* Need to wait for the Continue response */
 			io->write_state = SOUP_MESSAGE_IO_STATE_BLOCKING;
 			io->read_state = SOUP_MESSAGE_IO_STATE_HEADERS;
@@ -397,14 +397,14 @@ io_write (SoupMessage *msg, gboolean blocking,
 			break;
 		}
 
-		if (msg->request_body_stream) {
+		if (soup_message_get_request_body_stream (msg)) {
 			g_signal_connect_object (io->body_ostream,
 						 "wrote-data",
 						 G_CALLBACK (request_body_stream_wrote_data_cb),
 						 msg, G_CONNECT_SWAPPED);
 			if (blocking) {
 				nwrote = g_output_stream_splice (io->body_ostream,
-								 msg->request_body_stream,
+								 soup_message_get_request_body_stream (msg),
 								 G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE,
 								 cancellable,
 								 error);
@@ -416,7 +416,7 @@ io_write (SoupMessage *msg, gboolean blocking,
 				io->async_wait = g_cancellable_new ();
 				g_main_context_push_thread_default (io->async_context);
 				g_output_stream_splice_async (io->body_ostream,
-							      msg->request_body_stream,
+							      soup_message_get_request_body_stream (msg),
 							      G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE,
 							      soup_client_message_io_data_get_priority (client_io),
 							      cancellable,
@@ -474,36 +474,37 @@ parse_headers (SoupMessage  *msg,
 	       GError      **error)
 {
 	SoupHTTPVersion version;
+        char *reason_phrase;
+        SoupStatus status;
 
-	g_free(msg->reason_phrase);
-	msg->reason_phrase = NULL;
+        soup_message_set_reason_phrase (msg, NULL);
 
 	if (!soup_headers_parse_response (headers, headers_len,
-					  msg->response_headers,
+					  soup_message_get_response_headers (msg),
 					  &version,
-					  &msg->status_code,
-					  &msg->reason_phrase)) {
+					  &status,
+					  &reason_phrase)) {
 		g_set_error_literal (error, SOUP_SESSION_ERROR,
 				     SOUP_SESSION_ERROR_PARSING,
 				     _("Could not parse HTTP response"));
 		return SOUP_STATUS_MALFORMED;
 	}
 
-	g_object_notify (G_OBJECT (msg), "status-code");
-	g_object_notify (G_OBJECT (msg), "reason-phrase");
+        soup_message_set_status_full (msg, status, reason_phrase);
+        g_free (reason_phrase);
 
 	if (version < soup_message_get_http_version (msg))
 		soup_message_set_http_version (msg, version);
 
-	if ((msg->method == SOUP_METHOD_HEAD ||
-	     msg->status_code  == SOUP_STATUS_NO_CONTENT ||
-	     msg->status_code  == SOUP_STATUS_NOT_MODIFIED ||
-	     SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) ||
-	    (msg->method == SOUP_METHOD_CONNECT &&
-	     SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)))
+	if ((soup_message_get_method (msg) == SOUP_METHOD_HEAD ||
+	     soup_message_get_status (msg)  == SOUP_STATUS_NO_CONTENT ||
+	     soup_message_get_status (msg)  == SOUP_STATUS_NOT_MODIFIED ||
+	     SOUP_STATUS_IS_INFORMATIONAL (soup_message_get_status (msg))) ||
+	    (soup_message_get_method (msg) == SOUP_METHOD_CONNECT &&
+	     SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (msg))))
 		*encoding = SOUP_ENCODING_NONE;
 	else
-		*encoding = soup_message_headers_get_encoding (msg->response_headers);
+		*encoding = soup_message_headers_get_encoding (soup_message_get_response_headers (msg));
 
 	if (*encoding == SOUP_ENCODING_UNRECOGNIZED) {
 		g_set_error_literal (error, SOUP_SESSION_ERROR,
@@ -553,14 +554,14 @@ io_read (SoupMessage *msg, gboolean blocking,
 			 * closed when we're done.
 			 */
 			soup_message_set_status (msg, status);
-			soup_message_headers_append (msg->request_headers,
+			soup_message_headers_append (soup_message_get_request_headers (msg),
 						     "Connection", "close");
 			io->read_state = SOUP_MESSAGE_IO_STATE_FINISHING;
 			break;
 		}
 
-		if (SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) {
-			if (msg->status_code == SOUP_STATUS_CONTINUE &&
+		if (SOUP_STATUS_IS_INFORMATIONAL (soup_message_get_status (msg))) {
+			if (soup_message_get_status (msg) == SOUP_STATUS_CONTINUE &&
 			    io->write_state == SOUP_MESSAGE_IO_STATE_BLOCKING) {
 				/* Pause the reader, unpause the writer */
 				io->read_state =
@@ -597,7 +598,7 @@ io_read (SoupMessage *msg, gboolean blocking,
 		}
 
 		if (io->read_encoding == SOUP_ENCODING_CONTENT_LENGTH) {
-			io->read_length = soup_message_headers_get_content_length (msg->response_headers);
+			io->read_length = soup_message_headers_get_content_length (soup_message_get_response_headers (msg));
 
 			if (!soup_message_is_keepalive (msg)) {
 				/* Some servers suck and send
@@ -690,7 +691,7 @@ request_is_restartable (SoupMessage *msg, GError *error)
 		!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT) &&
 		!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK) &&
 		error->domain != G_TLS_ERROR &&
-		SOUP_METHOD_IS_IDEMPOTENT (msg->method));
+		SOUP_METHOD_IS_IDEMPOTENT (soup_message_get_method (msg)));
 }
 
 static gboolean
@@ -767,8 +768,8 @@ io_run_until (SoupMessage *msg, gboolean blocking,
 	    io->write_state == SOUP_MESSAGE_IO_STATE_DONE) {
 		SoupURI *uri = soup_message_get_uri (msg);
 		char *uri_str = soup_uri_to_string (uri, FALSE);
-		const gchar *last_modified = soup_message_headers_get_one (msg->request_headers, "Last-Modified");
-		const gchar *etag = soup_message_headers_get_one (msg->request_headers, "ETag");
+		const gchar *last_modified = soup_message_headers_get_one (soup_message_get_request_headers (msg), "Last-Modified");
+		const gchar *etag = soup_message_headers_get_one (soup_message_get_request_headers (msg), "ETag");
 
 		/* FIXME: Expand and generalise sysprof support:
 		 * https://gitlab.gnome.org/GNOME/sysprof/-/issues/43 */
@@ -804,7 +805,7 @@ soup_message_io_update_status (SoupMessage  *msg,
 		soup_message_set_status_full (msg,
 					      SOUP_STATUS_SSL_FAILED,
 					      error->message);
-	} else if (!SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code) &&
+	} else if (!SOUP_STATUS_IS_TRANSPORT_ERROR (soup_message_get_status (msg)) &&
 		   !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
 		soup_message_set_status (msg, SOUP_STATUS_IO_ERROR);
 	}
@@ -998,9 +999,9 @@ soup_message_io_get_response_istream (SoupMessage  *msg,
 	SoupClientMessageIOData *io = soup_message_get_io_data (msg);
 	GInputStream *client_stream;
 
-	if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
+	if (SOUP_STATUS_IS_TRANSPORT_ERROR (soup_message_get_status (msg))) {
 		g_set_error_literal (error, SOUP_HTTP_ERROR,
-				     msg->status_code, msg->reason_phrase);
+				     soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
 		return NULL;
 	}
 
diff --git a/libsoup/soup-message-private.h b/libsoup/soup-message-private.h
index 771049db..643140ae 100644
--- a/libsoup/soup-message-private.h
+++ b/libsoup/soup-message-private.h
@@ -17,37 +17,6 @@
 typedef struct _SoupClientMessageIOData SoupClientMessageIOData;
 void soup_client_message_io_data_free (SoupClientMessageIOData *io);
 
-typedef struct {
-	SoupClientMessageIOData *io_data;
-
-	guint              msg_flags;
-	gboolean           server_side;
-
-	SoupContentSniffer *sniffer;
-	gsize              bytes_for_sniffing;
-
-	SoupHTTPVersion    http_version, orig_http_version;
-
-	SoupURI           *uri;
-
-	SoupAuth          *auth, *proxy_auth;
-	SoupConnection    *connection;
-
-	GHashTable        *disabled_features;
-
-	SoupURI           *first_party;
-	SoupURI           *site_for_cookies;
-
-	GTlsCertificate      *tls_certificate;
-	GTlsCertificateFlags  tls_errors;
-
-	SoupRequest       *request;
-
-	SoupMessagePriority priority;
-
-	gboolean is_top_level_navigation;
-} SoupMessagePrivate;
-
 void             soup_message_cleanup_response (SoupMessage      *msg);
 
 typedef void     (*SoupMessageGetHeadersFn)  (SoupMessage      *msg,
@@ -166,4 +135,12 @@ void                soup_message_set_content_sniffer    (SoupMessage        *msg
 void                soup_message_set_bytes_for_sniffing (SoupMessage        *msg,
 							 gsize               bytes);
 
+GInputStream       *soup_message_get_request_body_stream (SoupMessage        *msg);
+
+void                soup_message_set_reason_phrase       (SoupMessage        *msg,
+                                                          const char         *reason_phrase);
+
+void                soup_message_set_method              (SoupMessage        *msg,
+                                                          const char         *method);
+
 #endif /* __SOUP_MESSAGE_PRIVATE_H__ */
diff --git a/libsoup/soup-message.c b/libsoup/soup-message.c
index bfbd6267..15d0d787 100644
--- a/libsoup/soup-message.c
+++ b/libsoup/soup-message.c
@@ -57,6 +57,49 @@
  * trying to do.
  */
 
+struct _SoupMessage {
+	GObject parent_instance;
+};
+
+typedef struct {
+	SoupClientMessageIOData *io_data;
+
+        SoupMessageHeaders *request_headers;
+	SoupMessageHeaders *response_headers;
+
+	GInputStream      *request_body_stream;
+        const char        *method;
+        char              *reason_phrase;
+        SoupStatus         status_code;
+
+	guint              msg_flags;
+	gboolean           server_side;
+
+	SoupContentSniffer *sniffer;
+	gsize              bytes_for_sniffing;
+
+	SoupHTTPVersion    http_version, orig_http_version;
+
+	SoupURI           *uri;
+
+	SoupAuth          *auth, *proxy_auth;
+	SoupConnection    *connection;
+
+	GHashTable        *disabled_features;
+
+	SoupURI           *first_party;
+	SoupURI           *site_for_cookies;
+
+	GTlsCertificate      *tls_certificate;
+	GTlsCertificateFlags  tls_errors;
+
+	SoupRequest       *request;
+
+	SoupMessagePriority priority;
+
+	gboolean is_top_level_navigation;
+} SoupMessagePrivate;
+
 G_DEFINE_TYPE_WITH_PRIVATE (SoupMessage, soup_message, G_TYPE_OBJECT)
 
 enum {
@@ -110,8 +153,8 @@ soup_message_init (SoupMessage *msg)
 	priv->http_version = priv->orig_http_version = SOUP_HTTP_1_1;
 	priv->priority = SOUP_MESSAGE_PRIORITY_NORMAL;
 
-	msg->request_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_REQUEST);
-	msg->response_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
+	priv->request_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_REQUEST);
+	priv->response_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
 }
 
 static void
@@ -133,11 +176,11 @@ soup_message_finalize (GObject *object)
 
 	g_clear_object (&priv->tls_certificate);
 
-	soup_message_headers_free (msg->request_headers);
-	soup_message_headers_free (msg->response_headers);
-	g_clear_object (&msg->request_body_stream);
+	soup_message_headers_free (priv->request_headers);
+	soup_message_headers_free (priv->response_headers);
+	g_clear_object (&priv->request_body_stream);
 
-	g_free (msg->reason_phrase);
+	g_free (priv->reason_phrase);
 
 	G_OBJECT_CLASS (soup_message_parent_class)->finalize (object);
 }
@@ -151,7 +194,7 @@ soup_message_set_property (GObject *object, guint prop_id,
 
 	switch (prop_id) {
 	case PROP_METHOD:
-		msg->method = g_intern_string (g_value_get_string (value));
+		priv->method = g_intern_string (g_value_get_string (value));
 		break;
 	case PROP_URI:
 		soup_message_set_uri (msg, g_value_get_boxed (value));
@@ -172,7 +215,7 @@ soup_message_set_property (GObject *object, guint prop_id,
 		soup_message_set_status (msg, g_value_get_uint (value));
 		break;
 	case PROP_REASON_PHRASE:
-		soup_message_set_status_full (msg, msg->status_code,
+		soup_message_set_status_full (msg, priv->status_code,
 					      g_value_get_string (value));
 		break;
 	case PROP_FIRST_PARTY:
@@ -212,7 +255,7 @@ soup_message_get_property (GObject *object, guint prop_id,
 
 	switch (prop_id) {
 	case PROP_METHOD:
-		g_value_set_string (value, msg->method);
+		g_value_set_string (value, priv->method);
 		break;
 	case PROP_URI:
 		g_value_set_boxed (value, priv->uri);
@@ -230,19 +273,19 @@ soup_message_get_property (GObject *object, guint prop_id,
 		g_value_set_flags (value, priv->msg_flags);
 		break;
 	case PROP_STATUS_CODE:
-		g_value_set_uint (value, msg->status_code);
+		g_value_set_uint (value, priv->status_code);
 		break;
 	case PROP_REASON_PHRASE:
-		g_value_set_string (value, msg->reason_phrase);
+		g_value_set_string (value, priv->reason_phrase);
 		break;
 	case PROP_FIRST_PARTY:
 		g_value_set_boxed (value, priv->first_party);
 		break;
 	case PROP_REQUEST_HEADERS:
-		g_value_set_boxed (value, msg->request_headers);
+		g_value_set_boxed (value, priv->request_headers);
 		break;
 	case PROP_RESPONSE_HEADERS:
-		g_value_set_boxed (value, msg->response_headers);
+		g_value_set_boxed (value, priv->response_headers);
 		break;
 	case PROP_TLS_CERTIFICATE:
 		g_value_set_object (value, priv->tls_certificate);
@@ -282,7 +325,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("wrote_headers",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, wrote_headers),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -318,7 +361,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("wrote_body",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, wrote_body),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -341,7 +384,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("got_informational",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, got_informational),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -369,7 +412,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("got_headers",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, got_headers),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -388,7 +431,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("got_body",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, got_body),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -431,7 +474,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("starting",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, starting),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -449,7 +492,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("restarted",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, restarted),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -465,7 +508,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("finished",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_FIRST,
-			      G_STRUCT_OFFSET (SoupMessageClass, finished),
+			      0,
 			      NULL, NULL,
 			      NULL,
 			      G_TYPE_NONE, 0);
@@ -497,7 +540,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 		g_signal_new ("authenticate",
 			      G_OBJECT_CLASS_TYPE (object_class),
 			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (SoupMessageClass, authenticate),
+			      0,
 			      g_signal_accumulator_true_handled, NULL,
 			      NULL,
 			      G_TYPE_BOOLEAN, 2,
@@ -769,21 +812,23 @@ soup_message_set_request_body (SoupMessage  *msg,
         g_return_if_fail (content_type != NULL || content_length == 0);
         g_return_if_fail (content_type == NULL || G_IS_INPUT_STREAM (stream));
 
-        g_clear_object (&msg->request_body_stream);
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        g_clear_object (&priv->request_body_stream);
 
         if (content_type) {
                 g_warn_if_fail (strchr (content_type, '/') != NULL);
 
-                if (soup_message_headers_get_content_type (msg->request_headers, NULL) != content_type)
-                        soup_message_headers_replace (msg->request_headers, "Content-Type", content_type);
+                if (soup_message_headers_get_content_type (priv->request_headers, NULL) != content_type)
+                        soup_message_headers_replace (priv->request_headers, "Content-Type", content_type);
                 if (content_length == -1)
-                        soup_message_headers_set_encoding (msg->request_headers, SOUP_ENCODING_CHUNKED);
+                        soup_message_headers_set_encoding (priv->request_headers, SOUP_ENCODING_CHUNKED);
                 else
-                        soup_message_headers_set_content_length (msg->request_headers, content_length);
-                msg->request_body_stream = g_object_ref (stream);
+                        soup_message_headers_set_content_length (priv->request_headers, content_length);
+                priv->request_body_stream = g_object_ref (stream);
         } else {
-                soup_message_headers_remove (msg->request_headers, "Content-Type");
-                soup_message_headers_remove (msg->request_headers, "Content-Length");
+                soup_message_headers_remove (priv->request_headers, "Content-Type");
+                soup_message_headers_remove (priv->request_headers, "Content-Length");
         }
 }
 
@@ -868,7 +913,9 @@ soup_message_starting (SoupMessage *msg)
 void
 soup_message_restarted (SoupMessage *msg)
 {
-	g_clear_object (&msg->request_body_stream);
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+	g_clear_object (&priv->request_body_stream);
 
 	g_signal_emit (msg, signals[RESTARTED], 0);
 }
@@ -911,9 +958,10 @@ header_handler_metamarshal (GClosure *closure, GValue *return_value,
 			    gpointer invocation_hint, gpointer marshal_data)
 {
 	SoupMessage *msg = g_value_get_object (&param_values[0]);
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
 	const char *header_name = marshal_data;
 
-	if (soup_message_headers_get_one (msg->response_headers, header_name)) {
+	if (soup_message_headers_get_one (priv->response_headers, header_name)) {
 		closure->marshal (closure, return_value, n_param_values,
 				  param_values, invocation_hint,
 				  ((GCClosure *)closure)->callback);
@@ -967,9 +1015,10 @@ status_handler_metamarshal (GClosure *closure, GValue *return_value,
 			    gpointer invocation_hint, gpointer marshal_data)
 {
 	SoupMessage *msg = g_value_get_object (&param_values[0]);
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
 	guint status = GPOINTER_TO_UINT (marshal_data);
 
-	if (msg->status_code == status) {
+	if (priv->status_code == status) {
 		closure->marshal (closure, return_value, n_param_values,
 				  param_values, invocation_hint,
 				  ((GCClosure *)closure)->callback);
@@ -1078,7 +1127,7 @@ soup_message_get_uri_for_auth (SoupMessage *msg)
 {
 	SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
 
-	if (msg->status_code == SOUP_STATUS_PROXY_UNAUTHORIZED) {
+	if (priv->status_code == SOUP_STATUS_PROXY_UNAUTHORIZED) {
 		/* When loaded from the disk cache, the connection is NULL. */
                 return priv->connection ? soup_connection_get_proxy_uri (priv->connection) : NULL;
 	}
@@ -1116,14 +1165,14 @@ soup_message_cleanup_response (SoupMessage *msg)
 {
 	SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
 
-	soup_message_headers_clear (msg->response_headers);
+	soup_message_headers_clear (priv->response_headers);
 
 	priv->msg_flags &= ~SOUP_MESSAGE_CONTENT_DECODED;
 
-	msg->status_code = SOUP_STATUS_NONE;
-	if (msg->reason_phrase) {
-		g_free (msg->reason_phrase);
-		msg->reason_phrase = NULL;
+	priv->status_code = SOUP_STATUS_NONE;
+	if (priv->reason_phrase) {
+		g_free (priv->reason_phrase);
+		priv->reason_phrase = NULL;
 	}
 	priv->http_version = priv->orig_http_version;
 
@@ -1230,7 +1279,7 @@ soup_message_set_http_version (SoupMessage *msg, SoupHTTPVersion version)
 	priv = soup_message_get_instance_private (msg);
 
 	priv->http_version = version;
-	if (msg->status_code == SOUP_STATUS_NONE)
+	if (priv->status_code == SOUP_STATUS_NONE)
 		priv->orig_http_version = version;
 	g_object_notify (G_OBJECT (msg), "http-version");
 }
@@ -1271,12 +1320,12 @@ soup_message_is_keepalive (SoupMessage *msg)
 {
 	SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
 
-	if (msg->status_code == SOUP_STATUS_OK &&
-	    msg->method == SOUP_METHOD_CONNECT)
+	if (priv->status_code == SOUP_STATUS_OK &&
+	    priv->method == SOUP_METHOD_CONNECT)
 		return TRUE;
 
 	/* Not persistent if the server sent a terminate-by-EOF response */
-	if (soup_message_headers_get_encoding (msg->response_headers) == SOUP_ENCODING_EOF)
+	if (soup_message_headers_get_encoding (priv->response_headers) == SOUP_ENCODING_EOF)
 		return FALSE;
 
 	if (priv->http_version == SOUP_HTTP_1_0) {
@@ -1286,14 +1335,14 @@ soup_message_is_keepalive (SoupMessage *msg)
 		 * doesn't request it. So ignore c_conn.
 		 */
 
-		if (!soup_message_headers_header_contains (msg->response_headers,
+		if (!soup_message_headers_header_contains (priv->response_headers,
 							   "Connection", "Keep-Alive"))
 			return FALSE;
 	} else {
 		/* Normally persistent unless either side requested otherwise */
-		if (soup_message_headers_header_contains (msg->request_headers,
+		if (soup_message_headers_header_contains (priv->request_headers,
 							  "Connection", "close") ||
-		    soup_message_headers_header_contains (msg->response_headers,
+		    soup_message_headers_header_contains (priv->response_headers,
 							  "Connection", "close"))
 			return FALSE;
 
@@ -1361,10 +1410,12 @@ soup_message_set_status (SoupMessage *msg, guint status_code)
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
 	g_return_if_fail (status_code != 0);
 
-	g_free (msg->reason_phrase);
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+	g_free (priv->reason_phrase);
 
-	msg->status_code = status_code;
-	msg->reason_phrase = g_strdup (soup_status_get_phrase (status_code));
+	priv->status_code = status_code;
+	priv->reason_phrase = g_strdup (soup_status_get_phrase (status_code));
 	g_object_notify (G_OBJECT (msg), "status-code");
 	g_object_notify (G_OBJECT (msg), "reason-phrase");
 }
@@ -1386,10 +1437,12 @@ soup_message_set_status_full (SoupMessage *msg,
 	g_return_if_fail (status_code != 0);
 	g_return_if_fail (reason_phrase != NULL);
 
-	g_free (msg->reason_phrase);
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
 
-	msg->status_code = status_code;
-	msg->reason_phrase = g_strdup (reason_phrase);
+	g_free (priv->reason_phrase);
+
+	priv->status_code = status_code;
+	priv->reason_phrase = g_strdup (reason_phrase);
 	g_object_notify (G_OBJECT (msg), "status-code");
 	g_object_notify (G_OBJECT (msg), "reason-phrase");
 }
@@ -1828,3 +1881,91 @@ soup_message_set_bytes_for_sniffing (SoupMessage *msg, gsize bytes)
 
 	priv->bytes_for_sniffing = bytes;
 }
+
+GInputStream *
+soup_message_get_request_body_stream (SoupMessage *msg)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        return priv->request_body_stream;
+}
+
+/**
+ * soup_message_get_method:
+ * @msg: The #SoupMessage
+ *
+ * Returns: The method of this message
+ */
+const char *
+soup_message_get_method (SoupMessage *msg)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        return priv->method;
+}
+
+/**
+ * soup_message_get_status:
+ * @msg: The #SoupMessage
+ *
+ * Returns: The #SoupStatus
+ */
+SoupStatus
+soup_message_get_status (SoupMessage *msg)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        return priv->status_code;
+}
+
+/**
+ * soup_message_get_reason_phrase:
+ * @msg: The #SoupMessage
+ *
+ * Returns the reason phrase for the status of this message.
+ *
+ * Returns: Phrase or %NULL
+ */
+const char *
+soup_message_get_reason_phrase (SoupMessage *msg)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        return priv->reason_phrase; 
+}
+
+SoupMessageHeaders *
+soup_message_get_request_headers (SoupMessage  *msg)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        return priv->request_headers; 
+}
+
+SoupMessageHeaders *
+soup_message_get_response_headers (SoupMessage  *msg)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        return priv->response_headers; 
+}
+
+void
+soup_message_set_reason_phrase (SoupMessage *msg, const char *reason_phrase)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        g_free (priv->reason_phrase);
+        priv->reason_phrase = g_strdup (reason_phrase);
+}
+
+void
+soup_message_set_method (SoupMessage *msg,
+                         const char  *method)
+{
+        SoupMessagePrivate *priv = soup_message_get_instance_private (msg);
+
+        g_return_if_fail (method != NULL);
+
+        priv->method = g_intern_string (method);
+}
diff --git a/libsoup/soup-message.h b/libsoup/soup-message.h
index 57bf79dd..d6fa92aa 100644
--- a/libsoup/soup-message.h
+++ b/libsoup/soup-message.h
@@ -3,8 +3,7 @@
  * Copyright (C) 2000-2003, Ximian, Inc.
  */
 
-#ifndef __SOUP_MESSAGE_H__
-#define __SOUP_MESSAGE_H__ 1
+#pragma once
 
 #include "soup-types.h"
 #include "soup-message-body.h"
@@ -13,51 +12,9 @@
 
 G_BEGIN_DECLS
 
-#define SOUP_TYPE_MESSAGE            (soup_message_get_type ())
-#define SOUP_MESSAGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_MESSAGE, SoupMessage))
-#define SOUP_MESSAGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_MESSAGE, SoupMessageClass))
-#define SOUP_IS_MESSAGE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_MESSAGE))
-#define SOUP_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_MESSAGE))
-#define SOUP_MESSAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_MESSAGE, SoupMessageClass))
-
-struct _SoupMessage {
-	GObject parent;
-
-	/*< public >*/
-	const char         *method;
-
-	guint               status_code;
-	char               *reason_phrase;
-
-	GInputStream       *request_body_stream;
-	SoupMessageHeaders *request_headers;
-	SoupMessageHeaders *response_headers;
-};
-
-typedef struct {
-	GObjectClass parent_class;
-
-	/* signals */
-	void     (*wrote_headers)       (SoupMessage *msg);
-	void     (*wrote_body)          (SoupMessage *msg);
-	void     (*got_informational)   (SoupMessage *msg);
-	void     (*got_headers)         (SoupMessage *msg);
-	void     (*got_body)            (SoupMessage *msg);
-	void     (*restarted)           (SoupMessage *msg);
-	void     (*finished)            (SoupMessage *msg);
-	void     (*starting)            (SoupMessage *msg);
-	void     (*authenticate)        (SoupMessage *msg,
-					 SoupAuth    *auth,
-					 gboolean     retrying);
-
-	/* Padding for future expansion */
-	void (*_libsoup_reserved1) (void);
-	void (*_libsoup_reserved2) (void);
-	void (*_libsoup_reserved3) (void);
-} SoupMessageClass;
-
-SOUP_AVAILABLE_IN_2_4
-GType soup_message_get_type (void);
+#define SOUP_TYPE_MESSAGE (soup_message_get_type ())
+SOUP_AVAILABLE_IN_ALL
+G_DECLARE_FINAL_TYPE (SoupMessage, soup_message, SOUP, MESSAGE, GObject)
 
 SOUP_AVAILABLE_IN_2_4
 SoupMessage   *soup_message_new                 (const char        *method,
@@ -182,6 +139,19 @@ void                soup_message_set_priority   (SoupMessage        *msg,
 SOUP_AVAILABLE_IN_2_44
 SoupMessagePriority soup_message_get_priority   (SoupMessage        *msg);
 
-G_END_DECLS
+SOUP_AVAILABLE_IN_ALL
+const char         *soup_message_get_method     (SoupMessage        *msg);
+
+SOUP_AVAILABLE_IN_ALL
+SoupStatus          soup_message_get_status     (SoupMessage        *msg);
 
-#endif /* __SOUP_MESSAGE_H__ */
+SOUP_AVAILABLE_IN_ALL
+const char         *soup_message_get_reason_phrase (SoupMessage     *msg);
+
+SOUP_AVAILABLE_IN_ALL
+SoupMessageHeaders *soup_message_get_request_headers  (SoupMessage  *msg);
+
+SOUP_AVAILABLE_IN_ALL
+SoupMessageHeaders *soup_message_get_response_headers (SoupMessage  *msg);
+
+G_END_DECLS
diff --git a/libsoup/soup-method.h b/libsoup/soup-method.h
index 39d92b73..952d4b6b 100644
--- a/libsoup/soup-method.h
+++ b/libsoup/soup-method.h
@@ -26,7 +26,7 @@ G_BEGIN_DECLS
  * most useful in SoupServer handlers. Eg:
  * 
  * <informalexample><programlisting>
- * 	if (msg->method != SOUP_METHOD_GET &amp;&amp; msg->method != SOUP_METHOD_HEAD) {
+ * 	if (soup_message_get_method (msg) != SOUP_METHOD_GET &amp;&amp; soup_message_get_method (msg) != SOUP_METHOD_HEAD) {
  * 		soup_message_set_status (msg, SOUP_METHOD_NOT_IMPLEMENTED);
  * 		return;
  * 	}
diff --git a/libsoup/soup-multipart-input-stream.c b/libsoup/soup-multipart-input-stream.c
index f17d0c3a..bb712b57 100644
--- a/libsoup/soup-multipart-input-stream.c
+++ b/libsoup/soup-multipart-input-stream.c
@@ -227,7 +227,7 @@ soup_multipart_input_stream_constructed (GObject *object)
 	base_stream = G_FILTER_INPUT_STREAM (multipart)->base_stream;
 	priv->base_stream = SOUP_FILTER_INPUT_STREAM (soup_filter_input_stream_new (base_stream));
 
-	soup_message_headers_get_content_type (priv->msg->response_headers,
+	soup_message_headers_get_content_type (soup_message_get_response_headers (priv->msg),
 					       &params);
 
 	boundary = g_hash_table_lookup (params, "boundary");
diff --git a/libsoup/soup-multipart.c b/libsoup/soup-multipart.c
index 82a7ef52..da307331 100644
--- a/libsoup/soup-multipart.c
+++ b/libsoup/soup-multipart.c
@@ -297,7 +297,8 @@ soup_multipart_append_part (SoupMultipart      *multipart,
 	 * 2) We can't change SoupMessageHeaders to not just do a ref
 	 *    from g_boxed_copy, because that would break language
 	 *    bindings (which need to be able to hold a ref on
-	 *    msg->request_headers, but don't want to duplicate it).
+	 *    soup_message_get_request_headers (msg), but don't want
+         *    to duplicate it).
 	 *
 	 * 3) We don't want to steal the reference to @headers,
 	 *    because then we'd have to either also steal the
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 3eb8b0be..9311a095 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -768,18 +768,18 @@ free_host (SoupSessionHost *host)
 }
 
 #define SOUP_SESSION_WOULD_REDIRECT_AS_GET(session, msg) \
-	((msg)->status_code == SOUP_STATUS_SEE_OTHER || \
-	 ((msg)->status_code == SOUP_STATUS_FOUND && \
-	  !SOUP_METHOD_IS_SAFE ((msg)->method)) || \
-	 ((msg)->status_code == SOUP_STATUS_MOVED_PERMANENTLY && \
-	  (msg)->method == SOUP_METHOD_POST))
+	(soup_message_get_status (msg) == SOUP_STATUS_SEE_OTHER || \
+	 (soup_message_get_status (msg) == SOUP_STATUS_FOUND && \
+	  !SOUP_METHOD_IS_SAFE (soup_message_get_method (msg))) || \
+	 (soup_message_get_status (msg) == SOUP_STATUS_MOVED_PERMANENTLY && \
+	  soup_message_get_method (msg) == SOUP_METHOD_POST))
 
 #define SOUP_SESSION_WOULD_REDIRECT_AS_SAFE(session, msg) \
-	(((msg)->status_code == SOUP_STATUS_MOVED_PERMANENTLY || \
-	  (msg)->status_code == SOUP_STATUS_PERMANENT_REDIRECT || \
-	  (msg)->status_code == SOUP_STATUS_TEMPORARY_REDIRECT || \
-	  (msg)->status_code == SOUP_STATUS_FOUND) && \
-	 SOUP_METHOD_IS_SAFE ((msg)->method))
+	((soup_message_get_status (msg) == SOUP_STATUS_MOVED_PERMANENTLY || \
+	  soup_message_get_status (msg) == SOUP_STATUS_PERMANENT_REDIRECT || \
+	  soup_message_get_status (msg) == SOUP_STATUS_TEMPORARY_REDIRECT || \
+	  soup_message_get_status (msg) == SOUP_STATUS_FOUND) && \
+	 SOUP_METHOD_IS_SAFE (soup_message_get_method (msg)))
 
 static inline SoupURI *
 redirection_uri (SoupMessage *msg)
@@ -787,7 +787,7 @@ redirection_uri (SoupMessage *msg)
 	const char *new_loc;
 	SoupURI *new_uri;
 
-	new_loc = soup_message_headers_get_one (msg->response_headers,
+	new_loc = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 						"Location");
 	if (!new_loc)
 		return NULL;
@@ -826,7 +826,7 @@ soup_session_would_redirect (SoupSession *session, SoupMessage *msg)
 		return FALSE;
 
 	/* and a Location header that parses to an http URI */
-	if (!soup_message_headers_get_one (msg->response_headers, "Location"))
+	if (!soup_message_headers_get_one (soup_message_get_response_headers (msg), "Location"))
 		return FALSE;
 	new_uri = redirection_uri (msg);
 	if (!new_uri)
@@ -876,13 +876,13 @@ soup_session_redirect_message (SoupSession *session, SoupMessage *msg)
 		return FALSE;
 
 	if (SOUP_SESSION_WOULD_REDIRECT_AS_GET (session, msg)) {
-		if (msg->method != SOUP_METHOD_HEAD) {
+		if (soup_message_get_method (msg) != SOUP_METHOD_HEAD) {
 			g_object_set (msg,
 				      "method", SOUP_METHOD_GET,
 				      NULL);
 		}
 		soup_message_set_request_body (msg, NULL, NULL, 0);
-		soup_message_headers_set_encoding (msg->request_headers,
+		soup_message_headers_set_encoding (soup_message_get_request_headers (msg),
 						   SOUP_ENCODING_NONE);
 	}
 
@@ -943,7 +943,7 @@ message_restarted (SoupMessage *msg, gpointer user_data)
 
 	if (item->conn &&
 	    (!soup_message_is_keepalive (msg) ||
-	     SOUP_STATUS_IS_REDIRECTION (msg->status_code))) {
+	     SOUP_STATUS_IS_REDIRECTION (soup_message_get_status (msg)))) {
 		if (soup_connection_get_state (item->conn) == SOUP_CONNECTION_IN_USE)
 			soup_connection_set_state (item->conn, SOUP_CONNECTION_IDLE);
 		soup_session_set_item_connection (item->session, item, NULL);
@@ -1002,14 +1002,14 @@ soup_session_send_queue_item (SoupSession *session,
 	SoupSessionPrivate *priv = soup_session_get_instance_private (session);
 
 	if (priv->user_agent) {
-		soup_message_headers_replace (item->msg->request_headers,
+		soup_message_headers_replace (soup_message_get_request_headers (item->msg),
 					      "User-Agent", priv->user_agent);
 	}
 
 	if (priv->accept_language &&
-	    !soup_message_headers_get_list (item->msg->request_headers,
+	    !soup_message_headers_get_list (soup_message_get_request_headers (item->msg),
 					    "Accept-Language")) {
-		soup_message_headers_append (item->msg->request_headers,
+		soup_message_headers_append (soup_message_get_request_headers (item->msg),
 					     "Accept-Language",
 					     priv->accept_language);
 	}
@@ -1019,13 +1019,13 @@ soup_session_send_queue_item (SoupSession *session,
 	 * a short period of time, as we wouldn't need to establish
 	 * new connections. Keep alive is implicit for HTTP 1.1.
 	 */
-	if (!soup_message_headers_header_contains (item->msg->request_headers,
+	if (!soup_message_headers_header_contains (soup_message_get_request_headers (item->msg),
 						   "Connection", "Keep-Alive") &&
-	    !soup_message_headers_header_contains (item->msg->request_headers,
+	    !soup_message_headers_header_contains (soup_message_get_request_headers (item->msg),
 						   "Connection", "close") &&
-	    !soup_message_headers_header_contains (item->msg->request_headers,
+	    !soup_message_headers_header_contains (soup_message_get_request_headers (item->msg),
 						   "Connection", "Upgrade")) {
-		soup_message_headers_append (item->msg->request_headers,
+		soup_message_headers_append (soup_message_get_request_headers (item->msg),
 					     "Connection", "Keep-Alive");
 	}
 
@@ -1173,8 +1173,8 @@ soup_session_unqueue_item (SoupSession          *session,
 	if (item->conn) {
 		if (item->conn_is_dedicated)
 			dedicated_conn = g_object_ref (item->conn);
-		else if (item->msg->method != SOUP_METHOD_CONNECT ||
-			 !SOUP_STATUS_IS_SUCCESSFUL (item->msg->status_code))
+		else if (soup_message_get_method (item->msg) != SOUP_METHOD_CONNECT ||
+			 !SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (item->msg)))
 			soup_connection_set_state (item->conn, SOUP_CONNECTION_IDLE);
 		soup_session_set_item_connection (session, item, NULL);
 	}
@@ -1333,7 +1333,7 @@ tunnel_complete (SoupMessageQueueItem *tunnel_item,
 	soup_message_finished (tunnel_item->msg);
 	soup_message_queue_item_unref (tunnel_item);
 
-	if (item->msg->status_code)
+	if (soup_message_get_status (item->msg))
 		item->state = SOUP_MESSAGE_FINISHING;
 	soup_message_set_https_status (item->msg, item->conn);
 
@@ -1343,7 +1343,7 @@ tunnel_complete (SoupMessageQueueItem *tunnel_item,
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 		soup_connection_disconnect (item->conn);
 		soup_session_set_item_connection (session, item, NULL);
-		if (item->msg->status_code == 0)
+		if (soup_message_get_status (item->msg) == 0)
 			soup_session_set_item_status (session, item, status, error);
 	}
 
@@ -1391,7 +1391,7 @@ tunnel_message_completed (SoupMessage *msg, SoupMessageIOCompletion completion,
 	tunnel_item->state = SOUP_MESSAGE_FINISHED;
 	soup_session_unqueue_item (session, tunnel_item);
 
-	status = tunnel_item->msg->status_code;
+	status = soup_message_get_status (tunnel_item->msg);
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 		tunnel_complete (tunnel_item, status, NULL);
 		return;
@@ -1454,7 +1454,7 @@ connect_complete (SoupMessageQueueItem *item, SoupConnection *conn, GError *erro
 	status = status_from_connect_error (item, error);
 	soup_connection_disconnect (conn);
 	if (item->state == SOUP_MESSAGE_CONNECTING) {
-		if (item->msg->status_code == 0)
+		if (soup_message_get_status (item->msg) == 0)
 			soup_session_set_item_status (session, item, status, error);
 		soup_session_set_item_connection (session, item, NULL);
 		item->state = SOUP_MESSAGE_READY;
@@ -1590,7 +1590,7 @@ get_connection (SoupMessageQueueItem *item, gboolean *should_cleanup)
 	need_new_connection =
 		(soup_message_get_flags (item->msg) & SOUP_MESSAGE_NEW_CONNECTION) ||
 		(!(soup_message_get_flags (item->msg) & SOUP_MESSAGE_IDEMPOTENT) &&
-		 !SOUP_METHOD_IS_IDEMPOTENT (item->msg->method));
+		 !SOUP_METHOD_IS_IDEMPOTENT (soup_message_get_method (item->msg)));
 	ignore_connection_limits =
 		(soup_message_get_flags (item->msg) & SOUP_MESSAGE_IGNORE_CONNECTION_LIMITS);
 
@@ -1681,8 +1681,8 @@ soup_session_process_queue_item (SoupSession          *session,
 				break;
 			}
 
-			if (item->msg->status_code) {
-				if (item->msg->status_code == SOUP_STATUS_TRY_AGAIN) {
+			if (soup_message_get_status (item->msg)) {
+				if (soup_message_get_status (item->msg) == SOUP_STATUS_TRY_AGAIN) {
 					soup_message_cleanup_response (item->msg);
 					item->state = SOUP_MESSAGE_STARTING;
 				} else
@@ -1754,7 +1754,7 @@ async_run_queue (SoupSession *session)
 		msg = item->msg;
 
 		/* CONNECT messages are handled specially */
-		if (msg->method == SOUP_METHOD_CONNECT)
+		if (soup_message_get_method (msg) == SOUP_METHOD_CONNECT)
 			continue;
 
 		if (!item->async ||
@@ -1824,7 +1824,7 @@ soup_session_requeue_message (SoupSession *session, SoupMessage *msg)
 	g_return_if_fail (item != NULL);
 
 	if (item->resend_count >= SOUP_SESSION_MAX_RESEND_COUNT) {
-		if (SOUP_STATUS_IS_REDIRECTION (msg->status_code))
+		if (SOUP_STATUS_IS_REDIRECTION (soup_message_get_status (msg)))
 			soup_message_set_status (msg, SOUP_STATUS_TOO_MANY_REDIRECTS);
 		else
 			g_warning ("SoupMessage %p stuck in infinite loop?", msg);
@@ -2806,8 +2806,8 @@ soup_session_class_init (SoupSessionClass *session_class)
 static gboolean
 expected_to_be_requeued (SoupSession *session, SoupMessage *msg)
 {
-	if (msg->status_code == SOUP_STATUS_UNAUTHORIZED ||
-	    msg->status_code == SOUP_STATUS_PROXY_UNAUTHORIZED) {
+	if (soup_message_get_status (msg) == SOUP_STATUS_UNAUTHORIZED ||
+	    soup_message_get_status (msg) == SOUP_STATUS_PROXY_UNAUTHORIZED) {
 		SoupSessionFeature *feature =
 			soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER);
 		return !feature || !soup_message_disables_feature (msg, feature);
@@ -2841,13 +2841,13 @@ async_send_request_return_result (SoupMessageQueueItem *item,
 		if (stream)
 			g_object_unref (stream);
 		g_task_return_error (task, g_error_copy (item->error));
-	} else if (SOUP_STATUS_IS_TRANSPORT_ERROR (item->msg->status_code)) {
+	} else if (SOUP_STATUS_IS_TRANSPORT_ERROR (soup_message_get_status (item->msg))) {
 		if (stream)
 			g_object_unref (stream);
 		g_task_return_new_error (task, SOUP_HTTP_ERROR,
-					 item->msg->status_code,
+					 soup_message_get_status (item->msg),
 					 "%s",
-					 item->msg->reason_phrase);
+					 soup_message_get_reason_phrase (item->msg));
 	} else
 		g_task_return_pointer (task, stream, g_object_unref);
 	g_object_unref (task);
@@ -3032,7 +3032,7 @@ async_return_from_cache (SoupMessageQueueItem *item,
 
 	soup_message_got_headers (item->msg);
 
-	content_type = soup_message_headers_get_content_type (item->msg->response_headers, &params);
+	content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (item->msg), &params);
 	if (content_type) {
 		soup_message_content_sniffed (item->msg, content_type, params);
 		g_hash_table_unref (params);
@@ -3088,7 +3088,7 @@ conditional_get_ready_cb (SoupSession               *session,
 
 	soup_cache_update_from_conditional_request (data->cache, data->conditional_msg);
 
-	if (data->conditional_msg->status_code == SOUP_STATUS_NOT_MODIFIED) {
+	if (soup_message_get_status (data->conditional_msg) == SOUP_STATUS_NOT_MODIFIED) {
 		stream = soup_cache_send_response (data->cache, data->item->msg);
 		if (stream) {
 			async_return_from_cache (data->item, stream);
@@ -3411,10 +3411,10 @@ soup_session_send (SoupSession   *session,
 		g_clear_object (&stream);
 		if (error)
 			*error = g_error_copy (item->error);
-	} else if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
+	} else if (SOUP_STATUS_IS_TRANSPORT_ERROR (soup_message_get_status (msg))) {
 		g_clear_object (&stream);
-		g_set_error_literal (error, SOUP_HTTP_ERROR, msg->status_code,
-				     msg->reason_phrase);
+		g_set_error_literal (error, SOUP_HTTP_ERROR, soup_message_get_status (msg),
+				     soup_message_get_reason_phrase (msg));
 	} else if (!stream)
 		stream = g_memory_input_stream_new ();
 
@@ -3500,9 +3500,9 @@ get_http_got_headers (SoupMessage         *msg,
         const char *content_type;
         GHashTable *params = NULL;
 
-        content_length = soup_message_headers_get_content_length (msg->response_headers);
+        content_length = soup_message_headers_get_content_length (soup_message_get_response_headers (msg));
         data->content_length = content_length != 0 ? content_length : -1;
-        content_type = soup_message_headers_get_content_type (msg->response_headers, &params);
+        content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (msg), &params);
         session_get_async_data_set_content_type (data, content_type, params);
         g_clear_pointer (&params, g_hash_table_destroy);
 }
@@ -4052,8 +4052,8 @@ websocket_connect_async_stop (SoupMessage *msg, gpointer user_data)
 		client = soup_websocket_connection_new_with_extensions (stream,
 									soup_message_get_uri (item->msg),
 									SOUP_WEBSOCKET_CONNECTION_CLIENT,
-									soup_message_headers_get_one (msg->request_headers, "Origin"),
-									soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol"),
+									soup_message_headers_get_one (soup_message_get_request_headers (msg), "Origin"),
+									soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Protocol"),
 									accepted_extensions);
 		g_object_unref (stream);
 		g_task_return_pointer (task, client, g_object_unref);
@@ -4178,7 +4178,7 @@ soup_session_get_original_message_for_authentication (SoupSession *session,
 	if (!item)
                 return msg;
 
-	if (msg->method != SOUP_METHOD_CONNECT) {
+	if (soup_message_get_method (msg) != SOUP_METHOD_CONNECT) {
 		soup_message_queue_item_unref (item);
 		return msg;
 	}
diff --git a/libsoup/websocket/soup-websocket.c b/libsoup/websocket/soup-websocket.c
index 3ef71759..9aeb4ba4 100644
--- a/libsoup/websocket/soup-websocket.c
+++ b/libsoup/websocket/soup-websocket.c
@@ -302,27 +302,27 @@ soup_websocket_client_prepare_handshake_with_extensions (SoupMessage *msg,
 
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
 
-	soup_message_headers_replace (msg->request_headers, "Upgrade", "websocket");
-	soup_message_headers_append (msg->request_headers, "Connection", "Upgrade");
+	soup_message_headers_replace (soup_message_get_request_headers (msg), "Upgrade", "websocket");
+	soup_message_headers_append (soup_message_get_request_headers (msg), "Connection", "Upgrade");
 
 	raw[0] = g_random_int ();
 	raw[1] = g_random_int ();
 	raw[2] = g_random_int ();
 	raw[3] = g_random_int ();
 	key = g_base64_encode ((const guchar *)raw, sizeof (raw));
-	soup_message_headers_replace (msg->request_headers, "Sec-WebSocket-Key", key);
+	soup_message_headers_replace (soup_message_get_request_headers (msg), "Sec-WebSocket-Key", key);
 	g_free (key);
 
-	soup_message_headers_replace (msg->request_headers, "Sec-WebSocket-Version", "13");
+	soup_message_headers_replace (soup_message_get_request_headers (msg), "Sec-WebSocket-Version", "13");
 
 	if (origin)
-		soup_message_headers_replace (msg->request_headers, "Origin", origin);
+		soup_message_headers_replace (soup_message_get_request_headers (msg), "Origin", origin);
 
 	if (protocols) {
 		char *protocols_str;
 
 		protocols_str = g_strjoinv (", ", protocols);
-		soup_message_headers_replace (msg->request_headers,
+		soup_message_headers_replace (soup_message_get_request_headers (msg),
 					      "Sec-WebSocket-Protocol", protocols_str);
 		g_free (protocols_str);
 	}
@@ -358,11 +358,11 @@ soup_websocket_client_prepare_handshake_with_extensions (SoupMessage *msg,
 		}
 
 		if (extensions->len > 0) {
-			soup_message_headers_replace (msg->request_headers,
+			soup_message_headers_replace (soup_message_get_request_headers (msg),
 						      "Sec-WebSocket-Extensions",
 						      extensions->str);
 		} else {
-			soup_message_headers_remove (msg->request_headers,
+			soup_message_headers_remove (soup_message_get_request_headers (msg),
 						     "Sec-WebSocket-Extensions");
 		}
 		g_string_free (extensions, TRUE);
@@ -426,7 +426,7 @@ extract_extension_names_from_request (SoupMessage *msg)
         GSList *extension_list, *l;
         GHashTable *return_value = NULL;
 
-        extensions = soup_message_headers_get_list (msg->request_headers, "Sec-WebSocket-Extensions");
+        extensions = soup_message_headers_get_list (soup_message_get_request_headers (msg), "Sec-WebSocket-Extensions");
         if (!extensions || !*extensions)
                 return NULL;
 
@@ -977,7 +977,7 @@ soup_websocket_client_verify_handshake_with_extensions (SoupMessage *msg,
 	g_return_val_if_fail (accepted_extensions == NULL || *accepted_extensions == NULL, FALSE);
 	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
-	if (msg->status_code == SOUP_STATUS_BAD_REQUEST) {
+	if (soup_message_get_status (msg) == SOUP_STATUS_BAD_REQUEST) {
 		g_set_error_literal (error,
 				     SOUP_WEBSOCKET_ERROR,
 				     SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE,
@@ -985,7 +985,7 @@ soup_websocket_client_verify_handshake_with_extensions (SoupMessage *msg,
 		return FALSE;
 	}
 
-	if (msg->status_code != SOUP_STATUS_SWITCHING_PROTOCOLS) {
+	if (soup_message_get_status (msg) != SOUP_STATUS_SWITCHING_PROTOCOLS) {
 		g_set_error_literal (error,
 				     SOUP_WEBSOCKET_ERROR,
 				     SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET,
@@ -993,8 +993,8 @@ soup_websocket_client_verify_handshake_with_extensions (SoupMessage *msg,
 		return FALSE;
 	}
 
-	if (!soup_message_headers_header_equals (msg->response_headers, "Upgrade", "websocket") ||
-	    !soup_message_headers_header_contains (msg->response_headers, "Connection", "upgrade")) {
+	if (!soup_message_headers_header_equals (soup_message_get_response_headers (msg), "Upgrade", "websocket") ||
+	    !soup_message_headers_header_contains (soup_message_get_response_headers (msg), "Connection", "upgrade")) {
 		g_set_error_literal (error,
 				     SOUP_WEBSOCKET_ERROR,
 				     SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET,
@@ -1002,9 +1002,9 @@ soup_websocket_client_verify_handshake_with_extensions (SoupMessage *msg,
 		return FALSE;
 	}
 
-	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
+	protocol = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Protocol");
 	if (protocol) {
-		request_protocols = soup_message_headers_get_one (msg->request_headers, "Sec-WebSocket-Protocol");
+		request_protocols = soup_message_headers_get_one (soup_message_get_request_headers (msg), "Sec-WebSocket-Protocol");
 		if (!request_protocols ||
 		    !soup_header_contains (request_protocols, protocol)) {
 			g_set_error_literal (error,
@@ -1015,14 +1015,14 @@ soup_websocket_client_verify_handshake_with_extensions (SoupMessage *msg,
 		}
 	}
 
-	extensions = soup_message_headers_get_list (msg->response_headers, "Sec-WebSocket-Extensions");
+	extensions = soup_message_headers_get_list (soup_message_get_response_headers (msg), "Sec-WebSocket-Extensions");
 	if (extensions && *extensions) {
 		if (!process_extensions (extensions, msg, supported_extensions, accepted_extensions, error))
 			return FALSE;
 	}
 
-	accept_key = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Accept");
-	expected_accept_key = compute_accept_key (soup_message_headers_get_one (msg->request_headers, "Sec-WebSocket-Key"));
+	accept_key = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Accept");
+	expected_accept_key = compute_accept_key (soup_message_headers_get_one (soup_message_get_request_headers (msg), "Sec-WebSocket-Key"));
 	key_ok = (accept_key && expected_accept_key &&
 		  !g_ascii_strcasecmp (accept_key, expected_accept_key));
 	g_free (expected_accept_key);
diff --git a/tests/auth-test.c b/tests/auth-test.c
index 01280d26..44b94b43 100644
--- a/tests/auth-test.c
+++ b/tests/auth-test.c
@@ -163,7 +163,7 @@ identify_auth (SoupMessage *msg)
 	const char *header;
 	int num;
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (soup_message_get_request_headers (msg),
 					       "Authorization");
 	if (!header)
 		return 0;
@@ -199,7 +199,7 @@ handler (SoupMessage *msg, gpointer data)
 	auth = identify_auth (msg);
 
 	debug_printf (1, "  %d %s (using %s)\n",
-		      msg->status_code, msg->reason_phrase,
+		      soup_message_get_status (msg), soup_message_get_reason_phrase (msg),
 		      auths[auth]);
 
 	if (*expected) {
@@ -508,7 +508,7 @@ async_authenticate (SoupMessage *msg,
 	 * it, because it already knows it's going to need the auth.
 	 * Ignore that.
 	 */
-	if (msg->status_code != SOUP_STATUS_UNAUTHORIZED) {
+	if (soup_message_get_status (msg) != SOUP_STATUS_UNAUTHORIZED) {
 		debug_printf (2, "    (ignoring)\n");
 		return FALSE;
 	}
@@ -570,7 +570,7 @@ static void
 do_async_auth_good_password_test (void)
 {
 	SoupSession *session;
-	SoupMessage *msg1, *msg2, *msg3, msg2_bak;
+	SoupMessage *msg1, *msg2, *msg3;
 	char *uri;
 	SoupAuth *auth = NULL;
 	int remaining;
@@ -601,11 +601,8 @@ do_async_auth_good_password_test (void)
 	soup_test_assert_message_status (msg2, SOUP_STATUS_UNAUTHORIZED);
 
 	/* msg2 should be done at this point; assuming everything is
-	 * working correctly, the session won't look at it again; we
-	 * ensure that if it does, it will crash the test program.
+	 * working correctly, the session won't look at it again.
 	 */
-	memcpy (&msg2_bak, msg2, sizeof (SoupMessage));
-	memset (msg2, 0, sizeof (SoupMessage));
 
 	msg3 = soup_message_new ("GET", uri);
 	g_object_set_data (G_OBJECT (msg3), "id", GINT_TO_POINTER (3));
@@ -637,7 +634,6 @@ do_async_auth_good_password_test (void)
 
 	g_object_unref (msg1);
 	g_object_unref (msg3);
-	memcpy (msg2, &msg2_bak, sizeof (SoupMessage));
 	g_object_unref (msg2);
 
 	g_free (uri);
@@ -772,7 +768,7 @@ select_auth_authenticate (SoupMessage    *msg,
 	const char *header, *basic, *digest;
 	int round = retrying ? 1 : 0;
 
-	header = soup_message_headers_get_list (msg->response_headers,
+	header = soup_message_headers_get_list (soup_message_get_response_headers (msg),
 						"WWW-Authenticate");
 	basic = strstr (header, "Basic");
 	digest = strstr (header, "Digest");
@@ -1119,7 +1115,7 @@ do_infinite_auth_test (void)
 	soup_test_session_send_message (session, msg);
 	g_test_assert_expected_messages ();
 
-	soup_test_assert (msg->status_code != SOUP_STATUS_CANCELLED,
+	soup_test_assert (soup_message_get_status (msg) != SOUP_STATUS_CANCELLED,
 			  "Got stuck in loop");
 	soup_test_assert_message_status (msg, SOUP_STATUS_UNAUTHORIZED);
 
@@ -1510,7 +1506,7 @@ do_message_has_authorization_header_test (void)
 	soup_auth_manager_clear_cached_credentials (manager);
 
 	msg = soup_message_new ("GET", uri);
-	soup_message_headers_replace (msg->request_headers, "Authorization", token);
+	soup_message_headers_replace (soup_message_get_request_headers (msg), "Authorization", token);
 	g_signal_connect (msg, "authenticate",
 			  G_CALLBACK (has_authorization_header_authenticate_assert),
 			  NULL);
@@ -1521,7 +1517,7 @@ do_message_has_authorization_header_test (void)
 	/* Check that we can also provide our own Authorization header when not using credentials cache. */
 	soup_auth_manager_clear_cached_credentials (manager);
 	msg = soup_message_new ("GET", uri);
-	soup_message_headers_replace (msg->request_headers, "Authorization", token);
+	soup_message_headers_replace (soup_message_get_request_headers (msg), "Authorization", token);
 	soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE);
 	soup_test_session_send_message (session, msg);
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
diff --git a/tests/cache-test.c b/tests/cache-test.c
index e03e146a..6cfadaad 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -167,7 +167,7 @@ do_request (SoupSession        *session,
 	va_start (ap, response_headers);
 	while ((header = va_arg (ap, const char *))) {
 		value = va_arg (ap, const char *);
-		soup_message_headers_append (msg->request_headers,
+		soup_message_headers_append (soup_message_get_request_headers (msg),
 					     header, value);
 	}
 	va_end (ap);
@@ -182,7 +182,7 @@ do_request (SoupSession        *session,
 	}
 
 	if (response_headers)
-		soup_message_headers_foreach (msg->response_headers, copy_headers, response_headers);
+		soup_message_headers_foreach (soup_message_get_response_headers (msg), copy_headers, response_headers);
 
 	g_object_unref (msg);
 
@@ -254,9 +254,9 @@ do_request_with_cancel (SoupSession          *session,
 static void
 message_starting (SoupMessage *msg, gpointer data)
 {
-	if (soup_message_headers_get_one (msg->request_headers,
+	if (soup_message_headers_get_one (soup_message_get_request_headers (msg),
 					  "If-Modified-Since") ||
-	    soup_message_headers_get_one (msg->request_headers,
+	    soup_message_headers_get_one (soup_message_get_request_headers (msg),
 					  "If-None-Match")) {
 		debug_printf (2, "    Conditional request for %s\n",
 			      soup_message_get_uri (msg)->path);
@@ -277,7 +277,7 @@ static void
 request_unqueued (SoupSession *session, SoupMessage *msg,
 		  gpointer data)
 {
-	if (msg->status_code == SOUP_STATUS_CANCELLED)
+	if (soup_message_get_status (msg) == SOUP_STATUS_CANCELLED)
 		cancelled_requests++;
 	last_request_unqueued = TRUE;
 }
diff --git a/tests/coding-test.c b/tests/coding-test.c
index 31488950..4f600775 100644
--- a/tests/coding-test.c
+++ b/tests/coding-test.c
@@ -154,7 +154,7 @@ check_response (CodingTestData *data,
 
 	soup_test_assert_message_status (data->msg, SOUP_STATUS_OK);
 
-	coding = soup_message_headers_get_one (data->msg->response_headers, "Content-Encoding");
+	coding = soup_message_headers_get_one (soup_message_get_response_headers (data->msg), "Content-Encoding");
 	g_assert_cmpstr (coding, ==, expected_encoding);
 
 	if (status != NO_CHECK) {
@@ -164,7 +164,7 @@ check_response (CodingTestData *data,
 			g_assert_false (soup_message_get_flags (data->msg) & SOUP_MESSAGE_CONTENT_DECODED);
 	}
 
-	type = soup_message_headers_get_one (data->msg->response_headers, "Content-Type");
+	type = soup_message_headers_get_one (soup_message_get_response_headers (data->msg), "Content-Type");
 	g_assert_cmpstr (type, ==, expected_content_type);
 
 	g_assert_true (g_bytes_equal (body, data->response));
@@ -234,7 +234,7 @@ do_coding_test_gzip_with_junk (CodingTestData *data, gconstpointer test_data)
 	g_test_bug ("606352");
 	g_test_bug ("676477");
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "trailing-junk");
 
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
@@ -249,7 +249,7 @@ do_coding_test_gzip_bad_server (CodingTestData *data, gconstpointer test_data)
 
 	g_test_bug ("613361");
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "force-encode");
 
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
@@ -267,7 +267,7 @@ do_coding_test_deflate (CodingTestData *data, gconstpointer test_data)
 {
 	GBytes *body;
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "prefer-deflate-zlib");
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
 	check_response (data, "deflate", "text/plain", EXPECT_DECODED, body);
@@ -282,7 +282,7 @@ do_coding_test_deflate_with_junk (CodingTestData *data, gconstpointer test_data)
 	g_test_bug ("606352");
 	g_test_bug ("676477");
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "prefer-deflate-zlib, trailing-junk");
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
 	check_response (data, "deflate", "text/plain", EXPECT_DECODED, body);
@@ -296,7 +296,7 @@ do_coding_test_deflate_bad_server (CodingTestData *data, gconstpointer test_data
 
 	g_test_bug ("613361");
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "force-encode, prefer-deflate-zlib");
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
 	check_response (data, "deflate", "text/plain", EXPECT_NOT_DECODED, body);
@@ -308,7 +308,7 @@ do_coding_test_deflate_raw (CodingTestData *data, gconstpointer test_data)
 {
 	GBytes *body;
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "prefer-deflate-raw");
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
 	check_response (data, "deflate", "text/plain", EXPECT_DECODED, body);
@@ -322,7 +322,7 @@ do_coding_test_deflate_raw_bad_server (CodingTestData *data, gconstpointer test_
 
 	g_test_bug ("613361");
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "force-encode, prefer-deflate-raw");
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
 	check_response (data, "deflate", "text/plain", EXPECT_NOT_DECODED, body);
@@ -336,7 +336,7 @@ do_coding_msg_empty_test (CodingTestData *data, gconstpointer test_data)
 
 	g_test_bug ("697527");
 
-	soup_message_headers_append (data->msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (data->msg),
 				     "X-Test-Options", "empty");
 	body = soup_test_session_send (data->session, data->msg, NULL, NULL);
 	check_response (data, "gzip", "text/plain", EXPECT_NOT_DECODED, body);
diff --git a/tests/connection-test.c b/tests/connection-test.c
index ab02114b..2021cad2 100644
--- a/tests/connection-test.c
+++ b/tests/connection-test.c
@@ -200,7 +200,7 @@ do_content_length_framing_test (void)
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
 
-	declared_length = soup_message_headers_get_content_length (msg->response_headers);
+	declared_length = soup_message_headers_get_content_length (soup_message_get_response_headers (msg));
 	debug_printf (2, "    Content-Length: %lu, body: %s\n",
 		      (gulong)declared_length, (char *)g_bytes_get_data (body, NULL));
 	g_assert_cmpint (g_bytes_get_size (body), <, declared_length);
@@ -216,7 +216,7 @@ do_content_length_framing_test (void)
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
 
-	declared_length = soup_message_headers_get_content_length (msg->response_headers);
+	declared_length = soup_message_headers_get_content_length (soup_message_get_response_headers (msg));
 	g_assert_cmpint (g_bytes_get_size (body), ==, declared_length);
 
 	soup_uri_free (request_uri);
@@ -602,7 +602,7 @@ do_non_persistent_test_for_session (SoupSession *session)
 			  &socket);
 
 	msg = soup_message_new_from_uri ("GET", base_uri);
-	soup_message_headers_append (msg->request_headers, "Connection", "close");
+	soup_message_headers_append (soup_message_get_request_headers (msg), "Connection", "close");
 	g_signal_connect (msg, "finished",
 			  G_CALLBACK (np_request_finished), loop);
 	soup_session_send_async (session, msg, G_PRIORITY_DEFAULT, NULL, NULL, NULL);
diff --git a/tests/continue-test.c b/tests/continue-test.c
index 3d00619f..bea725a7 100644
--- a/tests/continue-test.c
+++ b/tests/continue-test.c
@@ -109,9 +109,9 @@ do_message (const char *path, gboolean long_body,
 	body = long_body ? LONG_BODY : SHORT_BODY;
 	request_body = g_bytes_new_static (body, strlen (body));
 	soup_message_set_request_body_from_bytes (msg, "text/plain", request_body);
-	soup_message_headers_append (msg->request_headers, "Connection", "close");
+	soup_message_headers_append (soup_message_get_request_headers (msg), "Connection", "close");
 	if (expect_continue) {
-		soup_message_headers_set_expectations (msg->request_headers,
+		soup_message_headers_set_expectations (soup_message_get_request_headers (msg),
 						       SOUP_EXPECTATION_CONTINUE);
 	}
 
diff --git a/tests/cookies-test.c b/tests/cookies-test.c
index 3986191d..fafd1a0f 100644
--- a/tests/cookies-test.c
+++ b/tests/cookies-test.c
@@ -307,19 +307,19 @@ do_cookies_parsing_test (void)
 
 	/* "httponly" is case-insensitive, and its value (if any) is ignored */
 	msg = soup_message_new_from_uri ("GET", first_party_uri);
-	soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
+	soup_message_headers_append (soup_message_get_request_headers (msg), "Echo-Set-Cookie",
 				     "one=1; httponly; max-age=100");
 	soup_test_session_send_message (session, msg);
 	g_object_unref (msg);
 
 	msg = soup_message_new_from_uri ("GET", first_party_uri);
-	soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
+	soup_message_headers_append (soup_message_get_request_headers (msg), "Echo-Set-Cookie",
 				     "two=2; HttpOnly; max-age=100; SameSite=Invalid");
 	soup_test_session_send_message (session, msg);
 	g_object_unref (msg);
 
 	msg = soup_message_new_from_uri ("GET", first_party_uri);
-	soup_message_headers_append (msg->request_headers, "Echo-Set-Cookie",
+	soup_message_headers_append (soup_message_get_request_headers (msg), "Echo-Set-Cookie",
 				     "three=3; httpONLY=Wednesday; max-age=100; SameSite=Lax");
 	soup_test_session_send_message (session, msg);
 	g_object_unref (msg);
diff --git a/tests/misc-test.c b/tests/misc-test.c
index 4546bf41..063fb703 100644
--- a/tests/misc-test.c
+++ b/tests/misc-test.c
@@ -115,7 +115,7 @@ do_host_test (void)
 
 	one = soup_message_new_from_uri ("GET", base_uri);
 	two = soup_message_new_from_uri ("GET", base_uri);
-	soup_message_headers_replace (two->request_headers, "Host", "foo");
+	soup_message_headers_replace (soup_message_get_request_headers (two), "Host", "foo");
 
 	body_one = soup_test_session_send (session, one, NULL, NULL);
 	body_two = soup_test_session_send (session, two, NULL, NULL);
@@ -153,7 +153,7 @@ do_host_big_header (void)
 	for (i = 0; i < 2048; i++) {
 		char *key = g_strdup_printf ("test-long-header-key%d", i);
 		char *value = g_strdup_printf ("test-long-header-key%d", i);
-		soup_message_headers_append (msg->request_headers, key, value);
+		soup_message_headers_append (soup_message_get_request_headers (msg), key, value);
 		g_free (value);
 		g_free (key);
 	}
@@ -459,7 +459,7 @@ do_one_accept_language_test (const char *language, const char *expected_header)
 	soup_test_session_abort_unref (session);
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
-	val = soup_message_headers_get_list (msg->request_headers,
+	val = soup_message_headers_get_list (soup_message_get_request_headers (msg),
 					     "Accept-Language");
 	g_assert_cmpstr (val, ==, expected_header);
 
@@ -624,11 +624,11 @@ do_aliases_test_for_session (SoupSession *session,
 	uri = soup_uri_new_with_base (base_uri, "/alias-redirect");
 	msg = soup_message_new_from_uri ("GET", uri);
 	if (redirect_protocol)
-		soup_message_headers_append (msg->request_headers, "X-Redirect-Protocol", redirect_protocol);
+		soup_message_headers_append (soup_message_get_request_headers (msg), "X-Redirect-Protocol", redirect_protocol);
 	soup_uri_free (uri);
 	soup_test_session_send_message (session, msg);
 
-	redirected_protocol = soup_message_headers_get_one (msg->response_headers, "X-Redirected-Protocol");
+	redirected_protocol = soup_message_headers_get_one (soup_message_get_response_headers (msg), "X-Redirected-Protocol");
 
 	g_assert_cmpstr (redirect_protocol, ==, redirected_protocol);
 	if (redirect_protocol)
diff --git a/tests/multipart-test.c b/tests/multipart-test.c
index 95b6efa3..8d82f90d 100644
--- a/tests/multipart-test.c
+++ b/tests/multipart-test.c
@@ -111,7 +111,7 @@ got_headers (SoupMessage *msg, int *headers_count)
 
 	*headers_count = *headers_count + 1;
 
-	soup_message_headers_iter_init (&iter, msg->response_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_response_headers (msg));
 
 	is_next = soup_message_headers_iter_next (&iter, &name, &value);
 	check_is_next (is_next);
@@ -428,7 +428,7 @@ test_multipart (gconstpointer data)
 	passes = 0;
 
 	/* Force the server to close the connection. */
-	soup_message_headers_append (msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (msg),
 				     "Connection", "close");
 
 	g_signal_connect (msg, "got_headers",
@@ -453,7 +453,7 @@ test_multipart (gconstpointer data)
 	while (g_main_context_pending (NULL))
 		g_main_context_iteration (NULL, FALSE);
 
-	content_type = soup_message_headers_get_content_type (msg->response_headers, &params);
+	content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (msg), &params);
 
 	if (content_type &&
 	    g_str_has_prefix (content_type, "multipart/") &&
diff --git a/tests/ntlm-test.c b/tests/ntlm-test.c
index dfbf0d90..aca219eb 100644
--- a/tests/ntlm-test.c
+++ b/tests/ntlm-test.c
@@ -239,7 +239,7 @@ prompt_check (SoupMessage *msg, gpointer user_data)
 	NTLMState *state = user_data;
 	const char *header;
 
-	header = soup_message_headers_get_list (msg->response_headers,
+	header = soup_message_headers_get_list (soup_message_get_response_headers (msg),
 						"WWW-Authenticate");
 	if (header && strstr (header, "Basic "))
 		state->got_basic_prompt = TRUE;
@@ -257,7 +257,7 @@ challenge_check (SoupMessage *msg, gpointer user_data)
 	NTLMState *state = user_data;
 	const char *header;
 
-	header = soup_message_headers_get_list (msg->response_headers,
+	header = soup_message_headers_get_list (soup_message_get_response_headers (msg),
 						"WWW-Authenticate");
 	if (header && !strncmp (header, "NTLM ", 5))
 		state->got_ntlm_challenge = TRUE;
@@ -269,7 +269,7 @@ request_check (SoupMessage *msg, gpointer user_data)
 	NTLMState *state = user_data;
 	const char *header;
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (soup_message_get_request_headers (msg),
 					       "Authorization");
 	if (header && !strncmp (header, "NTLM " NTLM_REQUEST_START,
 				strlen ("NTLM " NTLM_REQUEST_START)))
@@ -287,7 +287,7 @@ response_check (SoupMessage *msg, gpointer user_data)
 	guint32 flags;
 	int nt_resp_sz;
 
-	header = soup_message_headers_get_one (msg->request_headers,
+	header = soup_message_headers_get_one (soup_message_get_request_headers (msg),
 					       "Authorization");
 	if (header && !strncmp (header, "NTLM " NTLM_RESPONSE_START,
 				strlen ("NTLM " NTLM_RESPONSE_START)))
@@ -395,8 +395,8 @@ do_message (SoupSession *session,
 	} else if (do_basic)
 		debug_printf (1, " no-basic-response???");
 
-	debug_printf (1, " -> %s", msg->reason_phrase);
-	if (msg->status_code != status_code)
+	debug_printf (1, " -> %s", soup_message_get_reason_phrase (msg));
+	if (soup_message_get_status (msg) != status_code)
 		debug_printf (1, "???");
 	debug_printf (1, "\n");
 
diff --git a/tests/proxy-test.c b/tests/proxy-test.c
index 2992c000..57a2e95f 100644
--- a/tests/proxy-test.c
+++ b/tests/proxy-test.c
@@ -84,8 +84,8 @@ set_close_on_connect (SoupMessage *msg,
 	 * the connection when returning a 407 in response to a
 	 * CONNECT. (Rude!)
 	 */
-	if (msg->method == SOUP_METHOD_CONNECT) {
-		soup_message_headers_append (msg->request_headers,
+	if (soup_message_get_method (msg) == SOUP_METHOD_CONNECT) {
+		soup_message_headers_append (soup_message_get_request_headers (msg),
 					     "Connection", "close");
 	}
 }
@@ -130,7 +130,7 @@ test_url (const char *url, int proxy, guint expected, gboolean close)
 
 	soup_test_session_send_message (session, msg);
 
-	debug_printf (1, "  %d %s\n", msg->status_code, msg->reason_phrase);
+	debug_printf (1, "  %d %s\n", soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
 	soup_test_assert_message_status (msg, expected);
 
 	g_object_unref (msg);
@@ -243,7 +243,7 @@ do_proxy_redirect_test (void)
 	req_uri = soup_uri_new (HTTPS_SERVER);
 	soup_uri_set_path (req_uri, "/redirected");
 	msg = soup_message_new_from_uri (SOUP_METHOD_GET, req_uri);
-	soup_message_headers_append (msg->request_headers,
+	soup_message_headers_append (soup_message_get_request_headers (msg),
 				     "Connection", "close");
 	soup_test_session_send_message (session, msg);
 
@@ -290,7 +290,7 @@ do_proxy_auth_request (const char *url, SoupSession *session, gboolean do_read)
 	g_clear_error (&error);
 	g_object_unref (stream);
 
-	debug_printf (1, "  %d %s\n", msg->status_code, msg->reason_phrase);
+	debug_printf (1, "  %d %s\n", soup_message_get_status (msg), soup_message_get_reason_phrase (msg));
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
 
 	g_object_unref (msg);
diff --git a/tests/range-test.c b/tests/range-test.c
index bf97f958..17d9b2a7 100644
--- a/tests/range-test.c
+++ b/tests/range-test.c
@@ -67,16 +67,16 @@ do_single_range (SoupSession *session, SoupMessage *msg,
 	GBytes *body;
 
 	debug_printf (1, "    Range: %s\n",
-		      soup_message_headers_get_one (msg->request_headers, "Range"));
+		      soup_message_headers_get_one (soup_message_get_request_headers (msg), "Range"));
 
 	body = soup_test_session_async_send (session, msg);
 
 	if (!succeed) {
 		soup_test_assert_message_status (msg, SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE);
-		if (msg->status_code != SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE) {
+		if (soup_message_get_status (msg) != SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE) {
 			const char *content_range;
 
-			content_range = soup_message_headers_get_one (msg->response_headers,
+			content_range = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 								      "Content-Range");
 			if (content_range)
 				debug_printf (1, "    Content-Range: %s\n", content_range);
@@ -89,10 +89,10 @@ do_single_range (SoupSession *session, SoupMessage *msg,
 	soup_test_assert_message_status (msg, SOUP_STATUS_PARTIAL_CONTENT);
 
 	content_type = soup_message_headers_get_content_type (
-		msg->response_headers, NULL);
+		soup_message_get_response_headers (msg), NULL);
 	g_assert_cmpstr (content_type, !=, "multipart/byteranges");
 
-	check_part (msg->response_headers, body, TRUE, start, end);
+	check_part (soup_message_get_response_headers (msg), body, TRUE, start, end);
 	g_bytes_unref (body);
 	g_object_unref (msg);
 }
@@ -104,7 +104,7 @@ request_single_range (SoupSession *session, const char *uri,
 	SoupMessage *msg;
 
 	msg = soup_message_new ("GET", uri);
-	soup_message_headers_set_range (msg->request_headers, start, end);
+	soup_message_headers_set_range (soup_message_get_request_headers (msg), start, end);
 	do_single_range (session, msg, start, end, succeed);
 }
 
@@ -118,16 +118,16 @@ do_multi_range (SoupSession *session, SoupMessage *msg,
 	GBytes *body;
 
 	debug_printf (1, "    Range: %s\n",
-		      soup_message_headers_get_one (msg->request_headers, "Range"));
+		      soup_message_headers_get_one (soup_message_get_request_headers (msg), "Range"));
 
 	body = soup_test_session_async_send (session, msg);
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_PARTIAL_CONTENT);
 
-	content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
+	content_type = soup_message_headers_get_content_type (soup_message_get_response_headers (msg), NULL);
 	g_assert_cmpstr (content_type, ==, "multipart/byteranges");
 
-	multipart = soup_multipart_new_from_message (msg->response_headers, body);
+	multipart = soup_multipart_new_from_message (soup_message_get_response_headers (msg), body);
 	g_bytes_unref (body);
 
 	if (!multipart) {
@@ -166,7 +166,7 @@ request_double_range (SoupSession *session, const char *uri,
 	ranges[0].end = first_end;
 	ranges[1].start = second_start;
 	ranges[1].end = second_end;
-	soup_message_headers_set_ranges (msg->request_headers, ranges, 2);
+	soup_message_headers_set_ranges (soup_message_get_request_headers (msg), ranges, 2);
 
 	if (expected_return_ranges == 1) {
 		do_single_range (session, msg,
@@ -194,7 +194,7 @@ request_triple_range (SoupSession *session, const char *uri,
 	ranges[1].end = second_end;
 	ranges[2].start = third_start;
 	ranges[2].end = third_end;
-	soup_message_headers_set_ranges (msg->request_headers, ranges, 3);
+	soup_message_headers_set_ranges (soup_message_get_request_headers (msg), ranges, 3);
 
 	if (expected_return_ranges == 1) {
 		do_single_range (session, msg,
@@ -221,7 +221,7 @@ request_semi_invalid_range (SoupSession *session, const char *uri,
 	ranges[1].end = bad_end;
 	ranges[2].start = second_good_start;
 	ranges[2].end = second_good_end;
-	soup_message_headers_set_ranges (msg->request_headers, ranges, 3);
+	soup_message_headers_set_ranges (soup_message_get_request_headers (msg), ranges, 3);
 
 	do_multi_range (session, msg, 2);
 }
diff --git a/tests/redirect-test.c b/tests/redirect-test.c
index 2c73b800..ee2b6388 100644
--- a/tests/redirect-test.c
+++ b/tests/redirect-test.c
@@ -126,9 +126,9 @@ got_headers (SoupMessage *msg, gpointer user_data)
 	TestRequest **treq = user_data;
 	const char *location;
 
-	debug_printf (2, "    -> %d %s\n", msg->status_code,
-		      msg->reason_phrase);
-	location = soup_message_headers_get_one (msg->response_headers,
+	debug_printf (2, "    -> %d %s\n", soup_message_get_status (msg),
+		      soup_message_get_reason_phrase (msg));
+	location = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 						 "Location");
 	if (location)
 		debug_printf (2, "       Location: %s\n", location);
@@ -145,7 +145,7 @@ restarted (SoupMessage *msg, gpointer user_data)
 	TestRequest **treq = user_data;
 	SoupURI *uri = soup_message_get_uri (msg);
 
-	debug_printf (2, "    %s %s\n", msg->method, uri->path);
+	debug_printf (2, "    %s %s\n", soup_message_get_method (msg), uri->path);
 
 	if ((*treq)->method && !(*treq)->repeat)
 		(*treq)++;
@@ -153,7 +153,7 @@ restarted (SoupMessage *msg, gpointer user_data)
 	soup_test_assert ((*treq)->method,
 			  "Expected to be done");
 
-	g_assert_cmpstr (msg->method, ==, (*treq)->method);
+	g_assert_cmpstr (soup_message_get_method (msg), ==, (*treq)->method);
 	g_assert_cmpstr (uri->path, ==, (*treq)->path);
 }
 
@@ -172,7 +172,7 @@ do_message_api_test (SoupSession *session, TestCase *test)
 	msg = soup_message_new_from_uri (test->requests[0].method, uri);
 	soup_uri_free (uri);
 
-	if (msg->method == SOUP_METHOD_POST) {
+	if (soup_message_get_method (msg) == SOUP_METHOD_POST) {
 		GBytes *request_body;
 
 		request_body = g_bytes_new_static ("post body", strlen ("post body"));
diff --git a/tests/request-body-test.c b/tests/request-body-test.c
index fad90c7f..c27475c6 100644
--- a/tests/request-body-test.c
+++ b/tests/request-body-test.c
@@ -5,6 +5,7 @@
  */
 
 #include "test-utils.h"
+#include "soup-message-private.h"
 
 static SoupSession *session;
 static SoupURI *base_uri;
@@ -74,7 +75,7 @@ restarted (SoupMessage *msg,
         ptd->nwrote = 0;
 
         /* FIXME: The 302 redirect will turn it into a GET request */
-        msg->method = SOUP_METHOD_PUT;
+        soup_message_set_method (msg, SOUP_METHOD_PUT);
 
         if (ptd->stream) {
                 g_object_unref (ptd->stream);
@@ -125,7 +126,7 @@ do_request_test (gconstpointer data)
         soup_test_assert_message_status (msg, SOUP_STATUS_CREATED);
         g_assert_cmpint (g_bytes_get_size (ptd.bytes), ==, ptd.nwrote);
 
-        server_md5 = soup_message_headers_get_one (msg->response_headers,
+        server_md5 = soup_message_headers_get_one (soup_message_get_response_headers (msg),
                                                    "Content-MD5");
         g_assert_cmpstr (client_md5, ==, server_md5);
 
diff --git a/tests/server-test.c b/tests/server-test.c
index 536a32a6..0abaaae7 100644
--- a/tests/server-test.c
+++ b/tests/server-test.c
@@ -140,7 +140,7 @@ do_star_test (ServerData *sd, gconstpointer test_data)
 	soup_test_session_send_message (session, msg);
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_NOT_FOUND);
-	handled_by = soup_message_headers_get_one (msg->response_headers,
+	handled_by = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 						   "X-Handled-By");
 	g_assert_cmpstr (handled_by, ==, NULL);
 	g_object_unref (msg);
@@ -152,7 +152,7 @@ do_star_test (ServerData *sd, gconstpointer test_data)
 	soup_test_session_send_message (session, msg);
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
-	handled_by = soup_message_headers_get_one (msg->response_headers,
+	handled_by = soup_message_headers_get_one (soup_message_get_response_headers (msg),
 						   "X-Handled-By");
 	g_assert_cmpstr (handled_by, ==, "star_callback");
 	g_object_unref (msg);
@@ -945,7 +945,7 @@ do_fail_500_test (ServerData *sd, gconstpointer pause)
 	session = soup_test_session_new (SOUP_TYPE_SESSION, NULL);
 	msg = soup_message_new_from_uri ("GET", sd->base_uri);
 	if (pause)
-		soup_message_headers_append (msg->request_headers, "X-Test-Server-Pause", "true");
+		soup_message_headers_append (soup_message_get_request_headers (msg), "X-Test-Server-Pause", "true");
 	body = soup_test_session_async_send (session, msg);
 	soup_test_assert_message_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
 	g_bytes_unref (body);
@@ -1142,7 +1142,7 @@ do_early_multi_test (ServerData *sd, gconstpointer test_data)
 		else
 			soup_test_assert_message_status (msg, SOUP_STATUS_NOT_FOUND);
 
-		header = soup_message_headers_get_one (msg->response_headers, "X-Early");
+		header = soup_message_headers_get_one (soup_message_get_response_headers (msg), "X-Early");
 		if (multi_tests[i].expect_early)
 			g_assert_cmpstr (header, ==, "yes");
 		else
@@ -1406,7 +1406,7 @@ do_steal_connect_test (ServerData *sd, gconstpointer test_data)
 	soup_test_session_send_message (session, msg);
 
 	soup_test_assert_message_status (msg, SOUP_STATUS_OK);
-	handled_by = soup_message_headers_get_one (msg->response_headers, "X-Handled-By");
+	handled_by = soup_message_headers_get_one (soup_message_get_response_headers (msg), "X-Handled-By");
 	g_assert_cmpstr (handled_by, ==, "server_callback");
 
 	g_object_unref (msg);
diff --git a/tests/ssl-test.c b/tests/ssl-test.c
index 163e2fd9..3be48ea3 100644
--- a/tests/ssl-test.c
+++ b/tests/ssl-test.c
@@ -53,12 +53,12 @@ do_strictness_test (gconstpointer data)
 	g_assert_true (soup_message_get_https_status (msg, NULL, &flags));
 
 	g_test_bug ("665182");
-	if (test->with_ca_list && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
+	if (test->with_ca_list && SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (msg)))
 		g_assert_true (soup_message_get_flags (msg) & SOUP_MESSAGE_CERTIFICATE_TRUSTED);
 	else
 		g_assert_false (soup_message_get_flags (msg) & SOUP_MESSAGE_CERTIFICATE_TRUSTED);
 
-	if (msg->status_code == SOUP_STATUS_SSL_FAILED &&
+	if (soup_message_get_status (msg) == SOUP_STATUS_SSL_FAILED &&
 	    test->expected_status != SOUP_STATUS_SSL_FAILED)
 		debug_printf (1, "              tls error flags: 0x%x\n", flags);
 
diff --git a/tests/test-utils.c b/tests/test-utils.c
index be561861..a0e164d9 100644
--- a/tests/test-utils.c
+++ b/tests/test-utils.c
@@ -366,7 +366,7 @@ soup_test_session_send_message (SoupSession *session,
 	if (stream)
 		g_object_unref (stream);
 
-	return msg->status_code;
+	return soup_message_get_status (msg);
 }
 
 static void
diff --git a/tests/test-utils.h b/tests/test-utils.h
index 496f99a6..6da73e41 100644
--- a/tests/test-utils.h
+++ b/tests/test-utils.h
@@ -114,9 +114,9 @@ G_STMT_START {								\
 	guint _status = (status);					\
 	char *_message;							\
 									\
-	if (G_UNLIKELY (_msg->status_code != _status)) {		\
+	if (G_UNLIKELY (soup_message_get_status (_msg) != _status)) {		\
 		_message = g_strdup_printf ("Unexpected status %d %s (expected %d %s)", \
-					    _msg->status_code, _msg->reason_phrase,     \
+					    soup_message_get_status (_msg), soup_message_get_reason_phrase (_msg),     \
 					    _status, soup_status_get_phrase (_status)); \
 		g_assertion_message (G_LOG_DOMAIN,			\
 				     __FILE__, __LINE__, G_STRFUNC,	\
diff --git a/tests/timeout-test.c b/tests/timeout-test.c
index 8b2bebd4..217a0784 100644
--- a/tests/timeout-test.c
+++ b/tests/timeout-test.c
@@ -41,7 +41,7 @@ do_message_to_session (SoupSession *session, SoupURI *uri,
 #endif
 
 	soup_test_assert_message_status (msg, expected_status);
-	if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
+	if (SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (msg)))
 		g_assert_true (soup_message_is_keepalive (msg));
 	g_assert_true (finished);
 
diff --git a/tests/websocket-test.c b/tests/websocket-test.c
index c3a401ce..f2790b7d 100644
--- a/tests/websocket-test.c
+++ b/tests/websocket-test.c
@@ -655,10 +655,10 @@ test_protocol_negotiate_direct (Test *test,
 						 (char **) negotiate_client_protocols);
 
 	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_method (server_msg, soup_message_get_method (msg));
 	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
 	request_headers = soup_server_message_get_request_headers (server_msg);
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		soup_message_headers_append (request_headers, name, value);
 	ok = soup_websocket_server_check_handshake (server_msg, NULL,
@@ -671,12 +671,12 @@ test_protocol_negotiate_direct (Test *test,
 						      (char **) negotiate_server_protocols);
 	g_assert_true (ok);
 
-	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+        soup_message_set_status (msg, soup_server_message_get_status (server_msg, NULL));
 	response_headers = soup_server_message_get_response_headers (server_msg);
 	soup_message_headers_iter_init (&iter, response_headers);
 	while (soup_message_headers_iter_next (&iter, &name, &value))
-		soup_message_headers_append (msg->response_headers, name, value);
-	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
+		soup_message_headers_append (soup_message_get_response_headers (msg), name, value);
+	protocol = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, negotiated_protocol);
 
 	ok = soup_websocket_client_verify_handshake (msg, &error);
@@ -723,10 +723,10 @@ test_protocol_mismatch_direct (Test *test,
 						 (char **) mismatch_client_protocols);
 
 	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_method (server_msg, soup_message_get_method (msg));
 	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
 	request_headers = soup_server_message_get_request_headers (server_msg);
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		soup_message_headers_append (request_headers, name, value);
 	ok = soup_websocket_server_check_handshake (server_msg, NULL,
@@ -739,14 +739,14 @@ test_protocol_mismatch_direct (Test *test,
 	ok = soup_websocket_server_process_handshake (server_msg, NULL,
 						      (char **) mismatch_server_protocols);
 	g_assert_false (ok);
-	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	soup_message_set_status (msg, soup_server_message_get_status (server_msg, NULL));
 	soup_test_assert_message_status (msg, SOUP_STATUS_BAD_REQUEST);
 
 	response_headers = soup_server_message_get_response_headers (server_msg);
 	soup_message_headers_iter_init (&iter, response_headers);
 	while (soup_message_headers_iter_next (&iter, &name, &value))
-		soup_message_headers_append (msg->response_headers, name, value);
-	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
+		soup_message_headers_append (soup_message_get_response_headers (msg), name, value);
+	protocol = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, NULL);
 
 	ok = soup_websocket_client_verify_handshake (msg, &error);
@@ -789,10 +789,10 @@ test_protocol_server_any_direct (Test *test,
 	soup_websocket_client_prepare_handshake (msg, NULL, (char **) all_protocols);
 
 	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_method (server_msg, soup_message_get_method (msg));
 	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
 	request_headers = soup_server_message_get_request_headers (server_msg);
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		soup_message_headers_append (request_headers, name, value);
 	ok = soup_websocket_server_check_handshake (server_msg, NULL, NULL, &error);
@@ -802,12 +802,12 @@ test_protocol_server_any_direct (Test *test,
 	ok = soup_websocket_server_process_handshake (server_msg, NULL, NULL);
 	g_assert_true (ok);
 
-	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+        soup_message_set_status (msg, soup_server_message_get_status (server_msg, NULL));
 	response_headers = soup_server_message_get_response_headers (server_msg);
 	soup_message_headers_iter_init (&iter, response_headers);
 	while (soup_message_headers_iter_next (&iter, &name, &value))
-		soup_message_headers_append (msg->response_headers, name, value);
-	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
+		soup_message_headers_append (soup_message_get_response_headers (msg), name, value);
+	protocol = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, NULL);
 
 	ok = soup_websocket_client_verify_handshake (msg, &error);
@@ -830,7 +830,7 @@ test_protocol_server_any_soup (Test *test,
 
 	g_assert_cmpstr (soup_websocket_connection_get_protocol (test->client), ==, NULL);
 	g_assert_cmpstr (soup_websocket_connection_get_protocol (test->server), ==, NULL);
-	g_assert_cmpstr (soup_message_headers_get_one (test->msg->response_headers, "Sec-WebSocket-Protocol"), ==, NULL);
+	g_assert_cmpstr (soup_message_headers_get_one (soup_message_get_response_headers (test->msg), "Sec-WebSocket-Protocol"), ==, NULL);
 }
 
 static void
@@ -851,10 +851,10 @@ test_protocol_client_any_direct (Test *test,
 	soup_websocket_client_prepare_handshake (msg, NULL, NULL);
 
 	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_method (server_msg, soup_message_get_method (msg));
 	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
 	request_headers = soup_server_message_get_request_headers (server_msg);
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		soup_message_headers_append (request_headers, name, value);
 	ok = soup_websocket_server_check_handshake (server_msg, NULL, (char **) all_protocols, &error);
@@ -864,12 +864,12 @@ test_protocol_client_any_direct (Test *test,
 	ok = soup_websocket_server_process_handshake (server_msg, NULL, (char **) all_protocols);
 	g_assert_true (ok);
 
-	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	soup_message_set_status (msg, soup_server_message_get_status (server_msg, NULL));
 	response_headers = soup_server_message_get_response_headers (server_msg);
 	soup_message_headers_iter_init (&iter, response_headers);
 	while (soup_message_headers_iter_next (&iter, &name, &value))
-		soup_message_headers_append (msg->response_headers, name, value);
-	protocol = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Protocol");
+		soup_message_headers_append (soup_message_get_response_headers (msg), name, value);
+	protocol = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Protocol");
 	g_assert_cmpstr (protocol, ==, NULL);
 
 	ok = soup_websocket_client_verify_handshake (msg, &error);
@@ -892,7 +892,7 @@ test_protocol_client_any_soup (Test *test,
 
 	g_assert_cmpstr (soup_websocket_connection_get_protocol (test->client), ==, NULL);
 	g_assert_cmpstr (soup_websocket_connection_get_protocol (test->server), ==, NULL);
-	g_assert_cmpstr (soup_message_headers_get_one (test->msg->response_headers, "Sec-WebSocket-Protocol"), ==, NULL);
+	g_assert_cmpstr (soup_message_headers_get_one (soup_message_get_response_headers (test->msg), "Sec-WebSocket-Protocol"), ==, NULL);
 }
 
 static const struct {
@@ -1696,13 +1696,13 @@ test_deflate_negotiate_direct (Test *test,
 		msg = soup_message_new ("GET", "http://127.0.0.1");
 
 		soup_websocket_client_prepare_handshake (msg, NULL, NULL);
-		soup_message_headers_append (msg->request_headers, "Sec-WebSocket-Extensions", deflate_negotiate_tests[i].client_extension);
+		soup_message_headers_append (soup_message_get_request_headers (msg), "Sec-WebSocket-Extensions", deflate_negotiate_tests[i].client_extension);
 
 		server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-		soup_server_message_set_method (server_msg, msg->method);
+		soup_server_message_set_method (server_msg, soup_message_get_method (msg));
 		soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
 		request_headers = soup_server_message_get_request_headers (server_msg);
-		soup_message_headers_iter_init (&iter, msg->request_headers);
+		soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 		while (soup_message_headers_iter_next (&iter, &name, &value))
 			soup_message_headers_append (request_headers, name, value);
 		result = soup_websocket_server_check_handshake_with_extensions (server_msg, NULL, NULL,
@@ -1723,15 +1723,15 @@ test_deflate_negotiate_direct (Test *test,
 										  &accepted_extensions);
 		g_assert (result == deflate_negotiate_tests[i].expected_check_result);
 
-		msg->status_code = soup_server_message_get_status (server_msg, NULL);
+		soup_message_set_status (msg, soup_server_message_get_status (server_msg, NULL));
 		response_headers = soup_server_message_get_response_headers (server_msg);
 		soup_message_headers_iter_init (&iter, response_headers);
                 while (soup_message_headers_iter_next (&iter, &name, &value))
-                        soup_message_headers_append (msg->response_headers, name, value);
+                        soup_message_headers_append (soup_message_get_response_headers (msg), name, value);
 		if (deflate_negotiate_tests[i].expected_accepted_extension) {
 			const char *extension;
 
-			extension = soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Extensions");
+			extension = soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Extensions");
 			g_assert_cmpstr (extension, ==, deflate_negotiate_tests[i].server_extension);
 			g_assert_nonnull (accepted_extensions);
 			g_assert_cmpuint (g_list_length (accepted_extensions), ==, 1);
@@ -1787,13 +1787,13 @@ test_deflate_disabled_in_message_direct (Test *test,
 	msg = soup_message_new ("GET", "http://127.0.0.1");
 	soup_message_disable_feature (msg, SOUP_TYPE_WEBSOCKET_EXTENSION_DEFLATE);
 	soup_websocket_client_prepare_handshake_with_extensions (msg, NULL, NULL, supported_extensions);
-	g_assert_cmpstr (soup_message_headers_get_one (msg->request_headers, "Sec-WebSocket-Extensions"), ==, NULL);
+	g_assert_cmpstr (soup_message_headers_get_one (soup_message_get_request_headers (msg), "Sec-WebSocket-Extensions"), ==, NULL);
 
 	server_msg = g_object_new (SOUP_TYPE_SERVER_MESSAGE, NULL);
-	soup_server_message_set_method (server_msg, msg->method);
+	soup_server_message_set_method (server_msg, soup_message_get_method (msg));
 	soup_server_message_set_uri (server_msg, soup_message_get_uri (msg));
 	request_headers = soup_server_message_get_request_headers (server_msg);
-	soup_message_headers_iter_init (&iter, msg->request_headers);
+	soup_message_headers_iter_init (&iter, soup_message_get_request_headers (msg));
 	while (soup_message_headers_iter_next (&iter, &name, &value))
 		soup_message_headers_append (request_headers, name, value);
 
@@ -1802,12 +1802,12 @@ test_deflate_disabled_in_message_direct (Test *test,
 
 	g_assert_true (soup_websocket_server_process_handshake_with_extensions (server_msg, NULL, NULL, supported_extensions, &accepted_extensions));
 	g_assert_null (accepted_extensions);
-	msg->status_code = soup_server_message_get_status (server_msg, NULL);
+	soup_message_set_status (msg, soup_server_message_get_status (server_msg, NULL));
 	response_headers = soup_server_message_get_response_headers (server_msg);
 	soup_message_headers_iter_init (&iter, response_headers);
 	while (soup_message_headers_iter_next (&iter, &name, &value))
-		soup_message_headers_append (msg->response_headers, name, value);
-	g_assert_cmpstr (soup_message_headers_get_one (msg->response_headers, "Sec-WebSocket-Extensions"), ==, NULL);
+		soup_message_headers_append (soup_message_get_response_headers (msg), name, value);
+	g_assert_cmpstr (soup_message_headers_get_one (soup_message_get_response_headers (msg), "Sec-WebSocket-Extensions"), ==, NULL);
 
 	g_assert_true (soup_websocket_client_verify_handshake_with_extensions (msg, supported_extensions, &accepted_extensions, &error));
 	g_assert_no_error (error);
@@ -1830,8 +1830,8 @@ test_deflate_disabled_in_message_soup (Test *test,
 	WAIT_UNTIL (test->client != NULL || test->client_error != NULL);
 	g_assert_no_error (test->client_error);
 
-	g_assert_cmpstr (soup_message_headers_get_one (test->msg->request_headers, "Sec-WebSocket-Extensions"), ==, NULL);
-	g_assert_cmpstr (soup_message_headers_get_one (test->msg->response_headers, "Sec-WebSocket-Extensions"), ==, NULL);
+	g_assert_cmpstr (soup_message_headers_get_one (soup_message_get_request_headers (test->msg), "Sec-WebSocket-Extensions"), ==, NULL);
+	g_assert_cmpstr (soup_message_headers_get_one (soup_message_get_response_headers (test->msg), "Sec-WebSocket-Extensions"), ==, NULL);
 }
 
 static gpointer
@@ -1933,7 +1933,7 @@ test_cookies_in_request (Test *test,
         WAIT_UNTIL (test->client != NULL || test->client_error != NULL);
         g_assert_no_error (test->client_error);
 
-        cookie_header = soup_message_headers_get_one (test->msg->request_headers, "Cookie");
+        cookie_header = soup_message_headers_get_one (soup_message_get_request_headers (test->msg), "Cookie");
         requested_cookie = soup_cookie_parse (cookie_header, NULL);
         g_assert_true (soup_cookie_equal (cookie, requested_cookie));
         soup_cookie_free (cookie);