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


#include "mozilla/dom/PWindowGlobalChild.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/WindowGlobalChild.h"
#include "mozilla/dom/WindowGlobalMessageUtils.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/PBrowserChild.h"
#include "mozilla/dom/PInProcessChild.h"
#include "mozilla/dom/PBrowserBridgeChild.h"
#include "mozilla/a11y/PDocAccessibleChild.h"
#include "mozilla/dom/PDigitalCredentialChild.h"
#include "mozilla/dom/PSerialManagerChild.h"
#include "mozilla/dom/PWebAuthnTransactionChild.h"
#include "mozilla/dom/PWebIdentityChild.h"
#include "mozilla/dom/PPrefetchRecordChild.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 PWindowGlobalChild::Recv__delete__() -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

MOZ_IMPLICIT PWindowGlobalChild::PWindowGlobalChild() :
    mozilla::ipc::IRefCountedProtocol(kProtocolId, mozilla::ipc::ChildSide)
{
    MOZ_COUNT_CTOR(PWindowGlobalChild);
}

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

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

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

auto PWindowGlobalChild::ManagedPDocAccessibleChild(nsTArray<PDocAccessibleChild*>& aArr) const -> void
{
    mManagedPDocAccessibleChild.ToArray(aArr);
}

auto PWindowGlobalChild::ManagedPDocAccessibleChild() const -> const ManagedContainer<PDocAccessibleChild>&
{
    return mManagedPDocAccessibleChild;
}

auto PWindowGlobalChild::ManagedPDigitalCredentialChild(nsTArray<PDigitalCredentialChild*>& aArr) const -> void
{
    mManagedPDigitalCredentialChild.ToArray(aArr);
}

auto PWindowGlobalChild::ManagedPDigitalCredentialChild() const -> const ManagedContainer<PDigitalCredentialChild>&
{
    return mManagedPDigitalCredentialChild;
}

auto PWindowGlobalChild::ManagedPPrefetchRecordChild(nsTArray<PPrefetchRecordChild*>& aArr) const -> void
{
    mManagedPPrefetchRecordChild.ToArray(aArr);
}

auto PWindowGlobalChild::ManagedPPrefetchRecordChild() const -> const ManagedContainer<PPrefetchRecordChild>&
{
    return mManagedPPrefetchRecordChild;
}

auto PWindowGlobalChild::ManagedPSerialManagerChild(nsTArray<PSerialManagerChild*>& aArr) const -> void
{
    mManagedPSerialManagerChild.ToArray(aArr);
}

auto PWindowGlobalChild::ManagedPSerialManagerChild() const -> const ManagedContainer<PSerialManagerChild>&
{
    return mManagedPSerialManagerChild;
}

auto PWindowGlobalChild::ManagedPWebAuthnTransactionChild(nsTArray<PWebAuthnTransactionChild*>& aArr) const -> void
{
    mManagedPWebAuthnTransactionChild.ToArray(aArr);
}

auto PWindowGlobalChild::ManagedPWebAuthnTransactionChild() const -> const ManagedContainer<PWebAuthnTransactionChild>&
{
    return mManagedPWebAuthnTransactionChild;
}

auto PWindowGlobalChild::ManagedPWebIdentityChild(nsTArray<PWebIdentityChild*>& aArr) const -> void
{
    mManagedPWebIdentityChild.ToArray(aArr);
}

auto PWindowGlobalChild::ManagedPWebIdentityChild() const -> const ManagedContainer<PWebIdentityChild>&
{
    return mManagedPWebIdentityChild;
}

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

auto PWindowGlobalChild::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PDocAccessibleMsgStart:
        return (&(mManagedPDocAccessibleChild));
    case PDigitalCredentialMsgStart:
        return (&(mManagedPDigitalCredentialChild));
    case PPrefetchRecordMsgStart:
        return (&(mManagedPPrefetchRecordChild));
    case PSerialManagerMsgStart:
        return (&(mManagedPSerialManagerChild));
    case PWebAuthnTransactionMsgStart:
        return (&(mManagedPWebAuthnTransactionChild));
    case PWebIdentityMsgStart:
        return (&(mManagedPWebIdentityChild));
    default:
        return nullptr;
    }
}

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

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

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

    // 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<PDocAccessibleParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

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

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

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

    // 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<PDigitalCredentialParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

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

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

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

    // 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<PPrefetchRecordParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

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

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

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

    // 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<PSerialManagerParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

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

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

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

    // 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<PWebAuthnTransactionParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

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

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

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

    // 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<PWebIdentityParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}

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

