[libgdata/libgdata-0-10] core: Don't use deprecated GLib threading API if we have a recent GLib

[Philip Withnall <pwithnall src gnome org>]

commit 9e2f968340d243d4ffb65e1d36f087fee8005bfe
Author: Philip Withnall <philip tecnocode co uk>
Date:   Tue Dec 20 21:53:23 2011 +0000

    core: Don't use deprecated GLib threading API if we have a recent GLib
    
    If we have GLib â 2.31.0, use the new threading/mutex/condition variable API
    to avoid deprecated function warnings.
    
    Note that this doesn't bump our GLib dependency from 2.30.0; if a recent
    enough GLib is not available, libgdata should still compile with the old
    threading API.
    
    Conflicts:
    
    	gdata/gdata-client-login-authorizer.c

 gdata/gdata-buffer.c                  |   61 ++++++++++-
 gdata/gdata-buffer.h                  |    5 +
 gdata/gdata-client-login-authorizer.c |   68 +++++++++++
 gdata/gdata-download-stream.c         |  103 +++++++++++++++++-
 gdata/gdata-oauth1-authorizer.c       |   43 +++++++
 gdata/gdata-service.c                 |   29 +++++-
 gdata/gdata-upload-stream.c           |  200 ++++++++++++++++++++++++++++++++-
 gdata/tests/common.c                  |    2 +
 gdata/tests/memory.c                  |    2 +
 gdata/tests/perf.c                    |    2 +
 gdata/tests/streams.c                 |   37 ++++---
 11 files changed, 531 insertions(+), 21 deletions(-)
---
diff --git a/gdata/gdata-buffer.c b/gdata/gdata-buffer.c
index 3175dde..d0292df 100644
--- a/gdata/gdata-buffer.c
+++ b/gdata/gdata-buffer.c
@@ -55,8 +55,14 @@ GDataBuffer *
 gdata_buffer_new (void)
 {
 	GDataBuffer *buffer = g_slice_new0 (GDataBuffer);
+
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_init (&(buffer->mutex));
+	g_cond_init (&(buffer->cond));
+#else
 	g_static_mutex_init (&(buffer->mutex));
 	buffer->cond = g_cond_new ();
+#endif
 
 	return buffer;
 }
@@ -82,8 +88,14 @@ gdata_buffer_free (GDataBuffer *self)
 		g_free (chunk);
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_cond_clear (&(self->cond));
+	g_mutex_clear (&(self->mutex));
+#else
 	g_cond_free (self->cond);
 	g_static_mutex_free (&(self->mutex));
+#endif
+
 	g_slice_free (GDataBuffer, self);
 }
 
@@ -113,18 +125,31 @@ gdata_buffer_push_data (GDataBuffer *self, const guint8 *data, gsize length)
 
 	g_return_val_if_fail (self != NULL, 0);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->mutex));
+#else
 	g_static_mutex_lock (&(self->mutex));
+#endif
 
 	if (G_UNLIKELY (self->reached_eof == TRUE)) {
 		/* If we're marked as having reached EOF, don't accept any more data */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_unlock (&(self->mutex));
+#else
 		g_static_mutex_unlock (&(self->mutex));
+#endif
 		return FALSE;
 	} else if (G_UNLIKELY (data == NULL && length == 0)) {
 		/* If @data is NULL and @length is 0, mark the buffer as having reached EOF,
 		 * and signal any waiting threads. */
 		self->reached_eof = TRUE;
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_cond_signal (&(self->cond));
+		g_mutex_unlock (&(self->mutex));
+#else
 		g_cond_signal (self->cond);
 		g_static_mutex_unlock (&(self->mutex));
+#endif
 		return FALSE;
 	}
 
@@ -147,9 +172,15 @@ gdata_buffer_push_data (GDataBuffer *self, const guint8 *data, gsize length)
 	self->total_length += length;
 
 	/* Signal any threads waiting to pop that data is available */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_cond_signal (&(self->cond));
+
+	g_mutex_unlock (&(self->mutex));
+#else
 	g_cond_signal (self->cond);
 
 	g_static_mutex_unlock (&(self->mutex));
+#endif
 
 	return TRUE;
 }
@@ -163,10 +194,17 @@ static void
 pop_cancelled_cb (GCancellable *cancellable, CancelledData *data)
 {
 	/* Signal the pop_data function that it should stop blocking and cancel */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(data->buffer->mutex));
+	*(data->cancelled) = TRUE;
+	g_cond_signal (&(data->buffer->cond));
+	g_mutex_unlock (&(data->buffer->mutex));
+#else
 	g_static_mutex_lock (&(data->buffer->mutex));
 	*(data->cancelled) = TRUE;
 	g_cond_signal (data->buffer->cond);
 	g_static_mutex_unlock (&(data->buffer->mutex));
+#endif
 }
 
 /**
@@ -227,7 +265,11 @@ gdata_buffer_pop_data (GDataBuffer *self, guint8 *data, gsize length_requested,
 		cancelled_signal = g_cancellable_connect (cancellable, (GCallback) pop_cancelled_cb, &cancelled_data, NULL);
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->mutex));
+#else
 	g_static_mutex_lock (&(self->mutex));
+#endif
 
 	/* Set reached_eof */
 	if (reached_eof != NULL)
@@ -240,8 +282,13 @@ gdata_buffer_pop_data (GDataBuffer *self, guint8 *data, gsize length_requested,
 		/* Block until more data is available */
 		while (length_requested > self->total_length) {
 			/* If we've already been cancelled, don't wait on @self->cond, since it'll never be signalled again. */
-			if (cancelled == FALSE)
+			if (cancelled == FALSE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+				g_cond_wait (&(self->cond), &(self->mutex));
+#else
 				g_cond_wait (self->cond, g_static_mutex_get_mutex (&(self->mutex)));
+#endif
+			}
 
 			/* If the g_cond_wait() returned because it was signalled from the GCancellable callback (rather than from
 			 * data being pushed into the buffer), stop blocking for data and make do with what we have so far. */
@@ -303,7 +350,11 @@ gdata_buffer_pop_data (GDataBuffer *self, guint8 *data, gsize length_requested,
 	self->total_length -= return_length;
 
 done:
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(self->mutex));
+#else
 	g_static_mutex_unlock (&(self->mutex));
+#endif
 
 	/* Disconnect from the cancelled signal. Note that this has to be done without @self->mutex held, or deadlock can occur.
 	 * (g_cancellable_disconnect() waits for any in-progress signal handler call to finish, which can't happen until the mutex is released.) */
@@ -337,10 +388,18 @@ gdata_buffer_pop_data_limited (GDataBuffer *self, guint8 *data, gsize maximum_le
 	g_return_val_if_fail (maximum_length > 0, 0);
 
 	/* If there's no data in the buffer, block until some is available */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->mutex));
+	if (self->total_length == 0 && self->reached_eof == FALSE) {
+		g_cond_wait (&(self->cond), &(self->mutex));
+	}
+	g_mutex_unlock (&(self->mutex));
+#else
 	g_static_mutex_lock (&(self->mutex));
 	if (self->total_length == 0 && self->reached_eof == FALSE)
 		g_cond_wait (self->cond, g_static_mutex_get_mutex (&(self->mutex)));
 	g_static_mutex_unlock (&(self->mutex));
+#endif
 
 	return gdata_buffer_pop_data (self, data, MIN (maximum_length, self->total_length), reached_eof, NULL);
 }
