Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 227 insertions, 0 deletions

diff --git a/dom/serviceworkers/FetchEventOpProxyParent.cpp b/dom/serviceworkers/FetchEventOpProxyParent.cpp
new file mode 100644
index 0000000000..8146131739
--- /dev/null
+++ b/dom/serviceworkers/FetchEventOpProxyParent.cpp
@@ -0,0 +1,227 @@
+/* -*- 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 "FetchEventOpProxyParent.h"
+
+#include <utility>
+
+#include "mozilla/dom/FetchTypes.h"
+#include "mozilla/dom/ServiceWorkerOpArgs.h"
+#include "nsCOMPtr.h"
+#include "nsIInputStream.h"
+
+#include "mozilla/Assertions.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Result.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/InternalResponse.h"
+#include "mozilla/dom/PRemoteWorkerParent.h"
+#include "mozilla/dom/PRemoteWorkerControllerParent.h"
+#include "mozilla/dom/FetchEventOpParent.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/ipc/IPCStreamUtils.h"
+#include "mozilla/RemoteLazyInputStreamStorage.h"
+
+namespace mozilla {
+
+using namespace ipc;
+
+namespace dom {
+
+namespace {
+
+nsresult MaybeDeserializeAndWrapForMainThread(
+    const Maybe<ChildToParentStream>& aSource, int64_t aBodyStreamSize,
+    Maybe<ParentToParentStream>& aSink, PBackgroundParent* aManager) {
+  if (aSource.isNothing()) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIInputStream> deserialized =
+      DeserializeIPCStream(aSource->stream());
+
+  aSink = Some(ParentToParentStream());
+  auto& uuid = aSink->uuid();
+
+  MOZ_TRY(nsID::GenerateUUIDInPlace(uuid));
+
+  auto storageOrErr = RemoteLazyInputStreamStorage::Get();
+
+  if (NS_WARN_IF(storageOrErr.isErr())) {
+    return storageOrErr.unwrapErr();
+  }
+
+  auto storage = storageOrErr.unwrap();
+  storage->AddStream(deserialized, uuid);
+  return NS_OK;
+}
+
+ParentToParentInternalResponse ToParentToParent(
+    const ChildToParentInternalResponse& aResponse,
+    NotNull<PBackgroundParent*> aBackgroundParent) {
+  ParentToParentInternalResponse parentToParentResponse(
+      aResponse.metadata(), Nothing(), aResponse.bodySize(), Nothing());
+
+  MOZ_ALWAYS_SUCCEEDS(MaybeDeserializeAndWrapForMainThread(
+      aResponse.body(), aResponse.bodySize(), parentToParentResponse.body(),
+      aBackgroundParent));
+  MOZ_ALWAYS_SUCCEEDS(MaybeDeserializeAndWrapForMainThread(
+      aResponse.alternativeBody(), InternalResponse::UNKNOWN_BODY_SIZE,
+      parentToParentResponse.alternativeBody(), aBackgroundParent));
+
+  return parentToParentResponse;
+}
+
+ParentToParentSynthesizeResponseArgs ToParentToParent(
+    const ChildToParentSynthesizeResponseArgs& aArgs,
+    NotNull<PBackgroundParent*> aBackgroundParent) {
+  return ParentToParentSynthesizeResponseArgs(
+      ToParentToParent(aArgs.internalResponse(), aBackgroundParent),
+      aArgs.closure(), aArgs.timeStamps());
+}
+
+ParentToParentFetchEventRespondWithResult ToParentToParent(
+    const ChildToParentFetchEventRespondWithResult& aResult,
+    NotNull<PBackgroundParent*> aBackgroundParent) {
+  switch (aResult.type()) {
+    case ChildToParentFetchEventRespondWithResult::
+        TChildToParentSynthesizeResponseArgs:
+      return ToParentToParent(aResult.get_ChildToParentSynthesizeResponseArgs(),
+                              aBackgroundParent);
+
+    case ChildToParentFetchEventRespondWithResult::TResetInterceptionArgs:
+      return aResult.get_ResetInterceptionArgs();
+
+    case ChildToParentFetchEventRespondWithResult::TCancelInterceptionArgs:
+      return aResult.get_CancelInterceptionArgs();
+
+    default:
+      MOZ_CRASH("Invalid ParentToParentFetchEventRespondWithResult");
+  }
+}
+
+}  // anonymous namespace
+
+/* static */ void FetchEventOpProxyParent::Create(
+    PRemoteWorkerParent* aManager,
+    RefPtr<ServiceWorkerFetchEventOpPromise::Private>&& aPromise,
+    const ParentToParentServiceWorkerFetchEventOpArgs& aArgs,
+    RefPtr<FetchEventOpParent> aReal, nsCOMPtr<nsIInputStream> aBodyStream) {
+  AssertIsInMainProcess();
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(aManager);
+  MOZ_ASSERT(aReal);
+
+  ParentToChildServiceWorkerFetchEventOpArgs copyArgs(aArgs.common(), Nothing(),
+                                                      Nothing());
+  if (aArgs.preloadResponse().isSome()) {
+    // Convert the preload response to ParentToChildInternalResponse.
+    copyArgs.preloadResponse() = Some(ToParentToChild(
+        aArgs.preloadResponse().ref(), WrapNotNull(aManager->Manager())));
+  }
+
+  if (aArgs.preloadResponseEndArgs().isSome()) {
+    copyArgs.preloadResponseEndArgs() = aArgs.preloadResponseEndArgs();
+  }
+
+  FetchEventOpProxyParent* actor =
+      new FetchEventOpProxyParent(std::move(aReal), std::move(aPromise));
+
+  // As long as the fetch event was pending, the FetchEventOpParent was
+  // responsible for keeping the preload response, if it already arrived. Once
+  // the fetch event starts it gives up the preload response (if any) and we
+  // need to add it to the arguments. Note that we have to make sure that the
+  // arguments don't contain the preload response already, otherwise we'll end
+  // up overwriting it with a Nothing.
+  Maybe<ParentToParentInternalResponse> preloadResponse;
+  Maybe<ResponseEndArgs> preloadResponseEndArgs;
+  Tie(preloadResponse, preloadResponseEndArgs) =
+      actor->mReal->OnStart(WrapNotNull(actor));
+  if (copyArgs.preloadResponse().isNothing() && preloadResponse.isSome()) {
+    copyArgs.preloadResponse() = Some(ToParentToChild(
+        preloadResponse.ref(), WrapNotNull(aManager->Manager())));
+  }
+  if (copyArgs.preloadResponseEndArgs().isNothing() &&
+      preloadResponseEndArgs.isSome()) {
+    copyArgs.preloadResponseEndArgs() = preloadResponseEndArgs;
+  }
+
+  IPCInternalRequest& copyRequest = copyArgs.common().internalRequest();
+
+  if (aBodyStream) {
+    copyRequest.body() = Some(ParentToChildStream());
+
+    RefPtr<RemoteLazyInputStream> stream =
+        RemoteLazyInputStream::WrapStream(aBodyStream);
+    MOZ_DIAGNOSTIC_ASSERT(stream);
+
+    copyRequest.body().ref().get_ParentToChildStream().stream() = stream;
+  }
+
+  Unused << aManager->SendPFetchEventOpProxyConstructor(actor, copyArgs);
+}
+
+FetchEventOpProxyParent::~FetchEventOpProxyParent() {
+  AssertIsOnBackgroundThread();
+}
+
+FetchEventOpProxyParent::FetchEventOpProxyParent(
+    RefPtr<FetchEventOpParent>&& aReal,
+    RefPtr<ServiceWorkerFetchEventOpPromise::Private>&& aPromise)
+    : mReal(std::move(aReal)), mLifetimePromise(std::move(aPromise)) {}
+
+mozilla::ipc::IPCResult FetchEventOpProxyParent::RecvAsyncLog(
+    const nsCString& aScriptSpec, const uint32_t& aLineNumber,
+    const uint32_t& aColumnNumber, const nsCString& aMessageName,
+    nsTArray<nsString>&& aParams) {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(mReal);
+
+  Unused << mReal->SendAsyncLog(aScriptSpec, aLineNumber, aColumnNumber,
+                                aMessageName, aParams);
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult FetchEventOpProxyParent::RecvRespondWith(
+    const ChildToParentFetchEventRespondWithResult& aResult) {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(mReal);
+
+  auto manager = WrapNotNull(mReal->Manager());
+  auto backgroundParent = WrapNotNull(manager->Manager());
+  Unused << mReal->SendRespondWith(ToParentToParent(aResult, backgroundParent));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult FetchEventOpProxyParent::Recv__delete__(
+    const ServiceWorkerFetchEventOpResult& aResult) {
+  AssertIsOnBackgroundThread();
+  MOZ_ASSERT(mLifetimePromise);
+  MOZ_ASSERT(mReal);
+  mReal->OnFinish();
+  if (mLifetimePromise) {
+    mLifetimePromise->Resolve(aResult, __func__);
+    mLifetimePromise = nullptr;
+    mReal = nullptr;
+  }
+
+  return IPC_OK();
+}
+
+void FetchEventOpProxyParent::ActorDestroy(ActorDestroyReason) {
+  AssertIsOnBackgroundThread();
+  if (mLifetimePromise) {
+    mLifetimePromise->Reject(NS_ERROR_DOM_ABORT_ERR, __func__);
+    mLifetimePromise = nullptr;
+    mReal = nullptr;
+  }
+}
+
+}  // namespace dom
+}  // namespace mozilla