GNOME.org
 

[libsoup/carlosgc/status: 5/5] session: make soup_session_cancel_message() private


commit 9f262586f4425721721cbbc7d2feae27642b2213
Author: Carlos Garcia Campos <cgarcia igalia com>
Date:   Sun Nov 15 14:46:43 2020 +0100

    session: make soup_session_cancel_message() private

 docs/reference/libsoup-3.0-sections.txt |  2 -
 libsoup/cache/soup-cache.c              |  3 +-
 libsoup/hsts/soup-hsts-enforcer.c       |  3 +-
 libsoup/soup-message-io.c               | 10 ++--
 libsoup/soup-message-queue.c            |  9 ++--
 libsoup/soup-message-queue.h            |  1 +
 libsoup/soup-session-private.h          |  2 +
 libsoup/soup-session.c                  | 83 +++++----------------------------
 libsoup/soup-session.h                  |  4 --
 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
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]