auto PWindowGlobalChild::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::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWindowGlobalChild",
            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 PWindowGlobalChild::SendLoadURI(
        const MaybeDiscardedBrowsingContext& aTargetBC,
        mozilla::NotNull<nsDocShellLoadState*> aLoadState,
        const bool& aSetNavigating) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_LoadURI(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTargetBC);
    // Sentinel = 'aTargetBC'
    ((&(writer__)))->WriteSentinel(287245134);
    IPC::WriteParam((&(writer__)), aLoadState);
    // Sentinel = 'aLoadState'
    ((&(writer__)))->WriteSentinel(349570019);
    IPC::WriteParam((&(writer__)), aSetNavigating);
    // Sentinel = 'aSetNavigating'
    ((&(writer__)))->WriteSentinel(686556566);


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

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

auto PWindowGlobalChild::SendInternalLoad(mozilla::NotNull<nsDocShellLoadState*> aLoadState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_InternalLoad(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateDocumentURI(mozilla::NotNull<nsIURI*> aUri) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateDocumentURI(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateDocumentPrincipal(
        mozilla::NotNull<nsIPrincipal*> aPrincipal,
        mozilla::NotNull<nsIPrincipal*> aPartitionedPrincipal) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateDocumentPrincipal(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), aPartitionedPrincipal);
    // Sentinel = 'aPartitionedPrincipal'
    ((&(writer__)))->WriteSentinel(1564280967);


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

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

auto PWindowGlobalChild::SendUpdatePrincipalPartitioning(const bool& aPartitionStoragePrincipal) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdatePrincipalPartitioning(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateDocumentHasLoaded(const bool& aDocumentHasLoaded) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateDocumentHasLoaded(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateDocumentHasUserInteracted(const bool& aDocumentHasUserInteracted) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateDocumentHasUserInteracted(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateSandboxFlags(const uint32_t& aSandboxFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateSandboxFlags(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateDocumentCspSettings(
        const bool& aBlockAllMixedContent,
        const bool& aUpgradeInsecureRequests) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateDocumentCspSettings(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aBlockAllMixedContent);
    // Sentinel = 'aBlockAllMixedContent'
    ((&(writer__)))->WriteSentinel(1473906744);
    IPC::WriteParam((&(writer__)), aUpgradeInsecureRequests);
    // Sentinel = 'aUpgradeInsecureRequests'
    ((&(writer__)))->WriteSentinel(2002848196);


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

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

auto PWindowGlobalChild::SendUpdateCookieJarSettings(const CookieJarSettingsArgs& cookieJarSettings) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateCookieJarSettings(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateDocumentTitle(const nsAString& aTitle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateDocumentTitle(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendUpdateChannels(
        ParentProcessChannelHandle* aDocumentHandle,
        ParentProcessChannelHandle* aFailedHandle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateChannels(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aDocumentHandle);
    // Sentinel = 'aDocumentHandle'
    ((&(writer__)))->WriteSentinel(786761197);
    IPC::WriteParam((&(writer__)), aFailedHandle);
    // Sentinel = 'aFailedHandle'
    ((&(writer__)))->WriteSentinel(569181427);


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

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

auto PWindowGlobalChild::SendUpdateHttpsOnlyStatus(const uint32_t& aHttpsOnlyStatus) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateHttpsOnlyStatus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendSetIsInitialDocument(const bool& aIsInitialDocument) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetIsInitialDocument(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendCommitToInitialDocument() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_CommitToInitialDocument(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWindowGlobalChild::SendShare(
        const IPCWebShareData& aData,
        mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_Share(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PWindowGlobal::Reply_Share__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;
            }


            aReader->EndRead();

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

auto PWindowGlobalChild::SendShare(const IPCWebShareData& aData) -> RefPtr<SharePromise>
{
    RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendShare(std::forward<const IPCWebShareData&>(aData), [promise__](nsresult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalChild::SendGetContentBlockingEvents(
        mozilla::ipc::ResolveCallback<uint32_t>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_GetContentBlockingEvents(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

            }
            auto& events = *maybe__events;
            // Sentinel = 'events'
            if ((!((aReader)->ReadSentinel(149619350)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PWindowGlobalChild::SendGetContentBlockingEvents() -> RefPtr<GetContentBlockingEventsPromise>
{
    RefPtr<MozPromise<uint32_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint32_t, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetContentBlockingEvents([promise__](uint32_t&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalChild::SendSetClientInfo(const IPCClientInfo& aClientInfo) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetClientInfo(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendCheckPermitUnload(
        const bool& aHasInProcessBlocker,
        const XPCOMPermitUnloadAction& aAction,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_CheckPermitUnload(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aHasInProcessBlocker);
    // Sentinel = 'aHasInProcessBlocker'
    ((&(writer__)))->WriteSentinel(1345652694);
    IPC::WriteParam((&(writer__)), aAction);
    // Sentinel = 'aAction'
    ((&(writer__)))->WriteSentinel(175768256);


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

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

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


            aReader->EndRead();

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

auto PWindowGlobalChild::SendCheckPermitUnload(
        const bool& aHasInProcessBlocker,
        const XPCOMPermitUnloadAction& aAction) -> RefPtr<CheckPermitUnloadPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendCheckPermitUnload(std::forward<const bool&>(aHasInProcessBlocker), std::forward<const XPCOMPermitUnloadAction&>(aAction), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalChild::SendExpectPageUseCounters(const MaybeDiscardedWindowContext& aTop) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_ExpectPageUseCounters(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendAccumulatePageUseCounters(const UseCounters& aUseCounters) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_AccumulatePageUseCounters(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendRequestRestoreTabContent() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RequestRestoreTabContent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWindowGlobalChild::SendUpdateBFCacheStatus(
        const uint32_t& aOnFlags,
        const uint32_t& aOffFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateBFCacheStatus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aOnFlags);
    // Sentinel = 'aOnFlags'
    ((&(writer__)))->WriteSentinel(222233356);
    IPC::WriteParam((&(writer__)), aOffFlags);
    // Sentinel = 'aOffFlags'
    ((&(writer__)))->WriteSentinel(277480298);


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

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

auto PWindowGlobalChild::SendUpdateActivePeerConnectionStatus(const bool& aIsAdded) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_UpdateActivePeerConnectionStatus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendSetSingleChannelId(const mozilla::Maybe<uint64_t>& singleChannelId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetSingleChannelId(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendSetDocumentDomain(mozilla::NotNull<nsIURI*> aDomain) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetDocumentDomain(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendSetSiteIntegrityProtected(
        mozilla::NotNull<nsIURI*> aSourceURI,
        const uint64_t& aMaxAge) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetSiteIntegrityProtected(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aSourceURI);
    // Sentinel = 'aSourceURI'
    ((&(writer__)))->WriteSentinel(361038787);
    IPC::WriteParam((&(writer__)), aMaxAge);
    // Sentinel = 'aMaxAge'
    ((&(writer__)))->WriteSentinel(171377301);


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

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

auto PWindowGlobalChild::SendDestroy() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_Destroy(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWindowGlobalChild::SendAddCertException(
        const bool& aTemporary,
        mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_AddCertException(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PWindowGlobalChild::SendAddCertException(const bool& aTemporary) -> RefPtr<AddCertExceptionPromise>
{
    RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendAddCertException(std::forward<const bool&>(aTemporary), [promise__](nsresult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalChild::SendReloadWithHttpsOnlyException() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_ReloadWithHttpsOnlyException(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWindowGlobalChild::SendGetStorageAccessPermission(
        const bool& aIncludeIdentityCredential,
        mozilla::ipc::ResolveCallback<uint32_t>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_GetStorageAccessPermission(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

            }
            auto& permission_action = *maybe__permission_action;
            // Sentinel = 'permission_action'
            if ((!((aReader)->ReadSentinel(1085605671)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PWindowGlobalChild::SendGetStorageAccessPermission(const bool& aIncludeIdentityCredential) -> RefPtr<GetStorageAccessPermissionPromise>
{
    RefPtr<MozPromise<uint32_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint32_t, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetStorageAccessPermission(std::forward<const bool&>(aIncludeIdentityCredential), [promise__](uint32_t&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWindowGlobalChild::SendSetCookies(
        const nsACString& baseDomain,
        const OriginAttributes& attrs,
        nsIURI* host,
        const bool& isThirdParty,
        mozilla::Span<CookieStruct const> cookies) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_SetCookies(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), baseDomain);
    // Sentinel = 'baseDomain'
    ((&(writer__)))->WriteSentinel(360449012);
    IPC::WriteParam((&(writer__)), attrs);
    // Sentinel = 'attrs'
    ((&(writer__)))->WriteSentinel(107807279);
    IPC::WriteParam((&(writer__)), host);
    // Sentinel = 'host'
    ((&(writer__)))->WriteSentinel(72024511);
    IPC::WriteParam((&(writer__)), isThirdParty);
    // Sentinel = 'isThirdParty'
    ((&(writer__)))->WriteSentinel(526517480);
    IPC::WriteParam((&(writer__)), cookies);
    // Sentinel = 'cookies'
    ((&(writer__)))->WriteSentinel(195363566);


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

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

auto PWindowGlobalChild::SendRecordUserActivationForBTP() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RecordUserActivationForBTP(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWindowGlobalChild::SendRecordUserInteractionForPermissions() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_RecordUserInteractionForPermissions(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWindowGlobalChild::SendNotifyAudioSessionTypeOverride(const AudioSessionType& aType) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_NotifyAudioSessionTypeOverride(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PWindowGlobalChild::SendPDigitalCredentialConstructor(PDigitalCredentialChild* actor) -> PDigitalCredentialChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PDigitalCredentialChild actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PDigitalCredentialChild actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_PDigitalCredentialConstructor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

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

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


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PDigitalCredentialChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PWindowGlobalChild::SendPPrefetchRecordConstructor(
        PPrefetchRecordChild* actor,
        const SpeculativePrefetchArgs& args) -> PPrefetchRecordChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PPrefetchRecordChild actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PPrefetchRecordChild actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_PPrefetchRecordConstructor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), args);
    // Sentinel = 'args'
    ((&(writer__)))->WriteSentinel(69140910);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

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

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


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PPrefetchRecordChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PWindowGlobalChild::SendPSerialManagerConstructor(PSerialManagerChild* actor) -> PSerialManagerChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PSerialManagerChild actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PSerialManagerChild actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_PSerialManagerConstructor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

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

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


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PSerialManagerChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PWindowGlobalChild::SendPWebAuthnTransactionConstructor(PWebAuthnTransactionChild* actor) -> PWebAuthnTransactionChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PWebAuthnTransactionChild actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PWebAuthnTransactionChild actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_PWebAuthnTransactionConstructor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

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

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


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PWebAuthnTransactionChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PWindowGlobalChild::SendPWebIdentityConstructor(PWebIdentityChild* actor) -> PWebIdentityChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PWebIdentityChild actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PWebIdentityChild actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_PWebIdentityConstructor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

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

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


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PWebIdentityChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PWindowGlobalChild::SendPDocAccessibleConstructor(
        PDocAccessibleChild* actor,
        const uint64_t& aParentAcc,
        const bool& aIsPrintDoc) -> PDocAccessibleChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PDocAccessibleChild actor");
        return nullptr;
    }

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PDocAccessibleChild actor");
        return nullptr;
    }


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PWindowGlobal::Msg_PDocAccessibleConstructor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), aParentAcc);
    // Sentinel = 'aParentAcc'
    ((&(writer__)))->WriteSentinel(352977875);
    IPC::WriteParam((&(writer__)), aIsPrintDoc);
    // Sentinel = 'aIsPrintDoc'
    ((&(writer__)))->WriteSentinel(422708289);


    // Notify the other side about the newly created actor. This can
    // fail if our manager has already been destroyed.
    //
    // NOTE: If the send call fails due to toplevel channel teardown,
    // the `IProtocol::ChannelSend` wrapper absorbs the error for us,
    // so we don't tear down actors unexpectedly.

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

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


    // Warn, destroy the actor, and return null if the message failed to
    // send. Otherwise, return the successfully created actor reference.
    if (!sendok__) {
        NS_WARNING("Error sending PDocAccessibleChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

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

auto PWindowGlobalChild::OnMessageReceived(const Message& msg__) -> PWindowGlobalChild::Result
{
    if (!CanSend()) {
        if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
            mozilla::ipc::LogMessageForProtocol(
                "PWindowGlobalChild",
                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::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg___delete__", OTHER);

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


            this->ActorDisconnected(Deletion);

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_MakeFrameLocal__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameLocal", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFrameContext = *maybe__aFrameContext;
            // Sentinel = 'aFrameContext'
            if ((!(((&(reader__)))->ReadSentinel(585565490)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aSwitchId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aSwitchId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aSwitchId = *maybe__aSwitchId;
            // Sentinel = 'aSwitchId'
            if ((!(((&(reader__)))->ReadSentinel(297730945)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvMakeFrameLocal(std::move(aFrameContext), std::move(aSwitchId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_MakeFrameRemote__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_MakeFrameRemote", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFrameContext = *maybe__aFrameContext;
            // Sentinel = 'aFrameContext'
            if ((!(((&(reader__)))->ReadSentinel(585565490)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aEndpoint = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>>((&(reader__)));
            if (!maybe__aEndpoint) {
                FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>'");
                return MsgValueError;

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserBridgeChild>'");
                return MsgValueError;
            }
            auto maybe__aTabId = IPC::ReadParam<TabId>((&(reader__)));
            if (!maybe__aTabId) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;

            }
            auto& aTabId = *maybe__aTabId;
            // Sentinel = 'aTabId'
            if ((!(((&(reader__)))->ReadSentinel(126878246)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            auto maybe__aLayersId = IPC::ReadParam<LayersId>((&(reader__)));
            if (!maybe__aLayersId) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;

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

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

            MakeFrameRemoteResolver 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 = 'success'
                    ((&(writer__)))->WriteSentinel(200082170);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvMakeFrameRemote(std::move(aFrameContext), std::move(aEndpoint), std::move(aTabId), std::move(aLayersId), 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_DrawSnapshot__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DrawSnapshot", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aRect = *maybe__aRect;
            // Sentinel = 'aRect'
            if ((!(((&(reader__)))->ReadSentinel(94044656)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IntRect?'");
                return MsgValueError;
            }
            auto maybe__aScale = IPC::ReadParam<float>((&(reader__)));
            if (!maybe__aScale) {
                FatalError("Error deserializing 'float'");
                return MsgValueError;

            }
            auto& aScale = *maybe__aScale;
            // Sentinel = 'aScale'
            if ((!(((&(reader__)))->ReadSentinel(131531338)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }
            auto maybe__aBackgroundColor = IPC::ReadParam<nscolor>((&(reader__)));
            if (!maybe__aBackgroundColor) {
                FatalError("Error deserializing 'nscolor'");
                return MsgValueError;

            }
            auto& aBackgroundColor = *maybe__aBackgroundColor;
            // Sentinel = 'aBackgroundColor'
            if ((!(((&(reader__)))->ReadSentinel(884999777)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nscolor'");
                return MsgValueError;
            }
            auto maybe__aFlags = IPC::ReadParam<CrossProcessPaintFlags>((&(reader__)));
            if (!maybe__aFlags) {
                FatalError("Error deserializing 'CrossProcessPaintFlags'");
                return MsgValueError;

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

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

            DrawSnapshotResolver resolver = [resolver__ = std::move(resolver__)](PaintFragment&& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::move(aParam));
                    // Sentinel = 'retval'
                    ((&(writer__)))->WriteSentinel(151716495);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvDrawSnapshot(std::move(aRect), std::move(aScale), std::move(aBackgroundColor), std::move(aFlags), 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_RequestDocumentLanguageMetadata__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RequestDocumentLanguageMetadata", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            RequestDocumentLanguageMetadataResolver resolver = [resolver__ = std::move(resolver__)](const mozilla::Maybe<DocumentLanguageMetadata>& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'metadata'
                    ((&(writer__)))->WriteSentinel(248251202);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvRequestDocumentLanguageMetadata(std::move(aTextSampleMinCodeUnits), std::move(aTextSampleTargetCodeUnits), 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_DispatchSecurityPolicyViolation__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_DispatchSecurityPolicyViolation", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aViolationEventJSON = *maybe__aViolationEventJSON;
            // Sentinel = 'aViolationEventJSON'
            if ((!(((&(reader__)))->ReadSentinel(1266878291)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aReportGroupName = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aReportGroupName) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aReportGroupName = *maybe__aReportGroupName;
            // Sentinel = 'aReportGroupName'
            if ((!(((&(reader__)))->ReadSentinel(912655980)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvDispatchSecurityPolicyViolation(std::move(aViolationEventJSON), std::move(aReportGroupName));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_SaveStorageAccessPermissionGranted__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_SaveStorageAccessPermissionGranted", OTHER);

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

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_AddBlockedFrameNodeByClassifier__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_AddBlockedFrameNodeByClassifier", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aNode = *maybe__aNode;
            // Sentinel = 'aNode'
            if ((!(((&(reader__)))->ReadSentinel(94110184)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvAddBlockedFrameNodeByClassifier(std::move(aNode));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_ResetScalingZoom__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ResetScalingZoom", OTHER);

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

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_RestoreDocShellState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreDocShellState", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            RestoreDocShellStateResolver 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 = 'success'
                    ((&(writer__)))->WriteSentinel(200082170);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvRestoreDocShellState(std::move(aState), 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_RestoreTabContent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_RestoreTabContent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            RestoreTabContentResolver 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 = 'success'
                    ((&(writer__)))->WriteSentinel(200082170);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvRestoreTabContent(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_RawMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    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::WindowGlobalChild*>(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::Reply_Share__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

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


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

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


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

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


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

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


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

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


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWindowGlobal::Reply_PDigitalCredentialConstructor__ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Reply_PPrefetchRecordConstructor__ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Reply_PSerialManagerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Reply_PWebAuthnTransactionConstructor__ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Reply_PWebIdentityConstructor__ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Reply_PDocAccessibleConstructor__ID:
        {
            return MsgProcessed;
        }
    case PWindowGlobal::Msg_NotifyAudioSessionStateChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_NotifyAudioSessionStateChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aState = *maybe__aState;
            // Sentinel = 'aState'
            if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'AudioSessionState'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvNotifyAudioSessionStateChanged(std::move(aState));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_NotifyPermissionChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_NotifyPermissionChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& type = *maybe__type;
            // Sentinel = 'type'
            if ((!(((&(reader__)))->ReadSentinel(75760067)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__permission = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__permission) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& permission = *maybe__permission;
            // Sentinel = 'permission'
            if ((!(((&(reader__)))->ReadSentinel(394921034)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvNotifyPermissionChange(std::move(type), std::move(permission));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_ProcessCloseRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_ProcessCloseRequest", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFocused = *maybe__aFocused;
            // Sentinel = 'aFocused'
            if ((!(((&(reader__)))->ReadSentinel(232653611)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvProcessCloseRequest(std::move(aFocused));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWindowGlobal::Msg_GetModelContextTools__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetModelContextTools", OTHER);

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

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

            GetModelContextToolsResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const nsresult&, mozilla::Span<IPCModelContextToolDefinition const>> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'tools'
                    ((&(writer__)))->WriteSentinel(110953010);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvGetModelContextTools(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_GetContentMetrics__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_GetContentMetrics", OTHER);

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

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

            GetContentMetricsResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const CSSSize&, const float&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'size'
                    ((&(writer__)))->WriteSentinel(73662908);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'devicePixelRatio'
                    ((&(writer__)))->WriteSentinel(915801714);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::WindowGlobalChild*>(this))->RecvGetContentMetrics(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_InvokeModelContextTool__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWindowGlobal", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWindowGlobalChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWindowGlobal::Msg_InvokeModelContextTool", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& toolName = *maybe__toolName;
            // Sentinel = 'toolName'
            if ((!(((&(reader__)))->ReadSentinel(251724608)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__input = IPC::ReadParam<mozilla::NotNull<RefPtr<StructuredCloneData>>>((&(reader__)));
            if (!maybe__input) {
                FatalError("Error deserializing 'NotNull<StructuredCloneData>'");
                return MsgValueError;

            }
            auto& input = *maybe__input;
            // Sentinel = 'input'
            if ((!(((&(reader__)))->ReadSentinel(108528177)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<StructuredCloneData>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PWindowGlobal::Reply_InvokeModelContextTool(id__));
            reply__->set_seqno(msg__.seqno());

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

            InvokeModelContextToolResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const CopyableErrorResult&, StructuredCloneData*> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'rv'
                    ((&(writer__)))->WriteSentinel(22806761);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'output'
                    ((&(writer__)))->WriteSentinel(157745842);

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

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

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}

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

    }
    return MsgNotKnown;
}



} // namespace dom
} // namespace mozilla