SoupSession: add soup_session_request_http() and _request_http_uri()

Add SoupSession helpers to return SoupRequestHTTP directly and allow
overriding the request method.

diff --git a/docs/reference/libsoup-2.4-sections.txt b/docs/reference/libsoup-2.4-sections.txt
index 4697853..43388ef 100644 (file)
--- a/docs/reference/libsoup-2.4-sections.txt
+++ b/docs/reference/libsoup-2.4-sections.txt
@@ -389,6 +389,8 @@ SoupSession
 <SUBSECTION>
 soup_session_request
 soup_session_request_uri
+soup_session_request_http
+soup_session_request_http_uri
 SoupRequestError
 SOUP_REQUEST_ERROR
 <SUBSECTION>

diff --git a/libsoup/libsoup-2.4.sym b/libsoup/libsoup-2.4.sym
index 900cb04..aa302c6 100644 (file)
--- a/libsoup/libsoup-2.4.sym
+++ b/libsoup/libsoup-2.4.sym
@@ -382,6 +382,8 @@ soup_session_redirect_message
 soup_session_remove_feature
 soup_session_remove_feature_by_type
 soup_session_request
+soup_session_request_http
+soup_session_request_http_uri
 soup_session_request_uri
 soup_session_requeue_message
 soup_session_send_message

diff --git a/libsoup/soup-request-http.h b/libsoup/soup-request-http.h
index 58fbbfd..5335b10 100644 (file)
--- a/libsoup/soup-request-http.h
+++ b/libsoup/soup-request-http.h
@@ -37,7 +37,7 @@ G_BEGIN_DECLS
 
 typedef struct _SoupRequestHTTPPrivate SoupRequestHTTPPrivate;
 
