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


#include "mozilla/dom/PWindowGlobalParent.h"
#include "ipc/ErrorIPCUtils.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/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/IdentityCredentialSerializationHelpers.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/SessionStoreMessageUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/dom/WindowGlobalParent.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.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 "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsPoint.h"

#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PInProcessParent.h"
#include "mozilla/dom/PBrowserBridgeParent.h"
#include "mozilla/dom/PWebAuthnTransactionParent.h"
#include "mozilla/dom/PWebIdentityParent.h"

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

namespace mozilla {
namespace dom {


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

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

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

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

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

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

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

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

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

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

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

auto PWindowGlobalParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PWebAuthnTransactionMsgStart:
        return (&(mManagedPWebAuthnTransactionParent));
    case PWebIdentityMsgStart:
        return (&(mManagedPWebIdentityParent));
    default:
        return nullptr;
    }
}

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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


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

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

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


            aReader->EndRead();

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

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

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

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


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

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

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


            aReader->EndRead();

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

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

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

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


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

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

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



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

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

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

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


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

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

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



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

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

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

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


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

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

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


            aReader->EndRead();

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

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

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

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


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

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

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


            aReader->EndRead();

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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


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

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


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

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


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

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


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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aSecurityInfo = *maybe__aSecurityInfo;
            // Sentinel = 'aSecurityInfo'
            if ((!(((&(reader__)))->ReadSentinel(610075974)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsITransportSecurityInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<WindowGlobalParent*>(this))->RecvUpdateDocumentSecurityInfo(aSecurityInfo);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

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

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

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

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

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

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

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            RefPtr<PWebAuthnTransactionParent> actor = (static_cast<WindowGlobalParent*>(this))->AllocPWebAuthnTransactionParent();
            if (!actor) {
                NS_WARNING("Cannot bind null PWebAuthnTransactionParent actor");
                return MsgValueError;
            }

            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to bind PWebAuthnTransactionParent actor");
                return MsgValueError;
            }

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            reader__.EndRead();
            RefPtr<PWebIdentityParent> actor = (static_cast<WindowGlobalParent*>(this))->AllocPWebIdentityParent();
            if (!actor) {
                NS_WARNING("Cannot bind null PWebIdentityParent actor");
                return MsgValueError;
            }

            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to bind PWebIdentityParent actor");
                return MsgValueError;
            }

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

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}

auto PWindowGlobalParent::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PWindowGlobalParent::Result
{
    return MsgNotKnown;
}



} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PWindowGlobalParent*>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, static_cast<mozilla::ipc::IProtocol*>(aVar));
    // Sentinel = 'PWindowGlobal'
    (aWriter)->WriteSentinel(588449050);
}

auto ParamTraits<::mozilla::dom::PWindowGlobalParent*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe__actor = IPC::ReadParam<mozilla::ipc::IProtocol*>(aReader);
    if (!maybe__actor) {
        aReader->FatalError("Error deserializing managed PWindowGlobal actor");
        return {};

    }
    auto& actor = *maybe__actor;
    // Sentinel = 'PWindowGlobal'
    if ((!((aReader)->ReadSentinel(588449050)))) {
        mozilla::ipc::SentinelReadError("Error deserializing managed PWindowGlobal actor");
        return {};
    }

    if (actor && actor->GetProtocolId() != PWindowGlobalMsgStart) {
        aReader->FatalError("Unexpected actor type (expected PWindowGlobal)");

        return {};
    }
    return static_cast<::mozilla::dom::PWindowGlobalParent*>(actor);
}

} // namespace IPC
