Imported WebKit commit 0dc6cd75e1d4836eaffbb520be96fac4847cc9d2 (http://svn.webkit.org/repository/webkit/trunk@131300)

WebKit update which introduces the QtWebKitWidgets module that contains the WK1
widgets based API. (In fact it renames QtWebKit to QtWebKitWidgets while we're
working on completing the entire split as part of
https://bugs.webkit.org/show_bug.cgi?id=99314

1 files changed, 323 insertions, 0 deletions

diff --git a/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp b/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
index cbf624926..c25ea9511 100644
--- a/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
+++ b/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp
@@ -41,7 +41,12 @@
 #include <WebCore/KURL.h>
 #include <WebCore/PluginData.h>
 #include <WebCore/ProtectionSpace.h>
+#include <WebCore/ResourceError.h>
+#include <WebCore/ResourceRequest.h>
+#include <WebCore/ResourceResponse.h>
 #include <WebCore/TextCheckerClient.h>
+#include <WebCore/UserScript.h>
+#include <WebCore/UserStyleSheet.h>
 #include <WebCore/ViewportArguments.h>
 #include <WebCore/WindowFeatures.h>
 #include <wtf/text/StringHash.h>
@@ -55,6 +60,9 @@
 #if ENABLE(CSS_FILTERS)
 #include <WebCore/FilterOperations.h>
 #endif
+#if USE(GRAPHICS_SURFACE)
+#include <WebCore/GraphicsSurface.h>
+#endif
 #endif
 
 using namespace WebCore;
@@ -384,6 +392,212 @@ bool ArgumentCoder<Cursor>::decode(ArgumentDecoder* decoder, Cursor& cursor)
     return true;
 }
 
+void ArgumentCoder<ResourceRequest>::encode(ArgumentEncoder* encoder, const ResourceRequest& resourceRequest)
+{
+    if (kShouldSerializeWebCoreData) {
+        encoder->encode(resourceRequest.url().string());
+        encoder->encode(resourceRequest.httpMethod());
+
+        const HTTPHeaderMap& headers = resourceRequest.httpHeaderFields();
+        encoder->encode(headers);
+
+        FormData* httpBody = resourceRequest.httpBody();
+        encoder->encode(static_cast<bool>(httpBody));
+        if (httpBody)
+            encoder->encode(httpBody->flattenToString());
+
+        encoder->encode(resourceRequest.firstPartyForCookies().string());
+    }
+
+    encodePlatformData(encoder, resourceRequest);
+}
+
+bool ArgumentCoder<ResourceRequest>::decode(ArgumentDecoder* decoder, ResourceRequest& resourceRequest)
+{
+    if (kShouldSerializeWebCoreData) {
+        ResourceRequest request;
+
+        String url;
+        if (!decoder->decode(url))
+            return false;
+        request.setURL(KURL(KURL(), url));
+
+        String httpMethod;
+        if (!decoder->decode(httpMethod))
+            return false;
+        request.setHTTPMethod(httpMethod);
+
+        HTTPHeaderMap headers;
+        if (!decoder->decode(headers))
+            return false;
+        request.addHTTPHeaderFields(headers);
+
+        bool hasHTTPBody;
+        if (!decoder->decode(hasHTTPBody))
+            return false;
+        if (hasHTTPBody) {
+            String httpBody;
+            if (!decoder->decode(httpBody))
+                return false;
+            request.setHTTPBody(FormData::create(httpBody.utf8()));
+        }
+
+        String firstPartyForCookies;
+        if (!decoder->decode(firstPartyForCookies))
+            return false;
+        request.setFirstPartyForCookies(KURL(KURL(), firstPartyForCookies));
+
+        resourceRequest = request;
+    }
+
+    return decodePlatformData(decoder, resourceRequest);
+}
+
+void ArgumentCoder<ResourceResponse>::encode(ArgumentEncoder* encoder, const ResourceResponse& resourceResponse)
+{
+    if (kShouldSerializeWebCoreData) {
+        bool responseIsNull = resourceResponse.isNull();
+        encoder->encode(responseIsNull);
+        if (responseIsNull)
+            return;
+
+        encoder->encode(resourceResponse.url().string());
+        encoder->encode(static_cast<int32_t>(resourceResponse.httpStatusCode()));
+
+        const HTTPHeaderMap& headers = resourceResponse.httpHeaderFields();
+        encoder->encode(headers);
+
+        encoder->encode(resourceResponse.mimeType());
+        encoder->encode(resourceResponse.textEncodingName());
+        encoder->encode(static_cast<int64_t>(resourceResponse.expectedContentLength()));
+        encoder->encode(resourceResponse.httpStatusText());
+        encoder->encode(resourceResponse.suggestedFilename());
+    }
+
+    encodePlatformData(encoder, resourceResponse);
+}
+
+bool ArgumentCoder<ResourceResponse>::decode(ArgumentDecoder* decoder, ResourceResponse& resourceResponse)
+{
+    if (kShouldSerializeWebCoreData) {
+        bool responseIsNull;
+        if (!decoder->decode(responseIsNull))
+            return false;
+        if (responseIsNull) {
+            resourceResponse = ResourceResponse();
+            return true;
+        }
+
+        ResourceResponse response;
+
+        String url;
+        if (!decoder->decode(url))
+            return false;
+        response.setURL(KURL(KURL(), url));
+
+        int32_t httpStatusCode;
+        if (!decoder->decode(httpStatusCode))
+            return false;
+        response.setHTTPStatusCode(httpStatusCode);
+
+        HTTPHeaderMap headers;
+        if (!decoder->decode(headers))
+            return false;
+        for (HTTPHeaderMap::const_iterator it = headers.begin(), end = headers.end(); it != end; ++it)
+            response.setHTTPHeaderField(it->key, it->value);
+
+        String mimeType;
+        if (!decoder->decode(mimeType))
+            return false;
+        response.setMimeType(mimeType);
+
+        String textEncodingName;
+        if (!decoder->decode(textEncodingName))
+            return false;
+        response.setTextEncodingName(textEncodingName);
+
+        int64_t contentLength;
+        if (!decoder->decode(contentLength))
+            return false;
+        response.setExpectedContentLength(contentLength);
+
+        String httpStatusText;
+        if (!decoder->decode(httpStatusText))
+            return false;
+        response.setHTTPStatusText(httpStatusText);
+
+        String suggestedFilename;
+        if (!decoder->decode(suggestedFilename))
+            return false;
+        response.setSuggestedFilename(suggestedFilename);
+
+        resourceResponse = response;
+    }
+
+    return decodePlatformData(decoder, resourceResponse);
+}
+
+void ArgumentCoder<ResourceError>::encode(ArgumentEncoder* encoder, const ResourceError& resourceError)
+{
+    if (kShouldSerializeWebCoreData) {
+        bool errorIsNull = resourceError.isNull();
+        encoder->encode(errorIsNull);
+        if (errorIsNull)
+            return;
+
+        encoder->encode(resourceError.domain());
+        encoder->encode(resourceError.errorCode());
+        encoder->encode(resourceError.failingURL());
+        encoder->encode(resourceError.localizedDescription());
+        encoder->encode(resourceError.isCancellation());
+        encoder->encode(resourceError.isTimeout());
+    }
+
+    encodePlatformData(encoder, resourceError);
+}
+
+bool ArgumentCoder<ResourceError>::decode(ArgumentDecoder* decoder, ResourceError& resourceError)
+{
+    if (kShouldSerializeWebCoreData) {
+        bool errorIsNull;
+        if (!decoder->decode(errorIsNull))
+            return false;
+        if (errorIsNull) {
+            resourceError = ResourceError();
+            return true;
+        }
+
+        String domain;
+        if (!decoder->decode(domain))
+            return false;
+
+        int errorCode;
+        if (!decoder->decode(errorCode))
+            return false;
+
+        String failingURL;
+        if (!decoder->decode(failingURL))
+            return false;
+
+        String localizedDescription;
+        if (!decoder->decode(localizedDescription))
+            return false;
+
+        bool isCancellation;
+        if (!decoder->decode(isCancellation))
+            return false;
+
+        bool isTimeout;
+        if (!decoder->decode(isTimeout))
+            return false;
+
+        resourceError = ResourceError(domain, errorCode, failingURL, localizedDescription);
+        resourceError.setIsCancellation(isCancellation);
+        resourceError.setIsTimeout(isTimeout);
+    }
+
+    return decodePlatformData(decoder, resourceError);
+}
 
 void ArgumentCoder<WindowFeatures>::encode(ArgumentEncoder* encoder, const WindowFeatures& windowFeatures)
 {
@@ -795,6 +1009,115 @@ bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder,
 }
 #endif
 
+#if USE(GRAPHICS_SURFACE)
+void ArgumentCoder<WebCore::GraphicsSurfaceToken>::encode(ArgumentEncoder* encoder, const WebCore::GraphicsSurfaceToken& token)
+{
+#if OS(DARWIN)
+    encoder->encodeUInt32(token.frontBufferHandle);
+    encoder->encodeUInt32(token.backBufferHandle);
+#endif
+#if OS(LINUX)
+    encoder->encodeUInt32(token.frontBufferHandle);
+#endif
+}
+
+bool ArgumentCoder<WebCore::GraphicsSurfaceToken>::decode(ArgumentDecoder* decoder, WebCore::GraphicsSurfaceToken& token)
+{
+#if OS(DARWIN)
+    if (!decoder->decodeUInt32(token.frontBufferHandle))
+        return false;
+    if (!decoder->decodeUInt32(token.backBufferHandle))
+        return false;
+#endif
+#if OS(LINUX)
+    if (!decoder->decodeUInt32(token.frontBufferHandle))
+        return false;
+#endif
+    return true;
+}
+
+#endif
+
 #endif
 
+void ArgumentCoder<WebCore::UserStyleSheet>::encode(ArgumentEncoder* encoder, const WebCore::UserStyleSheet& userStyleSheet)
+{
+    encoder->encode(userStyleSheet.source());
+    encoder->encode(userStyleSheet.url());
+    encoder->encode(userStyleSheet.whitelist());
+    encoder->encode(userStyleSheet.blacklist());
+    encoder->encodeEnum(userStyleSheet.injectedFrames());
+    encoder->encodeEnum(userStyleSheet.level());
+}
+
+bool ArgumentCoder<WebCore::UserStyleSheet>::decode(ArgumentDecoder* decoder, WebCore::UserStyleSheet& userStyleSheet)
+{
+    String source;
+    if (!decoder->decode(source))
+        return false;
+
+    KURL url;
+    if (!decoder->decode(url))
+        return false;
+
+    Vector<String> whitelist;
+    if (!decoder->decode(whitelist))
+        return false;
+
+    Vector<String> blacklist;
+    if (!decoder->decode(blacklist))
+        return false;
+
+    WebCore::UserContentInjectedFrames injectedFrames;
+    if (!decoder->decodeEnum(injectedFrames))
+        return false;
+
+    WebCore::UserStyleLevel level;
+    if (!decoder->decodeEnum(level))
+        return false;
+
+    userStyleSheet = WebCore::UserStyleSheet(source, url, whitelist, blacklist, injectedFrames, level);
+    return true;
+}
+
+void ArgumentCoder<WebCore::UserScript>::encode(ArgumentEncoder* encoder, const WebCore::UserScript& userScript)
+{
+    encoder->encode(userScript.source());
+    encoder->encode(userScript.url());
+    encoder->encode(userScript.whitelist());
+    encoder->encode(userScript.blacklist());
+    encoder->encodeEnum(userScript.injectionTime());
+    encoder->encodeEnum(userScript.injectedFrames());
+}
+
+bool ArgumentCoder<WebCore::UserScript>::decode(ArgumentDecoder* decoder, WebCore::UserScript& userScript)
+{
+    String source;
+    if (!decoder->decode(source))
+        return false;
+
+    KURL url;
+    if (!decoder->decode(url))
+        return false;
+
+    Vector<String> whitelist;
+    if (!decoder->decode(whitelist))
+        return false;
+
+    Vector<String> blacklist;
+    if (!decoder->decode(blacklist))
+        return false;
+
+    WebCore::UserScriptInjectionTime injectionTime;
+    if (!decoder->decodeEnum(injectionTime))
+        return false;
+
+    WebCore::UserContentInjectedFrames injectedFrames;
+    if (!decoder->decodeEnum(injectedFrames))
+        return false;
+
+    userScript = WebCore::UserScript(source, url, whitelist, blacklist, injectionTime, injectedFrames);
+    return true;
+}
+
 } // namespace CoreIPC