gboolean soup_test_request_close_stream (SoupRequest *req, GInputStream *stream, GCancellable *cancellable, GError **error) { AsyncAsSyncData data; gboolean ok; if (SOUP_IS_SESSION_SYNC (soup_request_get_session (req))) return g_input_stream_close (stream, cancellable, error); data.loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE); g_input_stream_close_async (stream, G_PRIORITY_DEFAULT, cancellable, async_as_sync_callback, &data); g_main_loop_run (data.loop); ok = g_input_stream_close_finish (stream, data.result, error); g_main_loop_unref (data.loop); g_object_unref (data.result); return ok; }
static GInputStream * soup_request_http_send (SoupRequest *request, GCancellable *cancellable, GError **error) { SoupHTTPInputStream *httpstream; SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request); httpstream = soup_http_input_stream_new (soup_request_get_session (request), http->priv->msg); if (!soup_http_input_stream_send (httpstream, cancellable, error)) { g_object_unref (httpstream); return NULL; } return (GInputStream *)httpstream; }
static void do_cancel_while_reading_req_test_for_session (SoupSession *session) { SoupRequest *req; SoupURI *uri; GCancellable *cancellable; GError *error = NULL; uri = soup_uri_new_with_base (base_uri, "/slow"); req = soup_session_request_uri (session, uri, NULL); soup_uri_free (uri); cancellable = g_cancellable_new (); if (SOUP_IS_SESSION_ASYNC (soup_request_get_session (req))) { g_timeout_add (100, cancel_request_timeout, cancellable); soup_test_request_send (req, cancellable, &error); } else { GThread *thread; thread = g_thread_new ("cancel_request_thread", cancel_request_thread, g_object_ref (cancellable)); soup_test_request_send (req, cancellable, &error); g_thread_unref (thread); } if (!error) { debug_printf (1, " Request succeeded?\n"); errors++; } else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { debug_printf (1, " Unexpected error: %s\n", error->message); errors++; } g_clear_error (&error); g_object_unref (req); g_object_unref (cancellable); }
GInputStream * soup_test_request_send (SoupRequest *req, GCancellable *cancellable, GError **error) { AsyncAsSyncData data; GInputStream *stream; if (SOUP_IS_SESSION_SYNC (soup_request_get_session (req))) return soup_request_send (req, cancellable, error); data.loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE); soup_request_send_async (req, cancellable, async_as_sync_callback, &data); g_main_loop_run (data.loop); stream = soup_request_send_finish (req, data.result, error); g_main_loop_unref (data.loop); g_object_unref (data.result); return stream; }
static gboolean send_async_cb (gpointer data) { GSimpleAsyncResult *simple; SoupSession *session; SendAsyncHelper *helper = (SendAsyncHelper *)data; session = soup_request_get_session (SOUP_REQUEST (helper->http)); simple = g_simple_async_result_new (G_OBJECT (helper->http), helper->callback, helper->user_data, soup_request_http_send_async); g_simple_async_result_set_op_res_gpointer (simple, helper->httpstream, g_object_unref); /* Update message status */ soup_message_set_status (helper->http->priv->msg, SOUP_STATUS_OK); /* Issue signals */ soup_message_got_headers (helper->http->priv->msg); if (soup_session_get_feature_for_message (session, SOUP_TYPE_CONTENT_SNIFFER, helper->http->priv->msg)) { const char *content_type = soup_message_headers_get_content_type (helper->http->priv->msg->response_headers, NULL); soup_message_content_sniffed (helper->http->priv->msg, content_type, NULL); } g_simple_async_result_complete (simple); soup_message_finished (helper->http->priv->msg); g_object_unref (simple); g_object_unref (helper->http); g_slice_free (SendAsyncHelper, helper); return FALSE; }
static void soup_request_http_send_async (SoupRequest *request, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { SoupRequestHTTP *http = SOUP_REQUEST_HTTP (request); SoupHTTPInputStream *httpstream; GSimpleAsyncResult *simple; SoupSession *session; SoupCache *cache; session = soup_request_get_session (request); cache = (SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE); if (cache) { SoupCacheResponse response; response = soup_cache_has_response (cache, http->priv->msg); if (response == SOUP_CACHE_RESPONSE_FRESH) { SoupHTTPInputStream *httpstream; httpstream = (SoupHTTPInputStream *) soup_cache_send_response (cache, http->priv->msg); /* Cached resource file could have been deleted outside */ if (httpstream) { /* Do return the stream asynchronously as in * the other cases. It's not enough to use * g_simple_async_result_complete_in_idle as * the signals must be also emitted * asynchronously */ SendAsyncHelper *helper = g_slice_new (SendAsyncHelper); helper->http = g_object_ref (http); helper->callback = callback; helper->user_data = user_data; helper->httpstream = httpstream; g_timeout_add (0, send_async_cb, helper); return; } } else if (response == SOUP_CACHE_RESPONSE_NEEDS_VALIDATION) { SoupMessage *conditional_msg; ConditionalHelper *helper; conditional_msg = soup_cache_generate_conditional_request (cache, http->priv->msg); helper = g_slice_new0 (ConditionalHelper); helper->req = g_object_ref (http); helper->original = g_object_ref (http->priv->msg); helper->cancellable = cancellable; helper->callback = callback; helper->user_data = user_data; soup_session_queue_message (session, conditional_msg, conditional_get_ready_cb, helper); return; } } simple = g_simple_async_result_new (G_OBJECT (http), callback, user_data, soup_request_http_send_async); httpstream = soup_http_input_stream_new (soup_request_get_session (request), http->priv->msg); soup_http_input_stream_send_async (httpstream, G_PRIORITY_DEFAULT, cancellable, sent_async, simple); }