firefox-main/dom/messagechannel/MessagePortParent.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* 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 "MessagePortParent.h"
#include "MessagePortService.h"
#include "mozilla/dom/RefMessageBodyService.h"
#include "mozilla/dom/SharedMessageBody.h"
namespace mozilla::dom {
MessagePortParent::MessagePortParent(const nsID& aUUID)
: mService(MessagePortService::GetOrCreate()),
mUUID(aUUID),
mEntangled(false),
mCanSendData(true) {
MOZ_ASSERT(mService);
}
MessagePortParent::~MessagePortParent() {
MOZ_ASSERT(!mService);
MOZ_ASSERT(!mEntangled);
}
bool MessagePortParent::Entangle(const nsID& aDestinationUUID,
const uint32_t& aSequenceID) {
if (!mService) {
NS_WARNING("Entangle is called after a shutdown!");
return false;
}
MOZ_ASSERT(!mEntangled);
return mService->RequestEntangling(this, aDestinationUUID, aSequenceID);
}
mozilla::ipc::IPCResult MessagePortParent::RecvPostMessages(
nsTArray<NotNull<RefPtr<SharedMessageBody>>>&& aMessages) {
if (!mService) {
NS_WARNING("PostMessages is called after a shutdown!");
// This implies most probably that CloseAndDelete() has been already called
// such that we have no better option than to silently ignore this call.
return IPC_OK();
}
if (!mEntangled) {
// The child may send PostMessages before the Entangled() callback arrives
// (e.g. if it calls postMessage() then Atomics.wait() before the entangling
// IPC round-trip completes). Buffer these messages and flush them when
// Entangled() is called.
if (!mPendingMessages.AppendElements(std::move(aMessages),
mozilla::fallible)) {
return IPC_FAIL(this, "RecvPostMessages OOM");
}
return IPC_OK();
}
if (aMessages.IsEmpty()) {
// An empty payload can be safely ignored.
return IPC_OK();
}
if (!mService->PostMessages(this, std::move(aMessages))) {
// TODO: Verify if all failure conditions of PostMessages() merit an
// IPC_FAIL. See bug 1750499.
return IPC_FAIL(this, "RecvPostMessages->PostMessages");
}
return IPC_OK();
}
mozilla::ipc::IPCResult MessagePortParent::RecvDisentangle(
nsTArray<NotNull<RefPtr<SharedMessageBody>>>&& aMessages) {
if (!mService) {
NS_WARNING("Entangle is called after a shutdown!");
// This implies most probably that CloseAndDelete() has been already called
// such that we can silently ignore this call.
return IPC_OK();
}
if (!mEntangled) {
// If we were shut down, the above condition already bailed out. So this
// should actually never happen and returning a failure is fine.
return IPC_FAIL(this, "RecvDisentangle not entangled");
}
if (!mService->DisentanglePort(this, std::move(aMessages))) {
// TODO: Verify if all failure conditions of DisentanglePort() merit an
// IPC_FAIL. See bug 1750501.
return IPC_FAIL(this, "RecvDisentangle->DisentanglePort");
}
CloseAndDelete();
return IPC_OK();
}
mozilla::ipc::IPCResult MessagePortParent::RecvStopSendingData() {
if (!mEntangled) {
return IPC_OK();
}
mCanSendData = false;
(void)SendStopSendingDataConfirmed();
return IPC_OK();
}
mozilla::ipc::IPCResult MessagePortParent::RecvClose() {
if (mService) {
MOZ_ASSERT(mEntangled);
if (!mService->ClosePort(this)) {
return IPC_FAIL(this, "RecvClose->ClosePort");
}
Close();
}
MOZ_ASSERT(!mEntangled);
(void)Send__delete__(this);
return IPC_OK();
}
void MessagePortParent::ActorDestroy(ActorDestroyReason aWhy) {
if (mService && mEntangled) {
// When the last parent is deleted, this service is freed but this cannot
// be done when the hashtables are written by CloseAll.
RefPtr<MessagePortService> kungFuDeathGrip = mService;
kungFuDeathGrip->ParentDestroy(this);
}
}
bool MessagePortParent::Entangled(
nsTArray<NotNull<RefPtr<SharedMessageBody>>>&& aMessages) {
MOZ_ASSERT(!mEntangled);
mEntangled = true;
// Flush any messages that arrived via PostMessages before entangling
// completed.
if (!mPendingMessages.IsEmpty() && mService) {
mService->PostMessages(this, std::move(mPendingMessages));
mPendingMessages.Clear();
}
return SendEntangled(aMessages);
}
void MessagePortParent::CloseAndDelete() {
Close();
(void)Send__delete__(this);
}
void MessagePortParent::Close() {
mService = nullptr;
mEntangled = false;
}
/* static */
bool MessagePortParent::ForceClose(const nsID& aUUID,
const nsID& aDestinationUUID,
const uint32_t& aSequenceID) {
MessagePortService* service = MessagePortService::Get();
if (!service) {
NS_WARNING(
"The service must exist if we want to close an existing MessagePort.");
// There is nothing to close so we are ok.
return true;
}
return service->ForceClose(aUUID, aDestinationUUID, aSequenceID);
}
} // namespace mozilla::dom