WebKitURISchemeRequest.cpp [plain text]
#include "config.h"
#include "WebKitURISchemeRequest.h"
#include "APIData.h"
#include "WebKitPrivate.h"
#include "WebKitURISchemeRequestPrivate.h"
#include "WebKitWebContextPrivate.h"
#include "WebKitWebView.h"
#include "WebPageProxy.h"
#include <WebCore/GUniquePtrSoup.h>
#include <WebCore/ResourceError.h>
#include <libsoup/soup.h>
#include <wtf/gobject/GRefPtr.h>
#include <wtf/text/CString.h>
using namespace WebKit;
static const unsigned int gReadBufferSize = 8192;
struct _WebKitURISchemeRequestPrivate {
WebKitWebContext* webContext;
RefPtr<WebSoupCustomProtocolRequestManager> webRequestManager;
RefPtr<WebPageProxy> initiatingPage;
uint64_t requestID;
CString uri;
GUniquePtr<SoupURI> soupURI;
GRefPtr<GInputStream> stream;
uint64_t streamLength;
GRefPtr<GCancellable> cancellable;
char readBuffer[gReadBufferSize];
uint64_t bytesRead;
CString mimeType;
};
WEBKIT_DEFINE_TYPE(WebKitURISchemeRequest, webkit_uri_scheme_request, G_TYPE_OBJECT)
static void webkit_uri_scheme_request_class_init(WebKitURISchemeRequestClass*)
{
}
WebKitURISchemeRequest* webkitURISchemeRequestCreate(uint64_t requestID, WebKitWebContext* webContext, API::URLRequest* urlRequest)
{
WebKitURISchemeRequest* request = WEBKIT_URI_SCHEME_REQUEST(g_object_new(WEBKIT_TYPE_URI_SCHEME_REQUEST, NULL));
request->priv->webContext = webContext;
request->priv->webRequestManager = webkitWebContextGetRequestManager(webContext);
request->priv->uri = urlRequest->resourceRequest().url().string().utf8();
request->priv->initiatingPage = WebProcessProxy::webPage(urlRequest->resourceRequest().initiatingPageID());
request->priv->requestID = requestID;
return request;
}
void webkitURISchemeRequestCancel(WebKitURISchemeRequest* request)
{
if (request->priv->cancellable.get())
g_cancellable_cancel(request->priv->cancellable.get());
}
const char* webkit_uri_scheme_request_get_scheme(WebKitURISchemeRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request), 0);
if (!request->priv->soupURI)
request->priv->soupURI.reset(soup_uri_new(request->priv->uri.data()));
return request->priv->soupURI->scheme;
}
const char* webkit_uri_scheme_request_get_uri(WebKitURISchemeRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request), 0);
return request->priv->uri.data();
}
const char* webkit_uri_scheme_request_get_path(WebKitURISchemeRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request), 0);
if (!request->priv->soupURI)
request->priv->soupURI.reset(soup_uri_new(request->priv->uri.data()));
return request->priv->soupURI->path;
}
WebKitWebView* webkit_uri_scheme_request_get_web_view(WebKitURISchemeRequest* request)
{
g_return_val_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request), 0);
return request->priv->initiatingPage ? WEBKIT_WEB_VIEW(request->priv->initiatingPage->viewWidget()) : nullptr;
}
static void webkitURISchemeRequestReadCallback(GInputStream* inputStream, GAsyncResult* result, WebKitURISchemeRequest* schemeRequest)
{
GRefPtr<WebKitURISchemeRequest> request = adoptGRef(schemeRequest);
GUniqueOutPtr<GError> error;
gssize bytesRead = g_input_stream_read_finish(inputStream, result, &error.outPtr());
if (bytesRead == -1) {
webkit_uri_scheme_request_finish_error(request.get(), error.get());
return;
}
WebKitURISchemeRequestPrivate* priv = request->priv;
RefPtr<API::Data> webData = API::Data::create(reinterpret_cast<const unsigned char*>(priv->readBuffer), bytesRead);
if (!priv->bytesRead) {
WebCore::ResourceResponse response(WebCore::URL(WebCore::URL(), String::fromUTF8(priv->uri)), String::fromUTF8(priv->mimeType.data()),
priv->streamLength, emptyString(), emptyString());
priv->webRequestManager->didReceiveResponse(priv->requestID, response);
priv->webRequestManager->didLoadData(priv->requestID, webData.get());
} else if (bytesRead || (!bytesRead && !priv->streamLength)) {
priv->webRequestManager->didLoadData(priv->requestID, webData.get());
}
if (!bytesRead) {
priv->webRequestManager->didFinishLoading(request->priv->requestID);
webkitWebContextDidFinishLoadingCustomProtocol(request->priv->webContext, request->priv->requestID);
return;
}
priv->bytesRead += bytesRead;
g_input_stream_read_async(inputStream, priv->readBuffer, gReadBufferSize, G_PRIORITY_DEFAULT, priv->cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(webkitURISchemeRequestReadCallback), g_object_ref(request.get()));
}
void webkit_uri_scheme_request_finish(WebKitURISchemeRequest* request, GInputStream* inputStream, gint64 streamLength, const gchar* mimeType)
{
g_return_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request));
g_return_if_fail(G_IS_INPUT_STREAM(inputStream));
g_return_if_fail(streamLength == -1 || streamLength >= 0);
request->priv->stream = inputStream;
request->priv->streamLength = streamLength == -1 ? 0 : streamLength;
request->priv->cancellable = adoptGRef(g_cancellable_new());
request->priv->bytesRead = 0;
request->priv->mimeType = mimeType;
g_input_stream_read_async(inputStream, request->priv->readBuffer, gReadBufferSize, G_PRIORITY_DEFAULT, request->priv->cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(webkitURISchemeRequestReadCallback), g_object_ref(request));
}
void webkit_uri_scheme_request_finish_error(WebKitURISchemeRequest* request, GError* error)
{
g_return_if_fail(WEBKIT_IS_URI_SCHEME_REQUEST(request));
g_return_if_fail(error);
WebKitURISchemeRequestPrivate* priv = request->priv;
WebCore::ResourceError resourceError(g_quark_to_string(error->domain), toWebCoreError(error->code), priv->uri.data(), String::fromUTF8(error->message));
priv->webRequestManager->didFailWithError(priv->requestID, resourceError);
webkitWebContextDidFinishLoadingCustomProtocol(priv->webContext, priv->requestID);
}