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


#include "mozilla/dom/PBrowserChild.h"
#include "ipc/nsGUIEventIPC.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/LayoutMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/BrowserChild.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/PColorPickerChild.h"
#include "mozilla/dom/PContentChild.h"
#include "mozilla/a11y/PDocAccessibleChild.h"
#include "mozilla/dom/PFilePickerChild.h"
#include "mozilla/layout/PRemotePrintJobChild.h"
#include "mozilla/dom/PPaymentRequestChild.h"
#include "mozilla/dom/PSessionStoreChild.h"
#include "mozilla/dom/PWindowGlobalChild.h"
#include "mozilla/dom/PBrowserBridgeChild.h"
#include "mozilla/dom/PVsyncChild.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 {


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

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

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

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

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

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

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

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

auto PBrowserChild::ManagedPColorPickerChild(nsTArray<PColorPickerChild*>& aArr) const -> void
{
    mManagedPColorPickerChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPColorPickerChild() const -> const ManagedContainer<PColorPickerChild>&
{
    return mManagedPColorPickerChild;
}

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

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

auto PBrowserChild::ManagedPFilePickerChild(nsTArray<PFilePickerChild*>& aArr) const -> void
{
    mManagedPFilePickerChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPFilePickerChild() const -> const ManagedContainer<PFilePickerChild>&
{
    return mManagedPFilePickerChild;
}

auto PBrowserChild::ManagedPPaymentRequestChild(nsTArray<PPaymentRequestChild*>& aArr) const -> void
{
    mManagedPPaymentRequestChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPPaymentRequestChild() const -> const ManagedContainer<PPaymentRequestChild>&
{
    return mManagedPPaymentRequestChild;
}

auto PBrowserChild::ManagedPSessionStoreChild(nsTArray<PSessionStoreChild*>& aArr) const -> void
{
    mManagedPSessionStoreChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPSessionStoreChild() const -> const ManagedContainer<PSessionStoreChild>&
{
    return mManagedPSessionStoreChild;
}

auto PBrowserChild::ManagedPWindowGlobalChild(nsTArray<PWindowGlobalChild*>& aArr) const -> void
{
    mManagedPWindowGlobalChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPWindowGlobalChild() const -> const ManagedContainer<PWindowGlobalChild>&
{
    return mManagedPWindowGlobalChild;
}

auto PBrowserChild::ManagedPBrowserBridgeChild(nsTArray<PBrowserBridgeChild*>& aArr) const -> void
{
    mManagedPBrowserBridgeChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPBrowserBridgeChild() const -> const ManagedContainer<PBrowserBridgeChild>&
{
    return mManagedPBrowserBridgeChild;
}

auto PBrowserChild::ManagedPVsyncChild(nsTArray<PVsyncChild*>& aArr) const -> void
{
    mManagedPVsyncChild.ToArray(aArr);
}

auto PBrowserChild::ManagedPVsyncChild() const -> const ManagedContainer<PVsyncChild>&
{
    return mManagedPVsyncChild;
}

auto PBrowserChild::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 PBrowserChild::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PColorPickerMsgStart:
        return (&(mManagedPColorPickerChild));
    case PDocAccessibleMsgStart:
        return (&(mManagedPDocAccessibleChild));
    case PFilePickerMsgStart:
        return (&(mManagedPFilePickerChild));
    case PPaymentRequestMsgStart:
        return (&(mManagedPPaymentRequestChild));
    case PSessionStoreMsgStart:
        return (&(mManagedPSessionStoreChild));
    case PWindowGlobalMsgStart:
        return (&(mManagedPWindowGlobalChild));
    case PBrowserBridgeMsgStart:
        return (&(mManagedPBrowserBridgeChild));
    case PVsyncMsgStart:
        return (&(mManagedPVsyncChild));
    default:
        return nullptr;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

auto PBrowserChild::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::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            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 PBrowserChild::SendPDocAccessibleConstructor(
        PDocAccessibleChild* aParentDoc,
        const uint64_t& aParentAcc,
        const MaybeDiscardedBrowsingContext& aBrowsingContext) -> PDocAccessibleChild*
{
    PDocAccessibleChild* actor = (static_cast<BrowserChild*>(this))->AllocPDocAccessibleChild(aParentDoc, aParentAcc, aBrowsingContext);
    return SendPDocAccessibleConstructor(std::move(actor), std::move(aParentDoc), std::move(aParentAcc), std::move(aBrowsingContext));
}

auto PBrowserChild::SendPDocAccessibleConstructor(
        PDocAccessibleChild* actor,
        PDocAccessibleChild* aParentDoc,
        const uint64_t& aParentAcc,
        const MaybeDiscardedBrowsingContext& aBrowsingContext) -> PDocAccessibleChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PDocAccessibleChild actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), aParentDoc);
    // Sentinel = 'aParentDoc'
    ((&(writer__)))->WriteSentinel(355140578);
    IPC::WriteParam((&(writer__)), aParentAcc);
    // Sentinel = 'aParentAcc'
    ((&(writer__)))->WriteSentinel(352977875);
    IPC::WriteParam((&(writer__)), aBrowsingContext);
    // Sentinel = 'aBrowsingContext'
    ((&(writer__)))->WriteSentinel(915015314);


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

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

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


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

        return nullptr;
    }
    return actor;
}

auto PBrowserChild::SendPPaymentRequestConstructor() -> PPaymentRequestChild*
{
    PPaymentRequestChild* actor = (static_cast<BrowserChild*>(this))->AllocPPaymentRequestChild();
    return SendPPaymentRequestConstructor(std::move(actor));
}

auto PBrowserChild::SendPPaymentRequestConstructor(PPaymentRequestChild* actor) -> PPaymentRequestChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PPaymentRequestChild actor");
        return nullptr;
    }

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


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

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


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

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

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


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

        return nullptr;
    }
    return actor;
}

auto PBrowserChild::SendPVsyncConstructor(PVsyncChild* actor) -> PVsyncChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PVsyncChild actor");
        return nullptr;
    }

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


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

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


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

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

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


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

        return nullptr;
    }
    return actor;
}

