GNOME.org
 

[libsoup] Add SoupMessageQueueItemState, remove SoupMessageIOStatus

commit dc6395ccdb50e930bf71cd789bcb06e9b25aec44
Author: Dan Winship <danw gnome org>
Date:   Sat May 29 16:37:34 2010 +0200

    Add SoupMessageQueueItemState, remove SoupMessageIOStatus
    
    SoupMessageIOStatus was always really more about the session than the
    message. (SoupServer I/O didn't use it at all.) Replace it with a new
    SoupMessageQueueItemState, on the queue item rather than the message.

 libsoup/soup-connection.c      |    2 +-
 libsoup/soup-message-io.c      |    2 +-
 libsoup/soup-message-private.h |   13 --------
 libsoup/soup-message-queue.c   |    2 +-
 libsoup/soup-message-queue.h   |   24 ++++++++++++--
 libsoup/soup-message.c         |   49 +++-------------------------
 libsoup/soup-session-async.c   |   67 ++++++++++++++++++++++++---------------
 libsoup/soup-session-sync.c    |   44 +++++++++++++++++---------
 libsoup/soup-session.c         |   45 +++++++++++++++++++--------
 9 files changed, 132 insertions(+), 116 deletions(-)
---
diff --git a/libsoup/soup-connection.c b/libsoup/soup-connection.c
index 7174e21..159d570 100644
--- a/libsoup/soup-connection.c
+++ b/libsoup/soup-connection.c
@@ -371,7 +371,7 @@ set_current_item (SoupConnection *conn, SoupMessageQueueItem *item)
 
 	stop_idle_timer (priv);
 
-	soup_message_set_io_status (item->msg, SOUP_MESSAGE_IO_STATUS_RUNNING);
+	item->state = SOUP_MESSAGE_RUNNING;
 	priv->cur_item = item;
 	g_object_notify (G_OBJECT (conn), "message");
 
diff --git a/libsoup/soup-message-io.c b/libsoup/soup-message-io.c
index 8314f96..3aa4002 100644
--- a/libsoup/soup-message-io.c
+++ b/libsoup/soup-message-io.c
@@ -195,7 +195,7 @@ io_error (SoupSocket *sock, SoupMessage *msg, GError *error)
 		   !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT) &&
 		   request_is_idempotent (msg)) {
 		/* Connection got closed, but we can safely try again */
-		priv->io_status = SOUP_MESSAGE_IO_STATUS_QUEUED;
+		io->item->state = SOUP_MESSAGE_STARTING;
 	} else if (!SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code))
 		soup_message_set_status (msg, SOUP_STATUS_IO_ERROR);
 
diff --git a/libsoup/soup-message-private.h b/libsoup/soup-message-private.h
index eba92df..5525ed7 100644
--- a/libsoup/soup-message-private.h
+++ b/libsoup/soup-message-private.h
@@ -10,16 +10,8 @@
 #include "soup-auth.h"
 #include "soup-content-sniffer.h"
 
