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


#include "mozilla/dom/PBrowserParent.h"
#include "ipc/nsGUIEventIPC.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/LayoutMessageUtils.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/BrowserParent.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/FilePickerMessageUtils.h"
#include "mozilla/dom/MessagePort.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/TabMessageTypes.h"
#include "mozilla/dom/TabMessageUtils.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/CompositorTypes.h"
#include "mozilla/layers/DoubleTapToZoom.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/layers/ScrollableLayerGuid.h"
#include "mozilla/layers/ZoomConstraints.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/widget/IMEData.h"
#include "mozilla/widget/WidgetMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsID.h"
#include "nsIPolicyContainer.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsRect.h"

#include "mozilla/dom/PColorPickerParent.h"
#include "mozilla/dom/PContentParent.h"
#include "mozilla/a11y/PDocAccessibleParent.h"
#include "mozilla/dom/PFilePickerParent.h"
#include "mozilla/layout/PRemotePrintJobParent.h"
#include "mozilla/dom/PPaymentRequestParent.h"
#include "mozilla/dom/PSessionStoreParent.h"
#include "mozilla/dom/PWindowGlobalParent.h"
#include "mozilla/dom/PBrowserBridgeParent.h"
#include "mozilla/dom/PVsyncParent.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 PBrowserParent::RecvPDocAccessibleConstructor(
        PDocAccessibleParent* actor,
        PDocAccessibleParent* aParentDoc,
        const uint64_t& aParentAcc,
        const MaybeDiscardedBrowsingContext& aBrowsingContext) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBrowserParent::RecvPPaymentRequestConstructor(PPaymentRequestParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBrowserParent::RecvPVsyncConstructor(PVsyncParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBrowserParent::RecvPColorPickerConstructor(
        PColorPickerParent* actor,
        const MaybeDiscardedBrowsingContext& aBrowsingContext,
        const nsAString& title,
        const nsAString& initialColor,
        nsTArray<nsString>&& defaultColors) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBrowserParent::RecvPFilePickerConstructor(
        PFilePickerParent* actor,
        const nsAString& aTitle,
        const Mode& aMode,
        const MaybeDiscardedBrowsingContext& aBrowsingContext) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBrowserParent::Recv__delete__() -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PBrowserParent::RecvPSessionStoreConstructor(PSessionStoreParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

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

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

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

auto PBrowserParent::OtherPid() const -> ::base::ProcessId
{
    ::base::ProcessId pid =
        ::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
    MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
    return pid;
}

auto PBrowserParent::OtherChildID() const -> ::GeckoChildID
{
    ::GeckoChildID childID =
        ::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherChildIDMaybeInvalid();
    MOZ_RELEASE_ASSERT(childID != -1);
    return childID;
}

auto PBrowserParent::OtherEndpointProcInfo() const -> ::mozilla::ipc::EndpointProcInfo
{
    return ::mozilla::ipc::EndpointProcInfo{OtherPid(), OtherChildID()};
}

auto PBrowserParent::Manager() const -> PContentParent*
{
    return static_cast<PContentParent*>(IProtocol::Manager());
}

auto PBrowserParent::ManagedPColorPickerParent(nsTArray<PColorPickerParent*>& aArr) const -> void
{
    mManagedPColorPickerParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPColorPickerParent() const -> const ManagedContainer<PColorPickerParent>&
{
    return mManagedPColorPickerParent;
}

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

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

auto PBrowserParent::ManagedPFilePickerParent(nsTArray<PFilePickerParent*>& aArr) const -> void
{
    mManagedPFilePickerParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPFilePickerParent() const -> const ManagedContainer<PFilePickerParent>&
{
    return mManagedPFilePickerParent;
}

auto PBrowserParent::ManagedPPaymentRequestParent(nsTArray<PPaymentRequestParent*>& aArr) const -> void
{
    mManagedPPaymentRequestParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPPaymentRequestParent() const -> const ManagedContainer<PPaymentRequestParent>&
{
    return mManagedPPaymentRequestParent;
}

auto PBrowserParent::ManagedPSessionStoreParent(nsTArray<PSessionStoreParent*>& aArr) const -> void
{
    mManagedPSessionStoreParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPSessionStoreParent() const -> const ManagedContainer<PSessionStoreParent>&
{
    return mManagedPSessionStoreParent;
}

auto PBrowserParent::ManagedPWindowGlobalParent(nsTArray<PWindowGlobalParent*>& aArr) const -> void
{
    mManagedPWindowGlobalParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPWindowGlobalParent() const -> const ManagedContainer<PWindowGlobalParent>&
{
    return mManagedPWindowGlobalParent;
}

auto PBrowserParent::ManagedPBrowserBridgeParent(nsTArray<PBrowserBridgeParent*>& aArr) const -> void
{
    mManagedPBrowserBridgeParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPBrowserBridgeParent() const -> const ManagedContainer<PBrowserBridgeParent>&
{
    return mManagedPBrowserBridgeParent;
}

auto PBrowserParent::ManagedPVsyncParent(nsTArray<PVsyncParent*>& aArr) const -> void
{
    mManagedPVsyncParent.ToArray(aArr);
}

auto PBrowserParent::ManagedPVsyncParent() const -> const ManagedContainer<PVsyncParent>&
{
    return mManagedPVsyncParent;
}

auto PBrowserParent::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
    static constexpr ::mozilla::ipc::ProtocolId sIds[] = {
        PColorPickerMsgStart,
        PDocAccessibleMsgStart,
        PFilePickerMsgStart,
        PPaymentRequestMsgStart,
        PSessionStoreMsgStart,
        PWindowGlobalMsgStart,
        PBrowserBridgeMsgStart,
        PVsyncMsgStart
    };
    return sIds;
}

auto PBrowserParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PColorPickerMsgStart:
        return (&(mManagedPColorPickerParent));
    case PDocAccessibleMsgStart:
        return (&(mManagedPDocAccessibleParent));
    case PFilePickerMsgStart:
        return (&(mManagedPFilePickerParent));
    case PPaymentRequestMsgStart:
        return (&(mManagedPPaymentRequestParent));
    case PSessionStoreMsgStart:
        return (&(mManagedPSessionStoreParent));
    case PWindowGlobalMsgStart:
        return (&(mManagedPWindowGlobalParent));
    case PBrowserBridgeMsgStart:
        return (&(mManagedPBrowserBridgeParent));
    case PVsyncMsgStart:
        return (&(mManagedPVsyncParent));
    default:
        return nullptr;
    }
}

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

auto PBrowserParent::OpenPColorPickerEndpoint(PColorPickerParent* aActor) -> ManagedEndpoint<PColorPickerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PColorPickerParent actor");
        return ManagedEndpoint<PColorPickerChild>();
    }

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

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

auto PBrowserParent::BindPColorPickerEndpoint(
        ManagedEndpoint<PColorPickerParent> aEndpoint,
        PColorPickerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

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

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

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

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

auto PBrowserParent::OpenPFilePickerEndpoint(PFilePickerParent* aActor) -> ManagedEndpoint<PFilePickerChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PFilePickerParent actor");
        return ManagedEndpoint<PFilePickerChild>();
    }

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

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

auto PBrowserParent::BindPFilePickerEndpoint(
        ManagedEndpoint<PFilePickerParent> aEndpoint,
        PFilePickerParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBrowserParent::OpenPPaymentRequestEndpoint(PPaymentRequestParent* aActor) -> ManagedEndpoint<PPaymentRequestChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PPaymentRequestParent actor");
        return ManagedEndpoint<PPaymentRequestChild>();
    }

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

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

auto PBrowserParent::BindPPaymentRequestEndpoint(
        ManagedEndpoint<PPaymentRequestParent> aEndpoint,
        PPaymentRequestParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBrowserParent::OpenPSessionStoreEndpoint(PSessionStoreParent* aActor) -> ManagedEndpoint<PSessionStoreChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PSessionStoreParent actor");
        return ManagedEndpoint<PSessionStoreChild>();
    }

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

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

auto PBrowserParent::BindPSessionStoreEndpoint(
        ManagedEndpoint<PSessionStoreParent> aEndpoint,
        PSessionStoreParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBrowserParent::OpenPWindowGlobalEndpoint(PWindowGlobalParent* aActor) -> ManagedEndpoint<PWindowGlobalChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PWindowGlobalParent actor");
        return ManagedEndpoint<PWindowGlobalChild>();
    }

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

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

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

auto PBrowserParent::OpenPBrowserBridgeEndpoint(PBrowserBridgeParent* aActor) -> ManagedEndpoint<PBrowserBridgeChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBrowserBridgeParent actor");
        return ManagedEndpoint<PBrowserBridgeChild>();
    }

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

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

auto PBrowserParent::BindPBrowserBridgeEndpoint(
        ManagedEndpoint<PBrowserBridgeParent> aEndpoint,
        PBrowserBridgeParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBrowserParent::OpenPVsyncEndpoint(PVsyncParent* aActor) -> ManagedEndpoint<PVsyncChild>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PVsyncParent actor");
        return ManagedEndpoint<PVsyncChild>();
    }

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

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

auto PBrowserParent::BindPVsyncEndpoint(
        ManagedEndpoint<PVsyncParent> aEndpoint,
        PVsyncParent* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PBrowserParent::SendAsyncMessage(
        const nsAString& aMessage,
        const ClonedMessageData& aData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AsyncMessage(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendReleasePointerLock() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReleasePointerLock(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendUpdateSHistory() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateSHistory(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendCloneDocumentTreeIntoSelf(
        const MaybeDiscardedBrowsingContext& aBc,
        const PrintData& aPrintData,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CloneDocumentTreeIntoSelf(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aBc);
    // Sentinel = 'aBc'
    ((&(writer__)))->WriteSentinel(34406663);
    IPC::WriteParam((&(writer__)), aPrintData);
    // Sentinel = 'aPrintData'
    ((&(writer__)))->WriteSentinel(359072745);


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

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

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


            aReader->EndRead();

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

auto PBrowserParent::SendCloneDocumentTreeIntoSelf(
        const MaybeDiscardedBrowsingContext& aBc,
        const PrintData& aPrintData) -> RefPtr<CloneDocumentTreeIntoSelfPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendCloneDocumentTreeIntoSelf(std::move(aBc), std::move(aPrintData), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserParent::SendUpdateRemotePrintSettings(const PrintData& aPrintData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateRemotePrintSettings(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendReleaseAllPointerCapture() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReleaseAllPointerCapture(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendUpdateEffects(const EffectsInfo& aEffects) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateEffects(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendShow(
        const ParentShowInfo& parentInfo,
        const OwnerShowInfo& childInfo) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Show(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), parentInfo);
    // Sentinel = 'parentInfo'
    ((&(writer__)))->WriteSentinel(380044311);
    IPC::WriteParam((&(writer__)), childInfo);
    // Sentinel = 'childInfo'
    ((&(writer__)))->WriteSentinel(298320785);


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

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

auto PBrowserParent::SendActivate(const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Activate(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendDeactivate(const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Deactivate(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendScrollbarPreferenceChanged(const ScrollbarPreference& pref) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ScrollbarPreferenceChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendInitRendering(
        const TextureFactoryIdentifier& textureFactoryIdentifier,
        const LayersId& layersId,
        const CompositorOptions& compositorOptions,
        const bool& layersConnected) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InitRendering(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), textureFactoryIdentifier);
    // Sentinel = 'textureFactoryIdentifier'
    ((&(writer__)))->WriteSentinel(2096630253);
    IPC::WriteParam((&(writer__)), layersId);
    // Sentinel = 'layersId'
    ((&(writer__)))->WriteSentinel(250938174);
    IPC::WriteParam((&(writer__)), compositorOptions);
    // Sentinel = 'compositorOptions'
    ((&(writer__)))->WriteSentinel(1089275708);
    IPC::WriteParam((&(writer__)), layersConnected);
    // Sentinel = 'layersConnected'
    ((&(writer__)))->WriteSentinel(829294116);


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

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

auto PBrowserParent::SendCompositorOptionsChanged(const CompositorOptions& newOptions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CompositorOptionsChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendLoadURL(
        mozilla::NotNull<nsDocShellLoadState*> loadState,
        const ParentShowInfo& info) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LoadURL(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), loadState);
    // Sentinel = 'loadState'
    ((&(writer__)))->WriteSentinel(304808866);
    IPC::WriteParam((&(writer__)), info);
    // Sentinel = 'info'
    ((&(writer__)))->WriteSentinel(70058413);


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

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

auto PBrowserParent::SendCreateAboutBlankDocumentViewer(
        nsIPrincipal* principal,
        nsIPrincipal* partitionedPrincipal) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CreateAboutBlankDocumentViewer(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), principal);
    // Sentinel = 'principal'
    ((&(writer__)))->WriteSentinel(319620035);
    IPC::WriteParam((&(writer__)), partitionedPrincipal);
    // Sentinel = 'partitionedPrincipal'
    ((&(writer__)))->WriteSentinel(1472661574);


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

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

auto PBrowserParent::SendResumeLoad(
        const uint64_t& pendingSwitchID,
        const ParentShowInfo& info) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ResumeLoad(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), pendingSwitchID);
    // Sentinel = 'pendingSwitchID'
    ((&(writer__)))->WriteSentinel(822478309);
    IPC::WriteParam((&(writer__)), info);
    // Sentinel = 'info'
    ((&(writer__)))->WriteSentinel(70058413);


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

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

auto PBrowserParent::SendUpdateDimensions(const DimensionInfo& dimensions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateDimensions(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendSizeModeChanged(const nsSizeMode& sizeMode) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SizeModeChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendChildToParentMatrix(
        const mozilla::Maybe<Matrix4x4>& aMatrix,
        const ScreenRect& aRemoteDocumentRect) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ChildToParentMatrix(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aMatrix);
    // Sentinel = 'aMatrix'
    ((&(writer__)))->WriteSentinel(181469911);
    IPC::WriteParam((&(writer__)), aRemoteDocumentRect);
    // Sentinel = 'aRemoteDocumentRect'
    ((&(writer__)))->WriteSentinel(1261242267);


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

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

auto PBrowserParent::SendUpdateRemoteStyle(const StyleImageRendering& aImageRendering) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateRemoteStyle(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendDynamicToolbarMaxHeightChanged(const ScreenIntCoord& height) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DynamicToolbarMaxHeightChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendDynamicToolbarOffsetChanged(const ScreenIntCoord& offset) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DynamicToolbarOffsetChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendKeyboardHeightChanged(const ScreenIntCoord& height) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_KeyboardHeightChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendAndroidPipModeChanged(const bool& aPipMode) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AndroidPipModeChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendStopIMEStateManagement() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_StopIMEStateManagement(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendRealMouseMoveEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseMoveEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPriorityRealMouseMoveEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseMoveEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendRealMouseMoveEventForTests(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseMoveEventForTests(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPriorityRealMouseMoveEventForTests(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendSynthMouseMoveEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthMouseMoveEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPrioritySynthMouseMoveEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPrioritySynthMouseMoveEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendRealMouseButtonEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseButtonEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPriorityRealMouseButtonEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseButtonEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendRealPointerButtonEvent(
        const WidgetPointerEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealPointerButtonEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPriorityRealPointerButtonEvent(
        const WidgetPointerEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealPointerButtonEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendRealMouseEnterExitWidgetEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealMouseEnterExitWidgetEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPriorityRealMouseEnterExitWidgetEvent(
        const WidgetMouseEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendRealKeyEvent(
        const WidgetKeyboardEvent& aEvent,
        const nsID& aUUID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealKeyEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aUUID);
    // Sentinel = 'aUUID'
    ((&(writer__)))->WriteSentinel(85131673);


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

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

auto PBrowserParent::SendNormalPriorityRealKeyEvent(
        const WidgetKeyboardEvent& aEvent,
        const nsID& aUUID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealKeyEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aUUID);
    // Sentinel = 'aUUID'
    ((&(writer__)))->WriteSentinel(85131673);


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

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

auto PBrowserParent::SendMouseWheelEvent(
        const WidgetWheelEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_MouseWheelEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendNormalPriorityMouseWheelEvent(
        const WidgetWheelEvent& event,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityMouseWheelEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);


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

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

auto PBrowserParent::SendRealTouchEvent(
        const WidgetTouchEvent& aEvent,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const nsEventStatus& aApzResponse) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealTouchEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aApzResponse);
    // Sentinel = 'aApzResponse'
    ((&(writer__)))->WriteSentinel(512951516);


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

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

auto PBrowserParent::SendNormalPriorityRealTouchEvent(
        const WidgetTouchEvent& aEvent,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const nsEventStatus& aApzResponse) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealTouchEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aApzResponse);
    // Sentinel = 'aApzResponse'
    ((&(writer__)))->WriteSentinel(512951516);


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

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

auto PBrowserParent::SendHandleTap(
        const GeckoContentController_TapType& aType,
        const LayoutDevicePoint& point,
        const Modifiers& aModifiers,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const mozilla::Maybe<DoubleTapToZoomMetrics>& aMetrics) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_HandleTap(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aType);
    // Sentinel = 'aType'
    ((&(writer__)))->WriteSentinel(99222020);
    IPC::WriteParam((&(writer__)), point);
    // Sentinel = 'point'
    ((&(writer__)))->WriteSentinel(108790315);
    IPC::WriteParam((&(writer__)), aModifiers);
    // Sentinel = 'aModifiers'
    ((&(writer__)))->WriteSentinel(358286340);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aMetrics);
    // Sentinel = 'aMetrics'
    ((&(writer__)))->WriteSentinel(235471673);


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

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

auto PBrowserParent::SendNormalPriorityHandleTap(
        const GeckoContentController_TapType& aType,
        const LayoutDevicePoint& point,
        const Modifiers& aModifiers,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const mozilla::Maybe<DoubleTapToZoomMetrics>& aMetrics) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityHandleTap(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aType);
    // Sentinel = 'aType'
    ((&(writer__)))->WriteSentinel(99222020);
    IPC::WriteParam((&(writer__)), point);
    // Sentinel = 'point'
    ((&(writer__)))->WriteSentinel(108790315);
    IPC::WriteParam((&(writer__)), aModifiers);
    // Sentinel = 'aModifiers'
    ((&(writer__)))->WriteSentinel(358286340);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aMetrics);
    // Sentinel = 'aMetrics'
    ((&(writer__)))->WriteSentinel(235471673);


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

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

auto PBrowserParent::SendRealTouchMoveEvent(
        const WidgetTouchEvent& aEvent,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const nsEventStatus& aApzResponse) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealTouchMoveEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aApzResponse);
    // Sentinel = 'aApzResponse'
    ((&(writer__)))->WriteSentinel(512951516);


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

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

auto PBrowserParent::SendNormalPriorityRealTouchMoveEvent(
        const WidgetTouchEvent& aEvent,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const nsEventStatus& aApzResponse) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealTouchMoveEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aApzResponse);
    // Sentinel = 'aApzResponse'
    ((&(writer__)))->WriteSentinel(512951516);


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

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

auto PBrowserParent::SendRealTouchMoveEvent2(
        const WidgetTouchEvent& aEvent,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const nsEventStatus& aApzResponse) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealTouchMoveEvent2(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aApzResponse);
    // Sentinel = 'aApzResponse'
    ((&(writer__)))->WriteSentinel(512951516);


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

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

auto PBrowserParent::SendNormalPriorityRealTouchMoveEvent2(
        const WidgetTouchEvent& aEvent,
        const ScrollableLayerGuid& aGuid,
        const uint64_t& aInputBlockId,
        const nsEventStatus& aApzResponse) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityRealTouchMoveEvent2(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aGuid);
    // Sentinel = 'aGuid'
    ((&(writer__)))->WriteSentinel(94044651);
    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aApzResponse);
    // Sentinel = 'aApzResponse'
    ((&(writer__)))->WriteSentinel(512951516);


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

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

auto PBrowserParent::SendRealDragEvent(
        const WidgetDragEvent& aEvent,
        const uint32_t& aDragAction,
        const uint32_t& aDropEffect,
        nsIPrincipal* aPrincipal,
        nsIPolicyContainer* policyContainer) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RealDragEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aDragAction);
    // Sentinel = 'aDragAction'
    ((&(writer__)))->WriteSentinel(411370558);
    IPC::WriteParam((&(writer__)), aDropEffect);
    // Sentinel = 'aDropEffect'
    ((&(writer__)))->WriteSentinel(419759172);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), policyContainer);
    // Sentinel = 'policyContainer'
    ((&(writer__)))->WriteSentinel(833619508);


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

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

auto PBrowserParent::SendSynthesizedEventResponse(const uint64_t& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizedEventResponse(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendCompositionEvent(const WidgetCompositionEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_CompositionEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendNormalPriorityCompositionEvent(const WidgetCompositionEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityCompositionEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendSelectionEvent(const WidgetSelectionEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SelectionEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendNormalPrioritySelectionEvent(const WidgetSelectionEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPrioritySelectionEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendSimpleContentCommandEvent(const EventMessage& message) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SimpleContentCommandEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendNormalPrioritySimpleContentCommandEvent(const EventMessage& message) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPrioritySimpleContentCommandEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendInsertText(const nsAString& aStringToInsert) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InsertText(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendNormalPriorityInsertText(const nsAString& aStringToInsert) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityInsertText(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendReplaceText(
        const nsAString& aReplacementString,
        const nsAString& aStringToInsert,
        const uint32_t& aOffset,
        const bool& aPreventSetSelection) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReplaceText(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aReplacementString);
    // Sentinel = 'aReplacementString'
    ((&(writer__)))->WriteSentinel(1139607369);
    IPC::WriteParam((&(writer__)), aStringToInsert);
    // Sentinel = 'aStringToInsert'
    ((&(writer__)))->WriteSentinel(801768977);
    IPC::WriteParam((&(writer__)), aOffset);
    // Sentinel = 'aOffset'
    ((&(writer__)))->WriteSentinel(179634889);
    IPC::WriteParam((&(writer__)), aPreventSetSelection);
    // Sentinel = 'aPreventSetSelection'
    ((&(writer__)))->WriteSentinel(1408370712);


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

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

auto PBrowserParent::SendNormalPriorityReplaceText(
        const nsAString& aReplacementString,
        const nsAString& aStringToInsert,
        const uint32_t& aOffset,
        const bool& aPreventSetSelection) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NormalPriorityReplaceText(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aReplacementString);
    // Sentinel = 'aReplacementString'
    ((&(writer__)))->WriteSentinel(1139607369);
    IPC::WriteParam((&(writer__)), aStringToInsert);
    // Sentinel = 'aStringToInsert'
    ((&(writer__)))->WriteSentinel(801768977);
    IPC::WriteParam((&(writer__)), aOffset);
    // Sentinel = 'aOffset'
    ((&(writer__)))->WriteSentinel(179634889);
    IPC::WriteParam((&(writer__)), aPreventSetSelection);
    // Sentinel = 'aPreventSetSelection'
    ((&(writer__)))->WriteSentinel(1408370712);


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

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

auto PBrowserParent::SendPasteTransferable(IPCTransferable&& aTransferable) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PasteTransferable(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(aTransferable));
    // Sentinel = 'aTransferable'
    ((&(writer__)))->WriteSentinel(609813819);


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

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

auto PBrowserParent::SendLoadRemoteScript(
        const nsAString& aURL,
        const bool& aRunInGlobalScope) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LoadRemoteScript(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aURL);
    // Sentinel = 'aURL'
    ((&(writer__)))->WriteSentinel(58130773);
    IPC::WriteParam((&(writer__)), aRunInGlobalScope);
    // Sentinel = 'aRunInGlobalScope'
    ((&(writer__)))->WriteSentinel(981862041);


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

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

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



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

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

auto PBrowserParent::SendRenderLayers(const bool& aEnabled) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RenderLayers(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendPreserveLayers(const bool& aPreserve) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PreserveLayers(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendSuppressDisplayport(const bool& aEnabled) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SuppressDisplayport(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendNavigateByKey(
        const bool& aForward,
        const bool& aForDocumentNavigation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NavigateByKey(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aForward);
    // Sentinel = 'aForward'
    ((&(writer__)))->WriteSentinel(236258103);
    IPC::WriteParam((&(writer__)), aForDocumentNavigation);
    // Sentinel = 'aForDocumentNavigation'
    ((&(writer__)))->WriteSentinel(1667434712);


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

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

auto PBrowserParent::SendUIResolutionChanged(
        const float& dpi,
        const int32_t& rounding,
        const double& scale) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UIResolutionChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), dpi);
    // Sentinel = 'dpi'
    ((&(writer__)))->WriteSentinel(41419070);
    IPC::WriteParam((&(writer__)), rounding);
    // Sentinel = 'rounding'
    ((&(writer__)))->WriteSentinel(261292903);
    IPC::WriteParam((&(writer__)), scale);
    // Sentinel = 'scale'
    ((&(writer__)))->WriteSentinel(103809545);


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

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

auto PBrowserParent::SendSafeAreaInsetsChanged(const LayoutDeviceIntMargin& aSafeAreaInsets) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SafeAreaInsetsChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendSwappedWithOtherRemoteLoader(const IPCTabContext& context) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SwappedWithOtherRemoteLoader(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendHandleAccessKey(
        const WidgetKeyboardEvent& event,
        mozilla::Span<uint32_t const> charCodes) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_HandleAccessKey(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), event);
    // Sentinel = 'event'
    ((&(writer__)))->WriteSentinel(106234403);
    IPC::WriteParam((&(writer__)), charCodes);
    // Sentinel = 'charCodes'
    ((&(writer__)))->WriteSentinel(294323085);


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

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

auto PBrowserParent::SendPrintPreview(
        const PrintData& aPrintData,
        const MaybeDiscardedBrowsingContext& aSourceBrowsingContext,
        mozilla::ipc::ResolveCallback<PrintPreviewResultInfo>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PrintPreview(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPrintData);
    // Sentinel = 'aPrintData'
    ((&(writer__)))->WriteSentinel(359072745);
    IPC::WriteParam((&(writer__)), aSourceBrowsingContext);
    // Sentinel = 'aSourceBrowsingContext'
    ((&(writer__)))->WriteSentinel(1709639939);


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

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

            }
            auto& aInfo = *maybe__aInfo;
            // Sentinel = 'aInfo'
            if ((!((aReader)->ReadSentinel(93520366)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrintPreviewResultInfo'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PBrowserParent::SendPrintPreview(
        const PrintData& aPrintData,
        const MaybeDiscardedBrowsingContext& aSourceBrowsingContext) -> RefPtr<PrintPreviewPromise>
{
    RefPtr<MozPromise<PrintPreviewResultInfo, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PrintPreviewResultInfo, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendPrintPreview(std::move(aPrintData), std::move(aSourceBrowsingContext), [promise__](PrintPreviewResultInfo&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserParent::SendExitPrintPreview() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ExitPrintPreview(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendPrint(
        const MaybeDiscardedBrowsingContext& aBC,
        const PrintData& aPrintData,
        const bool& aReturnStaticClone,
        mozilla::ipc::ResolveCallback<MaybeDiscardedBrowsingContext>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_Print(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aBC);
    // Sentinel = 'aBC'
    ((&(writer__)))->WriteSentinel(32309479);
    IPC::WriteParam((&(writer__)), aPrintData);
    // Sentinel = 'aPrintData'
    ((&(writer__)))->WriteSentinel(359072745);
    IPC::WriteParam((&(writer__)), aReturnStaticClone);
    // Sentinel = 'aReturnStaticClone'
    ((&(writer__)))->WriteSentinel(1151993659);


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

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

            }
            auto& staticCloneBrowsingContext = *maybe__staticCloneBrowsingContext;
            // Sentinel = 'staticCloneBrowsingContext'
            if ((!((aReader)->ReadSentinel(2396719786)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PBrowserParent::SendPrint(
        const MaybeDiscardedBrowsingContext& aBC,
        const PrintData& aPrintData,
        const bool& aReturnStaticClone) -> RefPtr<PrintPromise>
{
    RefPtr<MozPromise<MaybeDiscardedBrowsingContext, ResponseRejectReason, true>::Private> promise__ = new MozPromise<MaybeDiscardedBrowsingContext, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendPrint(std::move(aBC), std::move(aPrintData), std::move(aReturnStaticClone), [promise__](MaybeDiscardedBrowsingContext&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserParent::SendPrintClonedPage(
        const MaybeDiscardedBrowsingContext& aBC,
        const PrintData& aPrintData,
        const MaybeDiscardedBrowsingContext& aStaticCloneBrowsingContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_PrintClonedPage(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aBC);
    // Sentinel = 'aBC'
    ((&(writer__)))->WriteSentinel(32309479);
    IPC::WriteParam((&(writer__)), aPrintData);
    // Sentinel = 'aPrintData'
    ((&(writer__)))->WriteSentinel(359072745);
    IPC::WriteParam((&(writer__)), aStaticCloneBrowsingContext);
    // Sentinel = 'aStaticCloneBrowsingContext'
    ((&(writer__)))->WriteSentinel(2513898219);


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

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

auto PBrowserParent::SendDestroyPrintClone(const MaybeDiscardedBrowsingContext& aStaticCloneBrowsingContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DestroyPrintClone(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendUpdateNativeWindowHandle(const uintptr_t& aNewHandle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateNativeWindowHandle(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserParent::SendAllowScriptsToClose() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AllowScriptsToClose(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendWillChangeProcess() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_WillChangeProcess(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserParent::SendInvokeChildDragSession(
        const MaybeDiscardedWindowContext& aSourceWindowContext,
        const MaybeDiscardedWindowContext& aSourceTopWindowContext,
        nsIPrincipal* aPrincipal,
        nsTArray<IPCTransferableData>&& transfers,
        const uint32_t& action) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InvokeChildDragSession(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aSourceWindowContext);
    // Sentinel = 'aSourceWindowContext'
    ((&(writer__)))->WriteSentinel(1416038448);
    IPC::WriteParam((&(writer__)), aSourceTopWindowContext);
    // Sentinel = 'aSourceTopWindowContext'
    ((&(writer__)))->WriteSentinel(1858144611);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), std::move(transfers));
    // Sentinel = 'transfers'
    ((&(writer__)))->WriteSentinel(323290073);
    IPC::WriteParam((&(writer__)), action);
    // Sentinel = 'action'
    ((&(writer__)))->WriteSentinel(143786623);


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

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

auto PBrowserParent::SendUpdateDragSession(
        nsIPrincipal* aPrincipal,
        nsTArray<IPCTransferableData>&& transfers,
        const EventMessage& message) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateDragSession(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), std::move(transfers));
    // Sentinel = 'transfers'
    ((&(writer__)))->WriteSentinel(323290073);
    IPC::WriteParam((&(writer__)), message);
    // Sentinel = 'message'
    ((&(writer__)))->WriteSentinel(197198566);


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

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

auto PBrowserParent::SendEndDragSession(
        const bool& aDoneDrag,
        const bool& aUserCancelled,
        const LayoutDeviceIntPoint& aDragEndPoint,
        const uint32_t& aKeyModifiers,
        const uint32_t& aDropEffect) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_EndDragSession(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aDoneDrag);
    // Sentinel = 'aDoneDrag'
    ((&(writer__)))->WriteSentinel(280429414);
    IPC::WriteParam((&(writer__)), aUserCancelled);
    // Sentinel = 'aUserCancelled'
    ((&(writer__)))->WriteSentinel(682493308);
    IPC::WriteParam((&(writer__)), aDragEndPoint);
    // Sentinel = 'aDragEndPoint'
    ((&(writer__)))->WriteSentinel(567411969);
    IPC::WriteParam((&(writer__)), aKeyModifiers);
    // Sentinel = 'aKeyModifiers'
    ((&(writer__)))->WriteSentinel(588645677);
    IPC::WriteParam((&(writer__)), aDropEffect);
    // Sentinel = 'aDropEffect'
    ((&(writer__)))->WriteSentinel(419759172);


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

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

auto PBrowserParent::SendStoreDropTargetAndDelayEndDragSession(
        const LayoutDeviceIntPoint& aPt,
        const uint32_t& aDropEffect,
        const uint32_t& aDragAction,
        nsIPrincipal* aPrincipal,
        nsIPolicyContainer* aPolicyContainer) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_StoreDropTargetAndDelayEndDragSession(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPt);
    // Sentinel = 'aPt'
    ((&(writer__)))->WriteSentinel(37355814);
    IPC::WriteParam((&(writer__)), aDropEffect);
    // Sentinel = 'aDropEffect'
    ((&(writer__)))->WriteSentinel(419759172);
    IPC::WriteParam((&(writer__)), aDragAction);
    // Sentinel = 'aDragAction'
    ((&(writer__)))->WriteSentinel(411370558);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), aPolicyContainer);
    // Sentinel = 'aPolicyContainer'
    ((&(writer__)))->WriteSentinel(903939701);


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

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

auto PBrowserParent::SendDispatchToDropTargetAndResumeEndDragSession(
        const bool& aShouldDrop,
        const StringHashSet& aAllowedFilePaths) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchToDropTargetAndResumeEndDragSession(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aShouldDrop);
    // Sentinel = 'aShouldDrop'
    ((&(writer__)))->WriteSentinel(435618918);
    IPC::WriteParam((&(writer__)), aAllowedFilePaths);
    // Sentinel = 'aAllowedFilePaths'
    ((&(writer__)))->WriteSentinel(990316202);


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

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

auto PBrowserParent::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PDocAccessibleMsgStart:
        static_cast<BrowserParent*>(this)->DeallocPDocAccessibleParent(static_cast<PDocAccessibleParent*>(aListener));
        return;
    case PPaymentRequestMsgStart:
        static_cast<BrowserParent*>(this)->DeallocPPaymentRequestParent(static_cast<PPaymentRequestParent*>(aListener));
        return;
    default:
        FatalError("unreached");
        return;
    }
}

auto PBrowserParent::OnMessageReceived(const Message& msg__) -> PBrowserParent::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 PBrowser::Msg_AsyncMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_AsyncMessage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aMessage = *maybe__aMessage;
            // Sentinel = 'aMessage'
            if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<ClonedMessageData>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvAsyncMessage(std::move(aMessage), std::move(aData));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            }
            auto& aBrowsingContext = *maybe__aBrowsingContext;
            // Sentinel = 'aBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            PDocAccessibleParent* actor = (static_cast<BrowserParent*>(this))->AllocPDocAccessibleParent(aParentDoc, aParentAcc, aBrowsingContext);
            if (!actor) {
                NS_WARNING("Cannot bind null PDocAccessibleParent actor");
                return MsgValueError;
            }

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

            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPDocAccessibleConstructor(std::move(actor), std::move(aParentDoc), std::move(aParentAcc), std::move(aBrowsingContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_PPaymentRequestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PPaymentRequestConstructor", 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();
            PPaymentRequestParent* actor = (static_cast<BrowserParent*>(this))->AllocPPaymentRequestParent();
            if (!actor) {
                NS_WARNING("Cannot bind null PPaymentRequestParent actor");
                return MsgValueError;
            }

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_PVsyncConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PVsyncConstructor", 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<PVsyncParent> actor = (static_cast<BrowserParent*>(this))->AllocPVsyncParent();
            if (!actor) {
                NS_WARNING("Cannot bind null PVsyncParent actor");
                return MsgValueError;
            }

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_DidUnsuppressPainting__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DidUnsuppressPainting", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_DidUnsuppressPaintingNormalPriority__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DidUnsuppressPaintingNormalPriority", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_MoveFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_MoveFocus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& forDocumentNavigation = *maybe__forDocumentNavigation;
            // Sentinel = 'forDocumentNavigation'
            if ((!(((&(reader__)))->ReadSentinel(1571555479)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvMoveFocus(std::move(forward), std::move(forDocumentNavigation));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_DropLinks__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DropLinks", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aLinks = *maybe__aLinks;
            // Sentinel = 'aLinks'
            if ((!(((&(reader__)))->ReadSentinel(134152803)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDropLinks(std::move(aLinks));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyIMEFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEFocus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& contentCache = *maybe__contentCache;
            // Sentinel = 'contentCache'
            if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
                return MsgValueError;
            }
            auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
            if (!maybe__notification) {
                FatalError("Error deserializing 'IMENotification'");
                return MsgValueError;

            }
            auto& notification = *maybe__notification;
            // Sentinel = 'notification'
            if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PBrowser::Reply_NotifyIMEFocus(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyIMETextChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMETextChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& contentCache = *maybe__contentCache;
            // Sentinel = 'contentCache'
            if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
                return MsgValueError;
            }
            auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
            if (!maybe__notification) {
                FatalError("Error deserializing 'IMENotification'");
                return MsgValueError;

            }
            auto& notification = *maybe__notification;
            // Sentinel = 'notification'
            if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMETextChange(std::move(contentCache), std::move(notification));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyIMECompositionUpdate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMECompositionUpdate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& contentCache = *maybe__contentCache;
            // Sentinel = 'contentCache'
            if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
                return MsgValueError;
            }
            auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
            if (!maybe__notification) {
                FatalError("Error deserializing 'IMENotification'");
                return MsgValueError;

            }
            auto& notification = *maybe__notification;
            // Sentinel = 'notification'
            if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMECompositionUpdate(std::move(contentCache), std::move(notification));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyIMESelection__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMESelection", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& contentCache = *maybe__contentCache;
            // Sentinel = 'contentCache'
            if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
                return MsgValueError;
            }
            auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
            if (!maybe__notification) {
                FatalError("Error deserializing 'IMENotification'");
                return MsgValueError;

            }
            auto& notification = *maybe__notification;
            // Sentinel = 'notification'
            if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMESelection(std::move(contentCache), std::move(notification));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateContentCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateContentCache", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& contentCache = *maybe__contentCache;
            // Sentinel = 'contentCache'
            if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvUpdateContentCache(std::move(contentCache));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyIMEPositionChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEPositionChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& contentCache = *maybe__contentCache;
            // Sentinel = 'contentCache'
            if ((!(((&(reader__)))->ReadSentinel(535299280)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentCache'");
                return MsgValueError;
            }
            auto maybe__notification = IPC::ReadParam<IMENotification>((&(reader__)));
            if (!maybe__notification) {
                FatalError("Error deserializing 'IMENotification'");
                return MsgValueError;

            }
            auto& notification = *maybe__notification;
            // Sentinel = 'notification'
            if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMEPositionChange(std::move(contentCache), std::move(notification));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_OnEventNeedingAckHandled__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_OnEventNeedingAckHandled", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& message = *maybe__message;
            // Sentinel = 'message'
            if ((!(((&(reader__)))->ReadSentinel(197198566)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'EventMessage'");
                return MsgValueError;
            }
            auto maybe__compositionId = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__compositionId) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& compositionId = *maybe__compositionId;
            // Sentinel = 'compositionId'
            if ((!(((&(reader__)))->ReadSentinel(645268834)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnEventNeedingAckHandled(std::move(message), std::move(compositionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RequestFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RequestFocus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& canRaise = *maybe__canRaise;
            // Sentinel = 'canRaise'
            if ((!(((&(reader__)))->ReadSentinel(234816295)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aCallerType = IPC::ReadParam<CallerType>((&(reader__)));
            if (!maybe__aCallerType) {
                FatalError("Error deserializing 'CallerType'");
                return MsgValueError;

            }
            auto& aCallerType = *maybe__aCallerType;
            // Sentinel = 'aCallerType'
            if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestFocus(std::move(canRaise), std::move(aCallerType));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_WheelZoomChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_WheelZoomChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_EnableDisableCommands__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_EnableDisableCommands", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& bc = *maybe__bc;
            // Sentinel = 'bc'
            if ((!(((&(reader__)))->ReadSentinel(19464390)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__action = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__action) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& action = *maybe__action;
            // Sentinel = 'action'
            if ((!(((&(reader__)))->ReadSentinel(143786623)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__enabledCommands = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
            if (!maybe__enabledCommands) {
                FatalError("Error deserializing 'nsCString[]'");
                return MsgValueError;

            }
            auto& enabledCommands = *maybe__enabledCommands;
            // Sentinel = 'enabledCommands'
            if ((!(((&(reader__)))->ReadSentinel(796263934)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__disabledCommands = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
            if (!maybe__disabledCommands) {
                FatalError("Error deserializing 'nsCString[]'");
                return MsgValueError;

            }
            auto& disabledCommands = *maybe__disabledCommands;
            // Sentinel = 'disabledCommands'
            if ((!(((&(reader__)))->ReadSentinel(909706859)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvEnableDisableCommands(std::move(bc), std::move(action), std::move(enabledCommands), std::move(disabledCommands));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SetInputContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SetInputContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& context = *maybe__context;
            // Sentinel = 'context'
            if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'InputContext'");
                return MsgValueError;
            }
            auto maybe__action = IPC::ReadParam<InputContextAction>((&(reader__)));
            if (!maybe__action) {
                FatalError("Error deserializing 'InputContextAction'");
                return MsgValueError;

            }
            auto& action = *maybe__action;
            // Sentinel = 'action'
            if ((!(((&(reader__)))->ReadSentinel(143786623)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'InputContextAction'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetInputContext(std::move(context), std::move(action));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SetCursor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SetCursor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& value = *maybe__value;
            // Sentinel = 'value'
            if ((!(((&(reader__)))->ReadSentinel(107610654)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCursor'");
                return MsgValueError;
            }
            auto maybe__customCursor = IPC::ReadParam<mozilla::Maybe<IPCImage>>((&(reader__)));
            if (!maybe__customCursor) {
                FatalError("Error deserializing 'IPCImage?'");
                return MsgValueError;

            }
            auto& customCursor = *maybe__customCursor;
            // Sentinel = 'customCursor'
            if ((!(((&(reader__)))->ReadSentinel(554173722)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCImage?'");
                return MsgValueError;
            }
            auto maybe__resolutionX = IPC::ReadParam<float>((&(reader__)));
            if (!maybe__resolutionX) {
                FatalError("Error deserializing 'float'");
                return MsgValueError;

            }
            auto& resolutionX = *maybe__resolutionX;
            // Sentinel = 'resolutionX'
            if ((!(((&(reader__)))->ReadSentinel(478217389)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }
            auto maybe__resolutionY = IPC::ReadParam<float>((&(reader__)));
            if (!maybe__resolutionY) {
                FatalError("Error deserializing 'float'");
                return MsgValueError;

            }
            auto& resolutionY = *maybe__resolutionY;
            // Sentinel = 'resolutionY'
            if ((!(((&(reader__)))->ReadSentinel(478282926)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }
            auto maybe__hotspotX = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__hotspotX) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

            }
            auto& hotspotY = *maybe__hotspotY;
            // Sentinel = 'hotspotY'
            if ((!(((&(reader__)))->ReadSentinel(261489515)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__force = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__force) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& force = *maybe__force;
            // Sentinel = 'force'
            if ((!(((&(reader__)))->ReadSentinel(104858128)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetCursor(std::move(value), std::move(customCursor), std::move(resolutionX), std::move(resolutionY), std::move(hotspotX), std::move(hotspotY), std::move(force));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SetLinkStatus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SetLinkStatus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_ShowTooltip__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ShowTooltip", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& y = *maybe__y;
            // Sentinel = 'y'
            if ((!(((&(reader__)))->ReadSentinel(7995514)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__tooltip = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__tooltip) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

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

            }
            auto& direction = *maybe__direction;
            // Sentinel = 'direction'
            if ((!(((&(reader__)))->ReadSentinel(311886786)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvShowTooltip(std::move(x), std::move(y), std::move(tooltip), std::move(direction));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_HideTooltip__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_HideTooltip", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_PColorPickerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PColorPickerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aBrowsingContext = *maybe__aBrowsingContext;
            // Sentinel = 'aBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__title = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__title) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

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

            }
            auto& initialColor = *maybe__initialColor;
            // Sentinel = 'initialColor'
            if ((!(((&(reader__)))->ReadSentinel(536216810)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__defaultColors = IPC::ReadParam<nsTArray<nsString>>((&(reader__)));
            if (!maybe__defaultColors) {
                FatalError("Error deserializing 'nsString[]'");
                return MsgValueError;

            }
            auto& defaultColors = *maybe__defaultColors;
            // Sentinel = 'defaultColors'
            if ((!(((&(reader__)))->ReadSentinel(616760664)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            RefPtr<PColorPickerParent> actor = (static_cast<BrowserParent*>(this))->AllocPColorPickerParent(aBrowsingContext, title, initialColor, defaultColors);
            if (!actor) {
                NS_WARNING("Cannot bind null PColorPickerParent actor");
                return MsgValueError;
            }

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

            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPColorPickerConstructor(actor, std::move(aBrowsingContext), std::move(title), std::move(initialColor), std::move(defaultColors));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_PFilePickerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PFilePickerConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& actorid__ = *maybe__actorid__;
            // Sentinel = 'actorid'
            if ((!(((&(reader__)))->ReadSentinel(193725159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'mozilla::ipc::ActorId'");
                return MsgValueError;
            }
            auto maybe__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;
            }
            auto maybe__aMode = IPC::ReadParam<Mode>((&(reader__)));
            if (!maybe__aMode) {
                FatalError("Error deserializing 'Mode'");
                return MsgValueError;

            }
            auto& aMode = *maybe__aMode;
            // Sentinel = 'aMode'
            if ((!(((&(reader__)))->ReadSentinel(93848039)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Mode'");
                return MsgValueError;
            }
            auto maybe__aBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aBrowsingContext) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aBrowsingContext = *maybe__aBrowsingContext;
            // Sentinel = 'aBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            RefPtr<PFilePickerParent> actor = (static_cast<BrowserParent*>(this))->AllocPFilePickerParent(aTitle, aMode, aBrowsingContext);
            if (!actor) {
                NS_WARNING("Cannot bind null PFilePickerParent actor");
                return MsgValueError;
            }

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

            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvPFilePickerConstructor(actor, std::move(aTitle), std::move(aMode), std::move(aBrowsingContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RespondStartSwipeEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RespondStartSwipeEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aStartSwipe = *maybe__aStartSwipe;
            // Sentinel = 'aStartSwipe'
            if ((!(((&(reader__)))->ReadSentinel(442565752)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRespondStartSwipeEvent(std::move(aInputBlockId), std::move(aStartSwipe));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_LookUpDictionary__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_LookUpDictionary", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aText = *maybe__aText;
            // Sentinel = 'aText'
            if ((!(((&(reader__)))->ReadSentinel(97321479)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aFontRangeArray = IPC::ReadParam<nsTArray<FontRange>>((&(reader__)));
            if (!maybe__aFontRangeArray) {
                FatalError("Error deserializing 'FontRange[]'");
                return MsgValueError;

            }
            auto& aFontRangeArray = *maybe__aFontRangeArray;
            // Sentinel = 'aFontRangeArray'
            if ((!(((&(reader__)))->ReadSentinel(775095781)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FontRange[]'");
                return MsgValueError;
            }
            auto maybe__aIsVertical = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsVertical) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsVertical = *maybe__aIsVertical;
            // Sentinel = 'aIsVertical'
            if ((!(((&(reader__)))->ReadSentinel(427361368)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
            if (!maybe__aPoint) {
                FatalError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvLookUpDictionary(std::move(aText), std::move(aFontRangeArray), std::move(aIsVertical), std::move(aPoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg___delete__", OTHER);

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


            this->ActorDisconnected(Deletion);

            return MsgProcessed;
        }
    case PBrowser::Msg_ReplyKeyEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ReplyKeyEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEvent = *maybe__aEvent;
            // Sentinel = 'aEvent'
            if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
                return MsgValueError;
            }
            auto maybe__aUUID = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__aUUID) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& aUUID = *maybe__aUUID;
            // Sentinel = 'aUUID'
            if ((!(((&(reader__)))->ReadSentinel(85131673)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvReplyKeyEvent(std::move(aEvent), std::move(aUUID));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeKeyEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeKeyEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aNativeKeyboardLayout = *maybe__aNativeKeyboardLayout;
            // Sentinel = 'aNativeKeyboardLayout'
            if ((!(((&(reader__)))->ReadSentinel(1529153656)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aNativeKeyCode = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aNativeKeyCode) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aNativeKeyCode = *maybe__aNativeKeyCode;
            // Sentinel = 'aNativeKeyCode'
            if ((!(((&(reader__)))->ReadSentinel(680527213)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aModifierFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aModifierFlags = *maybe__aModifierFlags;
            // Sentinel = 'aModifierFlags'
            if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aCharacters = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aCharacters) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

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

            }
            auto& aUnmodifiedCharacters = *maybe__aUnmodifiedCharacters;
            // Sentinel = 'aUnmodifiedCharacters'
            if ((!(((&(reader__)))->ReadSentinel(1529874534)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeKeyEvent(std::move(aNativeKeyboardLayout), std::move(aNativeKeyCode), std::move(aModifierFlags), std::move(aCharacters), std::move(aUnmodifiedCharacters), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeMouseEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aNativeMessage = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aNativeMessage) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aNativeMessage = *maybe__aNativeMessage;
            // Sentinel = 'aNativeMessage'
            if ((!(((&(reader__)))->ReadSentinel(689702286)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aButton = IPC::ReadParam<int16_t>((&(reader__)));
            if (!maybe__aButton) {
                FatalError("Error deserializing 'int16_t'");
                return MsgValueError;

            }
            auto& aButton = *maybe__aButton;
            // Sentinel = 'aButton'
            if ((!(((&(reader__)))->ReadSentinel(184222430)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int16_t'");
                return MsgValueError;
            }
            auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aModifierFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aModifierFlags = *maybe__aModifierFlags;
            // Sentinel = 'aModifierFlags'
            if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeMouseEvent(std::move(aPoint), std::move(aNativeMessage), std::move(aButton), std::move(aModifierFlags), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeMouseMove__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseMove", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeMouseMove(std::move(aPoint), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeMouseScrollEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeMouseScrollEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aNativeMessage = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aNativeMessage) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aNativeMessage = *maybe__aNativeMessage;
            // Sentinel = 'aNativeMessage'
            if ((!(((&(reader__)))->ReadSentinel(689702286)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aDeltaX = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aDeltaX) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aDeltaX = *maybe__aDeltaX;
            // Sentinel = 'aDeltaX'
            if ((!(((&(reader__)))->ReadSentinel(174391972)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aDeltaY = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aDeltaY) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aDeltaY = *maybe__aDeltaY;
            // Sentinel = 'aDeltaY'
            if ((!(((&(reader__)))->ReadSentinel(174457509)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aDeltaZ = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aDeltaZ) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aDeltaZ = *maybe__aDeltaZ;
            // Sentinel = 'aDeltaZ'
            if ((!(((&(reader__)))->ReadSentinel(174523046)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aModifierFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

            }
            auto& aAdditionalFlags = *maybe__aAdditionalFlags;
            // Sentinel = 'aAdditionalFlags'
            if ((!(((&(reader__)))->ReadSentinel(880084552)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeMouseScrollEvent(std::move(aPoint), std::move(aNativeMessage), std::move(aDeltaX), std::move(aDeltaY), std::move(aDeltaZ), std::move(aModifierFlags), std::move(aAdditionalFlags), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeTouchPoint__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchPoint", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPointerId = *maybe__aPointerId;
            // Sentinel = 'aPointerId'
            if ((!(((&(reader__)))->ReadSentinel(364053488)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aPointerState = IPC::ReadParam<TouchPointerState>((&(reader__)));
            if (!maybe__aPointerState) {
                FatalError("Error deserializing 'TouchPointerState'");
                return MsgValueError;

            }
            auto& aPointerState = *maybe__aPointerState;
            // Sentinel = 'aPointerState'
            if ((!(((&(reader__)))->ReadSentinel(610600260)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TouchPointerState'");
                return MsgValueError;
            }
            auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
            if (!maybe__aPoint) {
                FatalError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aPointerPressure = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aPointerPressure) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aPointerPressure = *maybe__aPointerPressure;
            // Sentinel = 'aPointerPressure'
            if ((!(((&(reader__)))->ReadSentinel(922617500)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aPointerOrientation = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aPointerOrientation) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aPointerOrientation = *maybe__aPointerOrientation;
            // Sentinel = 'aPointerOrientation'
            if ((!(((&(reader__)))->ReadSentinel(1287653327)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchPoint(std::move(aPointerId), std::move(aPointerState), std::move(aPoint), std::move(aPointerPressure), std::move(aPointerOrientation), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeTouchPadPinch__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchPadPinch", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aModifierFlags = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aModifierFlags) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aModifierFlags = *maybe__aModifierFlags;
            // Sentinel = 'aModifierFlags'
            if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchPadPinch(std::move(aEventPhase), std::move(aScale), std::move(aPoint), std::move(aModifierFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeTouchTap__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchTap", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aLongTap = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aLongTap) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aLongTap = *maybe__aLongTap;
            // Sentinel = 'aLongTap'
            if ((!(((&(reader__)))->ReadSentinel(229507863)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchTap(std::move(aPoint), std::move(aLongTap), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativePenInput__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativePenInput", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPointerId = *maybe__aPointerId;
            // Sentinel = 'aPointerId'
            if ((!(((&(reader__)))->ReadSentinel(364053488)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aPointerState = IPC::ReadParam<TouchPointerState>((&(reader__)));
            if (!maybe__aPointerState) {
                FatalError("Error deserializing 'TouchPointerState'");
                return MsgValueError;

            }
            auto& aPointerState = *maybe__aPointerState;
            // Sentinel = 'aPointerState'
            if ((!(((&(reader__)))->ReadSentinel(610600260)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TouchPointerState'");
                return MsgValueError;
            }
            auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
            if (!maybe__aPoint) {
                FatalError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aPressure = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aPressure) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aPressure = *maybe__aPressure;
            // Sentinel = 'aPressure'
            if ((!(((&(reader__)))->ReadSentinel(304153531)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aRotation = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aRotation) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aRotation = *maybe__aRotation;
            // Sentinel = 'aRotation'
            if ((!(((&(reader__)))->ReadSentinel(301925298)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aTiltX = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aTiltX) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aTiltX = *maybe__aTiltX;
            // Sentinel = 'aTiltX'
            if ((!(((&(reader__)))->ReadSentinel(135791191)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aTiltY = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aTiltY) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aTiltY = *maybe__aTiltY;
            // Sentinel = 'aTiltY'
            if ((!(((&(reader__)))->ReadSentinel(135856728)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aButton = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aButton) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aButton = *maybe__aButton;
            // Sentinel = 'aButton'
            if ((!(((&(reader__)))->ReadSentinel(184222430)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativePenInput(std::move(aPointerId), std::move(aPointerState), std::move(aPoint), std::move(aPressure), std::move(aRotation), std::move(aTiltX), std::move(aTiltY), std::move(aButton), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aModifierFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aModifierFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aModifierFlags = *maybe__aModifierFlags;
            // Sentinel = 'aModifierFlags'
            if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchpadDoubleTap(std::move(aPoint), std::move(aModifierFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizeNativeTouchpadPan__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizeNativeTouchpadPan", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEventPhase = *maybe__aEventPhase;
            // Sentinel = 'aEventPhase'
            if ((!(((&(reader__)))->ReadSentinel(428737621)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TouchpadGesturePhase'");
                return MsgValueError;
            }
            auto maybe__aPoint = IPC::ReadParam<LayoutDeviceIntPoint>((&(reader__)));
            if (!maybe__aPoint) {
                FatalError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;

            }
            auto& aPoint = *maybe__aPoint;
            // Sentinel = 'aPoint'
            if ((!(((&(reader__)))->ReadSentinel(136512108)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            auto maybe__aDeltaX = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aDeltaX) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aDeltaX = *maybe__aDeltaX;
            // Sentinel = 'aDeltaX'
            if ((!(((&(reader__)))->ReadSentinel(174391972)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aDeltaY = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aDeltaY) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aDeltaY = *maybe__aDeltaY;
            // Sentinel = 'aDeltaY'
            if ((!(((&(reader__)))->ReadSentinel(174457509)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            auto maybe__aModifierFlags = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aModifierFlags) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aModifierFlags = *maybe__aModifierFlags;
            // Sentinel = 'aModifierFlags'
            if ((!(((&(reader__)))->ReadSentinel(681444734)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aCallbackId = IPC::ReadParam<mozilla::Maybe<uint64_t>>((&(reader__)));
            if (!maybe__aCallbackId) {
                FatalError("Error deserializing 'uint64_t?'");
                return MsgValueError;

            }
            auto& aCallbackId = *maybe__aCallbackId;
            // Sentinel = 'aCallbackId'
            if ((!(((&(reader__)))->ReadSentinel(411370524)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSynthesizeNativeTouchpadPan(std::move(aEventPhase), std::move(aPoint), std::move(aDeltaX), std::move(aDeltaY), std::move(aModifierFlags), std::move(aCallbackId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_LockNativePointer__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_LockNativePointer", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_UnlockNativePointer__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UnlockNativePointer", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_AccessKeyNotHandled__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_AccessKeyNotHandled", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvAccessKeyNotHandled(std::move(event));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RegisterProtocolHandler__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RegisterProtocolHandler", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& scheme = *maybe__scheme;
            // Sentinel = 'scheme'
            if ((!(((&(reader__)))->ReadSentinel(146080374)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__handlerURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__handlerURI) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& handlerURI = *maybe__handlerURI;
            // Sentinel = 'handlerURI'
            if ((!(((&(reader__)))->ReadSentinel(367264719)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            auto maybe__title = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__title) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& title = *maybe__title;
            // Sentinel = 'title'
            if ((!(((&(reader__)))->ReadSentinel(109445667)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__documentURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__documentURI) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& documentURI = *maybe__documentURI;
            // Sentinel = 'documentURI'
            if ((!(((&(reader__)))->ReadSentinel(453706832)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRegisterProtocolHandler(std::move(scheme), handlerURI, std::move(title), documentURI);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_OnStateChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_OnStateChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aWebProgressData = *maybe__aWebProgressData;
            // Sentinel = 'aWebProgressData'
            if ((!(((&(reader__)))->ReadSentinel(890504783)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressData'");
                return MsgValueError;
            }
            auto maybe__aRequestData = IPC::ReadParam<RequestData>((&(reader__)));
            if (!maybe__aRequestData) {
                FatalError("Error deserializing 'RequestData'");
                return MsgValueError;

            }
            auto& aRequestData = *maybe__aRequestData;
            // Sentinel = 'aRequestData'
            if ((!(((&(reader__)))->ReadSentinel(518390981)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RequestData'");
                return MsgValueError;
            }
            auto maybe__aStateFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aStateFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aStateFlags = *maybe__aStateFlags;
            // Sentinel = 'aStateFlags'
            if ((!(((&(reader__)))->ReadSentinel(428606544)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aStatus = IPC::ReadParam<nsresult>((&(reader__)));
            if (!maybe__aStatus) {
                FatalError("Error deserializing 'nsresult'");
                return MsgValueError;

            }
            auto& aStatus = *maybe__aStatus;
            // Sentinel = 'aStatus'
            if ((!(((&(reader__)))->ReadSentinel(186712806)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            auto maybe__aStateChangeData = IPC::ReadParam<mozilla::Maybe<WebProgressStateChangeData>>((&(reader__)));
            if (!maybe__aStateChangeData) {
                FatalError("Error deserializing 'WebProgressStateChangeData?'");
                return MsgValueError;

            }
            auto& aStateChangeData = *maybe__aStateChangeData;
            // Sentinel = 'aStateChangeData'
            if ((!(((&(reader__)))->ReadSentinel(876086819)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressStateChangeData?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnStateChange(std::move(aWebProgressData), std::move(aRequestData), std::move(aStateFlags), std::move(aStatus), std::move(aStateChangeData));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_OnLocationChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_OnLocationChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aWebProgressData = *maybe__aWebProgressData;
            // Sentinel = 'aWebProgressData'
            if ((!(((&(reader__)))->ReadSentinel(890504783)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressData'");
                return MsgValueError;
            }
            auto maybe__aRequestData = IPC::ReadParam<RequestData>((&(reader__)));
            if (!maybe__aRequestData) {
                FatalError("Error deserializing 'RequestData'");
                return MsgValueError;

            }
            auto& aRequestData = *maybe__aRequestData;
            // Sentinel = 'aRequestData'
            if ((!(((&(reader__)))->ReadSentinel(518390981)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RequestData'");
                return MsgValueError;
            }
            auto maybe__aLocation = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__aLocation) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& aLocation = *maybe__aLocation;
            // Sentinel = 'aLocation'
            if ((!(((&(reader__)))->ReadSentinel(292094875)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            auto maybe__aFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aFlags = *maybe__aFlags;
            // Sentinel = 'aFlags'
            if ((!(((&(reader__)))->ReadSentinel(129892943)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aCanGoBack = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aCanGoBack) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

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

            }
            auto& aCanGoForward = *maybe__aCanGoForward;
            // Sentinel = 'aCanGoForward'
            if ((!(((&(reader__)))->ReadSentinel(563152127)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aLocationChangeData = IPC::ReadParam<mozilla::Maybe<WebProgressLocationChangeData>>((&(reader__)));
            if (!maybe__aLocationChangeData) {
                FatalError("Error deserializing 'WebProgressLocationChangeData?'");
                return MsgValueError;

            }
            auto& aLocationChangeData = *maybe__aLocationChangeData;
            // Sentinel = 'aLocationChangeData'
            if ((!(((&(reader__)))->ReadSentinel(1235617627)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WebProgressLocationChangeData?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnLocationChange(std::move(aWebProgressData), std::move(aRequestData), aLocation, std::move(aFlags), std::move(aCanGoBack), std::move(aCanGoBackIgnoringUserInteraction), std::move(aCanGoForward), std::move(aLocationChangeData));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_OnProgressChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_OnProgressChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aCurTotalProgress = *maybe__aCurTotalProgress;
            // Sentinel = 'aCurTotalProgress'
            if ((!(((&(reader__)))->ReadSentinel(1012795109)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aMaxTotalProgress = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aMaxTotalProgress) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aMaxTotalProgress = *maybe__aMaxTotalProgress;
            // Sentinel = 'aMaxTotalProgress'
            if ((!(((&(reader__)))->ReadSentinel(1009125089)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvOnProgressChange(std::move(aCurTotalProgress), std::move(aMaxTotalProgress));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_OnStatusChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_OnStatusChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyContentBlockingEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyContentBlockingEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEvent = *maybe__aEvent;
            // Sentinel = 'aEvent'
            if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aRequestData = IPC::ReadParam<RequestData>((&(reader__)));
            if (!maybe__aRequestData) {
                FatalError("Error deserializing 'RequestData'");
                return MsgValueError;

            }
            auto& aRequestData = *maybe__aRequestData;
            // Sentinel = 'aRequestData'
            if ((!(((&(reader__)))->ReadSentinel(518390981)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RequestData'");
                return MsgValueError;
            }
            auto maybe__aBlocked = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aBlocked) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aBlocked = *maybe__aBlocked;
            // Sentinel = 'aBlocked'
            if ((!(((&(reader__)))->ReadSentinel(227279638)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aTrackingOrigin = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__aTrackingOrigin) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& aTrackingOrigin = *maybe__aTrackingOrigin;
            // Sentinel = 'aTrackingOrigin'
            if ((!(((&(reader__)))->ReadSentinel(792331773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__aTrackingFullHashes = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
            if (!maybe__aTrackingFullHashes) {
                FatalError("Error deserializing 'nsCString[]'");
                return MsgValueError;

            }
            auto& aTrackingFullHashes = *maybe__aTrackingFullHashes;
            // Sentinel = 'aTrackingFullHashes'
            if ((!(((&(reader__)))->ReadSentinel(1248069508)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aReason = IPC::ReadParam<mozilla::Maybe<StorageAccessPermissionGrantedReason>>((&(reader__)));
            if (!maybe__aReason) {
                FatalError("Error deserializing 'StorageAccessPermissionGrantedReason?'");
                return MsgValueError;

            }
            auto& aReason = *maybe__aReason;
            // Sentinel = 'aReason'
            if ((!(((&(reader__)))->ReadSentinel(180093642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPermissionGrantedReason?'");
                return MsgValueError;
            }
            auto maybe__aCanvasFingerprinter = IPC::ReadParam<mozilla::Maybe<CanvasFingerprinter>>((&(reader__)));
            if (!maybe__aCanvasFingerprinter) {
                FatalError("Error deserializing 'CanvasFingerprinter?'");
                return MsgValueError;

            }
            auto& aCanvasFingerprinter = *maybe__aCanvasFingerprinter;
            // Sentinel = 'aCanvasFingerprinter'
            if ((!(((&(reader__)))->ReadSentinel(1384777757)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CanvasFingerprinter?'");
                return MsgValueError;
            }
            auto maybe__aCanvasFingerprinterKnownText = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
            if (!maybe__aCanvasFingerprinterKnownText) {
                FatalError("Error deserializing 'bool?'");
                return MsgValueError;

            }
            auto& aCanvasFingerprinterKnownText = *maybe__aCanvasFingerprinterKnownText;
            // Sentinel = 'aCanvasFingerprinterKnownText'
            if ((!(((&(reader__)))->ReadSentinel(2910718927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyContentBlockingEvent(std::move(aEvent), std::move(aRequestData), std::move(aBlocked), std::move(aTrackingOrigin), std::move(aTrackingFullHashes), std::move(aReason), std::move(aCanvasFingerprinter), std::move(aCanvasFingerprinterKnownText));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NavigationFinished__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NavigationFinished", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_IntrinsicSizeOrRatioChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_IntrinsicSizeOrRatioChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aIntrinsicSize = *maybe__aIntrinsicSize;
            // Sentinel = 'aIntrinsicSize'
            if ((!(((&(reader__)))->ReadSentinel(708052400)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IntrinsicSize?'");
                return MsgValueError;
            }
            auto maybe__aIntrinsicRatio = IPC::ReadParam<mozilla::Maybe<AspectRatio>>((&(reader__)));
            if (!maybe__aIntrinsicRatio) {
                FatalError("Error deserializing 'AspectRatio?'");
                return MsgValueError;

            }
            auto& aIntrinsicRatio = *maybe__aIntrinsicRatio;
            // Sentinel = 'aIntrinsicRatio'
            if ((!(((&(reader__)))->ReadSentinel(807667220)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'AspectRatio?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvIntrinsicSizeOrRatioChanged(std::move(aIntrinsicSize), std::move(aIntrinsicRatio));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ImageLoadComplete__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ImageLoadComplete", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aResult = *maybe__aResult;
            // Sentinel = 'aResult'
            if ((!(((&(reader__)))->ReadSentinel(185205473)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvImageLoadComplete(std::move(aResult));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RequestPointerCapture__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerCapture", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            RequestPointerCaptureResolver 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 = 'aSuccess'
                    ((&(writer__)))->WriteSentinel(236323643);

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_ReleasePointerCapture__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ReleasePointerCapture", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_RequestPointerLock__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RequestPointerLock", OTHER);

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

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

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

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_ReleasePointerLock__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ReleasePointerLock", OTHER);

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

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

            AUTO_PROFILER_LABEL("PBrowser::Msg_CloneDocumentTreeIntoSelf", OTHER);


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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_SetDimensions__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SetDimensions", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aRequest = *maybe__aRequest;
            // Sentinel = 'aRequest'
            if ((!(((&(reader__)))->ReadSentinel(238945099)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DimensionRequest'");
                return MsgValueError;
            }
            auto maybe__aScale = IPC::ReadParam<double>((&(reader__)));
            if (!maybe__aScale) {
                FatalError("Error deserializing 'double'");
                return MsgValueError;

            }
            auto& aScale = *maybe__aScale;
            // Sentinel = 'aScale'
            if ((!(((&(reader__)))->ReadSentinel(131531338)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetDimensions(std::move(aRequest), std::move(aScale));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_InvokeDragSession__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_InvokeDragSession", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__transfers = IPC::ReadParam<nsTArray<IPCTransferableData>>((&(reader__)));
            if (!maybe__transfers) {
                FatalError("Error deserializing 'IPCTransferableData[]'");
                return MsgValueError;

            }
            auto& transfers = *maybe__transfers;
            // Sentinel = 'transfers'
            if ((!(((&(reader__)))->ReadSentinel(323290073)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferableData[]'");
                return MsgValueError;
            }
            auto maybe__action = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__action) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& action = *maybe__action;
            // Sentinel = 'action'
            if ((!(((&(reader__)))->ReadSentinel(143786623)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__visualData = IPC::ReadParam<mozilla::Maybe<BigBuffer>>((&(reader__)));
            if (!maybe__visualData) {
                FatalError("Error deserializing 'BigBuffer?'");
                return MsgValueError;

            }
            auto& visualData = *maybe__visualData;
            // Sentinel = 'visualData'
            if ((!(((&(reader__)))->ReadSentinel(385877007)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BigBuffer?'");
                return MsgValueError;
            }
            auto maybe__stride = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__stride) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& stride = *maybe__stride;
            // Sentinel = 'stride'
            if ((!(((&(reader__)))->ReadSentinel(153879180)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__format = IPC::ReadParam<SurfaceFormat>((&(reader__)));
            if (!maybe__format) {
                FatalError("Error deserializing 'SurfaceFormat'");
                return MsgValueError;

            }
            auto& format = *maybe__format;
            // Sentinel = 'format'
            if ((!(((&(reader__)))->ReadSentinel(148505226)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceFormat'");
                return MsgValueError;
            }
            auto maybe__dragRect = IPC::ReadParam<LayoutDeviceIntRect>((&(reader__)));
            if (!maybe__dragRect) {
                FatalError("Error deserializing 'LayoutDeviceIntRect'");
                return MsgValueError;

            }
            auto& dragRect = *maybe__dragRect;
            // Sentinel = 'dragRect'
            if ((!(((&(reader__)))->ReadSentinel(239076141)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntRect'");
                return MsgValueError;
            }
            auto maybe__principal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__principal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& principal = *maybe__principal;
            // Sentinel = 'principal'
            if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__policyContainer = IPC::ReadParam<RefPtr<nsIPolicyContainer>>((&(reader__)));
            if (!maybe__policyContainer) {
                FatalError("Error deserializing 'nsIPolicyContainer'");
                return MsgValueError;

            }
            auto& policyContainer = *maybe__policyContainer;
            // Sentinel = 'policyContainer'
            if ((!(((&(reader__)))->ReadSentinel(833619508)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPolicyContainer'");
                return MsgValueError;
            }
            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;
            }
            auto maybe__sourceWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__sourceWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& sourceWindowContext = *maybe__sourceWindowContext;
            // Sentinel = 'sourceWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(1328678895)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            auto maybe__sourceTopWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__sourceTopWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& sourceTopWindowContext = *maybe__sourceTopWindowContext;
            // Sentinel = 'sourceTopWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(1758005538)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvInvokeDragSession(std::move(transfers), std::move(action), std::move(visualData), std::move(stride), std::move(format), std::move(dragRect), principal, policyContainer, std::move(cookieJarSettings), std::move(sourceWindowContext), std::move(sourceTopWindowContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ShowCanvasPermissionPrompt__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ShowCanvasPermissionPrompt", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aOrigin = *maybe__aOrigin;
            // Sentinel = 'aOrigin'
            if ((!(((&(reader__)))->ReadSentinel(182125258)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__aHideDoorHanger = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aHideDoorHanger) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aHideDoorHanger = *maybe__aHideDoorHanger;
            // Sentinel = 'aHideDoorHanger'
            if ((!(((&(reader__)))->ReadSentinel(753731013)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvShowCanvasPermissionPrompt(std::move(aOrigin), std::move(aHideDoorHanger));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_MaybeFireEmbedderLoadEvents__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_MaybeFireEmbedderLoadEvents", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFireEventAtEmbeddingElement = *maybe__aFireEventAtEmbeddingElement;
            // Sentinel = 'aFireEventAtEmbeddingElement'
            if ((!(((&(reader__)))->ReadSentinel(2607483624)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'EmbedderElementEventType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvMaybeFireEmbedderLoadEvents(std::move(aFireEventAtEmbeddingElement));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ScrollRectIntoView__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ScrollRectIntoView", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aVertical = *maybe__aVertical;
            // Sentinel = 'aVertical'
            if ((!(((&(reader__)))->ReadSentinel(298845084)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollAxis'");
                return MsgValueError;
            }
            auto maybe__aHorizontal = IPC::ReadParam<ScrollAxis>((&(reader__)));
            if (!maybe__aHorizontal) {
                FatalError("Error deserializing 'ScrollAxis'");
                return MsgValueError;

            }
            auto& aHorizontal = *maybe__aHorizontal;
            // Sentinel = 'aHorizontal'
            if ((!(((&(reader__)))->ReadSentinel(447022220)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollAxis'");
                return MsgValueError;
            }
            auto maybe__aScrollFlags = IPC::ReadParam<ScrollFlags>((&(reader__)));
            if (!maybe__aScrollFlags) {
                FatalError("Error deserializing 'ScrollFlags'");
                return MsgValueError;

            }
            auto& aScrollFlags = *maybe__aScrollFlags;
            // Sentinel = 'aScrollFlags'
            if ((!(((&(reader__)))->ReadSentinel(510592190)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollFlags'");
                return MsgValueError;
            }
            auto maybe__aAppUnitsPerDevPixel = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aAppUnitsPerDevPixel) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aAppUnitsPerDevPixel = *maybe__aAppUnitsPerDevPixel;
            // Sentinel = 'aAppUnitsPerDevPixel'
            if ((!(((&(reader__)))->ReadSentinel(1366296542)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvScrollRectIntoView(std::move(aRect), std::move(aVertical), std::move(aHorizontal), std::move(aScrollFlags), std::move(aAppUnitsPerDevPixel));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ShowDynamicToolbar__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ShowDynamicToolbar", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthesizedEventResponse__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthesizedEventResponse", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            AUTO_PROFILER_LABEL("PBrowser::Msg_PrintPreview", OTHER);


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

            AUTO_PROFILER_LABEL("PBrowser::Msg_Print", OTHER);


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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aOuterWindowID = *maybe__aOuterWindowID;
            // Sentinel = 'aOuterWindowID'
            if ((!(((&(reader__)))->ReadSentinel(702612854)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PBrowser::Reply_IsWindowSupportingProtectedMedia(id__));
            reply__->set_seqno(msg__.seqno());

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

            IsWindowSupportingProtectedMediaResolver 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 = 'isSupported'
                    ((&(writer__)))->WriteSentinel(466355363);

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_IsWindowSupportingWebVR__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_IsWindowSupportingWebVR", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aOuterWindowID = *maybe__aOuterWindowID;
            // Sentinel = 'aOuterWindowID'
            if ((!(((&(reader__)))->ReadSentinel(702612854)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            UniquePtr<IPC::Message> reply__(PBrowser::Reply_IsWindowSupportingWebVR(id__));
            reply__->set_seqno(msg__.seqno());

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

            IsWindowSupportingWebVRResolver 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 = 'isSupported'
                    ((&(writer__)))->WriteSentinel(466355363);

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_VisitURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_VisitURI", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aURI = *maybe__aURI;
            // Sentinel = 'aURI'
            if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            auto maybe__aLastVisitedURI = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__aLastVisitedURI) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& aLastVisitedURI = *maybe__aLastVisitedURI;
            // Sentinel = 'aLastVisitedURI'
            if ((!(((&(reader__)))->ReadSentinel(786695614)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            auto maybe__aFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aFlags = *maybe__aFlags;
            // Sentinel = 'aFlags'
            if ((!(((&(reader__)))->ReadSentinel(129892943)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aBrowserId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aBrowserId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aBrowserId = *maybe__aBrowserId;
            // Sentinel = 'aBrowserId'
            if ((!(((&(reader__)))->ReadSentinel(363332595)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvVisitURI(aURI, aLastVisitedURI, std::move(aFlags), std::move(aBrowserId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_QueryVisitedState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_QueryVisitedState", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aURIs = IPC::ReadParam<nsTArray<RefPtr<nsIURI>>>((&(reader__)));
            if (!maybe__aURIs) {
                FatalError("Error deserializing 'nsIURI[]'");
                return MsgValueError;

            }
            auto& aURIs = *maybe__aURIs;
            // Sentinel = 'aURIs'
            if ((!(((&(reader__)))->ReadSentinel(87622085)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvQueryVisitedState(std::move(aURIs));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_PSessionStoreConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PSessionStoreConstructor", 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<PSessionStoreParent> actor = (static_cast<BrowserParent*>(this))->AllocPSessionStoreParent();
            if (!actor) {
                NS_WARNING("Cannot bind null PSessionStoreParent actor");
                return MsgValueError;
            }

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_NewWindowGlobal__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NewWindowGlobal", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aEndpoint = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>>((&(reader__)));
            if (!maybe__aEndpoint) {
                FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
                return MsgValueError;

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

            }
            auto& aInit = *maybe__aInit;
            // Sentinel = 'aInit'
            if ((!(((&(reader__)))->ReadSentinel(94241270)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WindowGlobalInit'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNewWindowGlobal(std::move(aEndpoint), std::move(aInit));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateDropEffect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateDropEffect", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aDropEffect = *maybe__aDropEffect;
            // Sentinel = 'aDropEffect'
            if ((!(((&(reader__)))->ReadSentinel(419759172)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvUpdateDropEffect(std::move(aDragAction), std::move(aDropEffect));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}

auto PBrowserParent::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PBrowserParent::Result
{
    switch (msg__.type()) {
    case PBrowser::Msg_SyncMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SyncMessage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aMessage = *maybe__aMessage;
            // Sentinel = 'aMessage'
            if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<ClonedMessageData>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            nsTArray<UniquePtr<StructuredCloneData>> retval{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSyncMessage(std::move(aMessage), std::move(aData), (&(retval)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_SyncMessage(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), retval);
            // Sentinel = 'retval'
            ((&(writer__)))->WriteSentinel(151716495);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_NotifyIMEMouseButtonEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NotifyIMEMouseButtonEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& notification = *maybe__notification;
            // Sentinel = 'notification'
            if ((!(((&(reader__)))->ReadSentinel(550438152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotification'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            bool consumedByIME{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvNotifyIMEMouseButtonEvent(std::move(notification), (&(consumedByIME)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_NotifyIMEMouseButtonEvent(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), consumedByIME);
            // Sentinel = 'consumedByIME'
            ((&(writer__)))->WriteSentinel(621282549);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_RequestIMEToCommitComposition__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RequestIMEToCommitComposition", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& cancel = *maybe__cancel;
            // Sentinel = 'cancel'
            if ((!(((&(reader__)))->ReadSentinel(139723367)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aCompositionId = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aCompositionId) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aCompositionId = *maybe__aCompositionId;
            // Sentinel = 'aCompositionId'
            if ((!(((&(reader__)))->ReadSentinel(707069347)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            bool isCommitted{};
            nsString committedString{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestIMEToCommitComposition(std::move(cancel), std::move(aCompositionId), (&(isCommitted)), (&(committedString)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_RequestIMEToCommitComposition(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), isCommitted);
            // Sentinel = 'isCommitted'
            ((&(writer__)))->WriteSentinel(449774723);
            IPC::WriteParam((&(writer__)), committedString);
            // Sentinel = 'committedString'
            ((&(writer__)))->WriteSentinel(840042046);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_GetInputContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_GetInputContext", OTHER);

            mozilla::ipc::ActorId id__ = Id();
            IMEState state{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvGetInputContext((&(state)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_GetInputContext(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), state);
            // Sentinel = 'state'
            ((&(writer__)))->WriteSentinel(109314594);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_RequestNativeKeyBindings__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RequestNativeKeyBindings", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aType = *maybe__aType;
            // Sentinel = 'aType'
            if ((!(((&(reader__)))->ReadSentinel(99222020)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aEvent = IPC::ReadParam<WidgetKeyboardEvent>((&(reader__)));
            if (!maybe__aEvent) {
                FatalError("Error deserializing 'WidgetKeyboardEvent'");
                return MsgValueError;

            }
            auto& aEvent = *maybe__aEvent;
            // Sentinel = 'aEvent'
            if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            nsTArray<CommandInt> commands{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvRequestNativeKeyBindings(std::move(aType), std::move(aEvent), (&(commands)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_RequestNativeKeyBindings(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), commands);
            // Sentinel = 'commands'
            ((&(writer__)))->WriteSentinel(249627475);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_DispatchWheelEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchWheelEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetWheelEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchWheelEvent(std::move(event));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_DispatchWheelEvent(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_DispatchMouseEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchMouseEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetMouseEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchMouseEvent(std::move(event));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_DispatchMouseEvent(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_DispatchKeyboardEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchKeyboardEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetKeyboardEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchKeyboardEvent(std::move(event));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_DispatchKeyboardEvent(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_DispatchTouchEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchTouchEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetTouchEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvDispatchTouchEvent(std::move(event));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_DispatchTouchEvent(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_EnsureLayersConnected__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_EnsureLayersConnected", OTHER);

            mozilla::ipc::ActorId id__ = Id();
            CompositorOptions compositorOptions{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvEnsureLayersConnected((&(compositorOptions)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_EnsureLayersConnected(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), compositorOptions);
            // Sentinel = 'compositorOptions'
            ((&(writer__)))->WriteSentinel(1089275708);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_SetSystemFont__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SetSystemFont", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFontName = *maybe__aFontName;
            // Sentinel = 'aFontName'
            if ((!(((&(reader__)))->ReadSentinel(287114106)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = Id();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvSetSystemFont(std::move(aFontName));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_SetSystemFont(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PBrowser::Msg_GetSystemFont__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_GetSystemFont", OTHER);

            mozilla::ipc::ActorId id__ = Id();
            nsCString retval{};
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserParent*>(this))->RecvGetSystemFont((&(retval)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PBrowser::Reply_GetSystemFont(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), retval);
            // Sentinel = 'retval'
            ((&(writer__)))->WriteSentinel(151716495);
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}



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

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

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

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

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

} // namespace IPC
