Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 191 insertions, 0 deletions

diff --git a/ipc/glue/IPCStreamUtils.cpp b/ipc/glue/IPCStreamUtils.cpp
new file mode 100644
index 0000000000..b884bf5d5d
--- /dev/null
+++ b/ipc/glue/IPCStreamUtils.cpp
@@ -0,0 +1,191 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 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/. */
+
+#include "IPCStreamUtils.h"
+
+#include "ipc/IPCMessageUtilsSpecializations.h"
+
+#include "nsIHttpHeaderVisitor.h"
+#include "nsIIPCSerializableInputStream.h"
+#include "mozIRemoteLazyInputStream.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/ipc/IPCStream.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/InputStreamLengthHelper.h"
+#include "mozilla/RemoteLazyInputStreamParent.h"
+#include "mozilla/Unused.h"
+#include "nsIMIMEInputStream.h"
+#include "nsNetCID.h"
+
+using namespace mozilla::dom;
+
+namespace mozilla::ipc {
+
+namespace {
+
+class MIMEStreamHeaderVisitor final : public nsIHttpHeaderVisitor {
+ public:
+  explicit MIMEStreamHeaderVisitor(
+      nsTArray<mozilla::ipc::HeaderEntry>& aHeaders)
+      : mHeaders(aHeaders) {}
+
+  NS_DECL_ISUPPORTS
+  NS_IMETHOD VisitHeader(const nsACString& aName,
+                         const nsACString& aValue) override {
+    auto el = mHeaders.AppendElement();
+    el->name() = aName;
+    el->value() = aValue;
+    return NS_OK;
+  }
+
+ private:
+  ~MIMEStreamHeaderVisitor() = default;
+
+  nsTArray<mozilla::ipc::HeaderEntry>& mHeaders;
+};
+
+NS_IMPL_ISUPPORTS(MIMEStreamHeaderVisitor, nsIHttpHeaderVisitor)
+
+static bool SerializeLazyInputStream(nsIInputStream* aStream,
+                                     IPCStream& aValue) {
+  MOZ_ASSERT(aStream);
+  MOZ_ASSERT(XRE_IsParentProcess());
+
+  // If we're serializing a MIME stream, ensure we preserve header data which
+  // would not be preserved by a RemoteLazyInputStream wrapper.
+  if (nsCOMPtr<nsIMIMEInputStream> mimeStream = do_QueryInterface(aStream)) {
+    MIMEInputStreamParams params;
+    params.startedReading() = false;
+
+    nsCOMPtr<nsIHttpHeaderVisitor> visitor =
+        new MIMEStreamHeaderVisitor(params.headers());
+    if (NS_WARN_IF(NS_FAILED(mimeStream->VisitHeaders(visitor)))) {
+      return false;
+    }
+
+    nsCOMPtr<nsIInputStream> dataStream;
+    if (NS_FAILED(mimeStream->GetData(getter_AddRefs(dataStream)))) {
+      return false;
+    }
+    if (dataStream) {
+      IPCStream data;
+      if (!SerializeLazyInputStream(dataStream, data)) {
+        return false;
+      }
+      params.optionalStream().emplace(std::move(data.stream()));
+    }
+
+    aValue.stream() = std::move(params);
+    return true;
+  }
+
+  RefPtr<RemoteLazyInputStream> lazyStream =
+      RemoteLazyInputStream::WrapStream(aStream);
+  if (NS_WARN_IF(!lazyStream)) {
+    return false;
+  }
+
+  aValue.stream() = RemoteLazyInputStreamParams(WrapNotNull(lazyStream));
+
+  return true;
+}
+
+}  // anonymous namespace
+
+bool SerializeIPCStream(already_AddRefed<nsIInputStream> aInputStream,
+                        IPCStream& aValue, bool aAllowLazy) {
+  nsCOMPtr<nsIInputStream> stream(std::move(aInputStream));
+  if (!stream) {
+    MOZ_ASSERT_UNREACHABLE(
+        "Use the Maybe<...> overload to serialize optional nsIInputStreams");
+    return false;
+  }
+
+  // When requesting a delayed start stream from the parent process, serialize
+  // it as a remote lazy stream to avoid bloating payloads.
+  if (aAllowLazy && XRE_IsParentProcess()) {
+    return SerializeLazyInputStream(stream, aValue);
+  }
+
+  if (nsCOMPtr<nsIIPCSerializableInputStream> serializable =
+          do_QueryInterface(stream)) {
+    // If you change this size, please also update the payload size in
+    // test_reload_large_postdata.html.
+    const uint64_t kTooLargeStream = 1024 * 1024;
+
+    uint32_t sizeUsed = 0;
+    serializable->Serialize(aValue.stream(), kTooLargeStream, &sizeUsed);
+
+    MOZ_ASSERT(sizeUsed <= kTooLargeStream);
+
+    if (aValue.stream().type() == InputStreamParams::T__None) {
+      MOZ_CRASH("Serialize failed!");
+    }
+    return true;
+  }
+
+  InputStreamHelper::SerializeInputStreamAsPipe(stream, aValue.stream());
+  if (aValue.stream().type() == InputStreamParams::T__None) {
+    MOZ_ASSERT_UNREACHABLE("Serializing as a pipe failed");
+    return false;
+  }
+  return true;
+}
+
+bool SerializeIPCStream(already_AddRefed<nsIInputStream> aInputStream,
+                        Maybe<IPCStream>& aValue, bool aAllowLazy) {
+  nsCOMPtr<nsIInputStream> stream(std::move(aInputStream));
+  if (!stream) {
+    aValue.reset();
+    return true;
+  }
+
+  IPCStream value;
+  if (SerializeIPCStream(stream.forget(), value, aAllowLazy)) {
+    aValue = Some(value);
+    return true;
+  }
+  return false;
+}
+
+already_AddRefed<nsIInputStream> DeserializeIPCStream(const IPCStream& aValue) {
+  return InputStreamHelper::DeserializeInputStream(aValue.stream());
+}
+
+already_AddRefed<nsIInputStream> DeserializeIPCStream(
+    const Maybe<IPCStream>& aValue) {
+  if (aValue.isNothing()) {
+    return nullptr;
+  }
+
+  return DeserializeIPCStream(aValue.ref());
+}
+
+}  // namespace mozilla::ipc
+
+void IPC::ParamTraits<nsIInputStream*>::Write(IPC::MessageWriter* aWriter,
+                                              nsIInputStream* aParam) {
+  mozilla::Maybe<mozilla::ipc::IPCStream> stream;
+  if (!mozilla::ipc::SerializeIPCStream(do_AddRef(aParam), stream,
+                                        /* aAllowLazy */ true)) {
+    MOZ_CRASH("Failed to serialize nsIInputStream");
+  }
+
+  WriteParam(aWriter, stream);
+}
+
+bool IPC::ParamTraits<nsIInputStream*>::Read(IPC::MessageReader* aReader,
+                                             RefPtr<nsIInputStream>* aResult) {
+  mozilla::Maybe<mozilla::ipc::IPCStream> ipcStream;
+  if (!ReadParam(aReader, &ipcStream)) {
+    return false;
+  }
+
+  *aResult = mozilla::ipc::DeserializeIPCStream(ipcStream);
+  return true;
+}