-typedef struct {
+struct _SoupRequestHTTP {
        SoupRequest parent;
 
        /*< public >*/
@@ -54,7 +54,7 @@ typedef struct {
        /*< private >*/
        SoupRequestHTTPPrivate *priv;
 
-} SoupRequestHTTP;
+};
 
 typedef struct {
        SoupRequestClass parent;

diff --git a/libsoup/soup-session.c b/libsoup/soup-session.c
index 85d705a..94a2214 100644 (file)
--- a/libsoup/soup-session.c
+++ b/libsoup/soup-session.c
@@ -3803,6 +3803,94 @@ soup_session_request_uri (SoupSession *session, SoupURI *uri,
                               NULL);
 }
 
+static SoupRequestHTTP *
+initialize_http_request (SoupRequest  *req,
+                        const char   *method,
+                        GError      **error)
+{
+       SoupRequestHTTP *http;
+       SoupMessage *msg;
+
+       if (!SOUP_IS_REQUEST_HTTP (req)) {
+               g_object_unref (req);
+               g_set_error (error, SOUP_REQUEST_ERROR,
+                            SOUP_REQUEST_ERROR_BAD_URI,
+                            _("Not an HTTP URI"));
+               return NULL;
+       }
+
+       http = SOUP_REQUEST_HTTP (req);
+       msg = soup_request_http_get_message (http);
+       g_object_set (G_OBJECT (msg),
+                     SOUP_MESSAGE_METHOD, method,
+                     NULL);
+       g_object_unref (msg);
+
+       return http;
+}
+
+/**
+ * soup_session_request_http:
+ * @session: a #SoupSession
+ * @method: an HTTP method
+ * @uri_string: a URI, in string form
+ * @error: return location for a #GError, or %NULL
+ *
+ * Creates a #SoupRequest for retrieving @uri_string, which must be an
+ * "http" or "https" URI (or another protocol listed in @session's
+ * #SoupSession:http-aliases or #SoupSession:https-aliases).
+ *
+ * Return value: (transfer full): a new #SoupRequestHTTP, or
+ *   %NULL on error.
+ *
+ * Since: 2.42
+ */
+SoupRequestHTTP *
+soup_session_request_http (SoupSession  *session,
+                          const char   *method,
+                          const char   *uri_string,
+                          GError      **error)
+{
+       SoupRequest *req;
+
+       req = soup_session_request (session, uri_string, error);
+       if (!req)
+               return NULL;
+
+       return initialize_http_request (req, method, error);
+}
+
+/**
+ * soup_session_request_http_uri:
+ * @session: a #SoupSession
+ * @method: an HTTP method
+ * @uri: a #SoupURI representing the URI to retrieve
+ * @error: return location for a #GError, or %NULL
+ *
+ * Creates a #SoupRequest for retrieving @uri, which must be an
+ * "http" or "https" URI (or another protocol listed in @session's
+ * #SoupSession:http-aliases or #SoupSession:https-aliases).
+ *
+ * Return value: (transfer full): a new #SoupRequestHTTP, or
+ *   %NULL on error.
+ *
+ * Since: 2.42
+ */
+SoupRequestHTTP *
+soup_session_request_http_uri (SoupSession  *session,
+                              const char   *method,
+                              SoupURI      *uri,
+                              GError      **error)
+{
+       SoupRequest *req;
+
+       req = soup_session_request_uri (session, uri, error);
+       if (!req)
+               return NULL;
+
+       return initialize_http_request (req, method, error);
+}
+
 /**
  * SOUP_REQUEST_ERROR:
  *

diff --git a/libsoup/soup-session.h b/libsoup/soup-session.h
index 0390862..ca5060e 100644 (file)
--- a/libsoup/soup-session.h
+++ b/libsoup/soup-session.h
@@ -149,13 +149,23 @@ SoupSessionFeature *soup_session_get_feature_for_message(SoupSession        *ses
                                                         SoupMessage        *msg);
 
 SOUP_AVAILABLE_IN_2_42
-SoupRequest *soup_session_request     (SoupSession  *session,
-                                      const char   *uri_string,
-                                      GError      **error);
+SoupRequest     *soup_session_request          (SoupSession  *session,
+                                               const char   *uri_string,
+                                               GError      **error);
 SOUP_AVAILABLE_IN_2_42
-SoupRequest *soup_session_request_uri (SoupSession  *session,
-                                      SoupURI      *uri,
-                                      GError      **error);
+SoupRequest     *soup_session_request_uri      (SoupSession  *session,
+                                               SoupURI      *uri,
+                                               GError      **error);
+SOUP_AVAILABLE_IN_2_42
+SoupRequestHTTP *soup_session_request_http     (SoupSession  *session,
+                                               const char   *method,
+                                               const char   *uri_string,
+                                               GError      **error);
+SOUP_AVAILABLE_IN_2_42
+SoupRequestHTTP *soup_session_request_http_uri (SoupSession  *session,
+                                               const char   *method,
+                                               SoupURI      *uri,
+                                               GError      **error);
 
 SOUP_AVAILABLE_IN_2_42
 GQuark soup_request_error_quark (void);

diff --git a/libsoup/soup-types.h b/libsoup/soup-types.h
index 4134b83..0776bdb 100644 (file)
--- a/libsoup/soup-types.h
+++ b/libsoup/soup-types.h
@@ -21,6 +21,7 @@ typedef struct _SoupCookieJar         SoupCookieJar;
 typedef struct _SoupDate              SoupDate;
 typedef struct _SoupMessage           SoupMessage;
 typedef struct _SoupRequest           SoupRequest;
+typedef struct _SoupRequestHTTP       SoupRequestHTTP;
 typedef struct _SoupServer            SoupServer;
 typedef struct _SoupSession           SoupSession;
 typedef struct _SoupSessionAsync      SoupSessionAsync;

diff --git a/tests/coding-test.c b/tests/coding-test.c
index 2718353..7723c19 100644 (file)
--- a/tests/coding-test.c
+++ b/tests/coding-test.c
@@ -323,7 +323,7 @@ read_finished (GObject *stream, GAsyncResult *result, gpointer user_data)
 }
 
 static GByteArray *
-do_single_coding_req_test (SoupRequest *req,
+do_single_coding_req_test (SoupRequestHTTP *reqh,
                           const char *expected_encoding,
                           const char *expected_content_type,
                           MessageContentStatus status)
@@ -337,9 +337,7 @@ do_single_coding_req_test (SoupRequest *req,
 
        data = g_byte_array_new ();
 
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-
-       stream = soup_test_request_send (req, NULL, &error);
+       stream = soup_test_request_send (SOUP_REQUEST (reqh), NULL, &error);
        if (error) {
                debug_printf (1, "    Error sending request: %s\n",
                              error->message);
@@ -360,7 +358,7 @@ do_single_coding_req_test (SoupRequest *req,
                        g_byte_array_append (data, buf, nread);
        } while (nread > 0);
 
-       soup_test_request_close_stream (req, stream, NULL, &error);
+       soup_test_request_close_stream (SOUP_REQUEST (reqh), stream, NULL, &error);
        if (error) {
                debug_printf (1, "    error closing stream: %s\n",
                              error->message);
@@ -369,6 +367,7 @@ do_single_coding_req_test (SoupRequest *req,
        }
        g_object_unref (stream);
 
+       msg = soup_request_http_get_message (reqh);
        check_response (msg, expected_encoding, expected_content_type, status);
        g_object_unref (msg);
 
@@ -397,8 +396,7 @@ static void
 do_coding_req_test (void)
 {
        SoupSession *session;
-       SoupRequest *req;
-       SoupMessage *msg;
+       SoupRequestHTTP *reqh;
        SoupURI *uri;
        GByteArray *plain, *cmp;
 
@@ -411,38 +409,35 @@ do_coding_req_test (void)
 
        /* Plain text data, no claim */
        debug_printf (1, "  GET /mbox, plain\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       plain = do_single_coding_req_test (req, NULL, "text/plain", EXPECT_NOT_DECODED);
-       g_object_unref (req);
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       plain = do_single_coding_req_test (reqh, NULL, "text/plain", EXPECT_NOT_DECODED);
+       g_object_unref (reqh);
 
        /* Plain text data, claim gzip */
        debug_printf (1, "  GET /mbox, Accept-Encoding: gzip\n");
        soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
-       req = soup_session_request_uri (session, uri, NULL);
-       cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       cmp = do_single_coding_req_test (reqh, "gzip", "text/plain", EXPECT_DECODED);
        check_req_bodies (plain, cmp, "plain", "compressed");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim gzip w/ junk */
        debug_printf (1, "  GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "trailing-junk");
-       cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "gzip", "text/plain", EXPECT_DECODED);
        check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim gzip with server error */
        debug_printf (1, "  GET /mbox, Accept-Encoding: gzip, with server error\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "force-encode");
-       cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "gzip", "text/plain", EXPECT_NOT_DECODED);
 
        /* Failed content-decoding should have left the body untouched
         * from what the server sent... which happens to be the
@@ -450,68 +445,57 @@ do_coding_req_test (void)
         */
        check_req_bodies (plain, cmp, "plain", "mis-encoded");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim deflate */
        debug_printf (1, "  GET /mbox, Accept-Encoding: deflate\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "prefer-deflate-zlib");
-       cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "deflate", "text/plain", EXPECT_DECODED);
        check_req_bodies (plain, cmp, "plain", "compressed");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim deflate w/ junk */
        debug_printf (1, "  GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "prefer-deflate-zlib, trailing-junk");
-       cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "deflate", "text/plain", EXPECT_DECODED);
        check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim deflate with server error */
        debug_printf (1, "  GET /mbox, Accept-Encoding: deflate, with server error\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "force-encode, prefer-deflate-zlib");
-       cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "deflate", "text/plain", EXPECT_NOT_DECODED);
        check_req_bodies (plain, cmp, "plain", "mis-encoded");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim deflate (no zlib headers)*/
        debug_printf (1, "  GET /mbox, Accept-Encoding: deflate (raw data)\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "prefer-deflate-raw");
-       cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "deflate", "text/plain", EXPECT_DECODED);
        check_req_bodies (plain, cmp, "plain", "compressed");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        /* Plain text data, claim deflate with server error */
        debug_printf (1, "  GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "force-encode, prefer-deflate-raw");
-       cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
+       cmp = do_single_coding_req_test (reqh, "deflate", "text/plain", EXPECT_NOT_DECODED);
        check_req_bodies (plain, cmp, "plain", "mis-encoded");
        g_byte_array_free (cmp, TRUE);
-       g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        g_byte_array_free (plain, TRUE);
        soup_uri_free (uri);
@@ -525,7 +509,7 @@ do_coding_empty_test (void)
        SoupSession *session;
        SoupMessage *msg;
        SoupURI *uri;
-       SoupRequest *req;
+       SoupRequestHTTP *reqh;
        GByteArray *body;
 
        debug_printf (1, "\nEmpty allegedly-encoded body test\n");
@@ -545,14 +529,12 @@ do_coding_empty_test (void)
        g_object_unref (msg);
 
        debug_printf (1, "  SoupRequest\n");
-       req = soup_session_request_uri (session, uri, NULL);
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       soup_message_headers_append (msg->request_headers,
+       reqh = soup_session_request_http_uri (session, "GET", uri, NULL);
+       soup_message_headers_append (reqh->request_headers,
                                     "X-Test-Options", "empty");
-       g_object_unref (msg);
-       body = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
+       body = do_single_coding_req_test (reqh, "gzip", "text/plain", EXPECT_NOT_DECODED);
        g_byte_array_free (body, TRUE);
-       g_object_unref (req);
+       g_object_unref (reqh);
 
        soup_uri_free (uri);
        soup_test_session_abort_unref (session);

diff --git a/tests/redirect-test.c b/tests/redirect-test.c
index 9adf5d5..f820d00 100644 (file)
--- a/tests/redirect-test.c
+++ b/tests/redirect-test.c
@@ -209,7 +209,7 @@ static void
 do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
 {
        SoupURI *uri;
-       SoupRequest *req;
+       SoupRequestHTTP *reqh;
        SoupMessage *msg;
        TestRequest *treq;
        GInputStream *stream;
@@ -225,9 +225,11 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
                final_status = tests[n].final_status;
 
        uri = soup_uri_new_with_base (base_uri, tests[n].requests[0].path);
-       req = soup_session_request_uri (session, uri, &error);
+       reqh = soup_session_request_http_uri (session,
+                                             tests[n].requests[0].method,
+                                             uri, &error);
        soup_uri_free (uri);
-       if (!req) {
+       if (!reqh) {
                debug_printf (1, "    could not create request: %s\n",
                              error->message);
                g_error_free (error);
@@ -236,11 +238,7 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
                return;
        }
 
-       msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
-       g_object_set (G_OBJECT (msg),
-                     SOUP_MESSAGE_METHOD, tests[n].requests[0].method,
-                     NULL);
-
+       msg = soup_request_http_get_message (reqh);
        if (msg->method == SOUP_METHOD_POST) {
                soup_message_set_request (msg, "text/plain",
                                          SOUP_MEMORY_STATIC,
@@ -254,7 +252,7 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
        g_signal_connect (msg, "restarted",
                          G_CALLBACK (restarted), &treq);
 
-       stream = soup_test_request_send (req, NULL, &error);
+       stream = soup_test_request_send (SOUP_REQUEST (reqh), NULL, &error);
 
        if (SOUP_STATUS_IS_TRANSPORT_ERROR (final_status)) {
                if (stream) {
@@ -272,22 +270,20 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
                }
 
                g_error_free (error);
-               g_object_unref (msg);
-               g_object_unref (req);
+               g_object_unref (reqh);
                debug_printf (2, "\n");
                return;
        } else if (!stream) {
                debug_printf (1, "    could not send request: %s\n",
                              error->message);
                g_error_free (error);
-               g_object_unref (msg);
-               g_object_unref (req);
+               g_object_unref (reqh);
                errors++;
                debug_printf (2, "\n");
                return;
        }
 
-       soup_test_request_close_stream (req, stream, NULL, &error);
+       soup_test_request_close_stream (SOUP_REQUEST (reqh), stream, NULL, &error);
        if (error) {
                debug_printf (1, "    could not close stream: %s\n",
                              error->message);
@@ -303,7 +299,7 @@ do_request_api_test (SoupSession *session, SoupURI *base_uri, int n)
        }
 
        g_object_unref (msg);
-       g_object_unref (req);
+       g_object_unref (reqh);
        debug_printf (2, "\n");
 }