session: make soup_session_cancel_message() privatecarlosgc/status

9 files changed, 27 insertions, 90 deletions

diff --git a/docs/reference/libsoup-3.0-sections.txt b/docs/reference/libsoup-3.0-sections.txt
index 9b779374..abf9008e 100644
--- a/docs/reference/libsoup-3.0-sections.txt
+++ b/docs/reference/libsoup-3.0-sections.txt
@@ -363,8 +363,6 @@ SoupSessionError
 soup_session_new
 soup_session_new_with_options
 <SUBSECTION>
-soup_session_cancel_message
-<SUBSECTION>
 soup_session_send
 soup_session_send_async
 soup_session_send_finish
diff --git a/libsoup/cache/soup-cache.c b/libsoup/cache/soup-cache.c
index e169a373..55c0555c 100644
--- a/libsoup/cache/soup-cache.c
+++ b/libsoup/cache/soup-cache.c
@@ -42,6 +42,7 @@
 #include "soup.h"
 #include "soup-message-private.h"
 #include "soup-misc.h"
+#include "soup-session-private.h"
 
 /**
  * SECTION:soup-cache
@@ -1425,7 +1426,7 @@ soup_cache_cancel_conditional_request (SoupCache   *cache,
 	if (entry)
 		entry->being_validated = FALSE;
 
-	soup_session_cancel_message (priv->session, msg, SOUP_STATUS_NONE);
+	soup_session_cancel_message (priv->session, msg);
 }
 
 void
diff --git a/libsoup/hsts/soup-hsts-enforcer.c b/libsoup/hsts/soup-hsts-enforcer.c
index 1889e98e..05155e0d 100644
--- a/libsoup/hsts/soup-hsts-enforcer.c
+++ b/libsoup/hsts/soup-hsts-enforcer.c
@@ -13,6 +13,7 @@
 #include "soup-hsts-enforcer.h"
 #include "soup-misc.h"
 #include "soup.h"
+#include "soup-session-private.h"
 
 /**
  * SECTION:soup-hsts-enforcer
@@ -534,7 +535,7 @@ on_sts_known_host_message_starting (SoupMessage *msg, SoupHSTSEnforcer *hsts_enf
 
 	errors = soup_message_get_tls_certificate_errors (msg);
 	if (errors)
-		soup_session_cancel_message (priv->session, msg, SOUP_STATUS_NONE);
+		soup_session_cancel_message (priv->session, msg);
 }
 
 static void
diff --git a/libsoup/soup-message-io.c b/libsoup/soup-message-io.c
index f4b2d663..9f51ab79 100644
--- a/libsoup/soup-message-io.c
+++ b/libsoup/soup-message-io.c
@@ -31,7 +31,6 @@ struct _SoupClientMessageIOData {
 	SoupMessageIOData base;
 
         SoupMessageQueueItem *item;
-        GCancellable         *cancellable;
 
 #ifdef HAVE_SYSPROF
         gint64 begin_time_nsec;
@@ -803,7 +802,6 @@ soup_message_io_run (SoupMessage *msg,
 	SoupClientMessageIOData *client_io = soup_message_get_io_data (msg);
 	SoupMessageIOData *io = &client_io->base;
 	GError *error = NULL;
-	GCancellable *cancellable;
 
 	if (io->io_source) {
 		g_source_destroy (io->io_source);
@@ -812,16 +810,16 @@ soup_message_io_run (SoupMessage *msg,
 	}
 
 	g_object_ref (msg);
-	cancellable = client_io->cancellable ? g_object_ref (client_io->cancellable) : NULL;
 
 	if (io_run_until (msg, blocking,
 			  SOUP_MESSAGE_IO_STATE_DONE,
 			  SOUP_MESSAGE_IO_STATE_DONE,
-			  cancellable, &error)) {
+			  client_io->item->cancellable, &error)) {
 		soup_message_io_finished (msg);
 	} else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
 		g_clear_error (&error);
-		io->io_source = soup_message_io_data_get_source (io, G_OBJECT (msg), cancellable,
+		io->io_source = soup_message_io_data_get_source (io, G_OBJECT (msg),
+								 client_io->item->cancellable,
 								 (SoupMessageIOSourceFunc)io_run_ready,
 								 NULL);
 		g_source_set_priority (io->io_source,
@@ -835,7 +833,6 @@ soup_message_io_run (SoupMessage *msg,
 	}
 
 	g_object_unref (msg);
-	g_clear_object (&cancellable);
 }
 
 gboolean
@@ -995,7 +992,6 @@ soup_message_send_request (SoupMessageQueueItem      *item,
 
 	io->item = item;
 	soup_message_queue_item_ref (item);
-	io->cancellable = io->item->cancellable;
 	io->base.iostream = g_object_ref (soup_connection_get_iostream (io->item->conn));
 	io->base.istream = SOUP_FILTER_INPUT_STREAM (g_io_stream_get_input_stream (io->base.iostream));
 	io->base.ostream = g_io_stream_get_output_stream (io->base.iostream);
diff --git a/libsoup/soup-message-queue.c b/libsoup/soup-message-queue.c
index 663061a8..65d2dab3 100644
--- a/libsoup/soup-message-queue.c
+++ b/libsoup/soup-message-queue.c
@@ -74,8 +74,11 @@ queue_message_restarted (SoupMessage *msg, gpointer user_data)
  * soup_message_queue_unref_item() when you are done with.
  **/
 SoupMessageQueueItem *