diff --git a/gdata/gdata-buffer.h b/gdata/gdata-buffer.h
index 306fae5..63299fc 100644
--- a/gdata/gdata-buffer.h
+++ b/gdata/gdata-buffer.h
@@ -43,8 +43,13 @@ typedef struct {
 	gboolean reached_eof; /* set to TRUE only once we've reached EOF */
 	GDataBufferChunk **tail; /* pointer to the GDataBufferChunk->next field of the current tail chunk */
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GMutex mutex; /* mutex protecting the entire structure on push and pop */
+	GCond cond; /* a GCond to allow a popping thread to block on data being pushed into the buffer */
+#else
 	GStaticMutex mutex; /* mutex protecting the entire structure on push and pop */
 	GCond *cond; /* a GCond to allow a popping thread to block on data being pushed into the buffer */
+#endif
 } GDataBuffer;
 
 GDataBuffer *gdata_buffer_new (void) G_GNUC_WARN_UNUSED_RESULT G_GNUC_MALLOC;
diff --git a/gdata/gdata-client-login-authorizer.c b/gdata/gdata-client-login-authorizer.c
index 7120b98..8944b99 100644
--- a/gdata/gdata-client-login-authorizer.c
+++ b/gdata/gdata-client-login-authorizer.c
@@ -127,7 +127,11 @@ struct _GDataClientLoginAuthorizerPrivate {
 	/* Mutex for username, password and auth_tokens. It has to be recursive as the top-level authentication functions need to hold a lock on
 	 * auth_tokens while looping over it, but lower-level functions also need to modify auth_tokens to add the auth_tokens themselves once they're
 	 * returned by the online service. */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GRecMutex mutex;
+#else
 	GStaticRecMutex mutex;
+#endif
 
 	gchar *username;
 	gchar *password;
@@ -280,7 +284,11 @@ gdata_client_login_authorizer_init (GDataClientLoginAuthorizer *self)
 	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GDATA_TYPE_CLIENT_LOGIN_AUTHORIZER, GDataClientLoginAuthorizerPrivate);
 
 	/* Set up the authentication mutex */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_init (&(self->priv->mutex));
+#else
 	g_static_rec_mutex_init (&(self->priv->mutex));
+#endif
 	self->priv->auth_tokens = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, g_free);
 
 	/* Set up the session */
@@ -314,7 +322,11 @@ finalize (GObject *object)
 	g_free (priv->password);
 	g_free (priv->client_id);
 	g_hash_table_destroy (priv->auth_tokens);
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_clear (&(priv->mutex));
+#else
 	g_static_rec_mutex_free (&(priv->mutex));
