1 files changed, 43 insertions, 36 deletions

diff --git a/Source/WebKit2/WebProcess/soup/WebKitSoupRequestInputStream.cpp b/Source/WebKit2/WebProcess/soup/WebKitSoupRequestInputStream.cpp
index 852a585d6..cfb5b10cc 100644
--- a/Source/WebKit2/WebProcess/soup/WebKitSoupRequestInputStream.cpp
+++ b/Source/WebKit2/WebProcess/soup/WebKitSoupRequestInputStream.cpp
@@ -20,24 +20,21 @@
 #include "config.h"
 #include "WebKitSoupRequestInputStream.h"
 
-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
-#include <wtf/Threading.h>
-#include <wtf/gobject/GRefPtr.h>
+#include <wtf/MainThread.h>
+#include <wtf/glib/GRefPtr.h>
+#include <wtf/glib/GUniquePtr.h>
 
 struct AsyncReadData {
-    AsyncReadData(GSimpleAsyncResult* result, void* buffer, gsize count, GCancellable* cancellable)
-        : result(result)
+    AsyncReadData(GRefPtr<GTask>&& task, void* buffer, gsize count)
+        : task(WTFMove(task))
         , buffer(buffer)
         , count(count)
-        , cancellable(cancellable)
     {
     }
 
-    GRefPtr<GSimpleAsyncResult> result;
+    GRefPtr<GTask> task;
     void* buffer;
     size_t count;
-    GRefPtr<GCancellable> cancellable;
 };
 
 struct _WebKitSoupRequestInputStreamPrivate {
@@ -45,32 +42,29 @@ struct _WebKitSoupRequestInputStreamPrivate {
     uint64_t bytesReceived;
     uint64_t bytesRead;
 
-    Mutex readLock;
-    OwnPtr<AsyncReadData> pendingAsyncRead;
+    GUniquePtr<GError> error;
+
+    std::unique_ptr<AsyncReadData> pendingAsyncRead;
 };
 
 G_DEFINE_TYPE(WebKitSoupRequestInputStream, webkit_soup_request_input_stream, G_TYPE_MEMORY_INPUT_STREAM)
 
-static void webkitSoupRequestInputStreamReadAsyncResultComplete(WebKitSoupRequestInputStream* stream, GSimpleAsyncResult* result, void* buffer, gsize count, GCancellable* cancellable)
+static void webkitSoupRequestInputStreamReadAsyncResultComplete(GTask* task, void* buffer, gsize count)
 {
-    GError* error = 0;
-    gssize bytesRead = G_INPUT_STREAM_GET_CLASS(stream)->read_fn(G_INPUT_STREAM(stream), buffer, count, cancellable, &error);
+    WebKitSoupRequestInputStream* stream = WEBKIT_SOUP_REQUEST_INPUT_STREAM(g_task_get_source_object(task));
+    GError* error = nullptr;
+    gssize bytesRead = G_INPUT_STREAM_GET_CLASS(stream)->read_fn(G_INPUT_STREAM(stream), buffer, count, g_task_get_cancellable(task), &error);
     if (!error) {
-        g_simple_async_result_set_op_res_gssize(result, bytesRead);
         stream->priv->bytesRead += bytesRead;
+        g_task_return_int(task, bytesRead);
     } else
-        g_simple_async_result_take_error(result, error);
-    g_simple_async_result_complete_in_idle(result);
+        g_task_return_error(task, error);
 }
 
 static void webkitSoupRequestInputStreamPendingReadAsyncComplete(WebKitSoupRequestInputStream* stream)
 {
-    if (!stream->priv->pendingAsyncRead)
-        return;
-
-    AsyncReadData* data = stream->priv->pendingAsyncRead.get();
-    webkitSoupRequestInputStreamReadAsyncResultComplete(stream, data->result.get(), data->buffer, data->count, data->cancellable.get());
-    stream->priv->pendingAsyncRead.clear();
+    if (auto data = WTFMove(stream->priv->pendingAsyncRead))
+        webkitSoupRequestInputStreamReadAsyncResultComplete(data->task.get(), data->buffer, data->count);
 }
 
 static bool webkitSoupRequestInputStreamHasDataToRead(WebKitSoupRequestInputStream* stream)
@@ -85,31 +79,33 @@ static bool webkitSoupRequestInputStreamIsWaitingForData(WebKitSoupRequestInputS
 
 static void webkitSoupRequestInputStreamReadAsync(GInputStream* inputStream, void* buffer, gsize count, int /*priority*/, GCancellable* cancellable, GAsyncReadyCallback callback, gpointer userData)
 {
+    ASSERT(isMainThread());
     WebKitSoupRequestInputStream* stream = WEBKIT_SOUP_REQUEST_INPUT_STREAM(inputStream);
-    GRefPtr<GSimpleAsyncResult> result = adoptGRef(g_simple_async_result_new(G_OBJECT(stream), callback, userData, reinterpret_cast<void*>(webkitSoupRequestInputStreamReadAsync)));
-
-    MutexLocker locker(stream->priv->readLock);
+    GRefPtr<GTask> task = adoptGRef(g_task_new(stream, cancellable, callback, userData));
 
     if (!webkitSoupRequestInputStreamHasDataToRead(stream) && !webkitSoupRequestInputStreamIsWaitingForData(stream)) {
-        g_simple_async_result_set_op_res_gssize(result.get(), 0);
-        g_simple_async_result_complete_in_idle(result.get());
+        g_task_return_int(task.get(), 0);
+        return;
+    }
+
+    if (stream->priv->error.get()) {
+        g_task_return_error(task.get(), stream->priv->error.release());
         return;
     }
 
     if (webkitSoupRequestInputStreamHasDataToRead(stream)) {
-        webkitSoupRequestInputStreamReadAsyncResultComplete(stream, result.get(), buffer, count, cancellable);
+        webkitSoupRequestInputStreamReadAsyncResultComplete(task.get(), buffer, count);
         return;
     }
 
-    stream->priv->pendingAsyncRead = adoptPtr(new AsyncReadData(result.get(), buffer, count, cancellable));
+    stream->priv->pendingAsyncRead = std::make_unique<AsyncReadData>(WTFMove(task), buffer, count);
 }
 
-static gssize webkitSoupRequestInputStreamReadFinish(GInputStream*, GAsyncResult* result, GError**)
+static gssize webkitSoupRequestInputStreamReadFinish(GInputStream* inputStream, GAsyncResult* result, GError** error)
 {
-    GSimpleAsyncResult* simpleResult = G_SIMPLE_ASYNC_RESULT(result);
-    g_warn_if_fail(g_simple_async_result_get_source_tag(simpleResult) == webkitSoupRequestInputStreamReadAsync);
+    g_return_val_if_fail(g_task_is_valid(result, inputStream), 0);
 
-    return g_simple_async_result_get_op_res_gssize(simpleResult);
+    return g_task_propagate_int(G_TASK(result), error);
 }
 
 static void webkitSoupRequestInputStreamFinalize(GObject* object)
@@ -146,11 +142,11 @@ GInputStream* webkitSoupRequestInputStreamNew(uint64_t contentLength)
 
 void webkitSoupRequestInputStreamAddData(WebKitSoupRequestInputStream* stream, const void* data, size_t dataLength)
 {
+    ASSERT(isMainThread());
+
     if (webkitSoupRequestInputStreamFinished(stream))
         return;
 
-    MutexLocker locker(stream->priv->readLock);
-
     if (dataLength) {
         // Truncate the dataLength to the contentLength if it's known.
         if (stream->priv->contentLength && stream->priv->bytesReceived + dataLength > stream->priv->contentLength)
@@ -168,6 +164,17 @@ void webkitSoupRequestInputStreamAddData(WebKitSoupRequestInputStream* stream, c
     webkitSoupRequestInputStreamPendingReadAsyncComplete(stream);
 }
 
+void webkitSoupRequestInputStreamDidFailWithError(WebKitSoupRequestInputStream* stream, const WebCore::ResourceError& resourceError)
+{
+    GUniquePtr<GError> error(g_error_new(g_quark_from_string(resourceError.domain().utf8().data()), resourceError.errorCode(), "%s", resourceError.localizedDescription().utf8().data()));
+    if (auto data = WTFMove(stream->priv->pendingAsyncRead))
+        g_task_return_error(data->task.get(), error.release());
+    else {
+        stream->priv->contentLength = stream->priv->bytesReceived;
+        stream->priv->error = WTFMove(error);
+    }
+}
+
 bool webkitSoupRequestInputStreamFinished(WebKitSoupRequestInputStream* stream)
 {
     return !webkitSoupRequestInputStreamIsWaitingForData(stream);