//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/dom/PWindowGlobalParent.h"
#include "ipc/ErrorIPCUtils.h"
#include "ipc/MediaControlIPC.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/ConsoleReportIPCUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/IdentityCredentialSerializationHelpers.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PermissionsPolicyUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/RemoteType.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/SessionStoreMessageUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/WindowGlobalMessageUtils.h"
#include "mozilla/dom/WindowGlobalParent.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsIPolicyContainer.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsPoint.h"
#include "nsStructuredCloneContainer.h"

#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PInProcessParent.h"
#include "mozilla/dom/PBrowserBridgeParent.h"
#include "mozilla/a11y/PDocAccessibleParent.h"
#include "mozilla/dom/PDigitalCredentialParent.h"
#include "mozilla/dom/PSerialManagerParent.h"
#include "mozilla/dom/PWebAuthnTransactionParent.h"
#include "mozilla/dom/PWebIdentityParent.h"
#include "mozilla/dom/PPrefetchRecordParent.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"

namespace mozilla {
namespace dom {


auto PWindowGlobalParent::RecvPDigitalCredentialConstructor(PDigitalCredentialParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PWindowGlobalParent::RecvPPrefetchRecordConstructor(
        PPrefetchRecordParent* actor,
        const SpeculativePrefetchArgs& args) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PWindowGlobalParent::RecvPSerialManagerConstructor(PSerialManagerParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PWindowGlobalParent::RecvPWebAuthnTransactionConstructor(PWebAuthnTransactionParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PWindowGlobalParent::RecvPWebIdentityConstructor(PWebIdentityParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PWindowGlobalParent::RecvPDocAccessibleConstructor(
        PDocAccessibleParent* actor,
        const uint64_t& aParentAcc,
        const bool& aIsPrintDoc) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

MOZ_IMPLICIT PWindowGlobalParent::PWindowGlobalParent() :
    mozilla::ipc::IRefCountedProtocol(kProtocolId, mozilla::ipc::ParentSide)
{
    MOZ_COUNT_CTOR(PWindowGlobalParent);
}

PWindowGlobalParent::~PWindowGlobalParent()
{
    MOZ_COUNT_DTOR(PWindowGlobalParent);
}

auto PWindowGlobalParent::ActorAlloc() -> void
{
    AddRef();
}

auto PWindowGlobalParent::ActorDealloc() -> void
{
    Release();
}

auto PWindowGlobalParent::ManagedPDocAccessibleParent(nsTArray<PDocAccessibleParent*>& aArr) const -> void
{
    mManagedPDocAccessibleParent.ToArray(aArr);
}

auto PWindowGlobalParent::ManagedPDocAccessibleParent() const -> const ManagedContainer<PDocAccessibleParent>&
{
    return mManagedPDocAccessibleParent;
}

auto PWindowGlobalParent::ManagedPDigitalCredentialParent(nsTArray<PDigitalCredentialParent*>& aArr) const -> void
{
    mManagedPDigitalCredentialParent.ToArray(aArr);
}

auto PWindowGlobalParent::ManagedPDigitalCredentialParent() const -> const ManagedContainer<PDigitalCredentialParent>&
{
    return mManagedPDigitalCredentialParent;
}

auto PWindowGlobalParent::ManagedPPrefetchRecordParent(nsTArray<PPrefetchRecordParent*>& aArr) const -> void
{
    mManagedPPrefetchRecordParent.ToArray(aArr);
}

auto PWindowGlobalParent::ManagedPPrefetchRecordParent() const -> const ManagedContainer<PPrefetchRecordParent>&
{
    return mManagedPPrefetchRecordParent;
}

auto PWindowGlobalParent::ManagedPSerialManagerParent(nsTArray<PSerialManagerParent*>& aArr) const -> void
{
    mManagedPSerialManagerParent.ToArray(aArr);
}

auto PWindowGlobalParent::ManagedPSerialManagerParent() const -> const ManagedContainer<PSerialManagerParent>&
{
    return mManagedPSerialManagerParent;
}

auto PWindowGlobalParent::ManagedPWebAuthnTransactionParent(nsTArray<PWebAuthnTransactionParent*>& aArr) const -> void
{
    mManagedPWebAuthnTransactionParent.ToArray(aArr);
}

auto PWindowGlobalParent::ManagedPWebAuthnTransactionParent() const -> const ManagedContainer<PWebAuthnTransactionParent>&
{
    return mManagedPWebAuthnTransactionParent;
}

auto PWindowGlobalParent::ManagedPWebIdentityParent(nsTArray<PWebIdentityParent*>& aArr) const -> void
{
    mManagedPWebIdentityParent.ToArray(aArr);
}

auto PWindowGlobalParent::ManagedPWebIdentityParent() const -> const ManagedContainer<PWebIdentityParent>&
{
    return mManagedPWebIdentityParent;
}

auto PWindowGlobalParent::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
    static constexpr ::mozilla::ipc::ProtocolId sIds[] = {
        PDocAccessibleMsgStart,
        PDigitalCredentialMsgStart,
        PPrefetchRecordMsgStart,
        PSerialManagerMsgStart,
        PWebAuthnTransactionMsgStart,
        PWebIdentityMsgStart
    };
    return sIds;
}

auto PWindowGlobalParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PDocAccessibleMsgStart:
        return (&(mManagedPDocAccessibleParent));
    case PDigitalCredentialMsgStart:
        return (&(mManagedPDigitalCredentialParent));
    case PPrefetchRecordMsgStart:
        return (&(mManagedPPrefetchRecordParent));
    case PSerialManagerMsgStart:
        return (&(mManagedPSerialManagerParent));
    case PWebAuthnTransactionMsgStart:
        return (&(mManagedPWebAuthnTransactionParent));
    case PWebIdentityMsgStart:
        return (&(mManagedPWebIdentityParent));
    default:
        return nullptr;
    }
}

auto PWindowGlobalParent::RejectPendingResponses(ResponseRejectReason aReason) -> void
{
    mAsyncCallbacks.RejectPendingResponses(aReason);
}

auto PWindowGlobalParent::OpenPDocAccessibleEndpoint(PDocAccessibleParent* aActor) -> ManagedEndpoint<PDocAccessibleChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PDocAccessibleParent actor");
        return ManagedEndpoint<PDocAccessibleChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PDocAccessibleParent actor");
        return ManagedEndpoint<PDocAccessibleChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PDocAccessibleChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PWindowGlobalParent::BindPDocAccessibleEndpoint(
        ManagedEndpoint<PDocAccessibleParent> aEndpoint,
        PDocAccessibleParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PWindowGlobalParent::OpenPDigitalCredentialEndpoint(PDigitalCredentialParent* aActor) -> ManagedEndpoint<PDigitalCredentialChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PDigitalCredentialParent actor");
        return ManagedEndpoint<PDigitalCredentialChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PDigitalCredentialParent actor");
        return ManagedEndpoint<PDigitalCredentialChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PDigitalCredentialChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PWindowGlobalParent::BindPDigitalCredentialEndpoint(
        ManagedEndpoint<PDigitalCredentialParent> aEndpoint,
        PDigitalCredentialParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PWindowGlobalParent::OpenPPrefetchRecordEndpoint(PPrefetchRecordParent* aActor) -> ManagedEndpoint<PPrefetchRecordChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PPrefetchRecordParent actor");
        return ManagedEndpoint<PPrefetchRecordChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PPrefetchRecordParent actor");
        return ManagedEndpoint<PPrefetchRecordChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PPrefetchRecordChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PWindowGlobalParent::BindPPrefetchRecordEndpoint(
        ManagedEndpoint<PPrefetchRecordParent> aEndpoint,
        PPrefetchRecordParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PWindowGlobalParent::OpenPSerialManagerEndpoint(PSerialManagerParent* aActor) -> ManagedEndpoint<PSerialManagerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PSerialManagerParent actor");
        return ManagedEndpoint<PSerialManagerChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PSerialManagerParent actor");
        return ManagedEndpoint<PSerialManagerChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PSerialManagerChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PWindowGlobalParent::BindPSerialManagerEndpoint(
        ManagedEndpoint<PSerialManagerParent> aEndpoint,
        PSerialManagerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PWindowGlobalParent::OpenPWebAuthnTransactionEndpoint(PWebAuthnTransactionParent* aActor) -> ManagedEndpoint<PWebAuthnTransactionChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PWebAuthnTransactionParent actor");
        return ManagedEndpoint<PWebAuthnTransactionChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PWebAuthnTransactionParent actor");
        return ManagedEndpoint<PWebAuthnTransactionChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PWebAuthnTransactionChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PWindowGlobalParent::BindPWebAuthnTransactionEndpoint(
        ManagedEndpoint<PWebAuthnTransactionParent> aEndpoint,
        PWebAuthnTransactionParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PWindowGlobalParent::OpenPWebIdentityEndpoint(PWebIdentityParent* aActor) -> ManagedEndpoint<PWebIdentityChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PWebIdentityParent actor");
        return ManagedEndpoint<PWebIdentityChild>();
    }

    if (!aActor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PWebIdentityParent actor");
        return ManagedEndpoint<PWebIdentityChild>();
    }

    // Mark our actor as awaiting the other side to be bound. This will
    // be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
    // received.
    aActor->mAwaitingManagedEndpointBind = true;
    return ManagedEndpoint<PWebIdentityChild>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

auto PWindowGlobalParent::BindPWebIdentityEndpoint(
        ManagedEndpoint<PWebIdentityParent> aEndpoint,
        PWebIdentityParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PWindowGlobalParent::Send__delete__(PWindowGlobalParent* actor) -> bool
{
    if (!actor || !actor->CanSend()) {
        NS_WARNING("Attempt to __delete__ missing or closed actor");
        return false;
    }
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg___delete__((actor)->Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            actor};


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            actor->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg___delete__", OTHER);

    bool sendok__ = (actor)->ChannelSend(std::move(msg__));

    actor->ActorDisconnected(Deletion);
    return sendok__;
}

auto PWindowGlobalParent::SendMakeFrameLocal(
        const MaybeDiscardedBrowsingContext& aFrameContext,
        const uint64_t& aSwitchId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_MakeFrameLocal(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFrameContext);
    // Sentinel = 'aFrameContext'
    ((&(writer__)))->WriteSentinel(585565490);
    IPC::WriteParam((&(writer__)), aSwitchId);
    // Sentinel = 'aSwitchId'
    ((&(writer__)))->WriteSentinel(297730945);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameLocal", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendMakeFrameRemote(
        const MaybeDiscardedBrowsingContext& aFrameContext,
        ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>&& aEndpoint,
        const TabId& aTabId,
        const LayersId& aLayersId,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_MakeFrameRemote(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFrameContext);
    // Sentinel = 'aFrameContext'
    ((&(writer__)))->WriteSentinel(585565490);
    IPC::WriteParam((&(writer__)), std::move(aEndpoint));
    // Sentinel = 'aEndpoint'
    ((&(writer__)))->WriteSentinel(292225955);
    IPC::WriteParam((&(writer__)), aTabId);
    // Sentinel = 'aTabId'
    ((&(writer__)))->WriteSentinel(126878246);
    IPC::WriteParam((&(writer__)), aLayersId);
    // Sentinel = 'aLayersId'
    ((&(writer__)))->WriteSentinel(291439487);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameRemote", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_MakeFrameRemote__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__success = IPC::ReadParam<bool>(aReader);
            if (!maybe__success) {
                (aReader)->FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& success = *maybe__success;
            // Sentinel = 'success'
            if ((!((aReader)->ReadSentinel(200082170)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::move(success));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendMakeFrameRemote(
        const MaybeDiscardedBrowsingContext& aFrameContext,
        ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>&& aEndpoint,
        const TabId& aTabId,
        const LayersId& aLayersId) -> RefPtr<MakeFrameRemotePromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendMakeFrameRemote(std::forward<const MaybeDiscardedBrowsingContext&>(aFrameContext), std::forward<ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>&&>(aEndpoint), std::forward<const TabId&>(aTabId), std::forward<const LayersId&>(aLayersId), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendDrawSnapshot(
        const mozilla::Maybe<IntRect>& aRect,
        const float& aScale,
        const nscolor& aBackgroundColor,
        const CrossProcessPaintFlags& aFlags,
        mozilla::ipc::ResolveCallback<PaintFragment>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_DrawSnapshot(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aRect);
    // Sentinel = 'aRect'
    ((&(writer__)))->WriteSentinel(94044656);
    IPC::WriteParam((&(writer__)), aScale);
    // Sentinel = 'aScale'
    ((&(writer__)))->WriteSentinel(131531338);
    IPC::WriteParam((&(writer__)), aBackgroundColor);
    // Sentinel = 'aBackgroundColor'
    ((&(writer__)))->WriteSentinel(884999777);
    IPC::WriteParam((&(writer__)), aFlags);
    // Sentinel = 'aFlags'
    ((&(writer__)))->WriteSentinel(129892943);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DrawSnapshot", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_DrawSnapshot__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__retval = IPC::ReadParam<PaintFragment>(aReader);
            if (!maybe__retval) {
                (aReader)->FatalError("Error deserializing 'PaintFragment'");
                return MsgValueError;

            }
            auto& retval = *maybe__retval;
            // Sentinel = 'retval'
            if ((!((aReader)->ReadSentinel(151716495)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PaintFragment'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::move(retval));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendDrawSnapshot(
        const mozilla::Maybe<IntRect>& aRect,
        const float& aScale,
        const nscolor& aBackgroundColor,
        const CrossProcessPaintFlags& aFlags) -> RefPtr<DrawSnapshotPromise>
{
    RefPtr<MozPromise<PaintFragment, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PaintFragment, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendDrawSnapshot(std::forward<const mozilla::Maybe<IntRect>&>(aRect), std::forward<const float&>(aScale), std::forward<const nscolor&>(aBackgroundColor), std::forward<const CrossProcessPaintFlags&>(aFlags), [promise__](PaintFragment&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendRequestDocumentLanguageMetadata(
        const uint32_t& aTextSampleMinCodeUnits,
        const uint32_t& aTextSampleTargetCodeUnits,
        mozilla::ipc::ResolveCallback<mozilla::Maybe<DocumentLanguageMetadata>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RequestDocumentLanguageMetadata(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTextSampleMinCodeUnits);
    // Sentinel = 'aTextSampleMinCodeUnits'
    ((&(writer__)))->WriteSentinel(1816791323);
    IPC::WriteParam((&(writer__)), aTextSampleTargetCodeUnits);
    // Sentinel = 'aTextSampleTargetCodeUnits'
    ((&(writer__)))->WriteSentinel(2328955486);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RequestDocumentLanguageMetadata", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_RequestDocumentLanguageMetadata__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__metadata = IPC::ReadParam<mozilla::Maybe<DocumentLanguageMetadata>>(aReader);
            if (!maybe__metadata) {
                (aReader)->FatalError("Error deserializing 'DocumentLanguageMetadata?'");
                return MsgValueError;

            }
            auto& metadata = *maybe__metadata;
            // Sentinel = 'metadata'
            if ((!((aReader)->ReadSentinel(248251202)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DocumentLanguageMetadata?'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::move(metadata));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendRequestDocumentLanguageMetadata(
        const uint32_t& aTextSampleMinCodeUnits,
        const uint32_t& aTextSampleTargetCodeUnits) -> RefPtr<RequestDocumentLanguageMetadataPromise>
{
    RefPtr<MozPromise<mozilla::Maybe<DocumentLanguageMetadata>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<DocumentLanguageMetadata>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRequestDocumentLanguageMetadata(std::forward<const uint32_t&>(aTextSampleMinCodeUnits), std::forward<const uint32_t&>(aTextSampleTargetCodeUnits), [promise__](mozilla::Maybe<DocumentLanguageMetadata>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendDispatchSecurityPolicyViolation(
        const nsAString& aViolationEventJSON,
        const nsAString& aReportGroupName) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_DispatchSecurityPolicyViolation(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aViolationEventJSON);
    // Sentinel = 'aViolationEventJSON'
    ((&(writer__)))->WriteSentinel(1266878291);
    IPC::WriteParam((&(writer__)), aReportGroupName);
    // Sentinel = 'aReportGroupName'
    ((&(writer__)))->WriteSentinel(912655980);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DispatchSecurityPolicyViolation", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendSaveStorageAccessPermissionGranted() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SaveStorageAccessPermissionGranted(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SaveStorageAccessPermissionGranted", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendAddBlockedFrameNodeByClassifier(const MaybeDiscardedBrowsingContext& aNode) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_AddBlockedFrameNodeByClassifier(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aNode);
    // Sentinel = 'aNode'
    ((&(writer__)))->WriteSentinel(94110184);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_AddBlockedFrameNodeByClassifier", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendResetScalingZoom() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_ResetScalingZoom(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ResetScalingZoom", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendRestoreDocShellState(
        const DocShellRestoreState& aState,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RestoreDocShellState(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aState);
    // Sentinel = 'aState'
    ((&(writer__)))->WriteSentinel(137036387);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreDocShellState", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_RestoreDocShellState__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__success = IPC::ReadParam<bool>(aReader);
            if (!maybe__success) {
                (aReader)->FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& success = *maybe__success;
            // Sentinel = 'success'
            if ((!((aReader)->ReadSentinel(200082170)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::move(success));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendRestoreDocShellState(const DocShellRestoreState& aState) -> RefPtr<RestoreDocShellStatePromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRestoreDocShellState(std::forward<const DocShellRestoreState&>(aState), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendRestoreTabContent(
        SessionStoreRestoreData* aData,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RestoreTabContent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aData);
    // Sentinel = 'aData'
    ((&(writer__)))->WriteSentinel(90571228);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreTabContent", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_RestoreTabContent__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__success = IPC::ReadParam<bool>(aReader);
            if (!maybe__success) {
                (aReader)->FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& success = *maybe__success;
            // Sentinel = 'success'
            if ((!((aReader)->ReadSentinel(200082170)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::move(success));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendRestoreTabContent(SessionStoreRestoreData* aData) -> RefPtr<RestoreTabContentPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRestoreTabContent(std::forward<SessionStoreRestoreData*>(aData), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendRawMessage(
        const JSActorMessageMeta& aMetadata,
        const JSIPCValue& aData,
        StructuredCloneData* aStack) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RawMessage(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aMetadata);
    // Sentinel = 'aMetadata'
    ((&(writer__)))->WriteSentinel(288752515);
    IPC::WriteParam((&(writer__)), aData);
    // Sentinel = 'aData'
    ((&(writer__)))->WriteSentinel(90571228);
    IPC::WriteParam((&(writer__)), aStack);
    // Sentinel = 'aStack'
    ((&(writer__)))->WriteSentinel(135201368);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RawMessage", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendNotifyAudioSessionStateChanged(const AudioSessionState& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_NotifyAudioSessionStateChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aState);
    // Sentinel = 'aState'
    ((&(writer__)))->WriteSentinel(137036387);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_NotifyAudioSessionStateChanged", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendNotifyPermissionChange(
        const nsACString& type,
        const uint32_t& permission) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_NotifyPermissionChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), type);
    // Sentinel = 'type'
    ((&(writer__)))->WriteSentinel(75760067);
    IPC::WriteParam((&(writer__)), permission);
    // Sentinel = 'permission'
    ((&(writer__)))->WriteSentinel(394921034);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_NotifyPermissionChange", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendProcessCloseRequest(const MaybeDiscardedBrowsingContext& aFocused) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_ProcessCloseRequest(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFocused);
    // Sentinel = 'aFocused'
    ((&(writer__)))->WriteSentinel(232653611);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ProcessCloseRequest", OTHER);

    bool sendok__ = ChannelSend(std::move(msg__));
    return sendok__;
}

auto PWindowGlobalParent::SendGetModelContextTools(
        mozilla::ipc::ResolveCallback<std::tuple<nsresult, nsTArray<IPCModelContextToolDefinition>>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_GetModelContextTools(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetModelContextTools", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_GetModelContextTools__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__rv = IPC::ReadParam<nsresult>(aReader);
            if (!maybe__rv) {
                (aReader)->FatalError("Error deserializing 'nsresult'");
                return MsgValueError;

            }
            auto& rv = *maybe__rv;
            // Sentinel = 'rv'
            if ((!((aReader)->ReadSentinel(22806761)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            auto maybe__tools = IPC::ReadParam<nsTArray<IPCModelContextToolDefinition>>(aReader);
            if (!maybe__tools) {
                (aReader)->FatalError("Error deserializing 'IPCModelContextToolDefinition[]'");
                return MsgValueError;

            }
            auto& tools = *maybe__tools;
            // Sentinel = 'tools'
            if ((!((aReader)->ReadSentinel(110953010)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCModelContextToolDefinition[]'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::make_tuple(std::move(rv), std::move(tools)));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendGetModelContextTools() -> RefPtr<GetModelContextToolsPromise>
{
    RefPtr<MozPromise<std::tuple<nsresult, nsTArray<IPCModelContextToolDefinition>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<nsresult, nsTArray<IPCModelContextToolDefinition>>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetModelContextTools([promise__](std::tuple<nsresult, nsTArray<IPCModelContextToolDefinition>>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendGetContentMetrics(
        mozilla::ipc::ResolveCallback<std::tuple<CSSSize, float>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_GetContentMetrics(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetContentMetrics", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_GetContentMetrics__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__size = IPC::ReadParam<CSSSize>(aReader);
            if (!maybe__size) {
                (aReader)->FatalError("Error deserializing 'CSSSize'");
                return MsgValueError;

            }
            auto& size = *maybe__size;
            // Sentinel = 'size'
            if ((!((aReader)->ReadSentinel(73662908)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CSSSize'");
                return MsgValueError;
            }
            auto maybe__devicePixelRatio = IPC::ReadParam<float>(aReader);
            if (!maybe__devicePixelRatio) {
                (aReader)->FatalError("Error deserializing 'float'");
                return MsgValueError;

            }
            auto& devicePixelRatio = *maybe__devicePixelRatio;
            // Sentinel = 'devicePixelRatio'
            if ((!((aReader)->ReadSentinel(915801714)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::make_tuple(std::move(size), std::move(devicePixelRatio)));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendGetContentMetrics() -> RefPtr<GetContentMetricsPromise>
{
    RefPtr<MozPromise<std::tuple<CSSSize, float>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<CSSSize, float>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetContentMetrics([promise__](std::tuple<CSSSize, float>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::SendInvokeModelContextTool(
        const nsACString& toolName,
        mozilla::NotNull<StructuredCloneData*> input,
        mozilla::ipc::ResolveCallback<std::tuple<CopyableErrorResult, RefPtr<StructuredCloneData>>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_InvokeModelContextTool(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), toolName);
    // Sentinel = 'toolName'
    ((&(writer__)))->WriteSentinel(251724608);
    IPC::WriteParam((&(writer__)), input);
    // Sentinel = 'input'
    ((&(writer__)))->WriteSentinel(108528177);


    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWindowGlobal::Msg_InvokeModelContextTool", OTHER);

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_InvokeModelContextTool__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__rv = IPC::ReadParam<CopyableErrorResult>(aReader);
            if (!maybe__rv) {
                (aReader)->FatalError("Error deserializing 'CopyableErrorResult'");
                return MsgValueError;

            }
            auto& rv = *maybe__rv;
            // Sentinel = 'rv'
            if ((!((aReader)->ReadSentinel(22806761)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CopyableErrorResult'");
                return MsgValueError;
            }
            auto maybe__output = IPC::ReadParam<RefPtr<StructuredCloneData>>(aReader);
            if (!maybe__output) {
                (aReader)->FatalError("Error deserializing 'StructuredCloneData'");
                return MsgValueError;

            }
            auto& output = *maybe__output;
            // Sentinel = 'output'
            if ((!((aReader)->ReadSentinel(157745842)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData'");
                return MsgValueError;
            }


            aReader->EndRead();

            resolve(std::make_tuple(std::move(rv), std::move(output)));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PWindowGlobalParent::SendInvokeModelContextTool(
        const nsACString& toolName,
        mozilla::NotNull<StructuredCloneData*> input) -> RefPtr<InvokeModelContextToolPromise>
{
    RefPtr<MozPromise<std::tuple<CopyableErrorResult, RefPtr<StructuredCloneData>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<CopyableErrorResult, RefPtr<StructuredCloneData>>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendInvokeModelContextTool(std::forward<const nsACString&>(toolName), std::forward<mozilla::NotNull<StructuredCloneData*>>(input), [promise__](std::tuple<CopyableErrorResult, RefPtr<StructuredCloneData>>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalParent::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    default:
        FatalError("unreached");
        return;
    }
}

auto PWindowGlobalParent::OnMessageReceived(const Message& msg__) -> PWindowGlobalParent::Result
{
    if (!CanSend()) {
        if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
            mozilla::ipc::LogMessageForProtocol(
                "PWindowGlobalParent",
                this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                "Ignored message for dead actor",
                (&(msg__))->type(),
                mozilla::ipc::MessageDirection::eSending);
        }
        return MsgProcessed;

    }
    switch (msg__.type()) {
    case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
        {
            if (!mAwaitingManagedEndpointBind) {
                NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
                return MsgNotAllowed;
            }
            mAwaitingManagedEndpointBind = false;
            return MsgProcessed;
        }
    case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
        {
            if (!mAwaitingManagedEndpointBind) {
                NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
                return MsgNotAllowed;
            }
            mAwaitingManagedEndpointBind = false;
            this->ActorDisconnected(ManagedEndpointDropped);
            return MsgProcessed;
        }
    case PWindowGlobal::Reply___delete____ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Reply_MakeFrameRemote__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameRemote", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_DrawSnapshot__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DrawSnapshot", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_RequestDocumentLanguageMetadata__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RequestDocumentLanguageMetadata", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_RestoreDocShellState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreDocShellState", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_RestoreTabContent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreTabContent", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Msg_RawMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RawMessage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aMetadata = IPC::ReadParam<JSActorMessageMeta>((&(reader__)));
            if (!maybe__aMetadata) {
                FatalError("Error deserializing 'JSActorMessageMeta'");
                return MsgValueError;

            }
            auto& aMetadata = *maybe__aMetadata;
            // Sentinel = 'aMetadata'
            if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'JSActorMessageMeta'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<JSIPCValue>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'JSIPCValue'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'JSIPCValue'");
                return MsgValueError;
            }
            auto maybe__aStack = IPC::ReadParam<RefPtr<StructuredCloneData>>((&(reader__)));
            if (!maybe__aStack) {
                FatalError("Error deserializing 'StructuredCloneData'");
                return MsgValueError;

            }
            auto& aStack = *maybe__aStack;
            // Sentinel = 'aStack'
            if ((!(((&(reader__)))->ReadSentinel(135201368)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvRawMessage(std::move(aMetadata), std::move(aData), aStack);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_LoadURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_LoadURI", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aTargetBC = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aTargetBC) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aTargetBC = *maybe__aTargetBC;
            // Sentinel = 'aTargetBC'
            if ((!(((&(reader__)))->ReadSentinel(287245134)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aLoadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
            if (!maybe__aLoadState) {
                FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
                return MsgValueError;

            }
            auto& aLoadState = *maybe__aLoadState;
            // Sentinel = 'aLoadState'
            if ((!(((&(reader__)))->ReadSentinel(349570019)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
                return MsgValueError;
            }
            auto maybe__aSetNavigating = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aSetNavigating) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aSetNavigating = *maybe__aSetNavigating;
            // Sentinel = 'aSetNavigating'
            if ((!(((&(reader__)))->ReadSentinel(686556566)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvLoadURI(std::move(aTargetBC), aLoadState, std::move(aSetNavigating));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_InternalLoad__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_InternalLoad", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aLoadState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>((&(reader__)));
            if (!maybe__aLoadState) {
                FatalError("Error deserializing 'NotNull<nsDocShellLoadState>'");
                return MsgValueError;

            }
            auto& aLoadState = *maybe__aLoadState;
            // Sentinel = 'aLoadState'
            if ((!(((&(reader__)))->ReadSentinel(349570019)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvInternalLoad(aLoadState);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateDocumentURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentURI", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aUri = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIURI>>>((&(reader__)));
            if (!maybe__aUri) {
                FatalError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;

            }
            auto& aUri = *maybe__aUri;
            // Sentinel = 'aUri'
            if ((!(((&(reader__)))->ReadSentinel(64225682)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateDocumentURI(aUri);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateDocumentPrincipal__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentPrincipal", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            auto maybe__aPartitionedPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aPartitionedPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aPartitionedPrincipal = *maybe__aPartitionedPrincipal;
            // Sentinel = 'aPartitionedPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1564280967)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateDocumentPrincipal(aPrincipal, aPartitionedPrincipal);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdatePrincipalPartitioning__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdatePrincipalPartitioning", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aPartitionStoragePrincipal = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aPartitionStoragePrincipal) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aPartitionStoragePrincipal = *maybe__aPartitionStoragePrincipal;
            // Sentinel = 'aPartitionStoragePrincipal'
            if ((!(((&(reader__)))->ReadSentinel(2387413651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdatePrincipalPartitioning(std::move(aPartitionStoragePrincipal));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateDocumentHasLoaded__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentHasLoaded", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aDocumentHasLoaded = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aDocumentHasLoaded) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aDocumentHasLoaded = *maybe__aDocumentHasLoaded;
            // Sentinel = 'aDocumentHasLoaded'
            if ((!(((&(reader__)))->ReadSentinel(1117259526)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateDocumentHasLoaded(std::move(aDocumentHasLoaded));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateDocumentHasUserInteracted__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentHasUserInteracted", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aDocumentHasUserInteracted = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aDocumentHasUserInteracted) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aDocumentHasUserInteracted = *maybe__aDocumentHasUserInteracted;
            // Sentinel = 'aDocumentHasUserInteracted'
            if ((!(((&(reader__)))->ReadSentinel(2324695647)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateDocumentHasUserInteracted(std::move(aDocumentHasUserInteracted));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateSandboxFlags__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateSandboxFlags", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aSandboxFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aSandboxFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aSandboxFlags = *maybe__aSandboxFlags;
            // Sentinel = 'aSandboxFlags'
            if ((!(((&(reader__)))->ReadSentinel(590611742)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateSandboxFlags(std::move(aSandboxFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateDocumentCspSettings__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentCspSettings", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aBlockAllMixedContent = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aBlockAllMixedContent) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aBlockAllMixedContent = *maybe__aBlockAllMixedContent;
            // Sentinel = 'aBlockAllMixedContent'
            if ((!(((&(reader__)))->ReadSentinel(1473906744)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aUpgradeInsecureRequests = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aUpgradeInsecureRequests) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aUpgradeInsecureRequests = *maybe__aUpgradeInsecureRequests;
            // Sentinel = 'aUpgradeInsecureRequests'
            if ((!(((&(reader__)))->ReadSentinel(2002848196)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateDocumentCspSettings(std::move(aBlockAllMixedContent), std::move(aUpgradeInsecureRequests));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateCookieJarSettings__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateCookieJarSettings", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__cookieJarSettings = IPC::ReadParam<CookieJarSettingsArgs>((&(reader__)));
            if (!maybe__cookieJarSettings) {
                FatalError("Error deserializing 'CookieJarSettingsArgs'");
                return MsgValueError;

            }
            auto& cookieJarSettings = *maybe__cookieJarSettings;
            // Sentinel = 'cookieJarSettings'
            if ((!(((&(reader__)))->ReadSentinel(1031800553)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CookieJarSettingsArgs'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateCookieJarSettings(std::move(cookieJarSettings));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateDocumentTitle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateDocumentTitle", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aTitle = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aTitle) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aTitle = *maybe__aTitle;
            // Sentinel = 'aTitle'
            if ((!(((&(reader__)))->ReadSentinel(137167460)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateDocumentTitle(std::move(aTitle));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateChannels__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateChannels", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aDocumentHandle = IPC::ReadParam<RefPtr<ParentProcessChannelHandle>>((&(reader__)));
            if (!maybe__aDocumentHandle) {
                FatalError("Error deserializing 'ParentProcessChannelHandle'");
                return MsgValueError;

            }
            auto& aDocumentHandle = *maybe__aDocumentHandle;
            // Sentinel = 'aDocumentHandle'
            if ((!(((&(reader__)))->ReadSentinel(786761197)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ParentProcessChannelHandle'");
                return MsgValueError;
            }
            auto maybe__aFailedHandle = IPC::ReadParam<RefPtr<ParentProcessChannelHandle>>((&(reader__)));
            if (!maybe__aFailedHandle) {
                FatalError("Error deserializing 'ParentProcessChannelHandle'");
                return MsgValueError;

            }
            auto& aFailedHandle = *maybe__aFailedHandle;
            // Sentinel = 'aFailedHandle'
            if ((!(((&(reader__)))->ReadSentinel(569181427)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ParentProcessChannelHandle'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateChannels(aDocumentHandle, aFailedHandle);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateHttpsOnlyStatus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateHttpsOnlyStatus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aHttpsOnlyStatus = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aHttpsOnlyStatus) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aHttpsOnlyStatus = *maybe__aHttpsOnlyStatus;
            // Sentinel = 'aHttpsOnlyStatus'
            if ((!(((&(reader__)))->ReadSentinel(920323739)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateHttpsOnlyStatus(std::move(aHttpsOnlyStatus));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SetIsInitialDocument__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetIsInitialDocument", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aIsInitialDocument = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsInitialDocument) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsInitialDocument = *maybe__aIsInitialDocument;
            // Sentinel = 'aIsInitialDocument'
            if ((!(((&(reader__)))->ReadSentinel(1108150055)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvSetIsInitialDocument(std::move(aIsInitialDocument));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_CommitToInitialDocument__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_CommitToInitialDocument", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvCommitToInitialDocument();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_Share__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_Share", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aData = IPC::ReadParam<IPCWebShareData>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'IPCWebShareData'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCWebShareData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_Share(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            ShareResolver resolver = [resolver__ = std::move(resolver__)](const nsresult& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);

                    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PWindowGlobalParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvShare(std::move(aData), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_GetContentBlockingEvents__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetContentBlockingEvents", OTHER);

            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_GetContentBlockingEvents(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            GetContentBlockingEventsResolver resolver = [resolver__ = std::move(resolver__)](const uint32_t& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'events'
                    ((&(writer__)))->WriteSentinel(149619350);

                    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PWindowGlobalParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvGetContentBlockingEvents(std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SetClientInfo__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetClientInfo", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aClientInfo = IPC::ReadParam<IPCClientInfo>((&(reader__)));
            if (!maybe__aClientInfo) {
                FatalError("Error deserializing 'IPCClientInfo'");
                return MsgValueError;

            }
            auto& aClientInfo = *maybe__aClientInfo;
            // Sentinel = 'aClientInfo'
            if ((!(((&(reader__)))->ReadSentinel(422315085)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCClientInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvSetClientInfo(std::move(aClientInfo));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_CheckPermitUnload__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_CheckPermitUnload", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aHasInProcessBlocker = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aHasInProcessBlocker) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aHasInProcessBlocker = *maybe__aHasInProcessBlocker;
            // Sentinel = 'aHasInProcessBlocker'
            if ((!(((&(reader__)))->ReadSentinel(1345652694)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aAction = IPC::ReadParam<XPCOMPermitUnloadAction>((&(reader__)));
            if (!maybe__aAction) {
                FatalError("Error deserializing 'XPCOMPermitUnloadAction'");
                return MsgValueError;

            }
            auto& aAction = *maybe__aAction;
            // Sentinel = 'aAction'
            if ((!(((&(reader__)))->ReadSentinel(175768256)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'XPCOMPermitUnloadAction'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_CheckPermitUnload(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            CheckPermitUnloadResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'permitUnload'
                    ((&(writer__)))->WriteSentinel(547816693);

                    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PWindowGlobalParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvCheckPermitUnload(std::move(aHasInProcessBlocker), std::move(aAction), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_ExpectPageUseCounters__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ExpectPageUseCounters", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aTop = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aTop) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aTop = *maybe__aTop;
            // Sentinel = 'aTop'
            if ((!(((&(reader__)))->ReadSentinel(64094613)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvExpectPageUseCounters(std::move(aTop));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_AccumulatePageUseCounters__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_AccumulatePageUseCounters", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aUseCounters = IPC::ReadParam<UseCounters>((&(reader__)));
            if (!maybe__aUseCounters) {
                FatalError("Error deserializing 'UseCounters'");
                return MsgValueError;

            }
            auto& aUseCounters = *maybe__aUseCounters;
            // Sentinel = 'aUseCounters'
            if ((!(((&(reader__)))->ReadSentinel(514131170)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'UseCounters'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvAccumulatePageUseCounters(std::move(aUseCounters));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_RequestRestoreTabContent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RequestRestoreTabContent", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvRequestRestoreTabContent();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateBFCacheStatus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateBFCacheStatus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aOnFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aOnFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aOnFlags = *maybe__aOnFlags;
            // Sentinel = 'aOnFlags'
            if ((!(((&(reader__)))->ReadSentinel(222233356)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aOffFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aOffFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aOffFlags = *maybe__aOffFlags;
            // Sentinel = 'aOffFlags'
            if ((!(((&(reader__)))->ReadSentinel(277480298)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateBFCacheStatus(std::move(aOnFlags), std::move(aOffFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_UpdateActivePeerConnectionStatus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_UpdateActivePeerConnectionStatus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aIsAdded = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsAdded) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsAdded = *maybe__aIsAdded;
            // Sentinel = 'aIsAdded'
            if ((!(((&(reader__)))->ReadSentinel(217055984)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvUpdateActivePeerConnectionStatus(std::move(aIsAdded));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SetSingleChannelId__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetSingleChannelId", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__singleChannelId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__singleChannelId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& singleChannelId = *maybe__singleChannelId;
            // Sentinel = 'singleChannelId'
            if ((!(((&(reader__)))->ReadSentinel(810812905)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvSetSingleChannelId(std::move(singleChannelId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SetDocumentDomain__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetDocumentDomain", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aDomain = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIURI>>>((&(reader__)));
            if (!maybe__aDomain) {
                FatalError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;

            }
            auto& aDomain = *maybe__aDomain;
            // Sentinel = 'aDomain'
            if ((!(((&(reader__)))->ReadSentinel(176685754)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvSetDocumentDomain(aDomain);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SetSiteIntegrityProtected__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetSiteIntegrityProtected", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aSourceURI = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIURI>>>((&(reader__)));
            if (!maybe__aSourceURI) {
                FatalError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;

            }
            auto& aSourceURI = *maybe__aSourceURI;
            // Sentinel = 'aSourceURI'
            if ((!(((&(reader__)))->ReadSentinel(361038787)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;
            }
            auto maybe__aMaxAge = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aMaxAge) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aMaxAge = *maybe__aMaxAge;
            // Sentinel = 'aMaxAge'
            if ((!(((&(reader__)))->ReadSentinel(171377301)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvSetSiteIntegrityProtected(aSourceURI, std::move(aMaxAge));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_Destroy__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_Destroy", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvDestroy();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_AddCertException__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_AddCertException", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aTemporary = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aTemporary) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aTemporary = *maybe__aTemporary;
            // Sentinel = 'aTemporary'
            if ((!(((&(reader__)))->ReadSentinel(368968741)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_AddCertException(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            AddCertExceptionResolver resolver = [resolver__ = std::move(resolver__)](const nsresult& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'success'
                    ((&(writer__)))->WriteSentinel(200082170);

                    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PWindowGlobalParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvAddCertException(std::move(aTemporary), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_ReloadWithHttpsOnlyException__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ReloadWithHttpsOnlyException", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvReloadWithHttpsOnlyException();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_GetStorageAccessPermission__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetStorageAccessPermission", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aIncludeIdentityCredential = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIncludeIdentityCredential) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIncludeIdentityCredential = *maybe__aIncludeIdentityCredential;
            // Sentinel = 'aIncludeIdentityCredential'
            if ((!(((&(reader__)))->ReadSentinel(2324892267)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_GetStorageAccessPermission(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            GetStorageAccessPermissionResolver resolver = [resolver__ = std::move(resolver__)](const uint32_t& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'permission_action'
                    ((&(writer__)))->WriteSentinel(1085605671);

                    if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PWindowGlobalParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvGetStorageAccessPermission(std::move(aIncludeIdentityCredential), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SetCookies__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SetCookies", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__baseDomain = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__baseDomain) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& baseDomain = *maybe__baseDomain;
            // Sentinel = 'baseDomain'
            if ((!(((&(reader__)))->ReadSentinel(360449012)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__attrs = IPC::ReadParam<OriginAttributes>((&(reader__)));
            if (!maybe__attrs) {
                FatalError("Error deserializing 'OriginAttributes'");
                return MsgValueError;

            }
            auto& attrs = *maybe__attrs;
            // Sentinel = 'attrs'
            if ((!(((&(reader__)))->ReadSentinel(107807279)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            auto maybe__host = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__host) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& host = *maybe__host;
            // Sentinel = 'host'
            if ((!(((&(reader__)))->ReadSentinel(72024511)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            auto maybe__isThirdParty = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__isThirdParty) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& isThirdParty = *maybe__isThirdParty;
            // Sentinel = 'isThirdParty'
            if ((!(((&(reader__)))->ReadSentinel(526517480)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__cookies = IPC::ReadParam<nsTArray<CookieStruct>>((&(reader__)));
            if (!maybe__cookies) {
                FatalError("Error deserializing 'CookieStruct[]'");
                return MsgValueError;

            }
            auto& cookies = *maybe__cookies;
            // Sentinel = 'cookies'
            if ((!(((&(reader__)))->ReadSentinel(195363566)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CookieStruct[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvSetCookies(std::move(baseDomain), std::move(attrs), host, std::move(isThirdParty), std::move(cookies));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_RecordUserActivationForBTP__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RecordUserActivationForBTP", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvRecordUserActivationForBTP();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_RecordUserInteractionForPermissions__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RecordUserInteractionForPermissions", OTHER);

            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvRecordUserInteractionForPermissions();
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_NotifyAudioSessionTypeOverride__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_NotifyAudioSessionTypeOverride", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aType = IPC::ReadParam<AudioSessionType>((&(reader__)));
            if (!maybe__aType) {
                FatalError("Error deserializing 'AudioSessionType'");
                return MsgValueError;

            }
            auto& aType = *maybe__aType;
            // Sentinel = 'aType'
            if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'AudioSessionType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvNotifyAudioSessionTypeOverride(std::move(aType));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_PDigitalCredentialConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_PDigitalCredentialConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PDigitalCredentialParent> actor = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->AllocPDigitalCredentialParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvPDigitalCredentialConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_PPrefetchRecordConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_PPrefetchRecordConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__args = IPC::ReadParam<SpeculativePrefetchArgs>((&(reader__)));
            if (!maybe__args) {
                FatalError("Error deserializing 'SpeculativePrefetchArgs'");
                return MsgValueError;

            }
            auto& args = *maybe__args;
            // Sentinel = 'args'
            if ((!(((&(reader__)))->ReadSentinel(69140910)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SpeculativePrefetchArgs'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PPrefetchRecordParent> actor = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->AllocPPrefetchRecordParent(args);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvPPrefetchRecordConstructor(actor, std::move(args));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_PSerialManagerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_PSerialManagerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PSerialManagerParent> actor = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->AllocPSerialManagerParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvPSerialManagerConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_PWebAuthnTransactionConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_PWebAuthnTransactionConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PWebAuthnTransactionParent> actor = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->AllocPWebAuthnTransactionParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvPWebAuthnTransactionConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_PWebIdentityConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_PWebIdentityConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PWebIdentityParent> actor = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->AllocPWebIdentityParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvPWebIdentityConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_PDocAccessibleConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_PDocAccessibleConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__actorid__ = IPC::ReadParam<mozilla::ipc::ActorId>((&(reader__)));
            if (!maybe__actorid__) {
                FatalError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__aParentAcc = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aParentAcc) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aParentAcc = *maybe__aParentAcc;
            // Sentinel = 'aParentAcc'
            if ((!(((&(reader__)))->ReadSentinel(352977875)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aIsPrintDoc = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsPrintDoc) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsPrintDoc = *maybe__aIsPrintDoc;
            // Sentinel = 'aIsPrintDoc'
            if ((!(((&(reader__)))->ReadSentinel(422708289)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PDocAccessibleParent> actor = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->AllocPDocAccessibleParent(aParentAcc, aIsPrintDoc);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalParent*>(this))->RecvPDocAccessibleConstructor(actor, std::move(aParentAcc), std::move(aIsPrintDoc));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Reply_GetModelContextTools__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetModelContextTools", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_GetContentMetrics__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetContentMetrics", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_InvokeModelContextTool__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_InvokeModelContextTool", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    default:
        return MsgNotKnown;
    }
}

auto PWindowGlobalParent::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PWindowGlobalParent::Result
{
    if (!CanSend()) {
        return MsgDropped;

    }
    return MsgNotKnown;
}



} // namespace dom
} // namespace mozilla