+#endif
 
 	if (priv->proxy_uri != NULL) {
 		soup_uri_free (priv->proxy_uri);
@@ -334,14 +346,26 @@ get_property (GObject *object, guint property_id, GValue *value, GParamSpec *psp
 			g_value_set_string (value, priv->client_id);
 			break;
 		case PROP_USERNAME:
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_rec_mutex_lock (&(priv->mutex));
+			g_value_set_string (value, priv->username);
+			g_rec_mutex_unlock (&(priv->mutex));
+#else
 			g_static_rec_mutex_lock (&(priv->mutex));
 			g_value_set_string (value, priv->username);
 			g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 			break;
 		case PROP_PASSWORD:
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_rec_mutex_lock (&(priv->mutex));
+			g_value_set_string (value, priv->password);
+			g_rec_mutex_unlock (&(priv->mutex));
+#else
 			g_static_rec_mutex_lock (&(priv->mutex));
 			g_value_set_string (value, priv->password);
 			g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 			break;
 		case PROP_PROXY_URI:
 			g_value_set_boxed (value, gdata_client_login_authorizer_get_proxy_uri (GDATA_CLIENT_LOGIN_AUTHORIZER (object)));
@@ -390,7 +414,11 @@ process_request (GDataAuthorizer *self, GDataAuthorizationDomain *domain, SoupMe
 	}
 
 	/* Set the authorisation header */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_lock (&(priv->mutex));
+#else
 	g_static_rec_mutex_lock (&(priv->mutex));
+#endif
 
 	auth_token = (const gchar*) g_hash_table_lookup (priv->auth_tokens, domain);
 
@@ -406,7 +434,11 @@ process_request (GDataAuthorizer *self, GDataAuthorizationDomain *domain, SoupMe
 		}
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_unlock (&(priv->mutex));
+#else
 	g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 }
 
 static gboolean
@@ -415,9 +447,15 @@ is_authorized_for_domain (GDataAuthorizer *self, GDataAuthorizationDomain *domai
 	GDataClientLoginAuthorizerPrivate *priv = GDATA_CLIENT_LOGIN_AUTHORIZER (self)->priv;
 	gpointer result;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_lock (&(priv->mutex));
+	result = g_hash_table_lookup (priv->auth_tokens, domain);
+	g_rec_mutex_unlock (&(priv->mutex));
+#else
 	g_static_rec_mutex_lock (&(priv->mutex));
 	result = g_hash_table_lookup (priv->auth_tokens, domain);
 	g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 
 	return (result != NULL) ? TRUE : FALSE;
 }
@@ -512,7 +550,11 @@ set_authentication_details (GDataClientLoginAuthorizer *self, const gchar *usern
 {
 	GDataClientLoginAuthorizerPrivate *priv = self->priv;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_lock (&(priv->mutex));
+#else
 	g_static_rec_mutex_lock (&(priv->mutex));
+#endif
 
 	/* Ensure the username is always a full e-mail address */
 	g_free (priv->username);
@@ -525,7 +567,11 @@ set_authentication_details (GDataClientLoginAuthorizer *self, const gchar *usern
 	g_free (priv->password);
 	priv->password = g_strdup (password);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_unlock (&(priv->mutex));
+#else
 	g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 
 	/* Notify of the property changes in the main thread; i.e. if we're running an async operation, schedule the notification in an idle
 	 * callback; but if we're running a sync operation, emit them immediately.
@@ -564,9 +610,15 @@ parse_authentication_response (GDataClientLoginAuthorizer *self, GDataAuthorizat
 		goto protocol_error;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_lock (&(priv->mutex));
+	g_hash_table_insert (priv->auth_tokens, g_object_ref (domain), auth_token);
+	g_rec_mutex_unlock (&(priv->mutex));
+#else
 	g_static_rec_mutex_lock (&(priv->mutex));
 	g_hash_table_insert (priv->auth_tokens, g_object_ref (domain), auth_token);
 	g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 
 	return TRUE;
 
@@ -876,7 +928,11 @@ authenticate_thread (GSimpleAsyncResult *result, GDataClientLoginAuthorizer *aut
 	GDataAuthorizationDomain *domain;
 	AuthenticateAsyncData *data = g_simple_async_result_get_op_res_gpointer (result);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_lock (&(priv->mutex));
+#else
 	g_static_rec_mutex_lock (&(priv->mutex));
+#endif
 
 	/* Authenticate and authorize against each of the services registered with the authorizer */
 	g_hash_table_iter_init (&iter, priv->auth_tokens);
@@ -895,7 +951,11 @@ authenticate_thread (GSimpleAsyncResult *result, GDataClientLoginAuthorizer *aut
 		g_clear_error (&authenticate_error);
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_unlock (&(priv->mutex));
+#else
 	g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 
 	/* Set or clear the authentication details and return now that we're done */
 	if (success == TRUE) {
@@ -1029,7 +1089,11 @@ gdata_client_login_authorizer_authenticate (GDataClientLoginAuthorizer *self, co
 
 	priv = self->priv;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_lock (&(priv->mutex));
+#else
 	g_static_rec_mutex_lock (&(priv->mutex));
+#endif
 
 	/* Authenticate and authorize against each of the services registered with the authorizer */
 	g_hash_table_iter_init (&iter, self->priv->auth_tokens);
@@ -1038,7 +1102,11 @@ gdata_client_login_authorizer_authenticate (GDataClientLoginAuthorizer *self, co
 		retval = authenticate (self, domain, username, password, NULL, NULL, cancellable, error) && retval;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_rec_mutex_unlock (&(priv->mutex));
+#else
 	g_static_rec_mutex_unlock (&(priv->mutex));
+#endif
 
 	/* Set or clear the authentication details */
 	if (retval == TRUE) {
diff --git a/gdata/gdata-download-stream.c b/gdata/gdata-download-stream.c
index ac14a85..a509e90 100644
--- a/gdata/gdata-download-stream.c
+++ b/gdata/gdata-download-stream.c
@@ -162,13 +162,22 @@ struct _GDataDownloadStreamPrivate {
 	GCancellable *network_cancellable; /* see the comment in gdata_download_stream_constructor() about the relationship between these two */
 
 	gboolean finished;
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GCond finished_cond;
+	GMutex finished_mutex; /* mutex for ->finished, protected by ->finished_cond */
+#else
 	GCond *finished_cond;
 	GStaticMutex finished_mutex; /* mutex for ->finished, protected by ->finished_cond */
+#endif
 
 	/* Cached data from the SoupMessage */
 	gchar *content_type;
 	gssize content_length;
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GMutex content_mutex; /* mutex to protect them */
+#else
 	GStaticMutex content_mutex; /* mutex to protect them */
+#endif
 };
 
 enum {
@@ -317,12 +326,21 @@ gdata_download_stream_init (GDataDownloadStream *self)
 	self->priv->buffer = NULL; /* created when the network thread is started and destroyed when the stream is closed */
 
 	self->priv->finished = FALSE;
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_cond_init (&(self->priv->finished_cond));
+	g_mutex_init (&(self->priv->finished_mutex));
+#else
 	self->priv->finished_cond = g_cond_new ();
 	g_static_mutex_init (&(self->priv->finished_mutex));
+#endif
 
 	self->priv->content_type = NULL;
 	self->priv->content_length = -1;
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_init (&(self->priv->content_mutex));
+#else
 	g_static_mutex_init (&(self->priv->content_mutex));
+#endif
 }
 
 static void
@@ -409,10 +427,17 @@ gdata_download_stream_finalize (GObject *object)
 
 	reset_network_thread (GDATA_DOWNLOAD_STREAM (object));
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_cond_clear (&(priv->finished_cond));
+	g_mutex_clear (&(priv->finished_mutex));
+
+	g_mutex_clear (&(priv->content_mutex));
+#else
 	g_cond_free (priv->finished_cond);
 	g_static_mutex_free (&(priv->finished_mutex));
 
 	g_static_mutex_free (&(priv->content_mutex));
+#endif
 
 	g_free (priv->download_uri);
 	g_free (priv->content_type);
@@ -437,14 +462,26 @@ gdata_download_stream_get_property (GObject *object, guint property_id, GValue *
 			g_value_set_string (value, priv->download_uri);
 			break;
 		case PROP_CONTENT_TYPE:
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_mutex_lock (&(priv->content_mutex));
+			g_value_set_string (value, priv->content_type);
+			g_mutex_unlock (&(priv->content_mutex));
+#else
 			g_static_mutex_lock (&(priv->content_mutex));
 			g_value_set_string (value, priv->content_type);
 			g_static_mutex_unlock (&(priv->content_mutex));
+#endif
 			break;
 		case PROP_CONTENT_LENGTH:
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_mutex_lock (&(priv->content_mutex));
+			g_value_set_long (value, priv->content_length);
+			g_mutex_unlock (&(priv->content_mutex));
+#else
 			g_static_mutex_lock (&(priv->content_mutex));
 			g_value_set_long (value, priv->content_length);
 			g_static_mutex_unlock (&(priv->content_mutex));
+#endif
 			break;
 		case PROP_CANCELLABLE:
 			g_value_set_object (value, priv->cancellable);
@@ -580,10 +617,17 @@ close_cancelled_cb (GCancellable *cancellable, CancelledData *data)
 {
 	GDataDownloadStreamPrivate *priv = data->download_stream->priv;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->finished_mutex));
+	*(data->cancelled) = TRUE;
+	g_cond_signal (&(priv->finished_cond));
+	g_mutex_unlock (&(priv->finished_mutex));
+#else
 	g_static_mutex_lock (&(priv->finished_mutex));
 	*(data->cancelled) = TRUE;
 	g_cond_signal (priv->finished_cond);
 	g_static_mutex_unlock (&(priv->finished_mutex));
+#endif
 }
 
 /* Even though calling g_input_stream_close() multiple times on this stream is guaranteed to call gdata_download_stream_close() at most once, other
@@ -623,7 +667,11 @@ gdata_download_stream_close (GInputStream *stream, GCancellable *cancellable, GE
 	if (cancellable != NULL)
 		cancelled_signal = g_cancellable_connect (cancellable, (GCallback) close_cancelled_cb, &data, NULL);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->finished_mutex));
+#else
 	g_static_mutex_lock (&(priv->finished_mutex));
+#endif
 
 	/* If the operation has started but hasn't already finished, cancel the network thread and wait for it to finish before returning */
 	if (priv->finished == FALSE) {
@@ -631,8 +679,13 @@ gdata_download_stream_close (GInputStream *stream, GCancellable *cancellable, GE
 
 		/* Allow the close() call to be cancelled by cancelling either @cancellable or ->cancellable. Note that this won't prevent the stream
 		 * from continuing to be closed in the background â it'll just stop waiting on the operation to finish being cancelled. */
-		if (cancelled == FALSE)
+		if (cancelled == FALSE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_cond_wait (&(priv->finished_cond), &(priv->finished_mutex));
+#else
 			g_cond_wait (priv->finished_cond, g_static_mutex_get_mutex (&(priv->finished_mutex)));
+#endif
+		}
 	}
 
 	/* Error handling */
@@ -644,7 +697,11 @@ gdata_download_stream_close (GInputStream *stream, GCancellable *cancellable, GE
 		success = FALSE;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->finished_mutex));
+#else
 	g_static_mutex_unlock (&(priv->finished_mutex));
+#endif
 
 	/* Disconnect from the signal handlers. Note that we have to do this without @finished_mutex held, as g_cancellable_disconnect() blocks
 	 * until any outstanding cancellation callbacks return, and they will block on @finished_mutex. */
@@ -655,13 +712,21 @@ gdata_download_stream_close (GInputStream *stream, GCancellable *cancellable, GE
 
 done:
 	/* If we were successful, tidy up various bits of state */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->finished_mutex));
+#else
 	g_static_mutex_lock (&(priv->finished_mutex));
+#endif
 
 	if (success == TRUE && priv->finished == TRUE) {
 		reset_network_thread (GDATA_DOWNLOAD_STREAM (stream));
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->finished_mutex));
+#else
 	g_static_mutex_unlock (&(priv->finished_mutex));
+#endif
 
 	g_assert ((success == TRUE && child_error == NULL) || (success == FALSE && child_error != NULL));
 
@@ -769,9 +834,15 @@ gdata_download_stream_seek (GSeekable *seekable, goffset offset, GSeekType type,
 		priv->offset = offset;
 
 		/* Mark the thread as unfinished */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_lock (&(priv->finished_mutex));
+		priv->finished = FALSE;
+		g_mutex_unlock (&(priv->finished_mutex));
+#else
 		g_static_mutex_lock (&(priv->finished_mutex));
 		priv->finished = FALSE;
 		g_static_mutex_unlock (&(priv->finished_mutex));
+#endif
 
 		goto done;
 	}
@@ -808,10 +879,17 @@ got_headers_cb (SoupMessage *message, GDataDownloadStream *self)
 	if (SOUP_STATUS_IS_SUCCESSFUL (message->status_code) == FALSE)
 		return;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->priv->content_mutex));
+	self->priv->content_type = g_strdup (soup_message_headers_get_content_type (message->response_headers, NULL));
+	self->priv->content_length = soup_message_headers_get_content_length (message->response_headers);
+	g_mutex_unlock (&(self->priv->content_mutex));
+#else
 	g_static_mutex_lock (&(self->priv->content_mutex));
 	self->priv->content_type = g_strdup (soup_message_headers_get_content_type (message->response_headers, NULL));
 	self->priv->content_length = soup_message_headers_get_content_length (message->response_headers);
 	g_static_mutex_unlock (&(self->priv->content_mutex));
+#endif
 
 	/* Emit the notifications for the Content-Length and -Type properties */
 	g_object_freeze_notify (G_OBJECT (self));
@@ -859,10 +937,17 @@ download_thread (GDataDownloadStream *self)
 	gdata_buffer_push_data (priv->buffer, NULL, 0);
 
 	/* Mark the download as finished */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->finished_mutex));
+	priv->finished = TRUE;
+	g_cond_signal (&(priv->finished_cond));
+	g_mutex_unlock (&(priv->finished_mutex));
+#else
 	g_static_mutex_lock (&(priv->finished_mutex));
 	priv->finished = TRUE;
 	g_cond_signal (priv->finished_cond);
 	g_static_mutex_unlock (&(priv->finished_mutex));
+#endif
 
 	g_object_unref (self);
 
@@ -878,7 +963,11 @@ create_network_thread (GDataDownloadStream *self, GError **error)
 	priv->buffer = gdata_buffer_new ();
 
 	g_assert (priv->network_thread == NULL);
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	priv->network_thread = g_thread_try_new ("download-thread", (GThreadFunc) download_thread, self, error);
+#else
 	priv->network_thread = g_thread_create ((GThreadFunc) download_thread, self, TRUE, error);
+#endif
 }
 
 static void
@@ -1012,9 +1101,15 @@ gdata_download_stream_get_content_type (GDataDownloadStream *self)
 
 	g_return_val_if_fail (GDATA_IS_DOWNLOAD_STREAM (self), NULL);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->priv->content_mutex));
