1 files changed, 116 insertions, 34 deletions

diff --git a/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp b/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp
index 727895087..49f407175 100644
--- a/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp
+++ b/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp
@@ -33,49 +33,24 @@
 #include <WebCore/ResourceError.h>
 #include <WebCore/ResourceRequest.h>
 #include <WebCore/ResourceResponse.h>
+#include <WebCore/SoupNetworkProxySettings.h>
 #include <wtf/text/CString.h>
 
 using namespace WebCore;
 
 namespace IPC {
 
-void ArgumentCoder<ResourceRequest>::encodePlatformData(ArgumentEncoder& encoder, const ResourceRequest& resourceRequest)
+void ArgumentCoder<ResourceRequest>::encodePlatformData(Encoder& encoder, const ResourceRequest& resourceRequest)
 {
-    encoder << static_cast<uint32_t>(resourceRequest.soupMessageFlags());
-    encoder << resourceRequest.initiatingPageID();
+    resourceRequest.encodeWithPlatformData(encoder);
 }
 
-bool ArgumentCoder<ResourceRequest>::decodePlatformData(ArgumentDecoder& decoder, ResourceRequest& resourceRequest)
+bool ArgumentCoder<ResourceRequest>::decodePlatformData(Decoder& decoder, ResourceRequest& resourceRequest)
 {
-    uint32_t soupMessageFlags;
-    if (!decoder.decode(soupMessageFlags))
-        return false;
-    resourceRequest.setSoupMessageFlags(static_cast<SoupMessageFlags>(soupMessageFlags));
-
-    uint64_t initiatingPageID;
-    if (!decoder.decode(initiatingPageID))
-        return false;
-    resourceRequest.setInitiatingPageID(initiatingPageID);
-
-    return true;
-}
-
-
-void ArgumentCoder<ResourceResponse>::encodePlatformData(ArgumentEncoder& encoder, const ResourceResponse& resourceResponse)
-{
-    encoder << static_cast<uint32_t>(resourceResponse.soupMessageFlags());
-}
-
-bool ArgumentCoder<ResourceResponse>::decodePlatformData(ArgumentDecoder& decoder, ResourceResponse& resourceResponse)
-{
-    uint32_t soupMessageFlags;
-    if (!decoder.decode(soupMessageFlags))
-        return false;
-    resourceResponse.setSoupMessageFlags(static_cast<SoupMessageFlags>(soupMessageFlags));
-    return true;
+    return resourceRequest.decodeWithPlatformData(decoder);
 }
 
-void ArgumentCoder<CertificateInfo>::encode(ArgumentEncoder& encoder, const CertificateInfo& certificateInfo)
+void ArgumentCoder<CertificateInfo>::encode(Encoder& encoder, const CertificateInfo& certificateInfo)
 {
     if (!certificateInfo.certificate()) {
         encoder << false;
@@ -95,7 +70,7 @@ void ArgumentCoder<CertificateInfo>::encode(ArgumentEncoder& encoder, const Cert
     encoder << static_cast<uint32_t>(certificateInfo.tlsErrors());
 }
 
-bool ArgumentCoder<CertificateInfo>::decode(ArgumentDecoder& decoder, CertificateInfo& certificateInfo)
+bool ArgumentCoder<CertificateInfo>::decode(Decoder& decoder, CertificateInfo& certificateInfo)
 {
     bool hasCertificate;
     if (!decoder.decode(hasCertificate))
@@ -125,13 +100,49 @@ bool ArgumentCoder<CertificateInfo>::decode(ArgumentDecoder& decoder, Certificat
     return true;
 }
 
-void ArgumentCoder<ResourceError>::encodePlatformData(ArgumentEncoder& encoder, const ResourceError& resourceError)
+void ArgumentCoder<ResourceError>::encodePlatformData(Encoder& encoder, const ResourceError& resourceError)
 {
+    encoder.encodeEnum(resourceError.type());
+    if (resourceError.isNull())
+        return;
+
+    encoder << resourceError.domain();
+    encoder << resourceError.errorCode();
+    encoder << resourceError.failingURL().string();
+    encoder << resourceError.localizedDescription();
+
     encoder << CertificateInfo(resourceError);
 }
 
-bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder& decoder, ResourceError& resourceError)
+bool ArgumentCoder<ResourceError>::decodePlatformData(Decoder& decoder, ResourceError& resourceError)
 {
+    ResourceErrorBase::Type errorType;
+    if (!decoder.decodeEnum(errorType))
+        return false;
+    if (errorType == ResourceErrorBase::Type::Null) {
+        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;
+
+    resourceError = ResourceError(domain, errorCode, URL(URL(), failingURL), localizedDescription);
+    resourceError.setType(errorType);
+
     CertificateInfo certificateInfo;
     if (!decoder.decode(certificateInfo))
         return false;
@@ -141,5 +152,76 @@ bool ArgumentCoder<ResourceError>::decodePlatformData(ArgumentDecoder& decoder,
     return true;
 }
 
+void ArgumentCoder<SoupNetworkProxySettings>::encode(Encoder& encoder, const SoupNetworkProxySettings& settings)
+{
+    ASSERT(!settings.isEmpty());
+    encoder.encodeEnum(settings.mode);
+    if (settings.mode != SoupNetworkProxySettings::Mode::Custom)
+        return;
+
+    encoder << settings.defaultProxyURL;
+    uint32_t ignoreHostsCount = settings.ignoreHosts ? g_strv_length(settings.ignoreHosts.get()) : 0;
+    encoder << ignoreHostsCount;
+    if (ignoreHostsCount) {
+        for (uint32_t i = 0; settings.ignoreHosts.get()[i]; ++i)
+            encoder << CString(settings.ignoreHosts.get()[i]);
+    }
+    encoder << settings.proxyMap;
+}
+
+bool ArgumentCoder<SoupNetworkProxySettings>::decode(Decoder& decoder, SoupNetworkProxySettings& settings)
+{
+    if (!decoder.decodeEnum(settings.mode))
+        return false;
+
+    if (settings.mode != SoupNetworkProxySettings::Mode::Custom)
+        return true;
+
+    if (!decoder.decode(settings.defaultProxyURL))
+        return false;
+
+    uint32_t ignoreHostsCount;
+    if (!decoder.decode(ignoreHostsCount))
+        return false;
+
+    if (ignoreHostsCount) {
+        settings.ignoreHosts.reset(g_new0(char*, ignoreHostsCount + 1));
+        for (uint32_t i = 0; i < ignoreHostsCount; ++i) {
+            CString host;
+            if (!decoder.decode(host))
+                return false;
+
+            settings.ignoreHosts.get()[i] = g_strdup(host.data());
+        }
+    }
+
+    if (!decoder.decode(settings.proxyMap))
+        return false;
+
+    return !settings.isEmpty();
+}
+
+void ArgumentCoder<ProtectionSpace>::encodePlatformData(Encoder&, const ProtectionSpace&)
+{
+    ASSERT_NOT_REACHED();
+}
+
+bool ArgumentCoder<ProtectionSpace>::decodePlatformData(Decoder&, ProtectionSpace&)
+{
+    ASSERT_NOT_REACHED();
+    return false;
+}
+
+void ArgumentCoder<Credential>::encodePlatformData(Encoder&, const Credential&)
+{
+    ASSERT_NOT_REACHED();
+}
+
+bool ArgumentCoder<Credential>::decodePlatformData(Decoder&, Credential&)
+{
+    ASSERT_NOT_REACHED();
+    return false;
+}
+
 }