-soup_message_queue_append (SoupMessageQueue *queue, SoupMessage *msg,
-			   SoupSessionCallback callback, gpointer user_data)
+soup_message_queue_append (SoupMessageQueue   *queue,
+			   SoupMessage        *msg,
+			   GCancellable       *cancellable,
+			   SoupSessionCallback callback,
+			   gpointer            user_data)
 {
 	SoupMessageQueueItem *item;
 
@@ -88,7 +91,7 @@ soup_message_queue_append (SoupMessageQueue *queue, SoupMessage *msg,
 	item->msg = g_object_ref (msg);
 	item->callback = callback;
 	item->callback_data = user_data;
-	item->cancellable = g_cancellable_new ();
+	item->cancellable = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
 	item->priority = soup_message_get_priority (msg);
 
 	g_signal_connect (msg, "restarted",
diff --git a/libsoup/soup-message-queue.h b/libsoup/soup-message-queue.h
index d38c1f3b..e030adaf 100644
--- a/libsoup/soup-message-queue.h
+++ b/libsoup/soup-message-queue.h
@@ -68,6 +68,7 @@ struct _SoupMessageQueueItem {
 SoupMessageQueue     *soup_message_queue_new        (SoupSession          *session);
 SoupMessageQueueItem *soup_message_queue_append     (SoupMessageQueue     *queue,
 						     SoupMessage          *msg,
+						     GCancellable         *cancellable,
 						     SoupSessionCallback   callback,
 						     gpointer              user_data);
 
diff --git a/libsoup/soup-session-private.h b/libsoup/soup-session-private.h
index 06f86961..69ec8d07 100644
--- a/libsoup/soup-session-private.h
+++ b/libsoup/soup-session-private.h
@@ -16,6 +16,8 @@ void     soup_session_pause_message         (SoupSession *session,
 					     SoupMessage *msg);
 void     soup_session_unpause_message       (SoupSession *session,
 					     SoupMessage *msg);
+void     soup_session_cancel_message        (SoupSession *session,
+					     SoupMessage *msg);
 
 SoupMessage *soup_session_get_original_message_for_authentication (SoupSession *session,
 								   SoupMessage *msg);
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index a5b7b3c6..4ba0b7b3 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -996,6 +996,7 @@ static SoupMessageQueueItem *
 soup_session_append_queue_item (SoupSession        *session,
 				SoupMessage        *msg,
 				gboolean            async,
+				GCancellable       *cancellable,
 				SoupSessionCallback callback,
 				gpointer            user_data)
 {
@@ -1006,7 +1007,7 @@ soup_session_append_queue_item (SoupSession        *session,
 
 	soup_message_cleanup_response (msg);
 
-	item = soup_message_queue_append (priv->queue, msg, callback, user_data);
+	item = soup_message_queue_append (priv->queue, msg, cancellable, callback, user_data);
 	item->async = async;
 
 	g_mutex_lock (&priv->conn_lock);
@@ -1368,6 +1369,7 @@ tunnel_connect (SoupMessageQueueItem *item)
 
 	tunnel_item = soup_session_append_queue_item (session, msg,
 						      item->async,
+						      item->cancellable,
 						      NULL, NULL);
 	tunnel_item->io_priority = item->io_priority;
 	tunnel_item->related = item;
@@ -1843,61 +1845,19 @@ soup_session_unpause_message (SoupSession *session,
 	soup_session_kick_queue (session);
 }
 
-
-/**
- * soup_session_cancel_message:
- * @session: a #SoupSession
- * @msg: the message to cancel
- * @status_code: status code to set on @msg
- *
- * Causes @session to immediately finish processing @msg (regardless
- * of its current state) with a final status_code of @status_code. You
- * may call this at any time after handing @msg off to @session; if
- * @session has started sending the request but has not yet received
- * the complete response, then it will close the request's connection.
- * Note that with requests that have side effects (eg,
- * <literal>POST</literal>, <literal>PUT</literal>,
- * <literal>DELETE</literal>) it is possible that you might cancel the
- * request after the server acts on it, but before it returns a
- * response, leaving the remote resource in an unknown state.
- *
- * If the message is cancelled while its response body is being read,
- * then the response body in @msg will be left partially-filled-in.
- * The response headers, on the other hand, will always be either
- * empty or complete.
- *
- * Note that cancelling an asynchronous message will merely queue its
- * callback to be run after returning to the main loop.
- **/
 void
-soup_session_cancel_message (SoupSession *session, SoupMessage *msg, guint status_code)
+soup_session_cancel_message (SoupSession *session,
+			     SoupMessage *msg)
 {
 	SoupSessionPrivate *priv = soup_session_get_instance_private (session);
 	SoupMessageQueueItem *item;
 
-	g_return_if_fail (SOUP_IS_SESSION (session));
-	g_return_if_fail (SOUP_IS_MESSAGE (msg));
-
 	item = soup_message_queue_lookup (priv->queue, msg);
         /* If the message is already ending, don't do anything */
 	if (!item)
                 return;
 
-	if (item->state == SOUP_MESSAGE_FINISHED) {
-		soup_message_queue_item_unref (item);
-		return;
-	}
-
-	if (item->paused) {
-		item->paused = FALSE;
-
-		if (soup_message_io_in_progress (msg))
-			soup_message_io_unpause (msg);
-	}
-
 	g_cancellable_cancel (item->cancellable);
-
-	soup_session_kick_queue (item->session);
 	soup_message_queue_item_unref (item);
 }
 
@@ -1908,9 +1868,7 @@ soup_session_cancel_message (SoupSession *session, SoupMessage *msg, guint statu
  * Cancels all pending requests in @session and closes all idle
  * persistent connections.
  *
- * The message cancellation has the same semantics as with
- * soup_session_cancel_message().
- **/
+ */
 void
 soup_session_abort (SoupSession *session)
 {
@@ -1927,7 +1885,7 @@ soup_session_abort (SoupSession *session)
 	for (item = soup_message_queue_first (priv->queue);
 	     item;
 	     item = soup_message_queue_next (priv->queue, item)) {
-		soup_session_cancel_message (session, item->msg, SOUP_STATUS_NONE);
+		g_cancellable_cancel (item->cancellable);
 	}
 
 	/* Close all idle connections */
@@ -2925,8 +2883,7 @@ idle_return_from_cache_cb (gpointer data)
 	GInputStream *istream;
 
 	if (item->state == SOUP_MESSAGE_FINISHED) {
-		/* The original request was cancelled using
-		 * soup_session_cancel_message () so it has been
+		/* The original request was cancelled so it has been
 		 * already handled by the cancellation code path.
 		 */
 		return FALSE;
@@ -2998,12 +2955,6 @@ async_respond_from_cache (SoupSession          *session,
 		return FALSE;
 }
 
-static void
-cancel_cancellable (G_GNUC_UNUSED GCancellable *cancellable, GCancellable *chained_cancellable)
-{
-	g_cancellable_cancel (chained_cancellable);
-}
-
 /**
  * soup_session_send_async:
  * @session: a #SoupSession
@@ -3036,19 +2987,13 @@ soup_session_send_async (SoupSession         *session,
 	g_return_if_fail (SOUP_IS_SESSION (session));
 
 	item = soup_session_append_queue_item (session, msg, TRUE,
-					       NULL, NULL);
+					       cancellable, NULL, NULL);
 	item->io_priority = io_priority;
 	g_signal_connect (msg, "restarted",
 			  G_CALLBACK (async_send_request_restarted), item);
 	g_signal_connect (msg, "finished",
 			  G_CALLBACK (async_send_request_finished), item);
 
-	if (cancellable) {
-		g_cancellable_connect (cancellable, G_CALLBACK (cancel_cancellable),
-				       g_object_ref (item->cancellable),
-				       (GDestroyNotify) g_object_unref);
-	}
-
 	item->task = g_task_new (session, item->cancellable, callback, user_data);
 	g_task_set_priority (item->task, io_priority);
 	g_task_set_task_data (item->task, item, (GDestroyNotify) soup_message_queue_item_unref);
@@ -3146,13 +3091,7 @@ soup_session_send (SoupSession   *session,
 	g_return_val_if_fail (SOUP_IS_SESSION (session), NULL);
 
 	item = soup_session_append_queue_item (session, msg, FALSE,
-					       NULL, NULL);
-
-	if (cancellable) {
-		g_cancellable_connect (cancellable, G_CALLBACK (cancel_cancellable),
-				       g_object_ref (item->cancellable),
-				       (GDestroyNotify) g_object_unref);
-	}
+					       cancellable, NULL, NULL);
 
 	while (!stream) {
 		/* Get a connection, etc */
@@ -3925,7 +3864,7 @@ soup_session_websocket_connect_async (SoupSession          *session,
 	soup_message_add_flags (msg, SOUP_MESSAGE_NEW_CONNECTION);
 
 	task = g_task_new (session, cancellable, callback, user_data);
-	item = soup_session_append_queue_item (session, msg, TRUE,
+	item = soup_session_append_queue_item (session, msg, TRUE, cancellable,
 					       websocket_connect_async_complete, task);
 	item->io_priority = io_priority;
 	g_task_set_task_data (task, item, (GDestroyNotify) soup_message_queue_item_unref);
diff --git a/libsoup/soup-session.h b/libsoup/soup-session.h
index 4da94903..e0d16a0b 100644
--- a/libsoup/soup-session.h
+++ b/libsoup/soup-session.h
@@ -38,10 +38,6 @@ SoupSession    *soup_session_new_with_options (const char *optname1,
 					       ...) G_GNUC_NULL_TERMINATED;
 
 SOUP_AVAILABLE_IN_2_4
-void            soup_session_cancel_message   (SoupSession           *session,
-					       SoupMessage           *msg,
-					       guint                  status_code);
-SOUP_AVAILABLE_IN_2_4
 void            soup_session_abort            (SoupSession           *session);
 
 SOUP_AVAILABLE_IN_2_42