+	content_type = self->priv->content_type;
+	g_mutex_unlock (&(self->priv->content_mutex));
+#else
 	g_static_mutex_lock (&(self->priv->content_mutex));
 	content_type = self->priv->content_type;
 	g_static_mutex_unlock (&(self->priv->content_mutex));
+#endif
 
 	/* It's safe to return this, even though we're not taking a copy of it, as it's immutable once set. */
 	return content_type;
@@ -1038,9 +1133,15 @@ gdata_download_stream_get_content_length (GDataDownloadStream *self)
 
 	g_return_val_if_fail (GDATA_IS_DOWNLOAD_STREAM (self), -1);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->priv->content_mutex));
+	content_length = self->priv->content_length;
+	g_mutex_unlock (&(self->priv->content_mutex));
+#else
 	g_static_mutex_lock (&(self->priv->content_mutex));
 	content_length = self->priv->content_length;
 	g_static_mutex_unlock (&(self->priv->content_mutex));
+#endif
 
 	g_assert (content_length >= -1);
 
diff --git a/gdata/gdata-oauth1-authorizer.c b/gdata/gdata-oauth1-authorizer.c
index bce48b7..b4820b1 100644
--- a/gdata/gdata-oauth1-authorizer.c
+++ b/gdata/gdata-oauth1-authorizer.c
@@ -161,7 +161,11 @@ struct _GDataOAuth1AuthorizerPrivate {
 	gchar *application_name;
 	gchar *locale;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GMutex mutex; /* mutex for token, token_secret and authorization_domains */
+#else
 	GStaticMutex mutex; /* mutex for token, token_secret and authorization_domains */
+#endif
 
 	/* Note: This is the access token, not the request token returned by gdata_oauth1_authorizer_request_authentication_uri().
 	 * It's NULL iff the authorizer isn't authenticated. token_secret must be NULL iff token is NULL. */
@@ -273,7 +277,11 @@ gdata_oauth1_authorizer_init (GDataOAuth1Authorizer *self)
 	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GDATA_TYPE_OAUTH1_AUTHORIZER, GDataOAuth1AuthorizerPrivate);
 
 	/* Set up the authorizer's mutex */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_init (&(self->priv->mutex));
+#else
 	g_static_mutex_init (&(self->priv->mutex));
+#endif
 	self->priv->authorization_domains = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL);
 
 	/* Set up the session */
@@ -306,7 +314,11 @@ finalize (GObject *object)
 	g_free (priv->locale);
 
 	g_hash_table_destroy (priv->authorization_domains);
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_clear (&(priv->mutex));
+#else
 	g_static_mutex_free (&(priv->mutex));
+#endif
 
 	if (priv->proxy_uri != NULL) {
 		soup_uri_free (priv->proxy_uri);
@@ -380,7 +392,11 @@ process_request (GDataAuthorizer *self, GDataAuthorizationDomain *domain, SoupMe
 	GDataOAuth1AuthorizerPrivate *priv = GDATA_OAUTH1_AUTHORIZER (self)->priv;
 
 	/* Set the authorisation header */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->mutex));
+#else
 	g_static_mutex_lock (&(priv->mutex));
+#endif
 
 	/* Sanity check */
 	g_assert ((priv->token == NULL) == (priv->token_secret == NULL));
@@ -389,7 +405,11 @@ process_request (GDataAuthorizer *self, GDataAuthorizationDomain *domain, SoupMe
 		sign_message (GDATA_OAUTH1_AUTHORIZER (self), message, priv->token, priv->token_secret, NULL);
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->mutex));
+#else
 	g_static_mutex_unlock (&(priv->mutex));
+#endif
 }
 
 static gboolean
@@ -399,10 +419,17 @@ is_authorized_for_domain (GDataAuthorizer *self, GDataAuthorizationDomain *domai
 	gpointer result;
 	const gchar *token;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->mutex));