auto PBrowserChild::SendDidUnsuppressPainting() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DidUnsuppressPainting(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendDidUnsuppressPaintingNormalPriority() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DidUnsuppressPaintingNormalPriority(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendMoveFocus(
        const bool& forward,
        const bool& forDocumentNavigation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_MoveFocus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), forward);
    // Sentinel = 'forward'
    ((&(writer__)))->WriteSentinel(200016630);
    IPC::WriteParam((&(writer__)), forDocumentNavigation);
    // Sentinel = 'forDocumentNavigation'
    ((&(writer__)))->WriteSentinel(1571555479);


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

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

auto PBrowserChild::SendDropLinks(mozilla::Span<nsString const> aLinks) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DropLinks(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendSyncMessage(
        const nsAString& aMessage,
        const ClonedMessageData& aData,
        nsTArray<UniquePtr<StructuredCloneData>>* retval) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SyncMessage(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_SyncMessage", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__retval__reply = IPC::ReadParam<nsTArray<UniquePtr<StructuredCloneData>>>((&(reader__)));
    if (!maybe__retval__reply) {
        FatalError("Error deserializing 'UniquePtr<StructuredCloneData>[]'");
        return false;

    }
    auto& retval__reply = *maybe__retval__reply;
    // Sentinel = 'retval'
    if ((!(((&(reader__)))->ReadSentinel(151716495)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'UniquePtr<StructuredCloneData>[]'");
        return false;
    }
    (*(retval)) = std::move(retval__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendNotifyIMEFocus(
        const ContentCache& contentCache,
        const IMENotification& notification,
        mozilla::ipc::ResolveCallback<IMENotificationRequests>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMEFocus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), contentCache);
    // Sentinel = 'contentCache'
    ((&(writer__)))->WriteSentinel(535299280);
    IPC::WriteParam((&(writer__)), notification);
    // Sentinel = 'notification'
    ((&(writer__)))->WriteSentinel(550438152);


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

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

            }
            auto& requests = *maybe__requests;
            // Sentinel = 'requests'
            if ((!((aReader)->ReadSentinel(261227389)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IMENotificationRequests'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PBrowserChild::SendNotifyIMEFocus(
        const ContentCache& contentCache,
        const IMENotification& notification) -> RefPtr<NotifyIMEFocusPromise>
{
    RefPtr<MozPromise<IMENotificationRequests, ResponseRejectReason, true>::Private> promise__ = new MozPromise<IMENotificationRequests, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendNotifyIMEFocus(std::move(contentCache), std::move(notification), [promise__](IMENotificationRequests&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserChild::SendNotifyIMETextChange(
        const ContentCache& contentCache,
        const IMENotification& notification) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMETextChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), contentCache);
    // Sentinel = 'contentCache'
    ((&(writer__)))->WriteSentinel(535299280);
    IPC::WriteParam((&(writer__)), notification);
    // Sentinel = 'notification'
    ((&(writer__)))->WriteSentinel(550438152);


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

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

auto PBrowserChild::SendNotifyIMECompositionUpdate(
        const ContentCache& contentCache,
        const IMENotification& notification) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMECompositionUpdate(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), contentCache);
    // Sentinel = 'contentCache'
    ((&(writer__)))->WriteSentinel(535299280);
    IPC::WriteParam((&(writer__)), notification);
    // Sentinel = 'notification'
    ((&(writer__)))->WriteSentinel(550438152);


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

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

auto PBrowserChild::SendNotifyIMESelection(
        const ContentCache& contentCache,
        const IMENotification& notification) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMESelection(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), contentCache);
    // Sentinel = 'contentCache'
    ((&(writer__)))->WriteSentinel(535299280);
    IPC::WriteParam((&(writer__)), notification);
    // Sentinel = 'notification'
    ((&(writer__)))->WriteSentinel(550438152);


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

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

auto PBrowserChild::SendUpdateContentCache(const ContentCache& contentCache) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateContentCache(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendNotifyIMEMouseButtonEvent(
        const IMENotification& notification,
        bool* consumedByIME) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMEMouseButtonEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_NotifyIMEMouseButtonEvent", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

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

    }
    auto& consumedByIME__reply = *maybe__consumedByIME__reply;
    // Sentinel = 'consumedByIME'
    if ((!(((&(reader__)))->ReadSentinel(621282549)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
        return false;
    }
    (*(consumedByIME)) = std::move(consumedByIME__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendNotifyIMEPositionChange(
        const ContentCache& contentCache,
        const IMENotification& notification) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyIMEPositionChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), contentCache);
    // Sentinel = 'contentCache'
    ((&(writer__)))->WriteSentinel(535299280);
    IPC::WriteParam((&(writer__)), notification);
    // Sentinel = 'notification'
    ((&(writer__)))->WriteSentinel(550438152);


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

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

auto PBrowserChild::SendRequestIMEToCommitComposition(
        const bool& cancel,
        const uint32_t& aCompositionId,
        bool* isCommitted,
        nsString* committedString) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestIMEToCommitComposition(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), cancel);
    // Sentinel = 'cancel'
    ((&(writer__)))->WriteSentinel(139723367);
    IPC::WriteParam((&(writer__)), aCompositionId);
    // Sentinel = 'aCompositionId'
    ((&(writer__)))->WriteSentinel(707069347);

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_RequestIMEToCommitComposition", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

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

    }
    auto& isCommitted__reply = *maybe__isCommitted__reply;
    // Sentinel = 'isCommitted'
    if ((!(((&(reader__)))->ReadSentinel(449774723)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
        return false;
    }
    auto maybe__committedString__reply = IPC::ReadParam<nsString>((&(reader__)));
    if (!maybe__committedString__reply) {
        FatalError("Error deserializing 'nsString'");
        return false;

    }
    auto& committedString__reply = *maybe__committedString__reply;
    // Sentinel = 'committedString'
    if ((!(((&(reader__)))->ReadSentinel(840042046)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
        return false;
    }
    (*(isCommitted)) = std::move(isCommitted__reply);
    (*(committedString)) = std::move(committedString__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendOnEventNeedingAckHandled(
        const EventMessage& message,
        const uint32_t& compositionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnEventNeedingAckHandled(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendRequestFocus(
        const bool& canRaise,
        const CallerType& aCallerType) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestFocus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), canRaise);
    // Sentinel = 'canRaise'
    ((&(writer__)))->WriteSentinel(234816295);
    IPC::WriteParam((&(writer__)), aCallerType);
    // Sentinel = 'aCallerType'
    ((&(writer__)))->WriteSentinel(422118487);


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

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

auto PBrowserChild::SendWheelZoomChange(const bool& increase) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_WheelZoomChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendEnableDisableCommands(
        const MaybeDiscardedBrowsingContext& bc,
        const nsAString& action,
        mozilla::Span<nsCString const> enabledCommands,
        mozilla::Span<nsCString const> disabledCommands) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_EnableDisableCommands(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), bc);
    // Sentinel = 'bc'
    ((&(writer__)))->WriteSentinel(19464390);
    IPC::WriteParam((&(writer__)), action);
    // Sentinel = 'action'
    ((&(writer__)))->WriteSentinel(143786623);
    IPC::WriteParam((&(writer__)), enabledCommands);
    // Sentinel = 'enabledCommands'
    ((&(writer__)))->WriteSentinel(796263934);
    IPC::WriteParam((&(writer__)), disabledCommands);
    // Sentinel = 'disabledCommands'
    ((&(writer__)))->WriteSentinel(909706859);


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

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

auto PBrowserChild::SendGetInputContext(IMEState* state) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_GetInputContext(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_GetInputContext", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__state__reply = IPC::ReadParam<IMEState>((&(reader__)));
    if (!maybe__state__reply) {
        FatalError("Error deserializing 'IMEState'");
        return false;

    }
    auto& state__reply = *maybe__state__reply;
    // Sentinel = 'state'
    if ((!(((&(reader__)))->ReadSentinel(109314594)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IMEState'");
        return false;
    }
    (*(state)) = std::move(state__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendSetInputContext(
        const InputContext& context,
        const InputContextAction& action) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetInputContext(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendSetCursor(
        const nsCursor& value,
        mozilla::Maybe<IPCImage>&& customCursor,
        const float& resolutionX,
        const float& resolutionY,
        const uint32_t& hotspotX,
        const uint32_t& hotspotY,
        const bool& force) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetCursor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), value);
    // Sentinel = 'value'
    ((&(writer__)))->WriteSentinel(107610654);
    IPC::WriteParam((&(writer__)), std::move(customCursor));
    // Sentinel = 'customCursor'
    ((&(writer__)))->WriteSentinel(554173722);
    IPC::WriteParam((&(writer__)), resolutionX);
    // Sentinel = 'resolutionX'
    ((&(writer__)))->WriteSentinel(478217389);
    IPC::WriteParam((&(writer__)), resolutionY);
    // Sentinel = 'resolutionY'
    ((&(writer__)))->WriteSentinel(478282926);
    IPC::WriteParam((&(writer__)), hotspotX);
    // Sentinel = 'hotspotX'
    ((&(writer__)))->WriteSentinel(261423978);
    IPC::WriteParam((&(writer__)), hotspotY);
    // Sentinel = 'hotspotY'
    ((&(writer__)))->WriteSentinel(261489515);
    IPC::WriteParam((&(writer__)), force);
    // Sentinel = 'force'
    ((&(writer__)))->WriteSentinel(104858128);


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

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

auto PBrowserChild::SendSetLinkStatus(const nsAString& status) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetLinkStatus(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendShowTooltip(
        const uint32_t& x,
        const uint32_t& y,
        const nsAString& tooltip,
        const nsAString& direction) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ShowTooltip(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), x);
    // Sentinel = 'x'
    ((&(writer__)))->WriteSentinel(7929977);
    IPC::WriteParam((&(writer__)), y);
    // Sentinel = 'y'
    ((&(writer__)))->WriteSentinel(7995514);
    IPC::WriteParam((&(writer__)), tooltip);
    // Sentinel = 'tooltip'
    ((&(writer__)))->WriteSentinel(205914892);
    IPC::WriteParam((&(writer__)), direction);
    // Sentinel = 'direction'
    ((&(writer__)))->WriteSentinel(311886786);


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

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

auto PBrowserChild::SendHideTooltip() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_HideTooltip(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendPColorPickerConstructor(
        PColorPickerChild* actor,
        const MaybeDiscardedBrowsingContext& aBrowsingContext,
        const nsAString& title,
        const nsAString& initialColor,
        mozilla::Span<nsString const> defaultColors) -> PColorPickerChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PColorPickerChild actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), aBrowsingContext);
    // Sentinel = 'aBrowsingContext'
    ((&(writer__)))->WriteSentinel(915015314);
    IPC::WriteParam((&(writer__)), title);
    // Sentinel = 'title'
    ((&(writer__)))->WriteSentinel(109445667);
    IPC::WriteParam((&(writer__)), initialColor);
    // Sentinel = 'initialColor'
    ((&(writer__)))->WriteSentinel(536216810);
    IPC::WriteParam((&(writer__)), defaultColors);
    // Sentinel = 'defaultColors'
    ((&(writer__)))->WriteSentinel(616760664);


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

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

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


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

        return nullptr;
    }
    return actor;
}

auto PBrowserChild::SendPFilePickerConstructor(
        PFilePickerChild* actor,
        const nsAString& aTitle,
        const Mode& aMode,
        const MaybeDiscardedBrowsingContext& aBrowsingContext) -> PFilePickerChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PFilePickerChild actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), aTitle);
    // Sentinel = 'aTitle'
    ((&(writer__)))->WriteSentinel(137167460);
    IPC::WriteParam((&(writer__)), aMode);
    // Sentinel = 'aMode'
    ((&(writer__)))->WriteSentinel(93848039);
    IPC::WriteParam((&(writer__)), aBrowsingContext);
    // Sentinel = 'aBrowsingContext'
    ((&(writer__)))->WriteSentinel(915015314);


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

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

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


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

        return nullptr;
    }
    return actor;
}

auto PBrowserChild::SendRespondStartSwipeEvent(
        const uint64_t& aInputBlockId,
        const bool& aStartSwipe) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RespondStartSwipeEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aStartSwipe);
    // Sentinel = 'aStartSwipe'
    ((&(writer__)))->WriteSentinel(442565752);


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

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

auto PBrowserChild::SendLookUpDictionary(
        const nsAString& aText,
        mozilla::Span<FontRange const> aFontRangeArray,
        const bool& aIsVertical,
        const LayoutDeviceIntPoint& aPoint) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LookUpDictionary(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aText);
    // Sentinel = 'aText'
    ((&(writer__)))->WriteSentinel(97321479);
    IPC::WriteParam((&(writer__)), aFontRangeArray);
    // Sentinel = 'aFontRangeArray'
    ((&(writer__)))->WriteSentinel(775095781);
    IPC::WriteParam((&(writer__)), aIsVertical);
    // Sentinel = 'aIsVertical'
    ((&(writer__)))->WriteSentinel(427361368);
    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);


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

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

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


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

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

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

auto PBrowserChild::SendReplyKeyEvent(
        const WidgetKeyboardEvent& aEvent,
        const nsID& aUUID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReplyKeyEvent(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::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PBrowser::Msg_ReplyKeyEvent", OTHER);

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

auto PBrowserChild::SendRequestNativeKeyBindings(
        const uint32_t& aType,
        const WidgetKeyboardEvent& aEvent,
        nsTArray<CommandInt>* commands) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestNativeKeyBindings(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_RequestNativeKeyBindings", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

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

    }
    auto& commands__reply = *maybe__commands__reply;
    // Sentinel = 'commands'
    if ((!(((&(reader__)))->ReadSentinel(249627475)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'CommandInt[]'");
        return false;
    }
    (*(commands)) = std::move(commands__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendSynthesizeNativeKeyEvent(
        const int32_t& aNativeKeyboardLayout,
        const int32_t& aNativeKeyCode,
        const uint32_t& aModifierFlags,
        const nsAString& aCharacters,
        const nsAString& aUnmodifiedCharacters,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeKeyEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aNativeKeyboardLayout);
    // Sentinel = 'aNativeKeyboardLayout'
    ((&(writer__)))->WriteSentinel(1529153656);
    IPC::WriteParam((&(writer__)), aNativeKeyCode);
    // Sentinel = 'aNativeKeyCode'
    ((&(writer__)))->WriteSentinel(680527213);
    IPC::WriteParam((&(writer__)), aModifierFlags);
    // Sentinel = 'aModifierFlags'
    ((&(writer__)))->WriteSentinel(681444734);
    IPC::WriteParam((&(writer__)), aCharacters);
    // Sentinel = 'aCharacters'
    ((&(writer__)))->WriteSentinel(422380642);
    IPC::WriteParam((&(writer__)), aUnmodifiedCharacters);
    // Sentinel = 'aUnmodifiedCharacters'
    ((&(writer__)))->WriteSentinel(1529874534);
    IPC::WriteParam((&(writer__)), aCallbackId);
    // Sentinel = 'aCallbackId'
    ((&(writer__)))->WriteSentinel(411370524);


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

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

auto PBrowserChild::SendSynthesizeNativeMouseEvent(
        const LayoutDeviceIntPoint& aPoint,
        const uint32_t& aNativeMessage,
        const int16_t& aButton,
        const uint32_t& aModifierFlags,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeMouseEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aNativeMessage);
    // Sentinel = 'aNativeMessage'
    ((&(writer__)))->WriteSentinel(689702286);
    IPC::WriteParam((&(writer__)), aButton);
    // Sentinel = 'aButton'
    ((&(writer__)))->WriteSentinel(184222430);
    IPC::WriteParam((&(writer__)), aModifierFlags);
    // Sentinel = 'aModifierFlags'
    ((&(writer__)))->WriteSentinel(681444734);
    IPC::WriteParam((&(writer__)), aCallbackId);
    // Sentinel = 'aCallbackId'
    ((&(writer__)))->WriteSentinel(411370524);


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

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

auto PBrowserChild::SendSynthesizeNativeMouseMove(
        const LayoutDeviceIntPoint& aPoint,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeMouseMove(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendSynthesizeNativeMouseScrollEvent(
        const LayoutDeviceIntPoint& aPoint,
        const uint32_t& aNativeMessage,
        const double& aDeltaX,
        const double& aDeltaY,
        const double& aDeltaZ,
        const uint32_t& aModifierFlags,
        const uint32_t& aAdditionalFlags,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeMouseScrollEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aNativeMessage);
    // Sentinel = 'aNativeMessage'
    ((&(writer__)))->WriteSentinel(689702286);
    IPC::WriteParam((&(writer__)), aDeltaX);
    // Sentinel = 'aDeltaX'
    ((&(writer__)))->WriteSentinel(174391972);
    IPC::WriteParam((&(writer__)), aDeltaY);
    // Sentinel = 'aDeltaY'
    ((&(writer__)))->WriteSentinel(174457509);
    IPC::WriteParam((&(writer__)), aDeltaZ);
    // Sentinel = 'aDeltaZ'
    ((&(writer__)))->WriteSentinel(174523046);
    IPC::WriteParam((&(writer__)), aModifierFlags);
    // Sentinel = 'aModifierFlags'
    ((&(writer__)))->WriteSentinel(681444734);
    IPC::WriteParam((&(writer__)), aAdditionalFlags);
    // Sentinel = 'aAdditionalFlags'
    ((&(writer__)))->WriteSentinel(880084552);
    IPC::WriteParam((&(writer__)), aCallbackId);
    // Sentinel = 'aCallbackId'
    ((&(writer__)))->WriteSentinel(411370524);


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

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

auto PBrowserChild::SendSynthesizeNativeTouchPoint(
        const uint32_t& aPointerId,
        const TouchPointerState& aPointerState,
        const LayoutDeviceIntPoint& aPoint,
        const double& aPointerPressure,
        const uint32_t& aPointerOrientation,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchPoint(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPointerId);
    // Sentinel = 'aPointerId'
    ((&(writer__)))->WriteSentinel(364053488);
    IPC::WriteParam((&(writer__)), aPointerState);
    // Sentinel = 'aPointerState'
    ((&(writer__)))->WriteSentinel(610600260);
    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aPointerPressure);
    // Sentinel = 'aPointerPressure'
    ((&(writer__)))->WriteSentinel(922617500);
    IPC::WriteParam((&(writer__)), aPointerOrientation);
    // Sentinel = 'aPointerOrientation'
    ((&(writer__)))->WriteSentinel(1287653327);
    IPC::WriteParam((&(writer__)), aCallbackId);
    // Sentinel = 'aCallbackId'
    ((&(writer__)))->WriteSentinel(411370524);


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

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

auto PBrowserChild::SendSynthesizeNativeTouchPadPinch(
        const TouchpadGesturePhase& aEventPhase,
        const float& aScale,
        const LayoutDeviceIntPoint& aPoint,
        const int32_t& aModifierFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchPadPinch(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEventPhase);
    // Sentinel = 'aEventPhase'
    ((&(writer__)))->WriteSentinel(428737621);
    IPC::WriteParam((&(writer__)), aScale);
    // Sentinel = 'aScale'
    ((&(writer__)))->WriteSentinel(131531338);
    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aModifierFlags);
    // Sentinel = 'aModifierFlags'
    ((&(writer__)))->WriteSentinel(681444734);


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

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

auto PBrowserChild::SendSynthesizeNativeTouchTap(
        const LayoutDeviceIntPoint& aPoint,
        const bool& aLongTap,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchTap(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendSynthesizeNativePenInput(
        const uint32_t& aPointerId,
        const TouchPointerState& aPointerState,
        const LayoutDeviceIntPoint& aPoint,
        const double& aPressure,
        const uint32_t& aRotation,
        const int32_t& aTiltX,
        const int32_t& aTiltY,
        const int32_t& aButton,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativePenInput(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPointerId);
    // Sentinel = 'aPointerId'
    ((&(writer__)))->WriteSentinel(364053488);
    IPC::WriteParam((&(writer__)), aPointerState);
    // Sentinel = 'aPointerState'
    ((&(writer__)))->WriteSentinel(610600260);
    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aPressure);
    // Sentinel = 'aPressure'
    ((&(writer__)))->WriteSentinel(304153531);
    IPC::WriteParam((&(writer__)), aRotation);
    // Sentinel = 'aRotation'
    ((&(writer__)))->WriteSentinel(301925298);
    IPC::WriteParam((&(writer__)), aTiltX);
    // Sentinel = 'aTiltX'
    ((&(writer__)))->WriteSentinel(135791191);
    IPC::WriteParam((&(writer__)), aTiltY);
    // Sentinel = 'aTiltY'
    ((&(writer__)))->WriteSentinel(135856728);
    IPC::WriteParam((&(writer__)), aButton);
    // Sentinel = 'aButton'
    ((&(writer__)))->WriteSentinel(184222430);
    IPC::WriteParam((&(writer__)), aCallbackId);
    // Sentinel = 'aCallbackId'
    ((&(writer__)))->WriteSentinel(411370524);


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

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

auto PBrowserChild::SendSynthesizeNativeTouchpadDoubleTap(
        const LayoutDeviceIntPoint& aPoint,
        const uint32_t& aModifierFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchpadDoubleTap(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aModifierFlags);
    // Sentinel = 'aModifierFlags'
    ((&(writer__)))->WriteSentinel(681444734);


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

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

auto PBrowserChild::SendSynthesizeNativeTouchpadPan(
        const TouchpadGesturePhase& aEventPhase,
        const LayoutDeviceIntPoint& aPoint,
        const double& aDeltaX,
        const double& aDeltaY,
        const int32_t& aModifierFlags,
        const mozilla::Maybe<uint64_t>& aCallbackId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SynthesizeNativeTouchpadPan(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEventPhase);
    // Sentinel = 'aEventPhase'
    ((&(writer__)))->WriteSentinel(428737621);
    IPC::WriteParam((&(writer__)), aPoint);
    // Sentinel = 'aPoint'
    ((&(writer__)))->WriteSentinel(136512108);
    IPC::WriteParam((&(writer__)), aDeltaX);
    // Sentinel = 'aDeltaX'
    ((&(writer__)))->WriteSentinel(174391972);
    IPC::WriteParam((&(writer__)), aDeltaY);
    // Sentinel = 'aDeltaY'
    ((&(writer__)))->WriteSentinel(174457509);
    IPC::WriteParam((&(writer__)), aModifierFlags);
    // Sentinel = 'aModifierFlags'
    ((&(writer__)))->WriteSentinel(681444734);
    IPC::WriteParam((&(writer__)), aCallbackId);
    // Sentinel = 'aCallbackId'
    ((&(writer__)))->WriteSentinel(411370524);


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

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

auto PBrowserChild::SendLockNativePointer() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_LockNativePointer(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendUnlockNativePointer() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UnlockNativePointer(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendAccessKeyNotHandled(const WidgetKeyboardEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_AccessKeyNotHandled(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendRegisterProtocolHandler(
        const nsAString& scheme,
        nsIURI* handlerURI,
        const nsAString& title,
        nsIURI* documentURI) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RegisterProtocolHandler(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), scheme);
    // Sentinel = 'scheme'
    ((&(writer__)))->WriteSentinel(146080374);
    IPC::WriteParam((&(writer__)), handlerURI);
    // Sentinel = 'handlerURI'
    ((&(writer__)))->WriteSentinel(367264719);
    IPC::WriteParam((&(writer__)), title);
    // Sentinel = 'title'
    ((&(writer__)))->WriteSentinel(109445667);
    IPC::WriteParam((&(writer__)), documentURI);
    // Sentinel = 'documentURI'
    ((&(writer__)))->WriteSentinel(453706832);


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

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

auto PBrowserChild::SendOnStateChange(
        const WebProgressData& aWebProgressData,
        const RequestData& aRequestData,
        const uint32_t& aStateFlags,
        const nsresult& aStatus,
        const mozilla::Maybe<WebProgressStateChangeData>& aStateChangeData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnStateChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aWebProgressData);
    // Sentinel = 'aWebProgressData'
    ((&(writer__)))->WriteSentinel(890504783);
    IPC::WriteParam((&(writer__)), aRequestData);
    // Sentinel = 'aRequestData'
    ((&(writer__)))->WriteSentinel(518390981);
    IPC::WriteParam((&(writer__)), aStateFlags);
    // Sentinel = 'aStateFlags'
    ((&(writer__)))->WriteSentinel(428606544);
    IPC::WriteParam((&(writer__)), aStatus);
    // Sentinel = 'aStatus'
    ((&(writer__)))->WriteSentinel(186712806);
    IPC::WriteParam((&(writer__)), aStateChangeData);
    // Sentinel = 'aStateChangeData'
    ((&(writer__)))->WriteSentinel(876086819);


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

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

auto PBrowserChild::SendOnLocationChange(
        const WebProgressData& aWebProgressData,
        const RequestData& aRequestData,
        nsIURI* aLocation,
        const uint32_t& aFlags,
        const bool& aCanGoBack,
        const bool& aCanGoBackIgnoringUserInteraction,
        const bool& aCanGoForward,
        const mozilla::Maybe<WebProgressLocationChangeData>& aLocationChangeData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnLocationChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aWebProgressData);
    // Sentinel = 'aWebProgressData'
    ((&(writer__)))->WriteSentinel(890504783);
    IPC::WriteParam((&(writer__)), aRequestData);
    // Sentinel = 'aRequestData'
    ((&(writer__)))->WriteSentinel(518390981);
    IPC::WriteParam((&(writer__)), aLocation);
    // Sentinel = 'aLocation'
    ((&(writer__)))->WriteSentinel(292094875);
    IPC::WriteParam((&(writer__)), aFlags);
    // Sentinel = 'aFlags'
    ((&(writer__)))->WriteSentinel(129892943);
    IPC::WriteParam((&(writer__)), aCanGoBack);
    // Sentinel = 'aCanGoBack'
    ((&(writer__)))->WriteSentinel(325714843);
    IPC::WriteParam((&(writer__)), aCanGoBackIgnoringUserInteraction);
    // Sentinel = 'aCanGoBackIgnoringUserInteraction'
    ((&(writer__)))->WriteSentinel(3575319799);
    IPC::WriteParam((&(writer__)), aCanGoForward);
    // Sentinel = 'aCanGoForward'
    ((&(writer__)))->WriteSentinel(563152127);
    IPC::WriteParam((&(writer__)), aLocationChangeData);
    // Sentinel = 'aLocationChangeData'
    ((&(writer__)))->WriteSentinel(1235617627);


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

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

auto PBrowserChild::SendOnProgressChange(
        const int32_t& aCurTotalProgress,
        const int32_t& aMaxTotalProgress) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnProgressChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aCurTotalProgress);
    // Sentinel = 'aCurTotalProgress'
    ((&(writer__)))->WriteSentinel(1012795109);
    IPC::WriteParam((&(writer__)), aMaxTotalProgress);
    // Sentinel = 'aMaxTotalProgress'
    ((&(writer__)))->WriteSentinel(1009125089);


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

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

auto PBrowserChild::SendOnStatusChange(const nsAString& aMessage) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_OnStatusChange(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendNotifyContentBlockingEvent(
        const uint32_t& aEvent,
        const RequestData& aRequestData,
        const bool& aBlocked,
        const nsACString& aTrackingOrigin,
        mozilla::Span<nsCString const> aTrackingFullHashes,
        const mozilla::Maybe<StorageAccessPermissionGrantedReason>& aReason,
        const mozilla::Maybe<CanvasFingerprinter>& aCanvasFingerprinter,
        const mozilla::Maybe<bool>& aCanvasFingerprinterKnownText) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NotifyContentBlockingEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEvent);
    // Sentinel = 'aEvent'
    ((&(writer__)))->WriteSentinel(133956196);
    IPC::WriteParam((&(writer__)), aRequestData);
    // Sentinel = 'aRequestData'
    ((&(writer__)))->WriteSentinel(518390981);
    IPC::WriteParam((&(writer__)), aBlocked);
    // Sentinel = 'aBlocked'
    ((&(writer__)))->WriteSentinel(227279638);
    IPC::WriteParam((&(writer__)), aTrackingOrigin);
    // Sentinel = 'aTrackingOrigin'
    ((&(writer__)))->WriteSentinel(792331773);
    IPC::WriteParam((&(writer__)), aTrackingFullHashes);
    // Sentinel = 'aTrackingFullHashes'
    ((&(writer__)))->WriteSentinel(1248069508);
    IPC::WriteParam((&(writer__)), aReason);
    // Sentinel = 'aReason'
    ((&(writer__)))->WriteSentinel(180093642);
    IPC::WriteParam((&(writer__)), aCanvasFingerprinter);
    // Sentinel = 'aCanvasFingerprinter'
    ((&(writer__)))->WriteSentinel(1384777757);
    IPC::WriteParam((&(writer__)), aCanvasFingerprinterKnownText);
    // Sentinel = 'aCanvasFingerprinterKnownText'
    ((&(writer__)))->WriteSentinel(2910718927);


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

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

auto PBrowserChild::SendNavigationFinished() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NavigationFinished(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendIntrinsicSizeOrRatioChanged(
        const mozilla::Maybe<IntrinsicSize>& aIntrinsicSize,
        const mozilla::Maybe<AspectRatio>& aIntrinsicRatio) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_IntrinsicSizeOrRatioChanged(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aIntrinsicSize);
    // Sentinel = 'aIntrinsicSize'
    ((&(writer__)))->WriteSentinel(708052400);
    IPC::WriteParam((&(writer__)), aIntrinsicRatio);
    // Sentinel = 'aIntrinsicRatio'
    ((&(writer__)))->WriteSentinel(807667220);


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

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

auto PBrowserChild::SendImageLoadComplete(const nsresult& aResult) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ImageLoadComplete(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendRequestPointerCapture(
        const uint32_t& aPointerId,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestPointerCapture(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PBrowser::Reply_RequestPointerCapture__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 PBrowserChild::SendRequestPointerCapture(const uint32_t& aPointerId) -> RefPtr<RequestPointerCapturePromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRequestPointerCapture(std::move(aPointerId), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserChild::SendReleasePointerCapture(const uint32_t& aPointerId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ReleasePointerCapture(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendRequestPointerLock(
        mozilla::ipc::ResolveCallback<nsCString>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RequestPointerLock(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

            }
            auto& error = *maybe__error;
            // Sentinel = 'error'
            if ((!((aReader)->ReadSentinel(107741739)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PBrowserChild::SendRequestPointerLock() -> RefPtr<RequestPointerLockPromise>
{
    RefPtr<MozPromise<nsCString, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsCString, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRequestPointerLock([promise__](nsCString&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

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



    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            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 PBrowserChild::SendRemoteIsReadyToHandleInputEvents() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_RemoteIsReadyToHandleInputEvents(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::SendSetDimensions(
        const DimensionRequest& aRequest,
        const double& aScale) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetDimensions(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aRequest);
    // Sentinel = 'aRequest'
    ((&(writer__)))->WriteSentinel(238945099);
    IPC::WriteParam((&(writer__)), aScale);
    // Sentinel = 'aScale'
    ((&(writer__)))->WriteSentinel(131531338);


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

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

auto PBrowserChild::SendDispatchWheelEvent(const WidgetWheelEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchWheelEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_DispatchWheelEvent", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PBrowserChild::SendDispatchMouseEvent(const WidgetMouseEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchMouseEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_DispatchMouseEvent", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PBrowserChild::SendDispatchKeyboardEvent(const WidgetKeyboardEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchKeyboardEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_DispatchKeyboardEvent", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PBrowserChild::SendDispatchTouchEvent(const WidgetTouchEvent& event) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_DispatchTouchEvent(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_DispatchTouchEvent", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PBrowserChild::SendInvokeDragSession(
        nsTArray<IPCTransferableData>&& transfers,
        const uint32_t& action,
        mozilla::Maybe<BigBuffer>&& visualData,
        const uint32_t& stride,
        const SurfaceFormat& format,
        const LayoutDeviceIntRect& dragRect,
        nsIPrincipal* principal,
        nsIPolicyContainer* policyContainer,
        const CookieJarSettingsArgs& cookieJarSettings,
        const MaybeDiscardedWindowContext& sourceWindowContext,
        const MaybeDiscardedWindowContext& sourceTopWindowContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_InvokeDragSession(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(transfers));
    // Sentinel = 'transfers'
    ((&(writer__)))->WriteSentinel(323290073);
    IPC::WriteParam((&(writer__)), action);
    // Sentinel = 'action'
    ((&(writer__)))->WriteSentinel(143786623);
    IPC::WriteParam((&(writer__)), std::move(visualData));
    // Sentinel = 'visualData'
    ((&(writer__)))->WriteSentinel(385877007);
    IPC::WriteParam((&(writer__)), stride);
    // Sentinel = 'stride'
    ((&(writer__)))->WriteSentinel(153879180);
    IPC::WriteParam((&(writer__)), format);
    // Sentinel = 'format'
    ((&(writer__)))->WriteSentinel(148505226);
    IPC::WriteParam((&(writer__)), dragRect);
    // Sentinel = 'dragRect'
    ((&(writer__)))->WriteSentinel(239076141);
    IPC::WriteParam((&(writer__)), principal);
    // Sentinel = 'principal'
    ((&(writer__)))->WriteSentinel(319620035);
    IPC::WriteParam((&(writer__)), policyContainer);
    // Sentinel = 'policyContainer'
    ((&(writer__)))->WriteSentinel(833619508);
    IPC::WriteParam((&(writer__)), cookieJarSettings);
    // Sentinel = 'cookieJarSettings'
    ((&(writer__)))->WriteSentinel(1031800553);
    IPC::WriteParam((&(writer__)), sourceWindowContext);
    // Sentinel = 'sourceWindowContext'
    ((&(writer__)))->WriteSentinel(1328678895);
    IPC::WriteParam((&(writer__)), sourceTopWindowContext);
    // Sentinel = 'sourceTopWindowContext'
    ((&(writer__)))->WriteSentinel(1758005538);


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

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

auto PBrowserChild::SendEnsureLayersConnected(CompositorOptions* compositorOptions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_EnsureLayersConnected(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_EnsureLayersConnected", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__compositorOptions__reply = IPC::ReadParam<CompositorOptions>((&(reader__)));
    if (!maybe__compositorOptions__reply) {
        FatalError("Error deserializing 'CompositorOptions'");
        return false;

    }
    auto& compositorOptions__reply = *maybe__compositorOptions__reply;
    // Sentinel = 'compositorOptions'
    if ((!(((&(reader__)))->ReadSentinel(1089275708)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
        return false;
    }
    (*(compositorOptions)) = std::move(compositorOptions__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendShowCanvasPermissionPrompt(
        const nsACString& aOrigin,
        const bool& aHideDoorHanger) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ShowCanvasPermissionPrompt(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aOrigin);
    // Sentinel = 'aOrigin'
    ((&(writer__)))->WriteSentinel(182125258);
    IPC::WriteParam((&(writer__)), aHideDoorHanger);
    // Sentinel = 'aHideDoorHanger'
    ((&(writer__)))->WriteSentinel(753731013);


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

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

auto PBrowserChild::SendSetSystemFont(const nsACString& aFontName) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_SetSystemFont(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_SetSystemFont", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PBrowserChild::SendGetSystemFont(nsCString* retval) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_GetSystemFont(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PBrowser::Msg_GetSystemFont", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

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

    }
    auto& retval__reply = *maybe__retval__reply;
    // Sentinel = 'retval'
    if ((!(((&(reader__)))->ReadSentinel(151716495)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
        return false;
    }
    (*(retval)) = std::move(retval__reply);
    reader__.EndRead();

    return true;
}

auto PBrowserChild::SendMaybeFireEmbedderLoadEvents(const EmbedderElementEventType& aFireEventAtEmbeddingElement) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_MaybeFireEmbedderLoadEvents(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendScrollRectIntoView(
        const nsRect& aRect,
        const ScrollAxis& aVertical,
        const ScrollAxis& aHorizontal,
        const ScrollFlags& aScrollFlags,
        const int32_t& aAppUnitsPerDevPixel) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ScrollRectIntoView(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aRect);
    // Sentinel = 'aRect'
    ((&(writer__)))->WriteSentinel(94044656);
    IPC::WriteParam((&(writer__)), aVertical);
    // Sentinel = 'aVertical'
    ((&(writer__)))->WriteSentinel(298845084);
    IPC::WriteParam((&(writer__)), aHorizontal);
    // Sentinel = 'aHorizontal'
    ((&(writer__)))->WriteSentinel(447022220);
    IPC::WriteParam((&(writer__)), aScrollFlags);
    // Sentinel = 'aScrollFlags'
    ((&(writer__)))->WriteSentinel(510592190);
    IPC::WriteParam((&(writer__)), aAppUnitsPerDevPixel);
    // Sentinel = 'aAppUnitsPerDevPixel'
    ((&(writer__)))->WriteSentinel(1366296542);


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

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

auto PBrowserChild::SendShowDynamicToolbar() -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_ShowDynamicToolbar(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PBrowserChild::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::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PBrowserChild",
            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 PBrowserChild::SendIsWindowSupportingProtectedMedia(
        const uint64_t& aOuterWindowID,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_IsWindowSupportingProtectedMedia(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PBrowserChild::SendIsWindowSupportingProtectedMedia(const uint64_t& aOuterWindowID) -> RefPtr<IsWindowSupportingProtectedMediaPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendIsWindowSupportingProtectedMedia(std::move(aOuterWindowID), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserChild::SendIsWindowSupportingWebVR(
        const uint64_t& aOuterWindowID,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_IsWindowSupportingWebVR(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PBrowserChild::SendIsWindowSupportingWebVR(const uint64_t& aOuterWindowID) -> RefPtr<IsWindowSupportingWebVRPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendIsWindowSupportingWebVR(std::move(aOuterWindowID), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PBrowserChild::SendVisitURI(
        nsIURI* aURI,
        nsIURI* aLastVisitedURI,
        const uint32_t& aFlags,
        const uint64_t& aBrowserId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_VisitURI(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aURI);
    // Sentinel = 'aURI'
    ((&(writer__)))->WriteSentinel(57934162);
    IPC::WriteParam((&(writer__)), aLastVisitedURI);
    // Sentinel = 'aLastVisitedURI'
    ((&(writer__)))->WriteSentinel(786695614);
    IPC::WriteParam((&(writer__)), aFlags);
    // Sentinel = 'aFlags'
    ((&(writer__)))->WriteSentinel(129892943);
    IPC::WriteParam((&(writer__)), aBrowserId);
    // Sentinel = 'aBrowserId'
    ((&(writer__)))->WriteSentinel(363332595);


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

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

auto PBrowserChild::SendQueryVisitedState(mozilla::Span<RefPtr<nsIURI> const> aURIs) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_QueryVisitedState(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PBrowserChild::SendPSessionStoreConstructor(PSessionStoreChild* actor) -> PSessionStoreChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PSessionStoreChild actor");
        return nullptr;
    }

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


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

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


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

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

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


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

        return nullptr;
    }
    return actor;
}

auto PBrowserChild::SendNewWindowGlobal(
        ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>&& aEndpoint,
        const WindowGlobalInit& aInit) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_NewWindowGlobal(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(aEndpoint));
    // Sentinel = 'aEndpoint'
    ((&(writer__)))->WriteSentinel(292225955);
    IPC::WriteParam((&(writer__)), aInit);
    // Sentinel = 'aInit'
    ((&(writer__)))->WriteSentinel(94241270);


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

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

auto PBrowserChild::SendUpdateDropEffect(
        const uint32_t& aDragAction,
        const uint32_t& aDropEffect) -> bool
{
    UniquePtr<IPC::Message> msg__ = PBrowser::Msg_UpdateDropEffect(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aDragAction);
    // Sentinel = 'aDragAction'
    ((&(writer__)))->WriteSentinel(411370558);
    IPC::WriteParam((&(writer__)), aDropEffect);
    // Sentinel = 'aDropEffect'
    ((&(writer__)))->WriteSentinel(419759172);


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

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

auto PBrowserChild::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PDocAccessibleMsgStart:
        static_cast<BrowserChild*>(this)->DeallocPDocAccessibleChild(static_cast<PDocAccessibleChild*>(aListener));
        return;
    case PPaymentRequestMsgStart:
        static_cast<BrowserChild*>(this)->DeallocPPaymentRequestChild(static_cast<PPaymentRequestChild*>(aListener));
        return;
    default:
        FatalError("unreached");
        return;
    }
}

auto PBrowserChild::OnMessageReceived(const Message& msg__) -> PBrowserChild::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::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    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<BrowserChild*>(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::Reply_PDocAccessibleConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBrowser::Reply_PPaymentRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBrowser::Reply_PVsyncConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBrowser::Reply_NotifyIMEFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

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


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PBrowser::Reply_PColorPickerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBrowser::Reply_PFilePickerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PBrowser::Reply___delete____ID:
        {
            return MsgProcessed;
        }
    case PBrowser::Reply_RequestPointerCapture__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

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


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

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


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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateSHistory__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateSHistory", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_CloneDocumentTreeIntoSelf__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_CloneDocumentTreeIntoSelf", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBc = *maybe__aBc;
            // Sentinel = 'aBc'
            if ((!(((&(reader__)))->ReadSentinel(34406663)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
            if (!maybe__aPrintData) {
                FatalError("Error deserializing 'PrintData'");
                return MsgValueError;

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

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

            CloneDocumentTreeIntoSelfResolver 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::ChildSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PBrowserChild",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCloneDocumentTreeIntoSelf(std::move(aBc), std::move(aPrintData), 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_UpdateRemotePrintSettings__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateRemotePrintSettings", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPrintData = *maybe__aPrintData;
            // Sentinel = 'aPrintData'
            if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateRemotePrintSettings(std::move(aPrintData));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ReleaseAllPointerCapture__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ReleaseAllPointerCapture", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateEffects__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateEffects", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEffects = *maybe__aEffects;
            // Sentinel = 'aEffects'
            if ((!(((&(reader__)))->ReadSentinel(225248034)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'EffectsInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateEffects(std::move(aEffects));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_Show__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_Show", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& parentInfo = *maybe__parentInfo;
            // Sentinel = 'parentInfo'
            if ((!(((&(reader__)))->ReadSentinel(380044311)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ParentShowInfo'");
                return MsgValueError;
            }
            auto maybe__childInfo = IPC::ReadParam<OwnerShowInfo>((&(reader__)));
            if (!maybe__childInfo) {
                FatalError("Error deserializing 'OwnerShowInfo'");
                return MsgValueError;

            }
            auto& childInfo = *maybe__childInfo;
            // Sentinel = 'childInfo'
            if ((!(((&(reader__)))->ReadSentinel(298320785)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OwnerShowInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvShow(std::move(parentInfo), std::move(childInfo));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_Activate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_Activate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_Deactivate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_Deactivate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_ScrollbarPreferenceChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ScrollbarPreferenceChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& pref = *maybe__pref;
            // Sentinel = 'pref'
            if ((!(((&(reader__)))->ReadSentinel(71958958)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollbarPreference'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvScrollbarPreferenceChanged(std::move(pref));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_InitRendering__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_InitRendering", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& textureFactoryIdentifier = *maybe__textureFactoryIdentifier;
            // Sentinel = 'textureFactoryIdentifier'
            if ((!(((&(reader__)))->ReadSentinel(2096630253)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TextureFactoryIdentifier'");
                return MsgValueError;
            }
            auto maybe__layersId = IPC::ReadParam<LayersId>((&(reader__)));
            if (!maybe__layersId) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;

            }
            auto& layersId = *maybe__layersId;
            // Sentinel = 'layersId'
            if ((!(((&(reader__)))->ReadSentinel(250938174)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            auto maybe__compositorOptions = IPC::ReadParam<CompositorOptions>((&(reader__)));
            if (!maybe__compositorOptions) {
                FatalError("Error deserializing 'CompositorOptions'");
                return MsgValueError;

            }
            auto& compositorOptions = *maybe__compositorOptions;
            // Sentinel = 'compositorOptions'
            if ((!(((&(reader__)))->ReadSentinel(1089275708)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
                return MsgValueError;
            }
            auto maybe__layersConnected = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__layersConnected) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& layersConnected = *maybe__layersConnected;
            // Sentinel = 'layersConnected'
            if ((!(((&(reader__)))->ReadSentinel(829294116)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvInitRendering(std::move(textureFactoryIdentifier), std::move(layersId), std::move(compositorOptions), std::move(layersConnected));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_CompositorOptionsChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_CompositorOptionsChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& newOptions = *maybe__newOptions;
            // Sentinel = 'newOptions'
            if ((!(((&(reader__)))->ReadSentinel(384304183)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCompositorOptionsChanged(std::move(newOptions));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_LoadURL__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_LoadURL", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& loadState = *maybe__loadState;
            // Sentinel = 'loadState'
            if ((!(((&(reader__)))->ReadSentinel(304808866)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsDocShellLoadState>'");
                return MsgValueError;
            }
            auto maybe__info = IPC::ReadParam<ParentShowInfo>((&(reader__)));
            if (!maybe__info) {
                FatalError("Error deserializing 'ParentShowInfo'");
                return MsgValueError;

            }
            auto& info = *maybe__info;
            // Sentinel = 'info'
            if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ParentShowInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvLoadURL(loadState, std::move(info));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_CreateAboutBlankDocumentViewer__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_CreateAboutBlankDocumentViewer", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            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__partitionedPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__partitionedPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& partitionedPrincipal = *maybe__partitionedPrincipal;
            // Sentinel = 'partitionedPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1472661574)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCreateAboutBlankDocumentViewer(principal, partitionedPrincipal);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ResumeLoad__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ResumeLoad", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& pendingSwitchID = *maybe__pendingSwitchID;
            // Sentinel = 'pendingSwitchID'
            if ((!(((&(reader__)))->ReadSentinel(822478309)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__info = IPC::ReadParam<ParentShowInfo>((&(reader__)));
            if (!maybe__info) {
                FatalError("Error deserializing 'ParentShowInfo'");
                return MsgValueError;

            }
            auto& info = *maybe__info;
            // Sentinel = 'info'
            if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ParentShowInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvResumeLoad(std::move(pendingSwitchID), std::move(info));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateDimensions__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateDimensions", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& dimensions = *maybe__dimensions;
            // Sentinel = 'dimensions'
            if ((!(((&(reader__)))->ReadSentinel(383845434)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DimensionInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateDimensions(std::move(dimensions));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SizeModeChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SizeModeChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& sizeMode = *maybe__sizeMode;
            // Sentinel = 'sizeMode'
            if ((!(((&(reader__)))->ReadSentinel(251790145)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsSizeMode'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSizeModeChanged(std::move(sizeMode));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_ChildToParentMatrix__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ChildToParentMatrix", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aMatrix = *maybe__aMatrix;
            // Sentinel = 'aMatrix'
            if ((!(((&(reader__)))->ReadSentinel(181469911)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Matrix4x4?'");
                return MsgValueError;
            }
            auto maybe__aRemoteDocumentRect = IPC::ReadParam<ScreenRect>((&(reader__)));
            if (!maybe__aRemoteDocumentRect) {
                FatalError("Error deserializing 'ScreenRect'");
                return MsgValueError;

            }
            auto& aRemoteDocumentRect = *maybe__aRemoteDocumentRect;
            // Sentinel = 'aRemoteDocumentRect'
            if ((!(((&(reader__)))->ReadSentinel(1261242267)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScreenRect'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvChildToParentMatrix(std::move(aMatrix), std::move(aRemoteDocumentRect));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateRemoteStyle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateRemoteStyle", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aImageRendering = *maybe__aImageRendering;
            // Sentinel = 'aImageRendering'
            if ((!(((&(reader__)))->ReadSentinel(768804323)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StyleImageRendering'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateRemoteStyle(std::move(aImageRendering));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_DynamicToolbarMaxHeightChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DynamicToolbarMaxHeightChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& height = *maybe__height;
            // Sentinel = 'height'
            if ((!(((&(reader__)))->ReadSentinel(143393402)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScreenIntCoord'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDynamicToolbarMaxHeightChanged(std::move(height));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_DynamicToolbarOffsetChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DynamicToolbarOffsetChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& offset = *maybe__offset;
            // Sentinel = 'offset'
            if ((!(((&(reader__)))->ReadSentinel(147653256)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScreenIntCoord'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDynamicToolbarOffsetChanged(std::move(offset));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_KeyboardHeightChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_KeyboardHeightChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& height = *maybe__height;
            // Sentinel = 'height'
            if ((!(((&(reader__)))->ReadSentinel(143393402)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScreenIntCoord'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvKeyboardHeightChanged(std::move(height));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_AndroidPipModeChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_AndroidPipModeChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_StopIMEStateManagement__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_StopIMEStateManagement", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_RealMouseMoveEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseMoveEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealMouseMoveEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseMoveEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealMouseMoveEventForTests__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseMoveEventForTests", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseMoveEventForTests(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseMoveEventForTests", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseMoveEventForTests(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SynthMouseMoveEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SynthMouseMoveEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSynthMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPrioritySynthMouseMoveEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySynthMouseMoveEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPrioritySynthMouseMoveEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealMouseButtonEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseButtonEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseButtonEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealMouseButtonEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseButtonEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseButtonEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealPointerButtonEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealPointerButtonEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetPointerEvent'");
                return MsgValueError;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealPointerButtonEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealPointerButtonEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealPointerButtonEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetPointerEvent'");
                return MsgValueError;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealPointerButtonEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealMouseEnterExitWidgetEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealMouseEnterExitWidgetEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealMouseEnterExitWidgetEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealMouseEnterExitWidgetEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealMouseEnterExitWidgetEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealKeyEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealKeyEvent", 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<BrowserChild*>(this))->RecvRealKeyEvent(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_NormalPriorityRealKeyEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealKeyEvent", 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<BrowserChild*>(this))->RecvNormalPriorityRealKeyEvent(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_MouseWheelEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_MouseWheelEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvMouseWheelEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityMouseWheelEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityMouseWheelEvent", 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;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityMouseWheelEvent(std::move(event), std::move(aGuid), std::move(aInputBlockId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealTouchEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
            if (!maybe__aApzResponse) {
                FatalError("Error deserializing 'nsEventStatus'");
                return MsgValueError;

            }
            auto& aApzResponse = *maybe__aApzResponse;
            // Sentinel = 'aApzResponse'
            if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealTouchEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealTouchEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
            if (!maybe__aApzResponse) {
                FatalError("Error deserializing 'nsEventStatus'");
                return MsgValueError;

            }
            auto& aApzResponse = *maybe__aApzResponse;
            // Sentinel = 'aApzResponse'
            if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealTouchEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_HandleTap__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_HandleTap", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& point = *maybe__point;
            // Sentinel = 'point'
            if ((!(((&(reader__)))->ReadSentinel(108790315)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDevicePoint'");
                return MsgValueError;
            }
            auto maybe__aModifiers = IPC::ReadParam<Modifiers>((&(reader__)));
            if (!maybe__aModifiers) {
                FatalError("Error deserializing 'Modifiers'");
                return MsgValueError;

            }
            auto& aModifiers = *maybe__aModifiers;
            // Sentinel = 'aModifiers'
            if ((!(((&(reader__)))->ReadSentinel(358286340)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Modifiers'");
                return MsgValueError;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aMetrics = IPC::ReadParam<mozilla::Maybe<DoubleTapToZoomMetrics>>((&(reader__)));
            if (!maybe__aMetrics) {
                FatalError("Error deserializing 'DoubleTapToZoomMetrics?'");
                return MsgValueError;

            }
            auto& aMetrics = *maybe__aMetrics;
            // Sentinel = 'aMetrics'
            if ((!(((&(reader__)))->ReadSentinel(235471673)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DoubleTapToZoomMetrics?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvHandleTap(std::move(aType), std::move(point), std::move(aModifiers), std::move(aGuid), std::move(aInputBlockId), std::move(aMetrics));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityHandleTap__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityHandleTap", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& point = *maybe__point;
            // Sentinel = 'point'
            if ((!(((&(reader__)))->ReadSentinel(108790315)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDevicePoint'");
                return MsgValueError;
            }
            auto maybe__aModifiers = IPC::ReadParam<Modifiers>((&(reader__)));
            if (!maybe__aModifiers) {
                FatalError("Error deserializing 'Modifiers'");
                return MsgValueError;

            }
            auto& aModifiers = *maybe__aModifiers;
            // Sentinel = 'aModifiers'
            if ((!(((&(reader__)))->ReadSentinel(358286340)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Modifiers'");
                return MsgValueError;
            }
            auto maybe__aGuid = IPC::ReadParam<ScrollableLayerGuid>((&(reader__)));
            if (!maybe__aGuid) {
                FatalError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aMetrics = IPC::ReadParam<mozilla::Maybe<DoubleTapToZoomMetrics>>((&(reader__)));
            if (!maybe__aMetrics) {
                FatalError("Error deserializing 'DoubleTapToZoomMetrics?'");
                return MsgValueError;

            }
            auto& aMetrics = *maybe__aMetrics;
            // Sentinel = 'aMetrics'
            if ((!(((&(reader__)))->ReadSentinel(235471673)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DoubleTapToZoomMetrics?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityHandleTap(std::move(aType), std::move(point), std::move(aModifiers), std::move(aGuid), std::move(aInputBlockId), std::move(aMetrics));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealTouchMoveEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchMoveEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
            if (!maybe__aApzResponse) {
                FatalError("Error deserializing 'nsEventStatus'");
                return MsgValueError;

            }
            auto& aApzResponse = *maybe__aApzResponse;
            // Sentinel = 'aApzResponse'
            if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealTouchMoveEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealTouchMoveEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchMoveEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
            if (!maybe__aApzResponse) {
                FatalError("Error deserializing 'nsEventStatus'");
                return MsgValueError;

            }
            auto& aApzResponse = *maybe__aApzResponse;
            // Sentinel = 'aApzResponse'
            if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealTouchMoveEvent(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealTouchMoveEvent2__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealTouchMoveEvent2", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
            if (!maybe__aApzResponse) {
                FatalError("Error deserializing 'nsEventStatus'");
                return MsgValueError;

            }
            auto& aApzResponse = *maybe__aApzResponse;
            // Sentinel = 'aApzResponse'
            if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealTouchMoveEvent2(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityRealTouchMoveEvent2__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityRealTouchMoveEvent2", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aGuid = *maybe__aGuid;
            // Sentinel = 'aGuid'
            if ((!(((&(reader__)))->ReadSentinel(94044651)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScrollableLayerGuid'");
                return MsgValueError;
            }
            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__aApzResponse = IPC::ReadParam<nsEventStatus>((&(reader__)));
            if (!maybe__aApzResponse) {
                FatalError("Error deserializing 'nsEventStatus'");
                return MsgValueError;

            }
            auto& aApzResponse = *maybe__aApzResponse;
            // Sentinel = 'aApzResponse'
            if ((!(((&(reader__)))->ReadSentinel(512951516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsEventStatus'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityRealTouchMoveEvent2(std::move(aEvent), std::move(aGuid), std::move(aInputBlockId), std::move(aApzResponse));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_RealDragEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RealDragEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEvent = *maybe__aEvent;
            // Sentinel = 'aEvent'
            if ((!(((&(reader__)))->ReadSentinel(133956196)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetDragEvent'");
                return MsgValueError;
            }
            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;
            }
            auto maybe__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvRealDragEvent(std::move(aEvent), std::move(aDragAction), std::move(aDropEffect), aPrincipal, policyContainer);
            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::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    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<BrowserChild*>(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::Msg_CompositionEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_CompositionEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetCompositionEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvCompositionEvent(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_NormalPriorityCompositionEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityCompositionEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetCompositionEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityCompositionEvent(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_SelectionEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SelectionEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetSelectionEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSelectionEvent(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_NormalPrioritySelectionEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySelectionEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& event = *maybe__event;
            // Sentinel = 'event'
            if ((!(((&(reader__)))->ReadSentinel(106234403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WidgetSelectionEvent'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPrioritySelectionEvent(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_SimpleContentCommandEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SimpleContentCommandEvent", 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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSimpleContentCommandEvent(std::move(message));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPrioritySimpleContentCommandEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPrioritySimpleContentCommandEvent", 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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPrioritySimpleContentCommandEvent(std::move(message));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_InsertText__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_InsertText", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityInsertText__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityInsertText", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_ReplaceText__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ReplaceText", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            }
            auto& aPreventSetSelection = *maybe__aPreventSetSelection;
            // Sentinel = 'aPreventSetSelection'
            if ((!(((&(reader__)))->ReadSentinel(1408370712)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvReplaceText(std::move(aReplacementString), std::move(aStringToInsert), std::move(aOffset), std::move(aPreventSetSelection));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_NormalPriorityReplaceText__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NormalPriorityReplaceText", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            }
            auto& aPreventSetSelection = *maybe__aPreventSetSelection;
            // Sentinel = 'aPreventSetSelection'
            if ((!(((&(reader__)))->ReadSentinel(1408370712)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNormalPriorityReplaceText(std::move(aReplacementString), std::move(aStringToInsert), std::move(aOffset), std::move(aPreventSetSelection));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_PasteTransferable__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PasteTransferable", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTransferable = *maybe__aTransferable;
            // Sentinel = 'aTransferable'
            if ((!(((&(reader__)))->ReadSentinel(609813819)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferable'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPasteTransferable(std::move(aTransferable));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_LoadRemoteScript__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_LoadRemoteScript", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aURL = *maybe__aURL;
            // Sentinel = 'aURL'
            if ((!(((&(reader__)))->ReadSentinel(58130773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aRunInGlobalScope = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aRunInGlobalScope) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aRunInGlobalScope = *maybe__aRunInGlobalScope;
            // Sentinel = 'aRunInGlobalScope'
            if ((!(((&(reader__)))->ReadSentinel(981862041)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvLoadRemoteScript(std::move(aURL), std::move(aRunInGlobalScope));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_RenderLayers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_RenderLayers", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_PreserveLayers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PreserveLayers", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_SuppressDisplayport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SuppressDisplayport", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_NavigateByKey__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_NavigateByKey", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aForDocumentNavigation = *maybe__aForDocumentNavigation;
            // Sentinel = 'aForDocumentNavigation'
            if ((!(((&(reader__)))->ReadSentinel(1667434712)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvNavigateByKey(std::move(aForward), std::move(aForDocumentNavigation));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_UIResolutionChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UIResolutionChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& dpi = *maybe__dpi;
            // Sentinel = 'dpi'
            if ((!(((&(reader__)))->ReadSentinel(41419070)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }
            auto maybe__rounding = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__rounding) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

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

            }
            auto& scale = *maybe__scale;
            // Sentinel = 'scale'
            if ((!(((&(reader__)))->ReadSentinel(103809545)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'double'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUIResolutionChanged(std::move(dpi), std::move(rounding), std::move(scale));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SafeAreaInsetsChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SafeAreaInsetsChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aSafeAreaInsets = *maybe__aSafeAreaInsets;
            // Sentinel = 'aSafeAreaInsets'
            if ((!(((&(reader__)))->ReadSentinel(752944592)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntMargin'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSafeAreaInsetsChanged(std::move(aSafeAreaInsets));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_SwappedWithOtherRemoteLoader__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_SwappedWithOtherRemoteLoader", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& context = *maybe__context;
            // Sentinel = 'context'
            if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvSwappedWithOtherRemoteLoader(std::move(context));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_HandleAccessKey__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_HandleAccessKey", 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;
            }
            auto maybe__charCodes = IPC::ReadParam<nsTArray<uint32_t>>((&(reader__)));
            if (!maybe__charCodes) {
                FatalError("Error deserializing 'uint32_t[]'");
                return MsgValueError;

            }
            auto& charCodes = *maybe__charCodes;
            // Sentinel = 'charCodes'
            if ((!(((&(reader__)))->ReadSentinel(294323085)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvHandleAccessKey(std::move(event), std::move(charCodes));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_PrintPreview__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PrintPreview", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPrintData = *maybe__aPrintData;
            // Sentinel = 'aPrintData'
            if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
                return MsgValueError;
            }
            auto maybe__aSourceBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aSourceBrowsingContext) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

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

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPrintPreview(std::move(aPrintData), std::move(aSourceBrowsingContext), 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_ExitPrintPreview__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_ExitPrintPreview", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_Print__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_Print", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBC = *maybe__aBC;
            // Sentinel = 'aBC'
            if ((!(((&(reader__)))->ReadSentinel(32309479)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
            if (!maybe__aPrintData) {
                FatalError("Error deserializing 'PrintData'");
                return MsgValueError;

            }
            auto& aPrintData = *maybe__aPrintData;
            // Sentinel = 'aPrintData'
            if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
                return MsgValueError;
            }
            auto maybe__aReturnStaticClone = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aReturnStaticClone) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPrint(std::move(aBC), std::move(aPrintData), std::move(aReturnStaticClone), 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_PrintClonedPage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_PrintClonedPage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBC = *maybe__aBC;
            // Sentinel = 'aBC'
            if ((!(((&(reader__)))->ReadSentinel(32309479)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aPrintData = IPC::ReadParam<PrintData>((&(reader__)));
            if (!maybe__aPrintData) {
                FatalError("Error deserializing 'PrintData'");
                return MsgValueError;

            }
            auto& aPrintData = *maybe__aPrintData;
            // Sentinel = 'aPrintData'
            if ((!(((&(reader__)))->ReadSentinel(359072745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrintData'");
                return MsgValueError;
            }
            auto maybe__aStaticCloneBrowsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aStaticCloneBrowsingContext) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aStaticCloneBrowsingContext = *maybe__aStaticCloneBrowsingContext;
            // Sentinel = 'aStaticCloneBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(2513898219)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvPrintClonedPage(std::move(aBC), std::move(aPrintData), std::move(aStaticCloneBrowsingContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_DestroyPrintClone__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DestroyPrintClone", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PBrowser::Msg_UpdateNativeWindowHandle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateNativeWindowHandle", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aNewHandle = *maybe__aNewHandle;
            // Sentinel = 'aNewHandle'
            if ((!(((&(reader__)))->ReadSentinel(347145176)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uintptr_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateNativeWindowHandle(std::move(aNewHandle));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_AllowScriptsToClose__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_AllowScriptsToClose", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_WillChangeProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_WillChangeProcess", OTHER);

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

            return MsgProcessed;
        }
    case PBrowser::Msg_InvokeChildDragSession__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_InvokeChildDragSession", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvInvokeChildDragSession(std::move(aSourceWindowContext), std::move(aSourceTopWindowContext), aPrincipal, std::move(transfers), 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_UpdateDragSession__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_UpdateDragSession", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__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__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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvUpdateDragSession(aPrincipal, std::move(transfers), std::move(message));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_EndDragSession__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_EndDragSession", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            }
            auto& aKeyModifiers = *maybe__aKeyModifiers;
            // Sentinel = 'aKeyModifiers'
            if ((!(((&(reader__)))->ReadSentinel(588645677)))) {
                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<BrowserChild*>(this))->RecvEndDragSession(std::move(aDoneDrag), std::move(aUserCancelled), std::move(aDragEndPoint), std::move(aKeyModifiers), std::move(aDropEffect));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_StoreDropTargetAndDelayEndDragSession__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_StoreDropTargetAndDelayEndDragSession", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPt = *maybe__aPt;
            // Sentinel = 'aPt'
            if ((!(((&(reader__)))->ReadSentinel(37355814)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                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;
            }
            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__aPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

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

            }
            auto& aPolicyContainer = *maybe__aPolicyContainer;
            // Sentinel = 'aPolicyContainer'
            if ((!(((&(reader__)))->ReadSentinel(903939701)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPolicyContainer'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvStoreDropTargetAndDelayEndDragSession(std::move(aPt), std::move(aDropEffect), std::move(aDragAction), aPrincipal, aPolicyContainer);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PBrowser::Msg_DispatchToDropTargetAndResumeEndDragSession__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PBrowser", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PBrowserChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PBrowser::Msg_DispatchToDropTargetAndResumeEndDragSession", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aShouldDrop = *maybe__aShouldDrop;
            // Sentinel = 'aShouldDrop'
            if ((!(((&(reader__)))->ReadSentinel(435618918)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aAllowedFilePaths = IPC::ReadParam<StringHashSet>((&(reader__)));
            if (!maybe__aAllowedFilePaths) {
                FatalError("Error deserializing 'StringHashSet'");
                return MsgValueError;

            }
            auto& aAllowedFilePaths = *maybe__aAllowedFilePaths;
            // Sentinel = 'aAllowedFilePaths'
            if ((!(((&(reader__)))->ReadSentinel(990316202)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StringHashSet'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<BrowserChild*>(this))->RecvDispatchToDropTargetAndResumeEndDragSession(std::move(aShouldDrop), std::move(aAllowedFilePaths));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

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


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

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


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PBrowser::Reply_PSessionStoreConstructor__ID:
        {
            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}

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



} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PBrowserChild*>::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::PBrowserChild*>::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::PBrowserChild*>(actor);
}

} // namespace IPC
