[libsoup] session: remove SoupSessionCallback

[Carlos Garcia Campos <carlosgc src gnome org>]

commit 866336a5f0a3ea48faa9f411b284f127741bdf9a
Author: Carlos Garcia Campos <cgarcia igalia com>
Date:   Mon Apr 26 12:24:16 2021 +0200

    session: remove SoupSessionCallback
    
    This complete callback is only used by WebSockets and preconnect and the
    callback is always called right after SoupMessage::finishes signal is
    emitted, so we can use the signal instead.

 libsoup/soup-message-queue-item.c |  6 +---
 libsoup/soup-message-queue-item.h |  7 +----
 libsoup/soup-session-private.h    |  4 ---
 libsoup/soup-session.c            | 63 ++++++++++++++-------------------------
 4 files changed, 24 insertions(+), 56 deletions(-)
---
diff --git a/libsoup/soup-message-queue-item.c b/libsoup/soup-message-queue-item.c
index 4097dd2b..aefc5cf8 100644
--- a/libsoup/soup-message-queue-item.c
+++ b/libsoup/soup-message-queue-item.c
@@ -17,9 +17,7 @@ SoupMessageQueueItem *
 soup_message_queue_item_new (SoupSession        *session,
                              SoupMessage        *msg,
                              gboolean            async,
-                             GCancellable       *cancellable,
-                             SoupSessionCallback callback,
-                             gpointer            user_data)
+                             GCancellable       *cancellable)
 {
         SoupMessageQueueItem *item;
 
@@ -27,8 +25,6 @@ soup_message_queue_item_new (SoupSession        *session,
         item->session = g_object_ref (session);
         item->msg = g_object_ref (msg);
         item->async = async;
-        item->callback = callback;
-        item->callback_data = user_data;
         item->cancellable = cancellable ? g_object_ref (cancellable) : g_cancellable_new ();
         item->priority = soup_message_get_priority (msg);
 
diff --git a/libsoup/soup-message-queue-item.h b/libsoup/soup-message-queue-item.h
index 4f7bf055..754c022e 100644
--- a/libsoup/soup-message-queue-item.h
+++ b/libsoup/soup-message-queue-item.h
@@ -28,8 +28,6 @@ typedef enum {
 struct _SoupMessageQueueItem {
         SoupSession *session;
         SoupMessage *msg;
-        SoupSessionCallback callback;
-        gpointer callback_data;
 
         GCancellable *cancellable;
         GError *error;
@@ -52,10 +50,7 @@ struct _SoupMessageQueueItem {
 SoupMessageQueueItem *soup_message_queue_item_new    (SoupSession          *session,
                                                       SoupMessage          *msg,
                                                       gboolean              async,
-                                                      GCancellable         *cancellable,
-                                                      SoupSessionCallback   callback,
-                                                      gpointer              user_data);
-
+                                                      GCancellable         *cancellable);
 SoupMessageQueueItem *soup_message_queue_item_ref    (SoupMessageQueueItem *item);
 void                  soup_message_queue_item_unref  (SoupMessageQueueItem *item);
 void                  soup_message_queue_item_cancel (SoupMessageQueueItem *item);
diff --git a/libsoup/soup-session-private.h b/libsoup/soup-session-private.h
index 36565c89..794d7c7a 100644
--- a/libsoup/soup-session-private.h
+++ b/libsoup/soup-session-private.h
@@ -10,10 +10,6 @@
 
 G_BEGIN_DECLS
 
-typedef void (*SoupSessionCallback) (SoupSession *session,
-                                     SoupMessage *msg,
-                                     gpointer     user_data);
-
 void     soup_session_requeue_message       (SoupSession *session,
                                             SoupMessage *msg);
 void     soup_session_pause_message         (SoupSession *session,
diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 64adb1de..ba482168 100644
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -1334,9 +1334,7 @@ static SoupMessageQueueItem *
 soup_session_append_queue_item (SoupSession        *session,
                                SoupMessage        *msg,
                                gboolean            async,
-                               GCancellable       *cancellable,
-                               SoupSessionCallback callback,
-                               gpointer            user_data)
+                               GCancellable       *cancellable)
 {
        SoupSessionPrivate *priv = soup_session_get_instance_private (session);
        SoupMessageQueueItem *item;
@@ -1346,7 +1344,7 @@ soup_session_append_queue_item (SoupSession        *session,
         soup_message_set_metrics_timestamp (msg, SOUP_MESSAGE_METRICS_FETCH_START);
        soup_message_cleanup_response (msg);
 
-       item = soup_message_queue_item_new (session, msg, async, cancellable, callback, user_data);
+       item = soup_message_queue_item_new (session, msg, async, cancellable);
        g_queue_insert_sorted (priv->queue,
                               soup_message_queue_item_ref (item),
                               (GCompareDataFunc)compare_queue_item, NULL);
@@ -1705,8 +1703,7 @@ tunnel_connect (SoupMessageQueueItem *item)
 
        tunnel_item = soup_session_append_queue_item (session, msg,
                                                      item->async,
-                                                     item->cancellable,
-                                                     NULL, NULL);
+                                                     item->cancellable);
        tunnel_item->io_priority = item->io_priority;
        tunnel_item->related = soup_message_queue_item_ref (item);
        soup_session_set_item_connection (session, tunnel_item, item->conn);
@@ -2040,11 +2037,7 @@ soup_session_process_queue_item (SoupSession          *session,
                case SOUP_MESSAGE_FINISHING:
                        item->state = SOUP_MESSAGE_FINISHED;
                        soup_message_finished (item->msg);
-                       soup_message_queue_item_ref (item);
                        soup_session_unqueue_item (session, item);
-                       if (item->async && item->callback)
-                               item->callback (session, item->msg, item->callback_data);
-                       soup_message_queue_item_unref (item);
                        return;
 
                default:
@@ -3251,8 +3244,7 @@ soup_session_send_async (SoupSession         *session,
 
        g_return_if_fail (SOUP_IS_SESSION (session));
 
-       item = soup_session_append_queue_item (session, msg, TRUE,
-                                              cancellable, NULL, NULL);
+       item = soup_session_append_queue_item (session, msg, TRUE, cancellable);
        item->io_priority = io_priority;
        g_signal_connect (msg, "restarted",
                          G_CALLBACK (async_send_request_restarted), item);
@@ -3353,8 +3345,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,
-                                              cancellable, NULL, NULL);
+       item = soup_session_append_queue_item (session, msg, FALSE, cancellable);
 
        while (!stream) {
                /* Get a connection, etc */
@@ -3695,12 +3686,11 @@ soup_session_get_supported_websocket_extensions_for_message (SoupSession *sessio
 static void websocket_connect_async_stop (SoupMessage *msg, gpointer user_data);
 
 static void
-websocket_connect_async_complete (SoupSession *session, SoupMessage *msg, gpointer user_data)
+websocket_connect_async_complete (SoupMessage *msg, gpointer user_data)
 {
        GTask *task = user_data;
        SoupMessageQueueItem *item = g_task_get_task_data (task);
 
-       /* Disconnect websocket_connect_async_stop() handler. */
        g_signal_handlers_disconnect_matched (msg, G_SIGNAL_MATCH_DATA,
                                              0, 0, NULL, NULL, task);
 
@@ -3727,11 +3717,8 @@ websocket_connect_async_stop (SoupMessage *msg, gpointer user_data)
        GList *accepted_extensions = NULL;
        GError *error = NULL;
 
-       /* Disconnect websocket_connect_async_stop() handler. */
        g_signal_handlers_disconnect_matched (msg, G_SIGNAL_MATCH_DATA,
                                              0, 0, NULL, NULL, task);
-       /* Ensure websocket_connect_async_complete is not called either. */
-       item->callback = NULL;
 
        supported_extensions = soup_session_get_supported_websocket_extensions_for_message (session, msg);
        if (soup_websocket_client_verify_handshake (item->msg, supported_extensions, &accepted_extensions, 
&error)) {
@@ -3814,15 +3801,18 @@ 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, cancellable,
-                                              websocket_connect_async_complete, task);
+       item = soup_session_append_queue_item (session, msg, TRUE, cancellable);
        item->io_priority = io_priority;
+
+        task = g_task_new (session, cancellable, callback, user_data);
        g_task_set_task_data (task, item, (GDestroyNotify) soup_message_queue_item_unref);
 
        soup_message_add_status_code_handler (msg, "got-informational",
                                              SOUP_STATUS_SWITCHING_PROTOCOLS,
                                              G_CALLBACK (websocket_connect_async_stop), task);
+        g_signal_connect_object (msg, "finished",
+                                 G_CALLBACK (websocket_connect_async_complete),
+                                 task, 0);
        soup_session_kick_queue (session);
 }
 
@@ -3869,26 +3859,18 @@ soup_session_get_original_message_for_authentication (SoupSession *session,
 }
 
 static void
-preconnect_async_message_finished (SoupMessage *msg,
-                                   GTask       *task)
-{
-        SoupMessageQueueItem *item = g_task_get_task_data (task);
-
-        if (item->conn && !item->error)
-                soup_connection_set_reusable (item->conn, TRUE);
-}
-
-static void
-preconnect_async_complete (SoupSession *session,
-                           SoupMessage *msg,
+preconnect_async_complete (SoupMessage *msg,
                            GTask       *task)
 {
         SoupMessageQueueItem *item = g_task_get_task_data (task);
 
-        if (item->error)
+        if (item->error) {
                 g_task_return_error (task, g_error_copy (item->error));
-        else
+        } else {
+                if (item->conn)
+                        soup_connection_set_reusable (item->conn, TRUE);
                 g_task_return_boolean (task, TRUE);
+        }
         g_object_unref (task);
 }
 
@@ -3924,17 +3906,16 @@ soup_session_preconnect_async (SoupSession        *session,
         g_return_if_fail (SOUP_IS_SESSION (session));
         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 
-        task = g_task_new (session, cancellable, callback, user_data);
-        item = soup_session_append_queue_item (session, msg, TRUE, cancellable,
-                                               (SoupSessionCallback)preconnect_async_complete,
-                                               task);
+        item = soup_session_append_queue_item (session, msg, TRUE, cancellable);
         item->connect_only = TRUE;
         item->io_priority = io_priority;
+
+        task = g_task_new (session, cancellable, callback, user_data);
         g_task_set_priority (task, io_priority);
         g_task_set_task_data (task, item, (GDestroyNotify)soup_message_queue_item_unref);
 
         g_signal_connect_object (msg, "finished",
-                                 G_CALLBACK (preconnect_async_message_finished),
+                                 G_CALLBACK (preconnect_async_complete),
                                  task, 0);
 
         soup_session_kick_queue (session);