+	token = priv->token;
+	result = g_hash_table_lookup (priv->authorization_domains, domain);
+	g_mutex_unlock (&(priv->mutex));
+#else
 	g_static_mutex_lock (&(priv->mutex));
 	token = priv->token;
 	result = g_hash_table_lookup (priv->authorization_domains, domain);
 	g_static_mutex_unlock (&(priv->mutex));
+#endif
 
 	/* Sanity check */
 	g_assert (result == NULL || result == domain);
@@ -696,7 +723,11 @@ gdata_oauth1_authorizer_request_authentication_uri (GDataOAuth1Authorizer *self,
 	*token_secret = NULL;
 
 	/* Build up the space-separated list of scopes we're requesting authorisation for */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->mutex));
+#else
 	g_static_mutex_lock (&(priv->mutex));
+#endif
 
 	scope_string = g_string_new (NULL);
 	g_hash_table_iter_init (&iter, priv->authorization_domains);
@@ -712,7 +743,11 @@ gdata_oauth1_authorizer_request_authentication_uri (GDataOAuth1Authorizer *self,
 		is_first = FALSE;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->mutex));
+#else
 	g_static_mutex_unlock (&(priv->mutex));
+#endif
 
 	/* Build the request body and the set of parameters to be signed */
 	parameters = g_hash_table_new (g_str_hash, g_str_equal);
@@ -1033,7 +1068,11 @@ gdata_oauth1_authorizer_request_authorization (GDataOAuth1Authorizer *self, cons
 	}
 
 	/* Store the token and token secret in the authoriser */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->mutex));
+#else
 	g_static_mutex_lock (&(priv->mutex));
+#endif
 
 	g_free (priv->token);
 	priv->token = g_strdup (_token);
@@ -1041,7 +1080,11 @@ gdata_oauth1_authorizer_request_authorization (GDataOAuth1Authorizer *self, cons
 	g_free (priv->token_secret);
 	priv->token_secret = g_strdup (_token_secret);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->mutex));
+#else
 	g_static_mutex_unlock (&(priv->mutex));
+#endif
 
 	g_hash_table_destroy (response_details);
 
diff --git a/gdata/gdata-service.c b/gdata/gdata-service.c
index f2a383f..c9dce29 100644
--- a/gdata/gdata-service.c
+++ b/gdata/gdata-service.c
@@ -554,7 +554,11 @@ _gdata_service_build_message (GDataService *self, GDataAuthorizationDomain *doma
 }
 
 typedef struct {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GMutex mutex; /* mutex to prevent cancellation before the message has been added to the session's message queue */
+#else
 	GStaticMutex mutex; /* mutex to prevent cancellation before the message has been added to the session's message queue */
+#endif
 	SoupSession *session;
 	SoupMessage *message;
 } MessageData;
@@ -562,16 +566,27 @@ typedef struct {
 static void
 message_cancel_cb (GCancellable *cancellable, MessageData *data)
 {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(data->mutex));
+	soup_session_cancel_message (data->session, data->message, SOUP_STATUS_CANCELLED);
+	g_mutex_unlock (&(data->mutex));
+#else
 	g_static_mutex_lock (&(data->mutex));
 	soup_session_cancel_message (data->session, data->message, SOUP_STATUS_CANCELLED);
 	g_static_mutex_unlock (&(data->mutex));
+#endif
 }
 
 static void
 message_request_queued_cb (SoupSession *session, SoupMessage *message, MessageData *data)
 {
-	if (message == data->message)
+	if (message == data->message) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_unlock (&(data->mutex));
+#else
 		g_static_mutex_unlock (&(data->mutex));
+#endif
+	}
 }
 
 /* Synchronously send @message via @service, handling asynchronous cancellation as best we can. If @cancellable has been cancelled before we start
@@ -593,7 +608,11 @@ _gdata_service_actually_send_message (SoupSession *session, SoupMessage *message
 
 	/* Listen for cancellation */
 	if (cancellable != NULL) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_init (&(data.mutex));
+#else
 		g_static_mutex_init (&(data.mutex));
+#endif
 		data.session = session;
 		data.message = message;
 
@@ -606,7 +625,11 @@ _gdata_service_actually_send_message (SoupSession *session, SoupMessage *message
 		 * This is a little ugly, but is the only way I can think of to avoid a race condition between calling soup_session_cancel_message()
 		 * and soup_session_send_message(), as the former doesn't have any effect until the request has been queued, and once the latter has
 		 * returned, all network activity has been finished so cancellation is pointless. */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_lock (&(data.mutex));
+#else
 		g_static_mutex_lock (&(data.mutex));
+#endif
 	}
 
 	/* Only send the message if it hasn't already been cancelled. There is no race condition here for the above reasons: if the cancellable has
@@ -626,7 +649,11 @@ _gdata_service_actually_send_message (SoupSession *session, SoupMessage *message
 		if (cancel_signal != 0)
 			g_cancellable_disconnect (cancellable, cancel_signal);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_clear (&(data.mutex));
+#else
 		g_static_mutex_free (&(data.mutex));
+#endif
 	}
 
 	/* Set the cancellation error if applicable. We can't assume that our GCancellable has been cancelled just because the message has;
diff --git a/gdata/gdata-upload-stream.c b/gdata/gdata-upload-stream.c
index e636bdf..079cab6 100644
--- a/gdata/gdata-upload-stream.c
+++ b/gdata/gdata-upload-stream.c
@@ -202,17 +202,33 @@ struct _GDataUploadStreamPrivate {
 	GCancellable *cancellable;
 	GThread *network_thread;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GMutex write_mutex; /* mutex for write operations (specifically, write_finished) */
+#else
 	GStaticMutex write_mutex; /* mutex for write operations (specifically, write_finished) */
+#endif
 	gsize message_bytes_outstanding; /* the number of bytes which have been written to the buffer but not libsoup (signalled by write_cond) */
 	gsize network_bytes_outstanding; /* the number of bytes which have been written to libsoup but not the network (signalled by write_cond) */
 	gsize network_bytes_written; /* the number of bytes which have been written to the network (signalled by write_cond) */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GCond write_cond; /* signalled when a chunk has been written (protected by write_mutex) */
+#else
 	GCond *write_cond; /* signalled when a chunk has been written (protected by write_mutex) */
+#endif
 
 	gboolean finished; /* set once the upload thread has finished (protected by response_mutex) */
 	guint response_status; /* set once we finish receiving the response (SOUP_STATUS_NONE otherwise) (protected by response_mutex) */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GCond finished_cond; /* signalled when sending the message (and receiving the response) is finished (protected by response_mutex) */
+#else
 	GCond *finished_cond; /* signalled when sending the message (and receiving the response) is finished (protected by response_mutex) */
+#endif
 	GError *response_error; /* error asynchronously set by the network thread, and picked up by the main thread when appropriate */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	GMutex response_mutex; /* mutex for ->response_error, ->response_status and ->finished_cond */
+#else
 	GStaticMutex response_mutex; /* mutex for ->response_error, ->response_status and ->finished_cond */