-typedef enum {
-	SOUP_MESSAGE_IO_STATUS_IDLE,
-	SOUP_MESSAGE_IO_STATUS_QUEUED,
-        SOUP_MESSAGE_IO_STATUS_RUNNING,
-	SOUP_MESSAGE_IO_STATUS_FINISHED
-} SoupMessageIOStatus;
-
 typedef struct {
 	gpointer           io_data;
-	SoupMessageIOStatus io_status;
 
 	SoupChunkAllocator chunk_allocator;
 	gpointer           chunk_allocator_data;
@@ -45,8 +37,6 @@ typedef struct {
 } SoupMessagePrivate;
 #define SOUP_MESSAGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_MESSAGE, SoupMessagePrivate))
 
-#define SOUP_MESSAGE_IS_STARTING(msg) (SOUP_MESSAGE_GET_PRIVATE (msg)->io_status == SOUP_MESSAGE_IO_STATUS_QUEUED && !SOUP_STATUS_IS_TRANSPORT_ERROR ((msg)->status_code))
-
 void             soup_message_cleanup_response (SoupMessage      *req);
 
 
@@ -95,9 +85,6 @@ void           soup_message_set_proxy_auth (SoupMessage *msg,
 SoupAuth      *soup_message_get_proxy_auth (SoupMessage *msg);
 
 /* I/O */
-void                soup_message_set_io_status  (SoupMessage          *msg,
-						 SoupMessageIOStatus  status);
-SoupMessageIOStatus soup_message_get_io_status  (SoupMessage          *msg);
 void                soup_message_io_stop        (SoupMessage          *msg);
 void                soup_message_io_pause       (SoupMessage          *msg);
 void                soup_message_io_unpause     (SoupMessage          *msg);
diff --git a/libsoup/soup-message-queue.c b/libsoup/soup-message-queue.c
index 6860524..b421eff 100644
--- a/libsoup/soup-message-queue.c
+++ b/libsoup/soup-message-queue.c
@@ -69,7 +69,7 @@ queue_message_restarted (SoupMessage *msg, gpointer user_data)
 		soup_uri_free (item->proxy_uri);
 		item->proxy_uri = NULL;
 	}
-	item->resolved_proxy_addr = FALSE;
+	item->state = SOUP_MESSAGE_STARTING;
 }
 
 /**
diff --git a/libsoup/soup-message-queue.h b/libsoup/soup-message-queue.h
index 9588e17..ecb874e 100644
--- a/libsoup/soup-message-queue.h
+++ b/libsoup/soup-message-queue.h
@@ -16,6 +16,24 @@
 
 G_BEGIN_DECLS
 
+typedef enum {
+	SOUP_MESSAGE_STARTING,
+	SOUP_MESSAGE_RESOLVING_PROXY_URI,
+	SOUP_MESSAGE_RESOLVED_PROXY_URI,
+	SOUP_MESSAGE_RESOLVING_PROXY_ADDRESS,
+	SOUP_MESSAGE_RESOLVED_PROXY_ADDRESS,
+	SOUP_MESSAGE_AWAITING_CONNECTION,
+	SOUP_MESSAGE_GOT_CONNECTION,
+	SOUP_MESSAGE_CONNECTING,
+	SOUP_MESSAGE_CONNECTED,
+	SOUP_MESSAGE_TUNNELING,
+	SOUP_MESSAGE_TUNNELED,
+	SOUP_MESSAGE_READY,
+	SOUP_MESSAGE_RUNNING,
+	SOUP_MESSAGE_RESTARTING,
+	SOUP_MESSAGE_FINISHED
+} SoupMessageQueueItemState;
+
 struct _SoupMessageQueueItem {
 	/*< public >*/
 	SoupSession *session;
@@ -31,12 +49,11 @@ struct _SoupMessageQueueItem {
 
 	guint redirection_count;
 
-	guint resolving_proxy_addr : 1;
-	guint resolved_proxy_addr  : 1;
+	SoupMessageQueueItemState state;
 
 	/*< private >*/
 	guint removed              : 1;
-	guint ref_count            : 29;
+	guint ref_count            : 31;
 	SoupMessageQueueItem *prev, *next;
 };
 
@@ -61,6 +78,7 @@ void                  soup_message_queue_item_unref (SoupMessageQueueItem *item)
 
 void                  soup_message_queue_destroy    (SoupMessageQueue     *queue);
 
+
 G_END_DECLS
 
 #endif /* SOUP_MESSAGE_QUEUE_H */
diff --git a/libsoup/soup-message.c b/libsoup/soup-message.c
index 93969fd..54c96af 100644
--- a/libsoup/soup-message.c
+++ b/libsoup/soup-message.c
@@ -129,8 +129,6 @@ enum {
 };
 
 static void got_body (SoupMessage *req);
-static void restarted (SoupMessage *req);
-static void finished (SoupMessage *req);
 
 static void set_property (GObject *object, guint prop_id,
 			  const GValue *value, GParamSpec *pspec);
