Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 280 insertions, 0 deletions

diff --git a/netwerk/protocol/http/PHttpChannelParams.h b/netwerk/protocol/http/PHttpChannelParams.h
new file mode 100644
index 0000000000..ef7582dfe5
--- /dev/null
+++ b/netwerk/protocol/http/PHttpChannelParams.h
@@ -0,0 +1,280 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_net_PHttpChannelParams_h
+#define mozilla_net_PHttpChannelParams_h
+
+#define ALLOW_LATE_NSHTTP_H_INCLUDE 1
+#include "base/basictypes.h"
+
+#include "ipc/IPCMessageUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
+#include "nsHttp.h"
+#include "nsHttpHeaderArray.h"
+#include "nsHttpRequestHead.h"
+#include "nsHttpResponseHead.h"
+#include "mozilla/Tuple.h"
+
+namespace mozilla {
+namespace net {
+
+struct RequestHeaderTuple {
+  nsCString mHeader;
+  nsCString mValue;
+  bool mMerge;
+  bool mEmpty;
+
+  bool operator==(const RequestHeaderTuple& other) const {
+    return mHeader.Equals(other.mHeader) && mValue.Equals(other.mValue) &&
+           mMerge == other.mMerge && mEmpty == other.mEmpty;
+  }
+};
+
+typedef CopyableTArray<RequestHeaderTuple> RequestHeaderTuples;
+
+}  // namespace net
+}  // namespace mozilla
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::net::RequestHeaderTuple> {
+  typedef mozilla::net::RequestHeaderTuple paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mHeader);
+    WriteParam(aMsg, aParam.mValue);
+    WriteParam(aMsg, aParam.mMerge);
+    WriteParam(aMsg, aParam.mEmpty);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    if (!ReadParam(aMsg, aIter, &aResult->mHeader) ||
+        !ReadParam(aMsg, aIter, &aResult->mValue) ||
+        !ReadParam(aMsg, aIter, &aResult->mMerge) ||
+        !ReadParam(aMsg, aIter, &aResult->mEmpty))
+      return false;
+
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::net::nsHttpAtom> {
+  typedef mozilla::net::nsHttpAtom paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    // aParam.get() cannot be null.
+    MOZ_ASSERT(aParam.get(), "null nsHTTPAtom value");
+    nsAutoCString value(aParam.get());
+    WriteParam(aMsg, value);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    nsAutoCString value;
+    if (!ReadParam(aMsg, aIter, &value)) return false;
+
+    *aResult = mozilla::net::nsHttp::ResolveAtom(value.get());
+    MOZ_ASSERT(aResult->get(), "atom table not initialized");
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::net::nsHttpHeaderArray::nsEntry> {
+  typedef mozilla::net::nsHttpHeaderArray::nsEntry paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    if (aParam.headerNameOriginal.IsEmpty()) {
+      WriteParam(aMsg, aParam.header);
+    } else {
+      WriteParam(aMsg, aParam.headerNameOriginal);
+    }
+    WriteParam(aMsg, aParam.value);
+    switch (aParam.variety) {
+      case mozilla::net::nsHttpHeaderArray::eVarietyUnknown:
+        WriteParam(aMsg, (uint8_t)0);
+        break;
+      case mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride:
+        WriteParam(aMsg, (uint8_t)1);
+        break;
+      case mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault:
+        WriteParam(aMsg, (uint8_t)2);
+        break;
+      case mozilla::net::nsHttpHeaderArray::
+          eVarietyResponseNetOriginalAndResponse:
+        WriteParam(aMsg, (uint8_t)3);
+        break;
+      case mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal:
+        WriteParam(aMsg, (uint8_t)4);
+        break;
+      case mozilla::net::nsHttpHeaderArray::eVarietyResponse:
+        WriteParam(aMsg, (uint8_t)5);
+    }
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    uint8_t variety;
+    nsAutoCString header;
+    if (!ReadParam(aMsg, aIter, &header) ||
+        !ReadParam(aMsg, aIter, &aResult->value) ||
+        !ReadParam(aMsg, aIter, &variety))
+      return false;
+
+    mozilla::net::nsHttpAtom atom = mozilla::net::nsHttp::ResolveAtom(header);
+    aResult->header = atom;
+    if (!header.Equals(atom.get())) {
+      aResult->headerNameOriginal = header;
+    }
+
+    switch (variety) {
+      case 0:
+        aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyUnknown;
+        break;
+      case 1:
+        aResult->variety =
+            mozilla::net::nsHttpHeaderArray::eVarietyRequestOverride;
+        break;
+      case 2:
+        aResult->variety =
+            mozilla::net::nsHttpHeaderArray::eVarietyRequestDefault;
+        break;
+      case 3:
+        aResult->variety = mozilla::net::nsHttpHeaderArray::
+            eVarietyResponseNetOriginalAndResponse;
+        break;
+      case 4:
+        aResult->variety =
+            mozilla::net::nsHttpHeaderArray::eVarietyResponseNetOriginal;
+        break;
+      case 5:
+        aResult->variety = mozilla::net::nsHttpHeaderArray::eVarietyResponse;
+        break;
+      default:
+        return false;
+    }
+
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::net::nsHttpHeaderArray> {
+  typedef mozilla::net::nsHttpHeaderArray paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    paramType& p = const_cast<paramType&>(aParam);
+
+    WriteParam(aMsg, p.mHeaders);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    if (!ReadParam(aMsg, aIter, &aResult->mHeaders)) return false;
+
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::net::nsHttpRequestHead> {
+  typedef mozilla::net::nsHttpRequestHead paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mHeaders);
+    WriteParam(aMsg, aParam.mMethod);
+    WriteParam(aMsg, static_cast<uint32_t>(aParam.mVersion));
+    WriteParam(aMsg, aParam.mRequestURI);
+    WriteParam(aMsg, aParam.mPath);
+    WriteParam(aMsg, aParam.mOrigin);
+    WriteParam(aMsg, static_cast<uint8_t>(aParam.mParsedMethod));
+    WriteParam(aMsg, aParam.mHTTPS);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    uint32_t version;
+    uint8_t method;
+    if (!ReadParam(aMsg, aIter, &aResult->mHeaders) ||
+        !ReadParam(aMsg, aIter, &aResult->mMethod) ||
+        !ReadParam(aMsg, aIter, &version) ||
+        !ReadParam(aMsg, aIter, &aResult->mRequestURI) ||
+        !ReadParam(aMsg, aIter, &aResult->mPath) ||
+        !ReadParam(aMsg, aIter, &aResult->mOrigin) ||
+        !ReadParam(aMsg, aIter, &method) ||
+        !ReadParam(aMsg, aIter, &aResult->mHTTPS)) {
+      return false;
+    }
+
+    aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
+    aResult->mParsedMethod =
+        static_cast<mozilla::net::nsHttpRequestHead::ParsedMethodType>(method);
+    return true;
+  }
+};
+
+// Note that the code below MUST be synchronized with the code in
+// nsHttpRequestHead's copy constructor.
+template <>
+struct ParamTraits<mozilla::net::nsHttpResponseHead> {
+  typedef mozilla::net::nsHttpResponseHead paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.mHeaders);
+    WriteParam(aMsg, static_cast<uint32_t>(aParam.mVersion));
+    WriteParam(aMsg, aParam.mStatus);
+    WriteParam(aMsg, aParam.mStatusText);
+    WriteParam(aMsg, aParam.mContentLength);
+    WriteParam(aMsg, aParam.mContentType);
+    WriteParam(aMsg, aParam.mContentCharset);
+    WriteParam(aMsg, aParam.mHasCacheControl);
+    WriteParam(aMsg, aParam.mCacheControlPublic);
+    WriteParam(aMsg, aParam.mCacheControlPrivate);
+    WriteParam(aMsg, aParam.mCacheControlNoStore);
+    WriteParam(aMsg, aParam.mCacheControlNoCache);
+    WriteParam(aMsg, aParam.mCacheControlImmutable);
+    WriteParam(aMsg, aParam.mCacheControlStaleWhileRevalidateSet);
+    WriteParam(aMsg, aParam.mCacheControlStaleWhileRevalidate);
+    WriteParam(aMsg, aParam.mCacheControlMaxAgeSet);
+    WriteParam(aMsg, aParam.mCacheControlMaxAge);
+    WriteParam(aMsg, aParam.mPragmaNoCache);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter,
+                   paramType* aResult) {
+    uint32_t version;
+    if (!ReadParam(aMsg, aIter, &aResult->mHeaders) ||
+        !ReadParam(aMsg, aIter, &version) ||
+        !ReadParam(aMsg, aIter, &aResult->mStatus) ||
+        !ReadParam(aMsg, aIter, &aResult->mStatusText) ||
+        !ReadParam(aMsg, aIter, &aResult->mContentLength) ||
+        !ReadParam(aMsg, aIter, &aResult->mContentType) ||
+        !ReadParam(aMsg, aIter, &aResult->mContentCharset) ||
+        !ReadParam(aMsg, aIter, &aResult->mHasCacheControl) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlPublic) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlPrivate) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlNoStore) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlNoCache) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlImmutable) ||
+        !ReadParam(aMsg, aIter,
+                   &aResult->mCacheControlStaleWhileRevalidateSet) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlStaleWhileRevalidate) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlMaxAgeSet) ||
+        !ReadParam(aMsg, aIter, &aResult->mCacheControlMaxAge) ||
+        !ReadParam(aMsg, aIter, &aResult->mPragmaNoCache))
+      return false;
+
+    aResult->mVersion = static_cast<mozilla::net::HttpVersion>(version);
+    return true;
+  }
+};
+
+}  // namespace IPC
+
+#endif  // mozilla_net_PHttpChannelParams_h