+#endif
 };
 
 enum {
@@ -367,10 +383,17 @@ gdata_upload_stream_init (GDataUploadStream *self)
 {
 	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GDATA_TYPE_UPLOAD_STREAM, GDataUploadStreamPrivate);
 	self->priv->buffer = gdata_buffer_new ();
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_init (&(self->priv->write_mutex));
+	g_cond_init (&(self->priv->write_cond));
+	g_cond_init (&(self->priv->finished_cond));
+	g_mutex_init (&(self->priv->response_mutex));
+#else
 	g_static_mutex_init (&(self->priv->write_mutex));
 	self->priv->write_cond = g_cond_new ();
 	self->priv->finished_cond = g_cond_new ();
 	g_static_mutex_init (&(self->priv->response_mutex));
+#endif
 }
 
 static GObject *
@@ -459,10 +482,17 @@ gdata_upload_stream_finalize (GObject *object)
 {
 	GDataUploadStreamPrivate *priv = GDATA_UPLOAD_STREAM (object)->priv;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_clear (&(priv->response_mutex));
+	g_cond_clear (&(priv->finished_cond));
+	g_cond_clear (&(priv->write_cond));
+	g_mutex_clear (&(priv->write_mutex));
+#else
 	g_static_mutex_free (&(priv->response_mutex));
 	g_cond_free (priv->finished_cond);
 	g_cond_free (priv->write_cond);
 	g_static_mutex_free (&(priv->write_mutex));
+#endif
 	gdata_buffer_free (priv->buffer);
 	g_clear_error (&(priv->response_error));
 	g_free (priv->upload_uri);
@@ -561,10 +591,17 @@ write_cancelled_cb (GCancellable *cancellable, CancelledData *data)
 	GDataUploadStreamPrivate *priv = data->upload_stream->priv;
 
 	/* Signal the gdata_upload_stream_write() function that it should stop blocking and cancel */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+	*(data->cancelled) = TRUE;
+	g_cond_signal (&(priv->write_cond));
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
 	*(data->cancelled) = TRUE;
 	g_cond_signal (priv->write_cond);
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 }
 
 static gssize
@@ -587,12 +624,20 @@ gdata_upload_stream_write (GOutputStream *stream, const void *buffer, gsize coun
 		cancelled_signal = g_cancellable_connect (cancellable, (GCallback) write_cancelled_cb, &data, NULL);
 
 	/* Check for an error and return if necessary */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
+#endif
 
 	if (cancelled == TRUE) {
 		g_assert (g_cancellable_set_error_if_cancelled (cancellable, error) == TRUE ||
 		          g_cancellable_set_error_if_cancelled (priv->cancellable, error) == TRUE);
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_unlock (&(priv->write_mutex));
+#else
 		g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 		length_written = -1;
 		goto done;
@@ -603,7 +648,11 @@ gdata_upload_stream_write (GOutputStream *stream, const void *buffer, gsize coun
 	old_network_bytes_written = priv->network_bytes_written;
 	priv->message_bytes_outstanding += count;
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Handle the more common case of the network thread already having been created first */
 	if (priv->network_thread != NULL) {
@@ -629,9 +678,15 @@ gdata_upload_stream_write (GOutputStream *stream, const void *buffer, gsize coun
 		soup_message_body_append (priv->message->request_body, SOUP_MEMORY_TAKE, entry_xml, strlen (entry_xml));
 		soup_message_body_append (priv->message->request_body, SOUP_MEMORY_TAKE, second_part_header, strlen (second_part_header));
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_lock (&(priv->write_mutex));
+		priv->network_bytes_outstanding += priv->message->request_body->length;
+		g_mutex_unlock (&(priv->write_mutex));
+#else
 		g_static_mutex_lock (&(priv->write_mutex));
 		priv->network_bytes_outstanding += priv->message->request_body->length;
 		g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 	}
 
 	/* Also write out the first chunk of data, so there's guaranteed to be something in the buffer */
@@ -645,11 +700,20 @@ gdata_upload_stream_write (GOutputStream *stream, const void *buffer, gsize coun
 	}
 
 write:
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
+#endif
 
 	/* Wait for it to be written */
-	while (priv->network_bytes_written - old_network_bytes_written < count && cancelled == FALSE)
+	while (priv->network_bytes_written - old_network_bytes_written < count && cancelled == FALSE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_cond_wait (&(priv->write_cond), &(priv->write_mutex));
+#else
 		g_cond_wait (priv->write_cond, g_static_mutex_get_mutex (&(priv->write_mutex)));
+#endif
+	}
 	length_written = MIN (count, priv->network_bytes_written - old_network_bytes_written);
 
 	/* Check for an error and return if necessary */
@@ -659,7 +723,11 @@ write:
 		length_written = -1;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 done:
 	/* Disconnect from the cancelled signals. Note that we have to do this with @write_mutex not held, as g_cancellable_disconnect() blocks
@@ -680,10 +748,17 @@ flush_cancelled_cb (GCancellable *cancellable, CancelledData *data)
 	GDataUploadStreamPrivate *priv = data->upload_stream->priv;
 
 	/* Signal the gdata_upload_stream_flush() function that it should stop blocking and cancel */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+	*(data->cancelled) = TRUE;
+	g_cond_signal (&(priv->write_cond));
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
 	*(data->cancelled) = TRUE;
 	g_cond_signal (priv->write_cond);
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 }
 
 /* Block until ->network_bytes_outstanding reaches zero. Cancelling the cancellable passed to gdata_upload_stream_flush() breaks out of the wait(),
@@ -710,11 +785,20 @@ gdata_upload_stream_flush (GOutputStream *stream, GCancellable *cancellable, GEr
 		cancelled_signal = g_cancellable_connect (cancellable, (GCallback) flush_cancelled_cb, &data, NULL);
 
 	/* Start the flush operation proper */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
+#endif
 
 	/* Wait for all outstanding bytes to be written to the network */
-	while (priv->network_bytes_outstanding > 0 && cancelled == FALSE)
+	while (priv->network_bytes_outstanding > 0 && cancelled == FALSE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_cond_wait (&(priv->write_cond), &(priv->write_mutex));
+#else
 		g_cond_wait (priv->write_cond, g_static_mutex_get_mutex (&(priv->write_mutex)));
+#endif
+	}
 
 	/* Check for an error and return if necessary */
 	if (cancelled == TRUE) {
@@ -723,7 +807,11 @@ gdata_upload_stream_flush (GOutputStream *stream, GCancellable *cancellable, GEr
 		success = FALSE;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Disconnect from the cancelled signals. Note that we have to do this without @write_mutex held, as g_cancellable_disconnect() blocks
 	 * until any outstanding cancellation callbacks return, and they will block on @write_mutex. */
@@ -741,10 +829,17 @@ close_cancelled_cb (GCancellable *cancellable, CancelledData *data)
 	GDataUploadStreamPrivate *priv = data->upload_stream->priv;
 
 	/* Signal the gdata_upload_stream_close() function that it should stop blocking and cancel */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->response_mutex));
+	*(data->cancelled) = TRUE;
+	g_cond_signal (&(priv->finished_cond));
+	g_mutex_unlock (&(priv->response_mutex));
+#else
 	g_static_mutex_lock (&(priv->response_mutex));
 	*(data->cancelled) = TRUE;
 	g_cond_signal (priv->finished_cond);
 	g_static_mutex_unlock (&(priv->response_mutex));
+#endif
 }
 
 /* It's guaranteed that we have set ->response_status and ->response_error and are done with *all* network activity before this returns, unless it's
@@ -779,13 +874,27 @@ gdata_upload_stream_close (GOutputStream *stream, GCancellable *cancellable, GEr
 		return TRUE;
 
 	/* If we've already closed the stream, return G_IO_ERROR_CLOSED */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->response_mutex));