@@ -142,7 +140,6 @@ soup_message_init (SoupMessage *msg)
 {
 	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
 
-	priv->io_status = SOUP_MESSAGE_IO_STATUS_IDLE;
 	priv->http_version = priv->orig_http_version = SOUP_HTTP_1_1;
 
 	msg->request_body = soup_message_body_new ();
@@ -198,9 +195,7 @@ soup_message_class_init (SoupMessageClass *message_class)
 	g_type_class_add_private (message_class, sizeof (SoupMessagePrivate));
 
 	/* virtual method definition */
-	message_class->got_body     = got_body;
-	message_class->restarted    = restarted;
-	message_class->finished     = finished;
+	message_class->got_body = got_body;
 
 	/* virtual method override */
 	object_class->finalize = finalize;
@@ -1014,12 +1009,6 @@ soup_message_content_sniffed (SoupMessage *msg, const char *content_type, GHashT
 	g_signal_emit (msg, signals[CONTENT_SNIFFED], 0, content_type, params);
 }
 
-static void
-restarted (SoupMessage *req)
-{
-	soup_message_io_stop (req);
-}
-
 /**
  * soup_message_restarted:
  * @msg: a #SoupMessage
@@ -1033,15 +1022,6 @@ soup_message_restarted (SoupMessage *msg)
 	g_signal_emit (msg, signals[RESTARTED], 0);
 }
 
-static void
-finished (SoupMessage *req)
-{
-	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req);
-
-	soup_message_io_stop (req);
-	priv->io_status = SOUP_MESSAGE_IO_STATUS_FINISHED;
-}
-
 /**
  * soup_message_finished:
  * @msg: a #SoupMessage
@@ -1052,10 +1032,7 @@ finished (SoupMessage *req)
 void
 soup_message_finished (SoupMessage *msg)
 {
-	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
-
-	if (priv->io_status != SOUP_MESSAGE_IO_STATUS_FINISHED)
-		g_signal_emit (msg, signals[FINISHED], 0);
+	g_signal_emit (msg, signals[FINISHED], 0);
 }
 
 static void
@@ -1074,8 +1051,10 @@ header_handler_metamarshal (GClosure *closure, GValue *return_value,
 	const char *header_name = marshal_data;
 	SoupMessageHeaders *hdrs;
 
+#ifdef FIXME
 	if (priv->io_status != SOUP_MESSAGE_IO_STATUS_RUNNING)
 		return;
+#endif
 
 	hdrs = priv->server_side ? msg->request_headers : msg->response_headers;
 	if (soup_message_headers_get_one (hdrs, header_name)) {
@@ -1139,11 +1118,12 @@ 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_PRIVATE (msg);
 	guint status = GPOINTER_TO_UINT (marshal_data);
 
+#ifdef FIXME
 	if (priv->io_status != SOUP_MESSAGE_IO_STATUS_RUNNING)
 		return;
+#endif
 
 	if (msg->status_code == status) {
 		closure->marshal (closure, return_value, n_param_values,
@@ -1617,23 +1597,6 @@ soup_message_set_status_full (SoupMessage *msg,
 	g_object_notify (G_OBJECT (msg), SOUP_MESSAGE_REASON_PHRASE);
 }
 
-void
-soup_message_set_io_status (SoupMessage          *msg,
-			    SoupMessageIOStatus   status)
-{
-	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
-
-	priv->io_status = status;
-}
-
-SoupMessageIOStatus
-soup_message_get_io_status (SoupMessage *msg)
-{
-	SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
-
-	return priv->io_status;
-}
-
 /**
  * SoupChunkAllocator:
  * @msg: the #SoupMessage the chunk is being allocated for
diff --git a/libsoup/soup-session-async.c b/libsoup/soup-session-async.c
index 57c0581..ee356ef 100644
--- a/libsoup/soup-session-async.c
+++ b/libsoup/soup-session-async.c
@@ -127,6 +127,7 @@ item_failed (SoupMessageQueueItem *item, guint status)
 	}
 
 	if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
+		item->state = SOUP_MESSAGE_FINISHED;
 		if (status != SOUP_STATUS_CANCELLED)
 			soup_session_cancel_message (item->session, item->msg, status);
 		soup_message_queue_item_unref (item);
@@ -146,8 +147,7 @@ resolved_proxy_addr (SoupAddress *addr, guint status, gpointer user_data)
 		return;
 
 	item->proxy_addr = g_object_ref (addr);
-	item->resolving_proxy_addr = FALSE;
-	item->resolved_proxy_addr = TRUE;
+	item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
 
 	soup_message_queue_item_unref (item);
 
@@ -168,6 +168,8 @@ resolved_proxy_uri (SoupProxyURIResolver *proxy_resolver,
 	if (proxy_uri) {
 		SoupAddress *proxy_addr;
 
+		item->state = SOUP_MESSAGE_RESOLVING_PROXY_ADDRESS;
+
 		item->proxy_uri = soup_uri_copy (proxy_uri);
 		proxy_addr = soup_address_new (proxy_uri->host,
 					       proxy_uri->port);
@@ -179,8 +181,7 @@ resolved_proxy_uri (SoupProxyURIResolver *proxy_resolver,
 		return;
 	}
 
-	item->resolving_proxy_addr = FALSE;
-	item->resolved_proxy_addr = TRUE;
+	item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
 	soup_message_queue_item_unref (item);
 
 	/* If we got here we know session still exists */
@@ -191,9 +192,7 @@ static void
 resolve_proxy_addr (SoupMessageQueueItem *item,
 		    SoupProxyURIResolver *proxy_resolver)
 {
-	if (item->resolving_proxy_addr)
-		return;
-	item->resolving_proxy_addr = TRUE;
+	item->state = SOUP_MESSAGE_RESOLVING_PROXY_URI;
 
 	soup_message_queue_item_ref (item);
 	soup_proxy_uri_resolver_get_proxy_uri_async (
@@ -216,7 +215,7 @@ tunnel_message_completed (SoupMessage *msg, gpointer user_data)
 {
 	SoupMessageQueueItem *item = user_data;
 
-	if (SOUP_MESSAGE_IS_STARTING (msg)) {
+	if (item->state == SOUP_MESSAGE_RESTARTING) {
 		soup_message_restarted (msg);
 		if (soup_connection_get_state (item->conn) != SOUP_CONNECTION_DISCONNECTED) {
 			soup_session_send_queue_item (item->session, item, item->conn, tunnel_message_completed);
@@ -226,6 +225,7 @@ tunnel_message_completed (SoupMessage *msg, gpointer user_data)
 		soup_message_set_status (msg, SOUP_STATUS_TRY_AGAIN);
 	}
 
+	item->state = SOUP_MESSAGE_FINISHED;
 	soup_message_finished (msg);
 }
 
@@ -306,10 +306,14 @@ got_connection (SoupConnection *conn, guint status, gpointer user_data)
 static void
 message_completed (SoupMessage *msg, gpointer user_data)
 {
-	if (SOUP_MESSAGE_IS_STARTING (msg))
+	SoupMessageQueueItem *item = user_data;
+
+	if (item->state == SOUP_MESSAGE_RESTARTING)
 		soup_message_restarted (msg);
-	else
+	else {
+		item->state = SOUP_MESSAGE_FINISHED;
 		soup_message_finished (msg);
+	}
 }
 
 static void
@@ -335,29 +339,34 @@ run_queue (SoupSessionAsync *sa)
 		if (msg->method == SOUP_METHOD_CONNECT)
 			continue;
 
-		if (soup_message_io_in_progress (msg))
-			continue;
-
-		if (!item->resolved_proxy_addr) {
+		if (item->state == SOUP_MESSAGE_STARTING) {
 			proxy_resolver = (SoupProxyURIResolver *)soup_session_get_feature_for_message (session, SOUP_TYPE_PROXY_URI_RESOLVER, msg);
 			if (proxy_resolver) {
 				resolve_proxy_addr (item, proxy_resolver);
 				continue;
 			} else
-				item->resolved_proxy_addr = TRUE;
+				item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
 		}
 
-		conn = soup_session_get_connection (session, item,
-						    &should_prune);
-		if (!conn)
-			continue;
+		if (item->state == SOUP_MESSAGE_AWAITING_CONNECTION) {
+			conn = soup_session_get_connection (session, item,
+							    &should_prune);
+			if (!conn)
+				continue;
 
-		if (soup_connection_get_state (conn) == SOUP_CONNECTION_NEW) {
-			soup_connection_connect_async (conn, item->cancellable,
-						       got_connection,
-						       g_object_ref (session));
-		} else
+			if (soup_connection_get_state (conn) == SOUP_CONNECTION_NEW) {
+				item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
+				soup_connection_connect_async (conn, item->cancellable,
+							       got_connection,
+							       g_object_ref (session));
+			} else
+				item->state = SOUP_MESSAGE_READY;
+		}
+
+		if (item->state == SOUP_MESSAGE_READY) {
+			item->state = SOUP_MESSAGE_RUNNING;
 			soup_session_send_queue_item (session, item, conn, message_completed);
+		}
 	}
 	if (item)
 		soup_message_queue_item_unref (item);
@@ -390,7 +399,7 @@ final_finished (SoupMessage *req, gpointer user_data)
 
 	g_object_ref (session);
 
-	if (!SOUP_MESSAGE_IS_STARTING (req)) {
+	if (item->state == SOUP_MESSAGE_FINISHED) {
 		g_signal_handlers_disconnect_by_func (req, final_finished, item);
 		g_signal_handlers_disconnect_by_func (req, request_restarted, item);
 		if (item->callback)
@@ -448,6 +457,7 @@ queue_message (SoupSession *session, SoupMessage *req,
 static guint
 send_message (SoupSession *session, SoupMessage *req)
 {
+	SoupMessageQueueItem *item;
 	GMainContext *async_context =
 		soup_session_get_async_context (session);
 
@@ -456,10 +466,15 @@ send_message (SoupSession *session, SoupMessage *req)
 
 	queue_message (session, req, NULL, NULL);
 
-	while (soup_message_get_io_status (req) != SOUP_MESSAGE_IO_STATUS_FINISHED &&
+	item = soup_message_queue_lookup (soup_session_get_queue (session), req);
+	g_return_val_if_fail (item != NULL, SOUP_STATUS_MALFORMED);
+
+	while (item->state != SOUP_MESSAGE_FINISHED &&
 	       !SOUP_STATUS_IS_TRANSPORT_ERROR (req->status_code))
 		g_main_context_iteration (async_context, TRUE);
 
+	soup_message_queue_item_unref (item);
+
 	return req->status_code;
 }
 
diff --git a/libsoup/soup-session-sync.c b/libsoup/soup-session-sync.c
index 1743f25..b9db714 100644
--- a/libsoup/soup-session-sync.c
+++ b/libsoup/soup-session-sync.c
@@ -149,17 +149,20 @@ tunnel_connect (SoupSession *session, SoupConnection *conn,
 	item = soup_session_make_connect_message (session, tunnel_addr);
 	do {
 		soup_session_send_queue_item (session, item, conn, NULL);
-		if (SOUP_MESSAGE_IS_STARTING (item->msg))
-			soup_message_restarted (item->msg) ;
-		else
+		if (item->state == SOUP_MESSAGE_RESTARTING) {
+			item->state = SOUP_MESSAGE_STARTING;
+			soup_message_restarted (item->msg);
+		} else {
+			item->state = SOUP_MESSAGE_FINISHED;
 			soup_message_finished (item->msg);
-	} while (SOUP_MESSAGE_IS_STARTING (item->msg) &&
+		}
+	} while (item->state == SOUP_MESSAGE_STARTING &&
 		 soup_connection_get_state (conn) != SOUP_CONNECTION_DISCONNECTED);
 
 	/* If the message was requeued but its connection was closed,
 	 * return TRY_AGAIN to our caller.
 	 */
-	if (SOUP_MESSAGE_IS_STARTING (item->msg))
+	if (item->state == SOUP_MESSAGE_STARTING)
 		status = SOUP_STATUS_TRY_AGAIN;
 	else
 		status = item->msg->status_code;
@@ -190,7 +193,8 @@ wait_for_connection (SoupMessageQueueItem *item)
 	guint status;
 
 	proxy_resolver = (SoupProxyURIResolver *)soup_session_get_feature_for_message (session, SOUP_TYPE_PROXY_URI_RESOLVER, msg);
-	if (proxy_resolver && !item->resolved_proxy_addr) {
+	if (proxy_resolver && item->state == SOUP_MESSAGE_STARTING) {
+		item->state = SOUP_MESSAGE_RESOLVING_PROXY_URI;
 		status = soup_proxy_uri_resolver_get_proxy_uri_sync (
 			proxy_resolver, soup_message_get_uri (msg),
 			item->cancellable, &item->proxy_uri);
@@ -199,8 +203,10 @@ wait_for_connection (SoupMessageQueueItem *item)
 				soup_session_cancel_message (session, msg, status);
 			return NULL;
 		}
+		item->state = SOUP_MESSAGE_RESOLVED_PROXY_URI;
 
 		if (item->proxy_uri) {
+			item->state = SOUP_MESSAGE_RESOLVING_PROXY_ADDRESS;
 			item->proxy_addr = soup_address_new (
 				item->proxy_uri->host, item->proxy_uri->port);
 			status = soup_address_resolve_sync (item->proxy_addr,
@@ -212,7 +218,7 @@ wait_for_connection (SoupMessageQueueItem *item)
 			}
 		}
 
-		item->resolved_proxy_addr = TRUE;
+		item->state = SOUP_MESSAGE_AWAITING_CONNECTION;
 	}
 
 	g_mutex_lock (priv->lock);
@@ -223,25 +229,29 @@ wait_for_connection (SoupMessageQueueItem *item)
 	conn = soup_session_get_connection (session, item, &try_pruning);
 	if (conn) {
 		if (soup_connection_get_state (conn) == SOUP_CONNECTION_NEW) {
+			item->state = SOUP_MESSAGE_CONNECTING;
 			status = soup_connection_connect_sync (conn, item->cancellable);
 
 			if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 				soup_session_connection_failed (session, conn, status);
 				conn = NULL;
-			} else if (soup_message_get_io_status (msg) == SOUP_MESSAGE_IO_STATUS_FINISHED) {
+			} else if (item->state == SOUP_MESSAGE_FINISHED) {
 				/* Message was cancelled while we were
 				 * connecting.
 				 */
 				soup_connection_disconnect (conn);
 				conn = NULL;
 			} else if ((tunnel_addr = soup_connection_get_tunnel_addr (conn))) {
+				item->state = SOUP_MESSAGE_TUNNELING;
 				status = tunnel_connect (session, conn, tunnel_addr);
 				if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
 					conn = NULL;
 					if (status == SOUP_STATUS_TRY_AGAIN)
 						goto try_again;
-				}
-                        }
+				} else
+					item->state = SOUP_MESSAGE_READY;
+                        } else
+				item->state = SOUP_MESSAGE_READY;
 		}
 
 		g_mutex_unlock (priv->lock);
@@ -258,7 +268,7 @@ wait_for_connection (SoupMessageQueueItem *item)
 	g_cond_wait (priv->cond, priv->lock);
 
 	/* See if something bad happened */
-	if (soup_message_get_io_status (msg) == SOUP_MESSAGE_IO_STATUS_FINISHED) {
+	if (item->state == SOUP_MESSAGE_FINISHED) {
 		g_mutex_unlock (priv->lock);
 		return NULL;
 	}
@@ -272,19 +282,23 @@ process_queue_item (SoupMessageQueueItem *item)
 	SoupSessionSyncPrivate *priv = SOUP_SESSION_SYNC_GET_PRIVATE (item->session);
 	SoupConnection *conn;
 
+	item->state = SOUP_MESSAGE_STARTING;
 	do {
 		conn = wait_for_connection (item);
 		if (!conn)
 			break;
 
+		item->state = SOUP_MESSAGE_RUNNING;
 		soup_session_send_queue_item (item->session, item, conn, NULL);
-		if (SOUP_MESSAGE_IS_STARTING (item->msg))
+		if (item->state == SOUP_MESSAGE_RESTARTING) {
+			item->state = SOUP_MESSAGE_STARTING;
 			soup_message_restarted (item->msg);
-		else
+		} else {
+			item->state = SOUP_MESSAGE_FINISHED;
 			soup_message_finished (item->msg);
+		}
 		g_cond_broadcast (priv->cond);
-	} while (soup_message_get_io_status (item->msg) !=
-		 SOUP_MESSAGE_IO_STATUS_FINISHED);
+	} while (item->state != SOUP_MESSAGE_FINISHED);
 }
 
 static gboolean
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 0022c99..22c91ae 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -1290,7 +1290,7 @@ soup_session_connection_failed (SoupSession *session,
 	g_object_ref (session);
 	for (item = soup_message_queue_first (priv->queue); item; item = soup_message_queue_next (priv->queue, item)) {
 		msg = item->msg;
-		if (SOUP_MESSAGE_IS_STARTING (msg) &&
+		if (item->state < SOUP_MESSAGE_RUNNING &&
 		    get_host_for_message (session, msg) == host)
 			soup_session_cancel_message (session, msg, status);
 	}
@@ -1472,7 +1472,7 @@ message_finished (SoupMessage *msg, gpointer user_data)
 		item->conn = NULL;
 	}
 
-	if (!SOUP_MESSAGE_IS_STARTING (msg)) {
+	if (item->state == SOUP_MESSAGE_FINISHED) {
 		soup_message_queue_remove (priv->queue, item);
 
 		g_mutex_lock (priv->host_lock);
@@ -1489,7 +1489,8 @@ message_finished (SoupMessage *msg, gpointer user_data)
 						      0, 0, NULL, NULL, session);
 		g_signal_emit (session, signals[REQUEST_UNQUEUED], 0, msg);
 		soup_message_queue_item_unref (item);
-	}
+	} else
+		g_warning ("finished an item with state %d", item->state);
 }
 
 static void
@@ -1507,8 +1508,6 @@ queue_message (SoupSession *session, SoupMessage *msg,
 	host->num_messages++;
 	g_mutex_unlock (priv->host_lock);
 
-	soup_message_set_io_status (msg, SOUP_MESSAGE_IO_STATUS_QUEUED);
-
 	g_signal_connect_after (msg, "finished",
 				G_CALLBACK (message_finished), item);
 
@@ -1562,7 +1561,13 @@ soup_session_queue_message (SoupSession *session, SoupMessage *msg,
 static void
 requeue_message (SoupSession *session, SoupMessage *msg)
 {
-	soup_message_set_io_status (msg, SOUP_MESSAGE_IO_STATUS_QUEUED);
+	SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
+	SoupMessageQueueItem *item;
+
+	item = soup_message_queue_lookup (priv->queue, msg);
+	g_return_if_fail (item != NULL);
+	item->state = SOUP_MESSAGE_RESTARTING;
+	soup_message_queue_item_unref (item);
 }
 
 /**
@@ -1654,15 +1659,19 @@ cancel_message (SoupSession *session, SoupMessage *msg, guint status_code)
 	SoupMessageQueueItem *item;
 
 	item = soup_message_queue_lookup (priv->queue, msg);
-	if (item) {
-		if (item->cancellable)
-			g_cancellable_cancel (item->cancellable);
-		soup_message_queue_item_unref (item);
-	}
+	g_return_if_fail (item != NULL);
+
+	if (item->cancellable)
+		g_cancellable_cancel (item->cancellable);
 
 	soup_message_io_stop (msg);
 	soup_message_set_status (msg, status_code);
-	soup_message_finished (msg);
+
+	if (item->state != SOUP_MESSAGE_FINISHED) {
+		item->state = SOUP_MESSAGE_FINISHED;
+		soup_message_finished (msg);
+	}
+	soup_message_queue_item_unref (item);
 }
 
 /**
@@ -1695,14 +1704,24 @@ void
 soup_session_cancel_message (SoupSession *session, SoupMessage *msg,
 			     guint status_code)
 {
+	SoupSessionPrivate *priv;
+	SoupMessageQueueItem *item;
+
 	g_return_if_fail (SOUP_IS_SESSION (session));
 	g_return_if_fail (SOUP_IS_MESSAGE (msg));
 
+	priv = SOUP_SESSION_GET_PRIVATE (session);
+	item = soup_message_queue_lookup (priv->queue, msg);
 	/* If the message is already ending, don't do anything */
-	if (soup_message_get_io_status (msg) == SOUP_MESSAGE_IO_STATUS_FINISHED)
+	if (!item)
 		return;
+	if (item->state == SOUP_MESSAGE_FINISHED) {
+		soup_message_queue_item_unref (item);
+		return;
+	}
 
 	SOUP_SESSION_GET_CLASS (session)->cancel_message (session, msg, status_code);
+	soup_message_queue_item_unref (item);
 }
 
 static void
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]