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);
}