+#else
 	g_static_mutex_lock (&(priv->response_mutex));
+#endif
+
 	if (priv->response_status != SOUP_STATUS_NONE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_unlock (&(priv->response_mutex));
+#else
 		g_static_mutex_unlock (&(priv->response_mutex));
+#endif
 		g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED, _("Stream is already closed"));
 		return FALSE;
 	}
+
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->response_mutex));
+#else
 	g_static_mutex_unlock (&(priv->response_mutex));
+#endif
 
 	/* Allow cancellation */
 	data.upload_stream = GDATA_UPLOAD_STREAM (stream);
@@ -796,7 +905,11 @@ gdata_upload_stream_close (GOutputStream *stream, GCancellable *cancellable, GEr
 	if (cancellable != NULL)
 		cancelled_signal = g_cancellable_connect (cancellable, (GCallback) close_cancelled_cb, &data, NULL);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->response_mutex));
+#else
 	g_static_mutex_lock (&(priv->response_mutex));
+#endif
 
 	/* If an operation is still in progress, the upload thread hasn't finished yetâ */
 	if (priv->finished == FALSE) {
@@ -807,9 +920,15 @@ gdata_upload_stream_close (GOutputStream *stream, GCancellable *cancellable, GEr
 
 			gdata_buffer_push_data (priv->buffer, (const guint8*) footer, footer_length);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_mutex_lock (&(priv->write_mutex));
+			priv->message_bytes_outstanding += footer_length;
+			g_mutex_unlock (&(priv->write_mutex));
+#else
 			g_static_mutex_lock (&(priv->write_mutex));
 			priv->message_bytes_outstanding += footer_length;
 			g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 		}
 
 		/* Mark the buffer as having reached EOF, and the write operation will close in its own time */
@@ -818,8 +937,13 @@ gdata_upload_stream_close (GOutputStream *stream, GCancellable *cancellable, GEr
 		/* Wait for the signal that we've finished. Cancelling the call to gdata_upload_stream_close() will cause this wait to be aborted,
 		 * but won't actually prevent the stream being closed (i.e. all it means is that the stream isn't guaranteed to have been closed by
 		 * the time gdata_upload_stream_close() returns â whereas normally it would be). */
-		if (cancelled == FALSE)
+		if (cancelled == FALSE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+			g_cond_wait (&(priv->finished_cond), &(priv->response_mutex));
+#else
 			g_cond_wait (priv->finished_cond, g_static_mutex_get_mutex (&(priv->response_mutex)));
+#endif
+		}
 	}
 
 	g_assert (priv->response_status == SOUP_STATUS_NONE);
@@ -849,7 +973,11 @@ gdata_upload_stream_close (GOutputStream *stream, GCancellable *cancellable, GEr
 
 	g_assert (priv->response_status != SOUP_STATUS_NONE && (SOUP_STATUS_IS_SUCCESSFUL (priv->response_status) || child_error != NULL));
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->response_mutex));
+#else
 	g_static_mutex_unlock (&(priv->response_mutex));
+#endif
 
 	/* Disconnect from the signal handler. Note that we have to do this with @response_mutex not held, as g_cancellable_disconnect() blocks
 	 * until any outstanding cancellation callbacks return, and they will block on @response_mutex. */
@@ -884,15 +1012,27 @@ write_next_chunk (GDataUploadStream *self, SoupMessage *message)
 	gboolean reached_eof = FALSE;
 	guint8 next_buffer[CHUNK_SIZE];
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
+#endif
 
 	/* If there are still bytes in libsoup's buffer, don't block on getting new bytes into the stream */
 	if (priv->network_bytes_outstanding > 0) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_unlock (&(priv->write_mutex));
+#else
 		g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 		return;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Append the next chunk to the message body so it can join in the fun.
 	 * Note that this call isn't blocking, and can return less than the CHUNK_SIZE. This is because
@@ -901,10 +1041,17 @@ write_next_chunk (GDataUploadStream *self, SoupMessage *message)
 	 * stream, so we'd happily block on receiving more bytes which weren't forthcoming. */
 	length = gdata_buffer_pop_data_limited (priv->buffer, next_buffer, CHUNK_SIZE, &reached_eof);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+	priv->message_bytes_outstanding -= length;
+	priv->network_bytes_outstanding += length;
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
 	priv->message_bytes_outstanding -= length;
 	priv->network_bytes_outstanding += length;
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Append whatever data was returned */
 	if (length > 0)
@@ -912,9 +1059,15 @@ write_next_chunk (GDataUploadStream *self, SoupMessage *message)
 
 	/* Finish off the request body if we've reached EOF (i.e. the stream has been closed) */
 	if (reached_eof == TRUE) {
+#if GLIB_CHECK_VERSION (2, 31, 0)
+		g_mutex_lock (&(priv->write_mutex));
+		g_assert (priv->message_bytes_outstanding == 0);
+		g_mutex_unlock (&(priv->write_mutex));
+#else
 		g_static_mutex_lock (&(priv->write_mutex));
 		g_assert (priv->message_bytes_outstanding == 0);
 		g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 		soup_message_body_complete (priv->message->request_body);
 	}
@@ -928,9 +1081,15 @@ wrote_headers_cb (SoupMessage *message, GDataUploadStream *self)
 	GDataUploadStreamPrivate *priv = self->priv;
 
 	/* Signal the main thread that the headers have been written */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+	g_cond_signal (&(priv->write_cond));
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
 	g_cond_signal (priv->write_cond);
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Send the first chunk to libsoup */
 	write_next_chunk (self, message);
@@ -942,12 +1101,21 @@ wrote_body_data_cb (SoupMessage *message, SoupBuffer *buffer, GDataUploadStream
 	GDataUploadStreamPrivate *priv = self->priv;
 
 	/* Signal the main thread that the chunk has been written */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->write_mutex));
+	g_assert (priv->network_bytes_outstanding > 0);
+	priv->network_bytes_outstanding -= buffer->length;
+	priv->network_bytes_written += buffer->length;
+	g_cond_signal (&(priv->write_cond));
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->write_mutex));
 	g_assert (priv->network_bytes_outstanding > 0);
 	priv->network_bytes_outstanding -= buffer->length;
 	priv->network_bytes_written += buffer->length;
 	g_cond_signal (priv->write_cond);
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Send the next chunk to libsoup */
 	write_next_chunk (self, message);
@@ -969,16 +1137,30 @@ upload_thread (GDataUploadStream *self)
 	_gdata_service_actually_send_message (priv->session, priv->message, priv->cancellable, NULL);
 
 	/* Signal write_cond, just in case we errored out and finished sending in the middle of a write */
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(priv->response_mutex));
+	g_mutex_lock (&(priv->write_mutex));
+	if (priv->message_bytes_outstanding > 0 || priv->network_bytes_outstanding > 0) {
+		g_cond_signal (&(priv->write_cond));
+	}
+	g_mutex_unlock (&(priv->write_mutex));
+#else
 	g_static_mutex_lock (&(priv->response_mutex));
 	g_static_mutex_lock (&(priv->write_mutex));
 	if (priv->message_bytes_outstanding > 0 || priv->network_bytes_outstanding > 0)
 		g_cond_signal (priv->write_cond);
 	g_static_mutex_unlock (&(priv->write_mutex));
