mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 00:35:44 +00:00
4c6f89824d
Differential Revision: https://phabricator.services.mozilla.com/D80931
188 lines
5.8 KiB
C++
188 lines
5.8 KiB
C++
/* -*- 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 "nsCOMPtr.h"
|
|
#include "nsContentUtils.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/FetchEventOpParent.h"
|
|
#include "mozilla/ipc/BackgroundParent.h"
|
|
#include "mozilla/ipc/IPCStreamUtils.h"
|
|
#include "mozilla/RemoteLazyInputStreamUtils.h"
|
|
#include "mozilla/RemoteLazyInputStreamStorage.h"
|
|
|
|
namespace mozilla {
|
|
|
|
using namespace ipc;
|
|
|
|
namespace dom {
|
|
|
|
namespace {
|
|
|
|
nsresult MaybeDeserializeAndWrapForMainThread(
|
|
const Maybe<BodyStreamVariant>& aSource, int64_t aBodyStreamSize,
|
|
Maybe<BodyStreamVariant>& aSink, PBackgroundParent* aManager) {
|
|
if (aSource.isNothing()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStream> deserialized =
|
|
DeserializeIPCStream(aSource->get_ChildToParentStream().stream());
|
|
|
|
aSink = Some(ParentToParentStream());
|
|
auto& uuid = aSink->get_ParentToParentStream().uuid();
|
|
|
|
MOZ_TRY(nsContentUtils::GenerateUUIDInPlace(uuid));
|
|
|
|
RemoteLazyInputStreamStorage::Get()->AddStream(deserialized, uuid,
|
|
aBodyStreamSize, 0);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
/* static */ void FetchEventOpProxyParent::Create(
|
|
PRemoteWorkerParent* aManager, const ServiceWorkerFetchEventOpArgs& aArgs,
|
|
RefPtr<FetchEventOpParent> aReal) {
|
|
AssertIsInMainProcess();
|
|
AssertIsOnBackgroundThread();
|
|
MOZ_ASSERT(aManager);
|
|
MOZ_ASSERT(aReal);
|
|
|
|
FetchEventOpProxyParent* actor =
|
|
new FetchEventOpProxyParent(std::move(aReal));
|
|
|
|
if (aArgs.internalRequest().body().isNothing()) {
|
|
Unused << aManager->SendPFetchEventOpProxyConstructor(actor, aArgs);
|
|
return;
|
|
}
|
|
|
|
ServiceWorkerFetchEventOpArgs copyArgs = aArgs;
|
|
IPCInternalRequest& copyRequest = copyArgs.internalRequest();
|
|
|
|
if (copyRequest.body().ref().type() ==
|
|
BodyStreamVariant::TParentToParentStream) {
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
auto streamLength = copyRequest.bodySize();
|
|
const auto& uuid =
|
|
copyRequest.body().ref().get_ParentToParentStream().uuid();
|
|
RemoteLazyInputStreamStorage* storage = RemoteLazyInputStreamStorage::Get();
|
|
|
|
storage->GetStream(uuid, 0, streamLength, getter_AddRefs(stream));
|
|
storage->ForgetStream(uuid);
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(stream);
|
|
|
|
PBackgroundParent* bgParent = aManager->Manager();
|
|
MOZ_ASSERT(bgParent);
|
|
|
|
copyRequest.body() = Some(ParentToChildStream());
|
|
|
|
RemoteLazyStream ipdlStream;
|
|
MOZ_ALWAYS_SUCCEEDS(RemoteLazyInputStreamUtils::SerializeInputStream(
|
|
stream, streamLength, ipdlStream, bgParent));
|
|
|
|
copyRequest.body().ref().get_ParentToChildStream().actorParent() =
|
|
ipdlStream;
|
|
}
|
|
|
|
Unused << aManager->SendPFetchEventOpProxyConstructor(actor, copyArgs);
|
|
}
|
|
|
|
FetchEventOpProxyParent::~FetchEventOpProxyParent() {
|
|
AssertIsOnBackgroundThread();
|
|
}
|
|
|
|
FetchEventOpProxyParent::FetchEventOpProxyParent(
|
|
RefPtr<FetchEventOpParent>&& aReal)
|
|
: mReal(std::move(aReal)) {}
|
|
|
|
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 IPCFetchEventRespondWithResult& aResult) {
|
|
AssertIsOnBackgroundThread();
|
|
MOZ_ASSERT(mReal);
|
|
|
|
// IPCSynthesizeResponseArgs possibly contains an IPCStream. If so,
|
|
// deserialize it and reserialize it before forwarding it to the main thread.
|
|
if (aResult.type() ==
|
|
IPCFetchEventRespondWithResult::TIPCSynthesizeResponseArgs) {
|
|
const IPCSynthesizeResponseArgs& originalArgs =
|
|
aResult.get_IPCSynthesizeResponseArgs();
|
|
const IPCInternalResponse& originalResponse =
|
|
originalArgs.internalResponse();
|
|
|
|
// Do nothing if neither the body nor the alt. body can be deserialized.
|
|
if (!originalResponse.body() && !originalResponse.alternativeBody()) {
|
|
Unused << mReal->SendRespondWith(aResult);
|
|
return IPC_OK();
|
|
}
|
|
|
|
IPCSynthesizeResponseArgs copyArgs = originalArgs;
|
|
IPCInternalResponse& copyResponse = copyArgs.internalResponse();
|
|
|
|
PRemoteWorkerControllerParent* manager = mReal->Manager();
|
|
MOZ_ASSERT(manager);
|
|
|
|
PBackgroundParent* bgParent = manager->Manager();
|
|
MOZ_ASSERT(bgParent);
|
|
|
|
MOZ_ALWAYS_SUCCEEDS(MaybeDeserializeAndWrapForMainThread(
|
|
originalResponse.body(), copyResponse.bodySize(), copyResponse.body(),
|
|
bgParent));
|
|
MOZ_ALWAYS_SUCCEEDS(MaybeDeserializeAndWrapForMainThread(
|
|
originalResponse.alternativeBody(), InternalResponse::UNKNOWN_BODY_SIZE,
|
|
copyResponse.alternativeBody(), bgParent));
|
|
|
|
Unused << mReal->SendRespondWith(copyArgs);
|
|
} else {
|
|
Unused << mReal->SendRespondWith(aResult);
|
|
}
|
|
|
|
return IPC_OK();
|
|
}
|
|
|
|
mozilla::ipc::IPCResult FetchEventOpProxyParent::Recv__delete__(
|
|
const ServiceWorkerFetchEventOpResult& aResult) {
|
|
AssertIsOnBackgroundThread();
|
|
MOZ_ASSERT(mReal);
|
|
|
|
Unused << mReal->Send__delete__(mReal, aResult);
|
|
mReal = nullptr;
|
|
|
|
return IPC_OK();
|
|
}
|
|
|
|
void FetchEventOpProxyParent::ActorDestroy(ActorDestroyReason) {
|
|
AssertIsOnBackgroundThread();
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|