+#endif
 
 	/* Signal that the operation has finished */
 	priv->finished = TRUE;
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_cond_signal (&(priv->finished_cond));
+	g_mutex_unlock (&(priv->response_mutex));
+#else
 	g_cond_signal (priv->finished_cond);
 	g_static_mutex_unlock (&(priv->response_mutex));
+#endif
 
 	g_object_unref (self);
 
@@ -991,7 +1173,11 @@ create_network_thread (GDataUploadStream *self, GError **error)
 	GDataUploadStreamPrivate *priv = self->priv;
 
 	g_assert (priv->network_thread == NULL);
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	priv->network_thread = g_thread_try_new ("upload-thread", (GThreadFunc) upload_thread, self, error);
+#else
 	priv->network_thread = g_thread_create ((GThreadFunc) upload_thread, self, TRUE, error);
+#endif
 }
 
 /**
@@ -1088,7 +1274,11 @@ gdata_upload_stream_get_response (GDataUploadStream *self, gssize *length)
 
 	g_return_val_if_fail (GDATA_IS_UPLOAD_STREAM (self), NULL);
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_lock (&(self->priv->response_mutex));
+#else
 	g_static_mutex_lock (&(self->priv->response_mutex));
+#endif
 
 	if (self->priv->response_status == SOUP_STATUS_NONE) {
 		/* We can't touch the message until the network thread has finished using it, since it isn't threadsafe */
@@ -1104,7 +1294,11 @@ gdata_upload_stream_get_response (GDataUploadStream *self, gssize *length)
 		_response = self->priv->message->response_body->data;
 	}
 
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	g_mutex_unlock (&(self->priv->response_mutex));
+#else
 	g_static_mutex_unlock (&(self->priv->response_mutex));
+#endif
 
 	if (length != NULL)
 		*length = _length;
diff --git a/gdata/tests/common.c b/gdata/tests/common.c
index a4b0573..ebda854 100644
--- a/gdata/tests/common.c
+++ b/gdata/tests/common.c
@@ -38,7 +38,9 @@ gdata_test_init (int argc, char **argv)
 	gint i;
 
 	g_type_init ();
+#if !GLIB_CHECK_VERSION (2, 31, 0)
 	g_thread_init (NULL);
+#endif
 
 	/* Parse the --no-internet and --no-interactive options */
 	for (i = 1; i < argc; i++) {
diff --git a/gdata/tests/memory.c b/gdata/tests/memory.c
index 67bbb4a..81b1f83 100644
--- a/gdata/tests/memory.c
+++ b/gdata/tests/memory.c
@@ -65,7 +65,9 @@ main (int argc, char *argv[])
 	g_mem_set_vtable (glib_mem_profiler_table);
 
 	g_type_init ();
+#if !GLIB_CHECK_VERSION (2, 31, 0)
 	g_thread_init (NULL);
+#endif
 
 	test_query_events ();
 
diff --git a/gdata/tests/perf.c b/gdata/tests/perf.c
index a783e18..eab1edc 100644
--- a/gdata/tests/perf.c
+++ b/gdata/tests/perf.c
@@ -84,7 +84,9 @@ main (int argc, char *argv[])
 	#define ITERATIONS 10000
 
 	g_type_init ();
+#if !GLIB_CHECK_VERSION (2, 31, 0)
 	g_thread_init (NULL);
+#endif
 
 	/* Test feed parsing time */
 	g_get_current_time (&start_time);
diff --git a/gdata/tests/streams.c b/gdata/tests/streams.c
index ae8300d..ef16e6d 100644
--- a/gdata/tests/streams.c
+++ b/gdata/tests/streams.c
@@ -32,6 +32,23 @@ run_server_thread (SoupServer *server)
 	return NULL;
 }
 
+static GThread *
+run_server (SoupServer *server)
+{
+	GThread *thread;
+	GError *error = NULL;
+
+#if GLIB_CHECK_VERSION (2, 31, 0)
+	thread = g_thread_try_new ("server-thread", (GThreadFunc) run_server_thread, server, &error);
+#else
+	thread = g_thread_create ((GThreadFunc) run_server_thread, server, TRUE, &error);
+#endif
+	g_assert_no_error (error);
+	g_assert (thread != NULL);
+
+	return thread;
+}
+
 static gboolean
 quit_server_cb (SoupServer *server)
 {
@@ -104,9 +121,7 @@ test_download_stream_download_content_length (void)
 	g_assert (server != NULL);
 
 	/* Create a thread for the server */
-	thread = g_thread_create ((GThreadFunc) run_server_thread, server, TRUE, &error);
-	g_assert_no_error (error);
-	g_assert (thread != NULL);
+	thread = run_server (server);
 
 	/* Create a new download stream connected to the server */
 	download_uri = g_strdup_printf ("http://127.0.0.1:%u/";, soup_server_get_port (server));
@@ -199,9 +214,7 @@ test_download_stream_download_seek_before_start (void)
 	g_assert (server != NULL);
 
 	/* Create a thread for the server */
-	thread = g_thread_create ((GThreadFunc) run_server_thread, server, TRUE, &error);
-	g_assert_no_error (error);
-	g_assert (thread != NULL);
+	thread = run_server (server);
 
 	/* Create a new download stream connected to the server */
 	download_uri = g_strdup_printf ("http://127.0.0.1:%u/";, soup_server_get_port (server));
@@ -304,9 +317,7 @@ test_download_stream_download_seek_after_start_forwards (void)
 	g_assert (server != NULL);
 
 	/* Create a thread for the server */
-	thread = g_thread_create ((GThreadFunc) run_server_thread, server, TRUE, &error);
-	g_assert_no_error (error);
-	g_assert (thread != NULL);
+	thread = run_server (server);
 
 	/* Create a new download stream connected to the server */
 	download_uri = g_strdup_printf ("http://127.0.0.1:%u/";, soup_server_get_port (server));
@@ -409,9 +420,7 @@ test_download_stream_download_seek_after_start_backwards (void)
 	g_assert (server != NULL);
 
 	/* Create a thread for the server */
-	thread = g_thread_create ((GThreadFunc) run_server_thread, server, TRUE, &error);
-	g_assert_no_error (error);
-	g_assert (thread != NULL);
+	thread = run_server (server);
 
 	/* Create a new download stream connected to the server */
 	download_uri = g_strdup_printf ("http://127.0.0.1:%u/";, soup_server_get_port (server));
@@ -535,9 +544,7 @@ test_upload_stream_upload_no_entry_content_length (void)
 	g_assert (server != NULL);
 
 	/* Create a thread for the server */
-	thread = g_thread_create ((GThreadFunc) run_server_thread, server, TRUE, &error);
-	g_assert_no_error (error);
-	g_assert (thread != NULL);
+	thread = run_server (server);
 
 	/* Create a new upload stream uploading to the server */
 	upload_uri = g_strdup_printf ("http://127.0.0.1:%u/";, soup_server_get_port (server));