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


#include "mozilla/dom/PContentChild.h"
#include "ipc/ErrorIPCUtils.h"
#include "ipc/MediaControlIPC.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/D3DMessageUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/PermissionDelegateIPCUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/URLClassifierIPCUtils.h"
#include "mozilla/chrome/RegistryMessageUtils.h"
#include "mozilla/dom/BindingIPCUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/ClientIPCUtils.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.h"
#include "mozilla/dom/FeaturePolicyUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/GeolocationIPCUtils.h"
#include "mozilla/dom/MediaSessionIPCUtils.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/NavigationAPIIPCUtils.h"
#include "mozilla/dom/PageLoadEventUtils.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/TabMessageUtils.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/dom/notification/IPCUtils.h"
#include "mozilla/glean/DomMetrics.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/ByteBufUtils.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/LayersMessageUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/widget/WidgetMessageUtils.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsGeoPositionIPCSerialiser.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsID.h"
#include "nsILayoutHistoryState.h"
#include "nsIPolicyContainer.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "nsIReferrerInfo.h"
#include "nsITransportSecurityInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsIX509Cert.h"
#include "nsPoint.h"

#include "mozilla/ipc/PBackgroundStarterChild.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/PClipboardContentAnalysisChild.h"
#include "mozilla/PClipboardReadRequestChild.h"
#include "mozilla/PClipboardWriteRequestChild.h"
#include "mozilla/layers/PCompositorManagerChild.h"
#include "mozilla/dom/PContentPermissionRequestChild.h"
#include "mozilla/dom/PCycleCollectWithLogsChild.h"
#include "mozilla/net/PDocumentChannelChild.h"
#include "mozilla/extensions/PExtensionsChild.h"
#include "mozilla/dom/PExternalHelperAppChild.h"
#include "mozilla/dom/PHandlerServiceChild.h"
#include "mozilla/hal_sandbox/PHalChild.h"
#include "mozilla/devtools/PHeapSnapshotTempFileHelperChild.h"
#include "mozilla/PProcessHangMonitorChild.h"
#include "mozilla/layers/PImageBridgeChild.h"
#include "mozilla/layout/PRemotePrintJobChild.h"
#include "mozilla/media/PMediaChild.h"
#include "mozilla/net/PNeckoChild.h"
#include "mozilla/extensions/PStreamFilterChild.h"
#include "mozilla/gmp/PGMPContentChild.h"
#include "mozilla/gmp/PGMPServiceChild.h"
#include "mozilla/gmp/PGMPChild.h"
#include "mozilla/dom/PSpeechSynthesisChild.h"
#include "mozilla/ipc/PTestShellChild.h"
#include "mozilla/PRemoteSpellcheckEngineChild.h"
#include "mozilla/PWebBrowserPersistDocumentChild.h"
#include "mozilla/dom/PWindowGlobalChild.h"
#include "mozilla/dom/PURLClassifierChild.h"
#include "mozilla/dom/PURLClassifierLocalChild.h"
#include "mozilla/dom/PURLClassifierLocalByNameChild.h"
#include "mozilla/gfx/PVRManagerChild.h"
#include "mozilla/PRemoteMediaManagerChild.h"
#include "mozilla/dom/PRemoteWorkerDebuggerManagerChild.h"
#include "mozilla/dom/PRemoteWorkerServiceChild.h"
#include "mozilla/PProfilerChild.h"
#include "mozilla/loader/PScriptCacheChild.h"
#include "mozilla/dom/PSessionStorageObserverChild.h"

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

namespace mozilla {
namespace dom {


auto PContentChild::RecvPWebBrowserPersistDocumentConstructor(
        PWebBrowserPersistDocumentChild* actor,
        PBrowserChild* aBrowser,
        const MaybeDiscardedBrowsingContext& aContext) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentChild::RecvPCycleCollectWithLogsConstructor(
        PCycleCollectWithLogsChild* actor,
        const bool& dumpAllTraces,
        const FileDescriptor& gcLog,
        const FileDescriptor& ccLog) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentChild::RecvPTestShellConstructor(PTestShellChild* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentChild::RecvPScriptCacheConstructor(
        PScriptCacheChild* actor,
        const FileDescOrError& cacheFile,
        const bool& wantCacheData) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentChild::RecvPRemotePrintJobConstructor(PRemotePrintJobChild* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentChild::ProcessingError(
        Result aCode,
        const char* aReason) -> void
{
}

auto PContentChild::ShouldContinueFromReplyTimeout() -> bool
{
    return true;
}

MOZ_IMPLICIT PContentChild::PContentChild() :
    mozilla::ipc::IToplevelProtocol("PContentChild", kProtocolId, mozilla::ipc::ChildSide)
{
    MOZ_COUNT_CTOR(PContentChild);
}

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

auto PContentChild::ActorAlloc() -> void
{
    MOZ_RELEASE_ASSERT(XRE_IsContentProcess(), "Invalid process for `PContentChild'");
    AddRef();
}

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

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

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

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

auto PContentChild::ManagedPBrowserChild(nsTArray<PBrowserChild*>& aArr) const -> void
{
    mManagedPBrowserChild.ToArray(aArr);
}

auto PContentChild::ManagedPBrowserChild() const -> const ManagedContainer<PBrowserChild>&
{
    return mManagedPBrowserChild;
}

auto PContentChild::ManagedPClipboardReadRequestChild(nsTArray<PClipboardReadRequestChild*>& aArr) const -> void
{
    mManagedPClipboardReadRequestChild.ToArray(aArr);
}

auto PContentChild::ManagedPClipboardReadRequestChild() const -> const ManagedContainer<PClipboardReadRequestChild>&
{
    return mManagedPClipboardReadRequestChild;
}

auto PContentChild::ManagedPClipboardWriteRequestChild(nsTArray<PClipboardWriteRequestChild*>& aArr) const -> void
{
    mManagedPClipboardWriteRequestChild.ToArray(aArr);
}

auto PContentChild::ManagedPClipboardWriteRequestChild() const -> const ManagedContainer<PClipboardWriteRequestChild>&
{
    return mManagedPClipboardWriteRequestChild;
}

auto PContentChild::ManagedPContentPermissionRequestChild(nsTArray<PContentPermissionRequestChild*>& aArr) const -> void
{
    mManagedPContentPermissionRequestChild.ToArray(aArr);
}

auto PContentChild::ManagedPContentPermissionRequestChild() const -> const ManagedContainer<PContentPermissionRequestChild>&
{
    return mManagedPContentPermissionRequestChild;
}

auto PContentChild::ManagedPCycleCollectWithLogsChild(nsTArray<PCycleCollectWithLogsChild*>& aArr) const -> void
{
    mManagedPCycleCollectWithLogsChild.ToArray(aArr);
}

auto PContentChild::ManagedPCycleCollectWithLogsChild() const -> const ManagedContainer<PCycleCollectWithLogsChild>&
{
    return mManagedPCycleCollectWithLogsChild;
}

auto PContentChild::ManagedPExtensionsChild(nsTArray<PExtensionsChild*>& aArr) const -> void
{
    mManagedPExtensionsChild.ToArray(aArr);
}

auto PContentChild::ManagedPExtensionsChild() const -> const ManagedContainer<PExtensionsChild>&
{
    return mManagedPExtensionsChild;
}

auto PContentChild::ManagedPExternalHelperAppChild(nsTArray<PExternalHelperAppChild*>& aArr) const -> void
{
    mManagedPExternalHelperAppChild.ToArray(aArr);
}

auto PContentChild::ManagedPExternalHelperAppChild() const -> const ManagedContainer<PExternalHelperAppChild>&
{
    return mManagedPExternalHelperAppChild;
}

auto PContentChild::ManagedPHalChild(nsTArray<PHalChild*>& aArr) const -> void
{
    mManagedPHalChild.ToArray(aArr);
}

auto PContentChild::ManagedPHalChild() const -> const ManagedContainer<PHalChild>&
{
    return mManagedPHalChild;
}

auto PContentChild::ManagedPHandlerServiceChild(nsTArray<PHandlerServiceChild*>& aArr) const -> void
{
    mManagedPHandlerServiceChild.ToArray(aArr);
}

auto PContentChild::ManagedPHandlerServiceChild() const -> const ManagedContainer<PHandlerServiceChild>&
{
    return mManagedPHandlerServiceChild;
}

auto PContentChild::ManagedPHeapSnapshotTempFileHelperChild(nsTArray<PHeapSnapshotTempFileHelperChild*>& aArr) const -> void
{
    mManagedPHeapSnapshotTempFileHelperChild.ToArray(aArr);
}

auto PContentChild::ManagedPHeapSnapshotTempFileHelperChild() const -> const ManagedContainer<PHeapSnapshotTempFileHelperChild>&
{
    return mManagedPHeapSnapshotTempFileHelperChild;
}

auto PContentChild::ManagedPRemotePrintJobChild(nsTArray<PRemotePrintJobChild*>& aArr) const -> void
{
    mManagedPRemotePrintJobChild.ToArray(aArr);
}

auto PContentChild::ManagedPRemotePrintJobChild() const -> const ManagedContainer<PRemotePrintJobChild>&
{
    return mManagedPRemotePrintJobChild;
}

auto PContentChild::ManagedPMediaChild(nsTArray<PMediaChild*>& aArr) const -> void
{
    mManagedPMediaChild.ToArray(aArr);
}

auto PContentChild::ManagedPMediaChild() const -> const ManagedContainer<PMediaChild>&
{
    return mManagedPMediaChild;
}

auto PContentChild::ManagedPNeckoChild(nsTArray<PNeckoChild*>& aArr) const -> void
{
    mManagedPNeckoChild.ToArray(aArr);
}

auto PContentChild::ManagedPNeckoChild() const -> const ManagedContainer<PNeckoChild>&
{
    return mManagedPNeckoChild;
}

auto PContentChild::ManagedPSpeechSynthesisChild(nsTArray<PSpeechSynthesisChild*>& aArr) const -> void
{
    mManagedPSpeechSynthesisChild.ToArray(aArr);
}

auto PContentChild::ManagedPSpeechSynthesisChild() const -> const ManagedContainer<PSpeechSynthesisChild>&
{
    return mManagedPSpeechSynthesisChild;
}

auto PContentChild::ManagedPTestShellChild(nsTArray<PTestShellChild*>& aArr) const -> void
{
    mManagedPTestShellChild.ToArray(aArr);
}

auto PContentChild::ManagedPTestShellChild() const -> const ManagedContainer<PTestShellChild>&
{
    return mManagedPTestShellChild;
}

auto PContentChild::ManagedPRemoteSpellcheckEngineChild(nsTArray<PRemoteSpellcheckEngineChild*>& aArr) const -> void
{
    mManagedPRemoteSpellcheckEngineChild.ToArray(aArr);
}

auto PContentChild::ManagedPRemoteSpellcheckEngineChild() const -> const ManagedContainer<PRemoteSpellcheckEngineChild>&
{
    return mManagedPRemoteSpellcheckEngineChild;
}

auto PContentChild::ManagedPWebBrowserPersistDocumentChild(nsTArray<PWebBrowserPersistDocumentChild*>& aArr) const -> void
{
    mManagedPWebBrowserPersistDocumentChild.ToArray(aArr);
}

auto PContentChild::ManagedPWebBrowserPersistDocumentChild() const -> const ManagedContainer<PWebBrowserPersistDocumentChild>&
{
    return mManagedPWebBrowserPersistDocumentChild;
}

auto PContentChild::ManagedPURLClassifierChild(nsTArray<PURLClassifierChild*>& aArr) const -> void
{
    mManagedPURLClassifierChild.ToArray(aArr);
}

auto PContentChild::ManagedPURLClassifierChild() const -> const ManagedContainer<PURLClassifierChild>&
{
    return mManagedPURLClassifierChild;
}

auto PContentChild::ManagedPURLClassifierLocalChild(nsTArray<PURLClassifierLocalChild*>& aArr) const -> void
{
    mManagedPURLClassifierLocalChild.ToArray(aArr);
}

auto PContentChild::ManagedPURLClassifierLocalChild() const -> const ManagedContainer<PURLClassifierLocalChild>&
{
    return mManagedPURLClassifierLocalChild;
}

auto PContentChild::ManagedPURLClassifierLocalByNameChild(nsTArray<PURLClassifierLocalByNameChild*>& aArr) const -> void
{
    mManagedPURLClassifierLocalByNameChild.ToArray(aArr);
}

auto PContentChild::ManagedPURLClassifierLocalByNameChild() const -> const ManagedContainer<PURLClassifierLocalByNameChild>&
{
    return mManagedPURLClassifierLocalByNameChild;
}

auto PContentChild::ManagedPScriptCacheChild(nsTArray<PScriptCacheChild*>& aArr) const -> void
{
    mManagedPScriptCacheChild.ToArray(aArr);
}

auto PContentChild::ManagedPScriptCacheChild() const -> const ManagedContainer<PScriptCacheChild>&
{
    return mManagedPScriptCacheChild;
}

auto PContentChild::ManagedPSessionStorageObserverChild(nsTArray<PSessionStorageObserverChild*>& aArr) const -> void
{
    mManagedPSessionStorageObserverChild.ToArray(aArr);
}

auto PContentChild::ManagedPSessionStorageObserverChild() const -> const ManagedContainer<PSessionStorageObserverChild>&
{
    return mManagedPSessionStorageObserverChild;
}

auto PContentChild::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
    static constexpr ::mozilla::ipc::ProtocolId sIds[] = {
        PBrowserMsgStart,
        PClipboardReadRequestMsgStart,
        PClipboardWriteRequestMsgStart,
        PContentPermissionRequestMsgStart,
        PCycleCollectWithLogsMsgStart,
        PExtensionsMsgStart,
        PExternalHelperAppMsgStart,
        PHalMsgStart,
        PHandlerServiceMsgStart,
        PHeapSnapshotTempFileHelperMsgStart,
        PRemotePrintJobMsgStart,
        PMediaMsgStart,
        PNeckoMsgStart,
        PSpeechSynthesisMsgStart,
        PTestShellMsgStart,
        PRemoteSpellcheckEngineMsgStart,
        PWebBrowserPersistDocumentMsgStart,
        PURLClassifierMsgStart,
        PURLClassifierLocalMsgStart,
        PURLClassifierLocalByNameMsgStart,
        PScriptCacheMsgStart,
        PSessionStorageObserverMsgStart
    };
    return sIds;
}

auto PContentChild::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PBrowserMsgStart:
        return (&(mManagedPBrowserChild));
    case PClipboardReadRequestMsgStart:
        return (&(mManagedPClipboardReadRequestChild));
    case PClipboardWriteRequestMsgStart:
        return (&(mManagedPClipboardWriteRequestChild));
    case PContentPermissionRequestMsgStart:
        return (&(mManagedPContentPermissionRequestChild));
    case PCycleCollectWithLogsMsgStart:
        return (&(mManagedPCycleCollectWithLogsChild));
    case PExtensionsMsgStart:
        return (&(mManagedPExtensionsChild));
    case PExternalHelperAppMsgStart:
        return (&(mManagedPExternalHelperAppChild));
    case PHalMsgStart:
        return (&(mManagedPHalChild));
    case PHandlerServiceMsgStart:
        return (&(mManagedPHandlerServiceChild));
    case PHeapSnapshotTempFileHelperMsgStart:
        return (&(mManagedPHeapSnapshotTempFileHelperChild));
    case PRemotePrintJobMsgStart:
        return (&(mManagedPRemotePrintJobChild));
    case PMediaMsgStart:
        return (&(mManagedPMediaChild));
    case PNeckoMsgStart:
        return (&(mManagedPNeckoChild));
    case PSpeechSynthesisMsgStart:
        return (&(mManagedPSpeechSynthesisChild));
    case PTestShellMsgStart:
        return (&(mManagedPTestShellChild));
    case PRemoteSpellcheckEngineMsgStart:
        return (&(mManagedPRemoteSpellcheckEngineChild));
    case PWebBrowserPersistDocumentMsgStart:
        return (&(mManagedPWebBrowserPersistDocumentChild));
    case PURLClassifierMsgStart:
        return (&(mManagedPURLClassifierChild));
    case PURLClassifierLocalMsgStart:
        return (&(mManagedPURLClassifierLocalChild));
    case PURLClassifierLocalByNameMsgStart:
        return (&(mManagedPURLClassifierLocalByNameChild));
    case PScriptCacheMsgStart:
        return (&(mManagedPScriptCacheChild));
    case PSessionStorageObserverMsgStart:
        return (&(mManagedPSessionStorageObserverChild));
    default:
        return nullptr;
    }
}

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

auto PContentChild::OpenPBrowserEndpoint(PBrowserChild* aActor) -> ManagedEndpoint<PBrowserParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PBrowserChild actor");
        return ManagedEndpoint<PBrowserParent>();
    }

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

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

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

auto PContentChild::OpenPClipboardReadRequestEndpoint(PClipboardReadRequestChild* aActor) -> ManagedEndpoint<PClipboardReadRequestParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PClipboardReadRequestChild actor");
        return ManagedEndpoint<PClipboardReadRequestParent>();
    }

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

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

auto PContentChild::BindPClipboardReadRequestEndpoint(
        ManagedEndpoint<PClipboardReadRequestChild> aEndpoint,
        PClipboardReadRequestChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPClipboardWriteRequestEndpoint(PClipboardWriteRequestChild* aActor) -> ManagedEndpoint<PClipboardWriteRequestParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PClipboardWriteRequestChild actor");
        return ManagedEndpoint<PClipboardWriteRequestParent>();
    }

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

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

auto PContentChild::BindPClipboardWriteRequestEndpoint(
        ManagedEndpoint<PClipboardWriteRequestChild> aEndpoint,
        PClipboardWriteRequestChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPContentPermissionRequestEndpoint(PContentPermissionRequestChild* aActor) -> ManagedEndpoint<PContentPermissionRequestParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PContentPermissionRequestChild actor");
        return ManagedEndpoint<PContentPermissionRequestParent>();
    }

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

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

auto PContentChild::BindPContentPermissionRequestEndpoint(
        ManagedEndpoint<PContentPermissionRequestChild> aEndpoint,
        PContentPermissionRequestChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPCycleCollectWithLogsEndpoint(PCycleCollectWithLogsChild* aActor) -> ManagedEndpoint<PCycleCollectWithLogsParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PCycleCollectWithLogsChild actor");
        return ManagedEndpoint<PCycleCollectWithLogsParent>();
    }

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

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

auto PContentChild::BindPCycleCollectWithLogsEndpoint(
        ManagedEndpoint<PCycleCollectWithLogsChild> aEndpoint,
        PCycleCollectWithLogsChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPExtensionsEndpoint(PExtensionsChild* aActor) -> ManagedEndpoint<PExtensionsParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PExtensionsChild actor");
        return ManagedEndpoint<PExtensionsParent>();
    }

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

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

auto PContentChild::BindPExtensionsEndpoint(
        ManagedEndpoint<PExtensionsChild> aEndpoint,
        PExtensionsChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPExternalHelperAppEndpoint(PExternalHelperAppChild* aActor) -> ManagedEndpoint<PExternalHelperAppParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PExternalHelperAppChild actor");
        return ManagedEndpoint<PExternalHelperAppParent>();
    }

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

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

auto PContentChild::BindPExternalHelperAppEndpoint(
        ManagedEndpoint<PExternalHelperAppChild> aEndpoint,
        PExternalHelperAppChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPHalEndpoint(PHalChild* aActor) -> ManagedEndpoint<PHalParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PHalChild actor");
        return ManagedEndpoint<PHalParent>();
    }

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

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

auto PContentChild::BindPHalEndpoint(
        ManagedEndpoint<PHalChild> aEndpoint,
        PHalChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPHandlerServiceEndpoint(PHandlerServiceChild* aActor) -> ManagedEndpoint<PHandlerServiceParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PHandlerServiceChild actor");
        return ManagedEndpoint<PHandlerServiceParent>();
    }

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

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

auto PContentChild::BindPHandlerServiceEndpoint(
        ManagedEndpoint<PHandlerServiceChild> aEndpoint,
        PHandlerServiceChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPHeapSnapshotTempFileHelperEndpoint(PHeapSnapshotTempFileHelperChild* aActor) -> ManagedEndpoint<PHeapSnapshotTempFileHelperParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperChild actor");
        return ManagedEndpoint<PHeapSnapshotTempFileHelperParent>();
    }

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

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

auto PContentChild::BindPHeapSnapshotTempFileHelperEndpoint(
        ManagedEndpoint<PHeapSnapshotTempFileHelperChild> aEndpoint,
        PHeapSnapshotTempFileHelperChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPRemotePrintJobEndpoint(PRemotePrintJobChild* aActor) -> ManagedEndpoint<PRemotePrintJobParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PRemotePrintJobChild actor");
        return ManagedEndpoint<PRemotePrintJobParent>();
    }

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

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

auto PContentChild::BindPRemotePrintJobEndpoint(
        ManagedEndpoint<PRemotePrintJobChild> aEndpoint,
        PRemotePrintJobChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPMediaEndpoint(PMediaChild* aActor) -> ManagedEndpoint<PMediaParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PMediaChild actor");
        return ManagedEndpoint<PMediaParent>();
    }

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

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

auto PContentChild::BindPMediaEndpoint(
        ManagedEndpoint<PMediaChild> aEndpoint,
        PMediaChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPNeckoEndpoint(PNeckoChild* aActor) -> ManagedEndpoint<PNeckoParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PNeckoChild actor");
        return ManagedEndpoint<PNeckoParent>();
    }

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

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

auto PContentChild::BindPNeckoEndpoint(
        ManagedEndpoint<PNeckoChild> aEndpoint,
        PNeckoChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPSpeechSynthesisEndpoint(PSpeechSynthesisChild* aActor) -> ManagedEndpoint<PSpeechSynthesisParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PSpeechSynthesisChild actor");
        return ManagedEndpoint<PSpeechSynthesisParent>();
    }

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

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

auto PContentChild::BindPSpeechSynthesisEndpoint(
        ManagedEndpoint<PSpeechSynthesisChild> aEndpoint,
        PSpeechSynthesisChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPTestShellEndpoint(PTestShellChild* aActor) -> ManagedEndpoint<PTestShellParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PTestShellChild actor");
        return ManagedEndpoint<PTestShellParent>();
    }

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

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

auto PContentChild::BindPTestShellEndpoint(
        ManagedEndpoint<PTestShellChild> aEndpoint,
        PTestShellChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPRemoteSpellcheckEngineEndpoint(PRemoteSpellcheckEngineChild* aActor) -> ManagedEndpoint<PRemoteSpellcheckEngineParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PRemoteSpellcheckEngineChild actor");
        return ManagedEndpoint<PRemoteSpellcheckEngineParent>();
    }

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

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

auto PContentChild::BindPRemoteSpellcheckEngineEndpoint(
        ManagedEndpoint<PRemoteSpellcheckEngineChild> aEndpoint,
        PRemoteSpellcheckEngineChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPWebBrowserPersistDocumentEndpoint(PWebBrowserPersistDocumentChild* aActor) -> ManagedEndpoint<PWebBrowserPersistDocumentParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor");
        return ManagedEndpoint<PWebBrowserPersistDocumentParent>();
    }

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

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

auto PContentChild::BindPWebBrowserPersistDocumentEndpoint(
        ManagedEndpoint<PWebBrowserPersistDocumentChild> aEndpoint,
        PWebBrowserPersistDocumentChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPURLClassifierEndpoint(PURLClassifierChild* aActor) -> ManagedEndpoint<PURLClassifierParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PURLClassifierChild actor");
        return ManagedEndpoint<PURLClassifierParent>();
    }

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

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

auto PContentChild::BindPURLClassifierEndpoint(
        ManagedEndpoint<PURLClassifierChild> aEndpoint,
        PURLClassifierChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPURLClassifierLocalEndpoint(PURLClassifierLocalChild* aActor) -> ManagedEndpoint<PURLClassifierLocalParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PURLClassifierLocalChild actor");
        return ManagedEndpoint<PURLClassifierLocalParent>();
    }

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

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

auto PContentChild::BindPURLClassifierLocalEndpoint(
        ManagedEndpoint<PURLClassifierLocalChild> aEndpoint,
        PURLClassifierLocalChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPURLClassifierLocalByNameEndpoint(PURLClassifierLocalByNameChild* aActor) -> ManagedEndpoint<PURLClassifierLocalByNameParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PURLClassifierLocalByNameChild actor");
        return ManagedEndpoint<PURLClassifierLocalByNameParent>();
    }

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

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

auto PContentChild::BindPURLClassifierLocalByNameEndpoint(
        ManagedEndpoint<PURLClassifierLocalByNameChild> aEndpoint,
        PURLClassifierLocalByNameChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPScriptCacheEndpoint(PScriptCacheChild* aActor) -> ManagedEndpoint<PScriptCacheParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PScriptCacheChild actor");
        return ManagedEndpoint<PScriptCacheParent>();
    }

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

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

auto PContentChild::BindPScriptCacheEndpoint(
        ManagedEndpoint<PScriptCacheChild> aEndpoint,
        PScriptCacheChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::OpenPSessionStorageObserverEndpoint(PSessionStorageObserverChild* aActor) -> ManagedEndpoint<PSessionStorageObserverParent>
{
    if (!aActor) {
        NS_WARNING("Cannot bind null PSessionStorageObserverChild actor");
        return ManagedEndpoint<PSessionStorageObserverParent>();
    }

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

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

auto PContentChild::BindPSessionStorageObserverEndpoint(
        ManagedEndpoint<PSessionStorageObserverChild> aEndpoint,
        PSessionStorageObserverChild* aActor) -> bool
{
    return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this);
}

auto PContentChild::SendConstructPopupBrowser(
        ManagedEndpoint<::mozilla::dom::PBrowserParent>&& browserEp,
        ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>&& windowEp,
        const TabId& tabId,
        const IPCTabContext& context,
        const WindowGlobalInit& windowInit,
        const uint32_t& chromeFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ConstructPopupBrowser(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(browserEp));
    // Sentinel = 'browserEp'
    ((&(writer__)))->WriteSentinel(318833594);
    IPC::WriteParam((&(writer__)), std::move(windowEp));
    // Sentinel = 'windowEp'
    ((&(writer__)))->WriteSentinel(255984462);
    IPC::WriteParam((&(writer__)), tabId);
    // Sentinel = 'tabId'
    ((&(writer__)))->WriteSentinel(99156453);
    IPC::WriteParam((&(writer__)), context);
    // Sentinel = 'context'
    ((&(writer__)))->WriteSentinel(199164678);
    IPC::WriteParam((&(writer__)), windowInit);
    // Sentinel = 'windowInit'
    ((&(writer__)))->WriteSentinel(388891693);
    IPC::WriteParam((&(writer__)), chromeFlags);
    // Sentinel = 'chromeFlags'
    ((&(writer__)))->WriteSentinel(446760044);


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

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

auto PContentChild::SendCloneDocumentTreeInto(
        const MaybeDiscardedBrowsingContext& aSourceBc,
        const MaybeDiscardedBrowsingContext& aTargetBc,
        const PrintData& aPrintData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CloneDocumentTreeInto(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendUpdateRemotePrintSettings(
        const MaybeDiscardedBrowsingContext& aBc,
        const PrintData& aPrintData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateRemotePrintSettings(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendPExtensionsConstructor(PExtensionsChild* actor) -> PExtensionsChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PExtensionsChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PExtensionsConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PExtensionsConstructor", 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 PExtensionsChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPWebBrowserPersistDocumentConstructor(
        PWebBrowserPersistDocumentChild* actor,
        PBrowserChild* aBrowser,
        const MaybeDiscardedBrowsingContext& aContext) -> PWebBrowserPersistDocumentChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor");
        return nullptr;
    }

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


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

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


    // 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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", 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 PWebBrowserPersistDocumentChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

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

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


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

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

auto PContentChild::SendConsumeHistoryActivation(const MaybeDiscardedBrowsingContext& aTop) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ConsumeHistoryActivation(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSynchronizeLayoutHistoryState(
        const MaybeDiscardedBrowsingContext& aContext,
        nsILayoutHistoryState* aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SynchronizeLayoutHistoryState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSessionHistoryEntryTitle(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsAString& aTitle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryTitle(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSessionHistoryEntryScrollRestorationIsManual(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aIsManual) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryScrollRestorationIsManual(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aIsManual);
    // Sentinel = 'aIsManual'
    ((&(writer__)))->WriteSentinel(282526588);


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

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

auto PContentChild::SendSessionHistoryEntryScrollPosition(
        const MaybeDiscardedBrowsingContext& aContext,
        const int32_t& aX,
        const int32_t& aY) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryScrollPosition(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aX);
    // Sentinel = 'aX'
    ((&(writer__)))->WriteSentinel(18612410);
    IPC::WriteParam((&(writer__)), aY);
    // Sentinel = 'aY'
    ((&(writer__)))->WriteSentinel(18677947);


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

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

auto PContentChild::SendSessionHistoryEntryCacheKey(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint32_t& aCacheKey) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryCacheKey(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aCacheKey);
    // Sentinel = 'aCacheKey'
    ((&(writer__)))->WriteSentinel(272827231);


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

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

auto PContentChild::SendSessionHistoryEntryStoreWindowNameInContiguousEntries(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsAString& aName) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aName);
    // Sentinel = 'aName'
    ((&(writer__)))->WriteSentinel(92537315);


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

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

auto PContentChild::SendSessionHistoryEntryWireframe(
        const MaybeDiscardedBrowsingContext& aContext,
        const Wireframe& aWireframe) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SessionHistoryEntryWireframe(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aWireframe);
    // Sentinel = 'aWireframe'
    ((&(writer__)))->WriteSentinel(365888516);


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

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

auto PContentChild::SendGetLoadingSessionHistoryInfoFromParent(
        const MaybeDiscardedBrowsingContext& aContext,
        mozilla::ipc::ResolveCallback<mozilla::Maybe<LoadingSessionHistoryInfo>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetLoadingSessionHistoryInfoFromParent(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

            }
            auto& aLoadingInfo = *maybe__aLoadingInfo;
            // Sentinel = 'aLoadingInfo'
            if ((!((aReader)->ReadSentinel(500827308)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LoadingSessionHistoryInfo?'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendGetLoadingSessionHistoryInfoFromParent(const MaybeDiscardedBrowsingContext& aContext) -> RefPtr<GetLoadingSessionHistoryInfoFromParentPromise>
{
    RefPtr<MozPromise<mozilla::Maybe<LoadingSessionHistoryInfo>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<LoadingSessionHistoryInfo>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetLoadingSessionHistoryInfoFromParent(std::move(aContext), [promise__](mozilla::Maybe<LoadingSessionHistoryInfo>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendSynchronizeNavigationAPIState(
        const MaybeDiscardedBrowsingContext& aContext,
        const ClonedMessageData& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SynchronizeNavigationAPIState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRemoveFromBFCache(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveFromBFCache(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendInitBackground(Endpoint<::mozilla::ipc::PBackgroundStarterParent>&& aEndpoint) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitBackground(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendCreateGMPService() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateGMPService(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentChild::SendCreateClipboardContentAnalysis(Endpoint<::mozilla::PClipboardContentAnalysisParent>&& aParentEndpoint) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateClipboardContentAnalysis(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendInitStreamFilter(
        const uint64_t& channelId,
        const nsAString& addonId,
        mozilla::ipc::ResolveCallback<Endpoint<::mozilla::extensions::PStreamFilterChild>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitStreamFilter(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), channelId);
    // Sentinel = 'channelId'
    ((&(writer__)))->WriteSentinel(301138823);
    IPC::WriteParam((&(writer__)), addonId);
    // Sentinel = 'addonId'
    ((&(writer__)))->WriteSentinel(183894708);


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

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_InitStreamFilter__ID, [resolve=std::move(aResolve)](IPC::MessageReader* aReader) mutable {
            auto maybe__aEndpoint = IPC::ReadParam<Endpoint<::mozilla::extensions::PStreamFilterChild>>(aReader);
            if (!maybe__aEndpoint) {
                (aReader)->FatalError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterChild>'");
                return MsgValueError;

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!((aReader)->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterChild>'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendInitStreamFilter(
        const uint64_t& channelId,
        const nsAString& addonId) -> RefPtr<InitStreamFilterPromise>
{
    RefPtr<MozPromise<Endpoint<::mozilla::extensions::PStreamFilterChild>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<Endpoint<::mozilla::extensions::PStreamFilterChild>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendInitStreamFilter(std::move(channelId), std::move(addonId), [promise__](Endpoint<::mozilla::extensions::PStreamFilterChild>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendPRemoteSpellcheckEngineConstructor() -> PRemoteSpellcheckEngineChild*
{
    PRemoteSpellcheckEngineChild* actor = (static_cast<ContentChild*>(this))->AllocPRemoteSpellcheckEngineChild();
    return SendPRemoteSpellcheckEngineConstructor(std::move(actor));
}

auto PContentChild::SendPRemoteSpellcheckEngineConstructor(PRemoteSpellcheckEngineChild* actor) -> PRemoteSpellcheckEngineChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PRemoteSpellcheckEngineChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PRemoteSpellcheckEngineConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PRemoteSpellcheckEngineConstructor", 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 PRemoteSpellcheckEngineChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendInitCrashReporter(const CrashReporterInitArgs& aInitArgs) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitCrashReporter(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendIsSecureURI(
        nsIURI* aURI,
        const OriginAttributes& aOriginAttributes,
        bool* isSecureURI) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_IsSecureURI(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aURI);
    // Sentinel = 'aURI'
    ((&(writer__)))->WriteSentinel(57934162);
    IPC::WriteParam((&(writer__)), aOriginAttributes);
    // Sentinel = 'aOriginAttributes'
    ((&(writer__)))->WriteSentinel(1021839089);

    UniquePtr<Message> reply__;

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

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

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

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

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

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

    return true;
}

auto PContentChild::SendAccumulateMixedContentHSTS(
        nsIURI* aURI,
        const bool& aActive,
        const OriginAttributes& aOriginAttributes) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AccumulateMixedContentHSTS(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aURI);
    // Sentinel = 'aURI'
    ((&(writer__)))->WriteSentinel(57934162);
    IPC::WriteParam((&(writer__)), aActive);
    // Sentinel = 'aActive'
    ((&(writer__)))->WriteSentinel(176095934);
    IPC::WriteParam((&(writer__)), aOriginAttributes);
    // Sentinel = 'aOriginAttributes'
    ((&(writer__)))->WriteSentinel(1021839089);


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

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

auto PContentChild::SendPHalConstructor() -> PHalChild*
{
    PHalChild* actor = (static_cast<ContentChild*>(this))->AllocPHalChild();
    return SendPHalConstructor(std::move(actor));
}

auto PContentChild::SendPHalConstructor(PHalChild* actor) -> PHalChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PHalChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PHalConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PHalConstructor", 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 PHalChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPHeapSnapshotTempFileHelperConstructor() -> PHeapSnapshotTempFileHelperChild*
{
    PHeapSnapshotTempFileHelperChild* actor = (static_cast<ContentChild*>(this))->AllocPHeapSnapshotTempFileHelperChild();
    return SendPHeapSnapshotTempFileHelperConstructor(std::move(actor));
}

auto PContentChild::SendPHeapSnapshotTempFileHelperConstructor(PHeapSnapshotTempFileHelperChild* actor) -> PHeapSnapshotTempFileHelperChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PHeapSnapshotTempFileHelperChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PHeapSnapshotTempFileHelperConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PHeapSnapshotTempFileHelperConstructor", 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 PHeapSnapshotTempFileHelperChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPNeckoConstructor(PNeckoChild* actor) -> PNeckoChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PNeckoChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PNeckoConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PNeckoConstructor", 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 PNeckoChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPSpeechSynthesisConstructor(PSpeechSynthesisChild* actor) -> PSpeechSynthesisChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PSpeechSynthesisChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PSpeechSynthesisConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PSpeechSynthesisConstructor", 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 PSpeechSynthesisChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPMediaConstructor() -> PMediaChild*
{
    PMediaChild* actor = (static_cast<ContentChild*>(this))->AllocPMediaChild();
    return SendPMediaConstructor(std::move(actor));
}

auto PContentChild::SendPMediaConstructor(PMediaChild* actor) -> PMediaChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PMediaChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PMediaConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PMediaConstructor", 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 PMediaChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendCreateAudioIPCConnection(
        mozilla::ipc::ResolveCallback<FileDescOrError>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateAudioIPCConnection(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

            }
            auto& fd = *maybe__fd;
            // Sentinel = 'fd'
            if ((!((aReader)->ReadSentinel(20054219)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendCreateAudioIPCConnection() -> RefPtr<CreateAudioIPCConnectionPromise>
{
    RefPtr<MozPromise<FileDescOrError, ResponseRejectReason, true>::Private> promise__ = new MozPromise<FileDescOrError, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendCreateAudioIPCConnection([promise__](FileDescOrError&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendPURLClassifierConstructor(
        nsIPrincipal* principal,
        bool* success) -> PURLClassifierChild*
{
    PURLClassifierChild* actor = (static_cast<ContentChild*>(this))->AllocPURLClassifierChild(principal, success);
    return SendPURLClassifierConstructor(std::move(actor), principal, success);
}

auto PContentChild::SendPURLClassifierConstructor(
        PURLClassifierChild* actor,
        nsIPrincipal* principal,
        bool* success) -> PURLClassifierChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PURLClassifierChild actor");
        return nullptr;
    }

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


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

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


    // Synchronously send the constructor message to the other side. If
    // the send fails, e.g. due to the remote side shutting down, the
    // actor will be destroyed and potentially freed.
    UniquePtr<Message> reply__;

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

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PContent::Msg_PURLClassifierConstructor", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }


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

        return nullptr;
    }


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

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

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

    }
    auto& success__reply = *maybe__success__reply;
    // Sentinel = 'success'
    if ((!(((&(reader__)))->ReadSentinel(200082170)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
        return nullptr;
    }
    (*(success)) = std::move(success__reply);
    reader__.EndRead();

    return actor;
}

auto PContentChild::SendPURLClassifierLocalConstructor(
        nsIURI* uri,
        mozilla::Span<IPCURLClassifierFeature const> features) -> PURLClassifierLocalChild*
{
    PURLClassifierLocalChild* actor = (static_cast<ContentChild*>(this))->AllocPURLClassifierLocalChild(uri, features);
    return SendPURLClassifierLocalConstructor(std::move(actor), uri, std::move(features));
}

auto PContentChild::SendPURLClassifierLocalConstructor(
        PURLClassifierLocalChild* actor,
        nsIURI* uri,
        mozilla::Span<IPCURLClassifierFeature const> features) -> PURLClassifierLocalChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PURLClassifierLocalChild actor");
        return nullptr;
    }

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


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

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


    // 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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalConstructor", 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 PURLClassifierLocalChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPURLClassifierLocalByNameConstructor(
        nsIURI* uri,
        mozilla::Span<nsCString const> featureNames,
        const listType& aListType) -> PURLClassifierLocalByNameChild*
{
    PURLClassifierLocalByNameChild* actor = (static_cast<ContentChild*>(this))->AllocPURLClassifierLocalByNameChild(uri, featureNames, aListType);
    return SendPURLClassifierLocalByNameConstructor(std::move(actor), uri, std::move(featureNames), std::move(aListType));
}

auto PContentChild::SendPURLClassifierLocalByNameConstructor(
        PURLClassifierLocalByNameChild* actor,
        nsIURI* uri,
        mozilla::Span<nsCString const> featureNames,
        const listType& aListType) -> PURLClassifierLocalByNameChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PURLClassifierLocalByNameChild actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), uri);
    // Sentinel = 'uri'
    ((&(writer__)))->WriteSentinel(45023569);
    IPC::WriteParam((&(writer__)), featureNames);
    // Sentinel = 'featureNames'
    ((&(writer__)))->WriteSentinel(532350177);
    IPC::WriteParam((&(writer__)), aListType);
    // Sentinel = 'aListType'
    ((&(writer__)))->WriteSentinel(296158112);


    // 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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalByNameConstructor", 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 PURLClassifierLocalByNameChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPSessionStorageObserverConstructor() -> PSessionStorageObserverChild*
{
    PSessionStorageObserverChild* actor = (static_cast<ContentChild*>(this))->AllocPSessionStorageObserverChild();
    return SendPSessionStorageObserverConstructor(std::move(actor));
}

auto PContentChild::SendPSessionStorageObserverConstructor(PSessionStorageObserverChild* actor) -> PSessionStorageObserverChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PSessionStorageObserverChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PSessionStorageObserverConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PSessionStorageObserverConstructor", 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 PSessionStorageObserverChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendStartVisitedQueries(mozilla::Span<RefPtr<nsIURI> const> uri) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_StartVisitedQueries(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSetURITitle(
        nsIURI* uri,
        const nsAString& title) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetURITitle(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), uri);
    // Sentinel = 'uri'
    ((&(writer__)))->WriteSentinel(45023569);
    IPC::WriteParam((&(writer__)), title);
    // Sentinel = 'title'
    ((&(writer__)))->WriteSentinel(109445667);


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

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

auto PContentChild::SendLoadURIExternal(
        nsIURI* uri,
        nsIPrincipal* triggeringPrincipal,
        nsIPrincipal* redirectPrincipal,
        const MaybeDiscardedBrowsingContext& browsingContext,
        const bool& wasExternallyTriggered,
        const bool& hasValidUserGestureActivation,
        const bool& newWindowTarget) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadURIExternal(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), uri);
    // Sentinel = 'uri'
    ((&(writer__)))->WriteSentinel(45023569);
    IPC::WriteParam((&(writer__)), triggeringPrincipal);
    // Sentinel = 'triggeringPrincipal'
    ((&(writer__)))->WriteSentinel(1325729749);
    IPC::WriteParam((&(writer__)), redirectPrincipal);
    // Sentinel = 'redirectPrincipal'
    ((&(writer__)))->WriteSentinel(1052772085);
    IPC::WriteParam((&(writer__)), browsingContext);
    // Sentinel = 'browsingContext'
    ((&(writer__)))->WriteSentinel(844695121);
    IPC::WriteParam((&(writer__)), wasExternallyTriggered);
    // Sentinel = 'wasExternallyTriggered'
    ((&(writer__)))->WriteSentinel(1758005521);
    IPC::WriteParam((&(writer__)), hasValidUserGestureActivation);
    // Sentinel = 'hasValidUserGestureActivation'
    ((&(writer__)))->WriteSentinel(2914388925);
    IPC::WriteParam((&(writer__)), newWindowTarget);
    // Sentinel = 'newWindowTarget'
    ((&(writer__)))->WriteSentinel(826934826);


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

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

auto PContentChild::SendExtProtocolChannelConnectParent(const uint64_t& registrarId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ExtProtocolChannelConnectParent(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSyncMessage(
        const nsAString& aMessage,
        const ClonedMessageData& aData,
        nsTArray<UniquePtr<StructuredCloneData>>* retval) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SyncMessage(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SyncMessage", OTHER);

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

    if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            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 PContentChild::SendAddSecurityState(
        const MaybeDiscardedWindowContext& aContext,
        const uint32_t& aStateFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddSecurityState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aStateFlags);
    // Sentinel = 'aStateFlags'
    ((&(writer__)))->WriteSentinel(428606544);


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

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

auto PContentChild::SendPExternalHelperAppConstructor(
        PExternalHelperAppChild* actor,
        nsIURI* uri,
        const LoadInfoArgs& loadInfoArgs,
        const nsACString& aMimeContentType,
        const nsACString& aContentDisposition,
        const uint32_t& aContentDispositionHint,
        const nsAString& aContentDispositionFilename,
        const bool& aForceSave,
        const int64_t& aContentLength,
        const bool& aWasFileChannel,
        nsIURI* aReferrer,
        const MaybeDiscardedBrowsingContext& aContext) -> PExternalHelperAppChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PExternalHelperAppChild actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), uri);
    // Sentinel = 'uri'
    ((&(writer__)))->WriteSentinel(45023569);
    IPC::WriteParam((&(writer__)), loadInfoArgs);
    // Sentinel = 'loadInfoArgs'
    ((&(writer__)))->WriteSentinel(514000058);
    IPC::WriteParam((&(writer__)), aMimeContentType);
    // Sentinel = 'aMimeContentType'
    ((&(writer__)))->WriteSentinel(888538727);
    IPC::WriteParam((&(writer__)), aContentDisposition);
    // Sentinel = 'aContentDisposition'
    ((&(writer__)))->WriteSentinel(1279461330);
    IPC::WriteParam((&(writer__)), aContentDispositionHint);
    // Sentinel = 'aContentDispositionHint'
    ((&(writer__)))->WriteSentinel(1865812325);
    IPC::WriteParam((&(writer__)), aContentDispositionFilename);
    // Sentinel = 'aContentDispositionFilename'
    ((&(writer__)))->WriteSentinel(2558331635);
    IPC::WriteParam((&(writer__)), aForceSave);
    // Sentinel = 'aForceSave'
    ((&(writer__)))->WriteSentinel(350946272);
    IPC::WriteParam((&(writer__)), aContentLength);
    // Sentinel = 'aContentLength'
    ((&(writer__)))->WriteSentinel(694158751);
    IPC::WriteParam((&(writer__)), aWasFileChannel);
    // Sentinel = 'aWasFileChannel'
    ((&(writer__)))->WriteSentinel(759367110);
    IPC::WriteParam((&(writer__)), aReferrer);
    // Sentinel = 'aReferrer'
    ((&(writer__)))->WriteSentinel(293340063);
    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);


    // 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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PExternalHelperAppConstructor", 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 PExternalHelperAppChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendPHandlerServiceConstructor(PHandlerServiceChild* actor) -> PHandlerServiceChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PHandlerServiceChild actor");
        return nullptr;
    }

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


    // Build our constructor message.
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PHandlerServiceConstructor(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PHandlerServiceConstructor", 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 PHandlerServiceChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendAddGeolocationListener(const bool& highAccuracy) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddGeolocationListener(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRemoveGeolocationListener() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveGeolocationListener(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentChild::SendSetGeolocationHigherAccuracy(const bool& enable) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetGeolocationHigherAccuracy(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendConsoleMessage(const nsAString& message) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ConsoleMessage(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendScriptErrorWithStack(
        const nsAString& message,
        const nsACString& sourceName,
        const uint32_t& lineNumber,
        const uint32_t& colNumber,
        const uint32_t& flags,
        const nsACString& category,
        const bool& isFromPrivateWindow,
        const bool& isFromChromeContext,
        const ClonedMessageData& stack) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ScriptErrorWithStack(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), message);
    // Sentinel = 'message'
    ((&(writer__)))->WriteSentinel(197198566);
    IPC::WriteParam((&(writer__)), sourceName);
    // Sentinel = 'sourceName'
    ((&(writer__)))->WriteSentinel(387580947);
    IPC::WriteParam((&(writer__)), lineNumber);
    // Sentinel = 'lineNumber'
    ((&(writer__)))->WriteSentinel(374932498);
    IPC::WriteParam((&(writer__)), colNumber);
    // Sentinel = 'colNumber'
    ((&(writer__)))->WriteSentinel(304284584);
    IPC::WriteParam((&(writer__)), flags);
    // Sentinel = 'flags'
    ((&(writer__)))->WriteSentinel(102171150);
    IPC::WriteParam((&(writer__)), category);
    // Sentinel = 'category'
    ((&(writer__)))->WriteSentinel(247333727);
    IPC::WriteParam((&(writer__)), isFromPrivateWindow);
    // Sentinel = 'isFromPrivateWindow'
    ((&(writer__)))->WriteSentinel(1288964036);
    IPC::WriteParam((&(writer__)), isFromChromeContext);
    // Sentinel = 'isFromChromeContext'
    ((&(writer__)))->WriteSentinel(1269368756);
    IPC::WriteParam((&(writer__)), stack);
    // Sentinel = 'stack'
    ((&(writer__)))->WriteSentinel(107479575);


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

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

auto PContentChild::SendSetClipboard(
        IPCTransferable&& aTransferable,
        const ClipboardType& aWhichClipboard,
        const MaybeDiscardedWindowContext& aRequestingWindowContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetClipboard(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendGetClipboard(
        mozilla::Span<nsCString const> aTypes,
        const ClipboardType& aWhichClipboard,
        const MaybeDiscardedWindowContext& aRequestingWindowContext,
        IPCTransferableDataOrError* transferableDataOrError) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetClipboard(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTypes);
    // Sentinel = 'aTypes'
    ((&(writer__)))->WriteSentinel(140575351);
    IPC::WriteParam((&(writer__)), aWhichClipboard);
    // Sentinel = 'aWhichClipboard'
    ((&(writer__)))->WriteSentinel(776996325);
    IPC::WriteParam((&(writer__)), aRequestingWindowContext);
    // Sentinel = 'aRequestingWindowContext'
    ((&(writer__)))->WriteSentinel(2049051110);

    UniquePtr<Message> reply__;

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

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

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

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

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

    }
    auto& transferableDataOrError__reply = *maybe__transferableDataOrError__reply;
    // Sentinel = 'transferableDataOrError'
    if ((!(((&(reader__)))->ReadSentinel(1880557887)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferableDataOrError'");
        return false;
    }
    (*(transferableDataOrError)) = std::move(transferableDataOrError__reply);
    reader__.EndRead();

    return true;
}

auto PContentChild::SendGetClipboardDataSnapshot(
        mozilla::Span<nsCString const> aTypes,
        const ClipboardType& aWhichClipboard,
        const MaybeDiscardedWindowContext& aRequestingWindowContext,
        mozilla::NotNull<nsIPrincipal*> aRequestingPrincipal,
        mozilla::ipc::ResolveCallback<ClipboardReadRequestOrError>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetClipboardDataSnapshot(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTypes);
    // Sentinel = 'aTypes'
    ((&(writer__)))->WriteSentinel(140575351);
    IPC::WriteParam((&(writer__)), aWhichClipboard);
    // Sentinel = 'aWhichClipboard'
    ((&(writer__)))->WriteSentinel(776996325);
    IPC::WriteParam((&(writer__)), aRequestingWindowContext);
    // Sentinel = 'aRequestingWindowContext'
    ((&(writer__)))->WriteSentinel(2049051110);
    IPC::WriteParam((&(writer__)), aRequestingPrincipal);
    // Sentinel = 'aRequestingPrincipal'
    ((&(writer__)))->WriteSentinel(1431439403);


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

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

            }
            auto& aClipboardReadRequestOrError = *maybe__aClipboardReadRequestOrError;
            // Sentinel = 'aClipboardReadRequestOrError'
            if ((!((aReader)->ReadSentinel(2662402850)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardReadRequestOrError'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendGetClipboardDataSnapshot(
        mozilla::Span<nsCString const> aTypes,
        const ClipboardType& aWhichClipboard,
        const MaybeDiscardedWindowContext& aRequestingWindowContext,
        mozilla::NotNull<nsIPrincipal*> aRequestingPrincipal) -> RefPtr<GetClipboardDataSnapshotPromise>
{
    RefPtr<MozPromise<ClipboardReadRequestOrError, ResponseRejectReason, true>::Private> promise__ = new MozPromise<ClipboardReadRequestOrError, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetClipboardDataSnapshot(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), std::move(aRequestingPrincipal), [promise__](ClipboardReadRequestOrError&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendGetClipboardDataSnapshotSync(
        mozilla::Span<nsCString const> aTypes,
        const ClipboardType& aWhichClipboard,
        const MaybeDiscardedWindowContext& aRequestingWindowContext,
        ClipboardReadRequestOrError* aClipboardReadRequestOrError) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetClipboardDataSnapshotSync(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTypes);
    // Sentinel = 'aTypes'
    ((&(writer__)))->WriteSentinel(140575351);
    IPC::WriteParam((&(writer__)), aWhichClipboard);
    // Sentinel = 'aWhichClipboard'
    ((&(writer__)))->WriteSentinel(776996325);
    IPC::WriteParam((&(writer__)), aRequestingWindowContext);
    // Sentinel = 'aRequestingWindowContext'
    ((&(writer__)))->WriteSentinel(2049051110);

    UniquePtr<Message> reply__;

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

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

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

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

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

    }
    auto& aClipboardReadRequestOrError__reply = *maybe__aClipboardReadRequestOrError__reply;
    // Sentinel = 'aClipboardReadRequestOrError'
    if ((!(((&(reader__)))->ReadSentinel(2662402850)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardReadRequestOrError'");
        return false;
    }
    (*(aClipboardReadRequestOrError)) = std::move(aClipboardReadRequestOrError__reply);
    reader__.EndRead();

    return true;
}

auto PContentChild::SendEmptyClipboard(const ClipboardType& aWhichClipboard) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_EmptyClipboard(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendClipboardHasType(
        mozilla::Span<nsCString const> aTypes,
        const ClipboardType& aWhichClipboard,
        bool* hasType) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ClipboardHasType(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTypes);
    // Sentinel = 'aTypes'
    ((&(writer__)))->WriteSentinel(140575351);
    IPC::WriteParam((&(writer__)), aWhichClipboard);
    // Sentinel = 'aWhichClipboard'
    ((&(writer__)))->WriteSentinel(776996325);

    UniquePtr<Message> reply__;

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

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

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

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

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

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

    return true;
}

auto PContentChild::SendPClipboardWriteRequestConstructor(
        PClipboardWriteRequestChild* actor,
        const ClipboardType& aClipboardType,
        const MaybeDiscardedWindowContext& aSettingWindowContext) -> PClipboardWriteRequestChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PClipboardWriteRequestChild actor");
        return nullptr;
    }

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


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

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


    // 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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PClipboardWriteRequestConstructor", 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 PClipboardWriteRequestChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendGetIconForExtension(
        const nsACString& aFileExt,
        const uint32_t& aIconSize,
        nsTArray<uint8_t>* bits) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetIconForExtension(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFileExt);
    // Sentinel = 'aFileExt'
    ((&(writer__)))->WriteSentinel(223544083);
    IPC::WriteParam((&(writer__)), aIconSize);
    // Sentinel = 'aIconSize'
    ((&(writer__)))->WriteSentinel(286196614);

    UniquePtr<Message> reply__;

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

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

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

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

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

    }
    auto& bits__reply = *maybe__bits__reply;
    // Sentinel = 'bits'
    if ((!(((&(reader__)))->ReadSentinel(69337523)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
        return false;
    }
    (*(bits)) = std::move(bits__reply);
    reader__.EndRead();

    return true;
}

auto PContentChild::SendFirstIdle() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FirstIdle(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentChild::SendCopyFavicon(
        nsIURI* oldURI,
        nsIURI* newURI,
        const bool& isPrivate) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CopyFavicon(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), oldURI);
    // Sentinel = 'oldURI'
    ((&(writer__)))->WriteSentinel(137888304);
    IPC::WriteParam((&(writer__)), newURI);
    // Sentinel = 'newURI'
    ((&(writer__)))->WriteSentinel(140182075);
    IPC::WriteParam((&(writer__)), isPrivate);
    // Sentinel = 'isPrivate'
    ((&(writer__)))->WriteSentinel(310576056);


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

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

auto PContentChild::SendFindImageText(
        IPCImage&& image,
        mozilla::Span<nsCString const> languages,
        mozilla::ipc::ResolveCallback<TextRecognitionResultOrError>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FindImageText(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(image));
    // Sentinel = 'image'
    ((&(writer__)))->WriteSentinel(102498820);
    IPC::WriteParam((&(writer__)), languages);
    // Sentinel = 'languages'
    ((&(writer__)))->WriteSentinel(310903736);


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

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

            }
            auto& result = *maybe__result;
            // Sentinel = 'result'
            if ((!((aReader)->ReadSentinel(153223840)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TextRecognitionResultOrError'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendFindImageText(
        IPCImage&& image,
        mozilla::Span<nsCString const> languages) -> RefPtr<FindImageTextPromise>
{
    RefPtr<MozPromise<TextRecognitionResultOrError, ResponseRejectReason, true>::Private> promise__ = new MozPromise<TextRecognitionResultOrError, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendFindImageText(std::move(image), std::move(languages), [promise__](TextRecognitionResultOrError&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendGraphicsError(const nsACString& aError) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GraphicsError(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendBeginDriverCrashGuard(
        const uint32_t& aGuardType,
        bool* crashDetected) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BeginDriverCrashGuard(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

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

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

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

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

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

    return true;
}

auto PContentChild::SendEndDriverCrashGuard(const uint32_t& aGuardType) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_EndDriverCrashGuard(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

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

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

    return true;
}

auto PContentChild::SendAddIdleObserver(
        const uint64_t& observerId,
        const uint32_t& idleTimeInS) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddIdleObserver(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), observerId);
    // Sentinel = 'observerId'
    ((&(writer__)))->WriteSentinel(386335766);
    IPC::WriteParam((&(writer__)), idleTimeInS);
    // Sentinel = 'idleTimeInS'
    ((&(writer__)))->WriteSentinel(434832440);


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

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

auto PContentChild::SendRemoveIdleObserver(
        const uint64_t& observerId,
        const uint32_t& idleTimeInS) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveIdleObserver(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), observerId);
    // Sentinel = 'observerId'
    ((&(writer__)))->WriteSentinel(386335766);
    IPC::WriteParam((&(writer__)), idleTimeInS);
    // Sentinel = 'idleTimeInS'
    ((&(writer__)))->WriteSentinel(434832440);


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

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

auto PContentChild::SendBackUpXResources(const FileDescriptor& aXSocketFd) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BackUpXResources(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRequestAnonymousTemporaryFile(const uint64_t& aID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RequestAnonymousTemporaryFile(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendNotifyShutdownSuccess() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyShutdownSuccess(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentChild::SendFinishShutdown() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FinishShutdown(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentChild::SendPContentPermissionRequestConstructor(
        mozilla::Span<PermissionRequest const> aRequests,
        nsIPrincipal* aPrincipal,
        nsIPrincipal* aTopLevelPrincipal,
        const bool& aIsHandlingUserInput,
        const bool& aMaybeUnsafePermissionDelegate,
        const TabId& tabId) -> PContentPermissionRequestChild*
{
    PContentPermissionRequestChild* actor = (static_cast<ContentChild*>(this))->AllocPContentPermissionRequestChild(aRequests, aPrincipal, aTopLevelPrincipal, aIsHandlingUserInput, aMaybeUnsafePermissionDelegate, tabId);
    return SendPContentPermissionRequestConstructor(std::move(actor), std::move(aRequests), aPrincipal, aTopLevelPrincipal, std::move(aIsHandlingUserInput), std::move(aMaybeUnsafePermissionDelegate), std::move(tabId));
}

auto PContentChild::SendPContentPermissionRequestConstructor(
        PContentPermissionRequestChild* actor,
        mozilla::Span<PermissionRequest const> aRequests,
        nsIPrincipal* aPrincipal,
        nsIPrincipal* aTopLevelPrincipal,
        const bool& aIsHandlingUserInput,
        const bool& aMaybeUnsafePermissionDelegate,
        const TabId& tabId) -> PContentPermissionRequestChild*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PContentPermissionRequestChild actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), aRequests);
    // Sentinel = 'aRequests'
    ((&(writer__)))->WriteSentinel(301728702);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), aTopLevelPrincipal);
    // Sentinel = 'aTopLevelPrincipal'
    ((&(writer__)))->WriteSentinel(1128007471);
    IPC::WriteParam((&(writer__)), aIsHandlingUserInput);
    // Sentinel = 'aIsHandlingUserInput'
    ((&(writer__)))->WriteSentinel(1357514738);
    IPC::WriteParam((&(writer__)), aMaybeUnsafePermissionDelegate);
    // Sentinel = 'aMaybeUnsafePermissionDelegate'
    ((&(writer__)))->WriteSentinel(3078949878);
    IPC::WriteParam((&(writer__)), tabId);
    // Sentinel = 'tabId'
    ((&(writer__)))->WriteSentinel(99156453);


    // 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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PContentPermissionRequestConstructor", 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 PContentPermissionRequestChild constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentChild::SendShutdownProfile(const nsACString& aProfile) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownProfile(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendShutdownPerfStats(const nsACString& aPerfStats) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownPerfStats(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendGetFontListShmBlock(
        const uint32_t& aGeneration,
        const uint32_t& aIndex,
        ReadOnlySharedMemoryHandle* aHandle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetFontListShmBlock(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGeneration);
    // Sentinel = 'aGeneration'
    ((&(writer__)))->WriteSentinel(430179438);
    IPC::WriteParam((&(writer__)), aIndex);
    // Sentinel = 'aIndex'
    ((&(writer__)))->WriteSentinel(132055642);

    UniquePtr<Message> reply__;

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

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

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

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

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

    }
    auto& aHandle__reply = *maybe__aHandle__reply;
    // Sentinel = 'aHandle'
    if ((!(((&(reader__)))->ReadSentinel(174326446)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'");
        return false;
    }
    (*(aHandle)) = std::move(aHandle__reply);
    reader__.EndRead();

    return true;
}

auto PContentChild::SendInitializeFamily(
        const uint32_t& aGeneration,
        const uint32_t& aFamilyIndex,
        const bool& aLoadCmaps) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitializeFamily(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGeneration);
    // Sentinel = 'aGeneration'
    ((&(writer__)))->WriteSentinel(430179438);
    IPC::WriteParam((&(writer__)), aFamilyIndex);
    // Sentinel = 'aFamilyIndex'
    ((&(writer__)))->WriteSentinel(501089468);
    IPC::WriteParam((&(writer__)), aLoadCmaps);
    // Sentinel = 'aLoadCmaps'
    ((&(writer__)))->WriteSentinel(342885334);

    UniquePtr<Message> reply__;

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

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

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

    return true;
}

auto PContentChild::SendSetCharacterMap(
        const uint32_t& aGeneration,
        const uint32_t& aFamilyIndex,
        const bool& aAlias,
        const uint32_t& aFaceIndex,
        const gfxSparseBitSet& aMap) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetCharacterMap(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGeneration);
    // Sentinel = 'aGeneration'
    ((&(writer__)))->WriteSentinel(430179438);
    IPC::WriteParam((&(writer__)), aFamilyIndex);
    // Sentinel = 'aFamilyIndex'
    ((&(writer__)))->WriteSentinel(501089468);
    IPC::WriteParam((&(writer__)), aAlias);
    // Sentinel = 'aAlias'
    ((&(writer__)))->WriteSentinel(129040972);
    IPC::WriteParam((&(writer__)), aFaceIndex);
    // Sentinel = 'aFaceIndex'
    ((&(writer__)))->WriteSentinel(335021001);
    IPC::WriteParam((&(writer__)), aMap);
    // Sentinel = 'aMap'
    ((&(writer__)))->WriteSentinel(60883328);


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

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

auto PContentChild::SendSetupFamilyCharMap(
        const uint32_t& aGeneration,
        const uint32_t& aFamilyIndex,
        const bool& aAlias) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetupFamilyCharMap(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGeneration);
    // Sentinel = 'aGeneration'
    ((&(writer__)))->WriteSentinel(430179438);
    IPC::WriteParam((&(writer__)), aFamilyIndex);
    // Sentinel = 'aFamilyIndex'
    ((&(writer__)))->WriteSentinel(501089468);
    IPC::WriteParam((&(writer__)), aAlias);
    // Sentinel = 'aAlias'
    ((&(writer__)))->WriteSentinel(129040972);


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

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

auto PContentChild::SendInitOtherFamilyNames(
        const uint32_t& aGeneration,
        const bool& aDefer,
        bool* aLoaded) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitOtherFamilyNames(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGeneration);
    // Sentinel = 'aGeneration'
    ((&(writer__)))->WriteSentinel(430179438);
    IPC::WriteParam((&(writer__)), aDefer);
    // Sentinel = 'aDefer'
    ((&(writer__)))->WriteSentinel(128057928);

    UniquePtr<Message> reply__;

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

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

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

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

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

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

    return true;
}

auto PContentChild::SendStartCmapLoading(
        const uint32_t& aGeneration,
        const uint32_t& aStartIndex) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_StartCmapLoading(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGeneration);
    // Sentinel = 'aGeneration'
    ((&(writer__)))->WriteSentinel(430179438);
    IPC::WriteParam((&(writer__)), aStartIndex);
    // Sentinel = 'aStartIndex'
    ((&(writer__)))->WriteSentinel(435749992);


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

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

auto PContentChild::SendGetHyphDict(
        nsIURI* aURI,
        ReadOnlySharedMemoryHandle* aHandle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetHyphDict(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

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

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

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

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

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

    }
    auto& aHandle__reply = *maybe__aHandle__reply;
    // Sentinel = 'aHandle'
    if ((!(((&(reader__)))->ReadSentinel(174326446)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'");
        return false;
    }
    (*(aHandle)) = std::move(aHandle__reply);
    reader__.EndRead();

    return true;
}

auto PContentChild::SendCreateWindow(
        mozilla::NotNull<PBrowserChild*> aThisTab,
        const MaybeDiscardedBrowsingContext& aParent,
        mozilla::NotNull<PBrowserChild*> aNewTab,
        const uint32_t& aChromeFlags,
        const bool& aCalledFromJS,
        const bool& aForPrinting,
        const bool& aForWindowDotPrint,
        const bool& aTopLevelCreatedByContent,
        nsIURI* aURIToLoad,
        const nsACString& aFeatures,
        const Modifiers& aModifiers,
        nsIPrincipal* aTriggeringPrincipal,
        nsIPolicyContainer* aPolicyContainer,
        nsIReferrerInfo* aReferrerInfo,
        const OriginAttributes& aOriginAttributes,
        const bool& aUserActivation,
        const bool& aTextDirectiveUserActivation,
        mozilla::ipc::ResolveCallback<CreatedWindowInfo>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateWindow(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aThisTab);
    // Sentinel = 'aThisTab'
    ((&(writer__)))->WriteSentinel(231015185);
    IPC::WriteParam((&(writer__)), aParent);
    // Sentinel = 'aParent'
    ((&(writer__)))->WriteSentinel(179962572);
    IPC::WriteParam((&(writer__)), aNewTab);
    // Sentinel = 'aNewTab'
    ((&(writer__)))->WriteSentinel(175571619);
    IPC::WriteParam((&(writer__)), aChromeFlags);
    // Sentinel = 'aChromeFlags'
    ((&(writer__)))->WriteSentinel(500040877);
    IPC::WriteParam((&(writer__)), aCalledFromJS);
    // Sentinel = 'aCalledFromJS'
    ((&(writer__)))->WriteSentinel(569967832);
    IPC::WriteParam((&(writer__)), aForPrinting);
    // Sentinel = 'aForPrinting'
    ((&(writer__)))->WriteSentinel(511313108);
    IPC::WriteParam((&(writer__)), aForWindowDotPrint);
    // Sentinel = 'aForWindowDotPrint'
    ((&(writer__)))->WriteSentinel(1123813173);
    IPC::WriteParam((&(writer__)), aTopLevelCreatedByContent);
    // Sentinel = 'aTopLevelCreatedByContent'
    ((&(writer__)))->WriteSentinel(2117143003);
    IPC::WriteParam((&(writer__)), aURIToLoad);
    // Sentinel = 'aURIToLoad'
    ((&(writer__)))->WriteSentinel(321258389);
    IPC::WriteParam((&(writer__)), aFeatures);
    // Sentinel = 'aFeatures'
    ((&(writer__)))->WriteSentinel(290849697);
    IPC::WriteParam((&(writer__)), aModifiers);
    // Sentinel = 'aModifiers'
    ((&(writer__)))->WriteSentinel(358286340);
    IPC::WriteParam((&(writer__)), aTriggeringPrincipal);
    // Sentinel = 'aTriggeringPrincipal'
    ((&(writer__)))->WriteSentinel(1413089302);
    IPC::WriteParam((&(writer__)), aPolicyContainer);
    // Sentinel = 'aPolicyContainer'
    ((&(writer__)))->WriteSentinel(903939701);
    IPC::WriteParam((&(writer__)), aReferrerInfo);
    // Sentinel = 'aReferrerInfo'
    ((&(writer__)))->WriteSentinel(597755179);
    IPC::WriteParam((&(writer__)), aOriginAttributes);
    // Sentinel = 'aOriginAttributes'
    ((&(writer__)))->WriteSentinel(1021839089);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);
    IPC::WriteParam((&(writer__)), aTextDirectiveUserActivation);
    // Sentinel = 'aTextDirectiveUserActivation'
    ((&(writer__)))->WriteSentinel(2721450839);


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

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

            }
            auto& window = *maybe__window;
            // Sentinel = 'window'
            if ((!((aReader)->ReadSentinel(152437401)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CreatedWindowInfo'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendCreateWindow(
        mozilla::NotNull<PBrowserChild*> aThisTab,
        const MaybeDiscardedBrowsingContext& aParent,
        mozilla::NotNull<PBrowserChild*> aNewTab,
        const uint32_t& aChromeFlags,
        const bool& aCalledFromJS,
        const bool& aForPrinting,
        const bool& aForWindowDotPrint,
        const bool& aTopLevelCreatedByContent,
        nsIURI* aURIToLoad,
        const nsACString& aFeatures,
        const Modifiers& aModifiers,
        nsIPrincipal* aTriggeringPrincipal,
        nsIPolicyContainer* aPolicyContainer,
        nsIReferrerInfo* aReferrerInfo,
        const OriginAttributes& aOriginAttributes,
        const bool& aUserActivation,
        const bool& aTextDirectiveUserActivation) -> RefPtr<CreateWindowPromise>
{
    RefPtr<MozPromise<CreatedWindowInfo, ResponseRejectReason, true>::Private> promise__ = new MozPromise<CreatedWindowInfo, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendCreateWindow(std::move(aThisTab), std::move(aParent), std::move(aNewTab), std::move(aChromeFlags), std::move(aCalledFromJS), std::move(aForPrinting), std::move(aForWindowDotPrint), std::move(aTopLevelCreatedByContent), std::move(aURIToLoad), std::move(aFeatures), std::move(aModifiers), std::move(aTriggeringPrincipal), std::move(aPolicyContainer), std::move(aReferrerInfo), std::move(aOriginAttributes), std::move(aUserActivation), std::move(aTextDirectiveUserActivation), [promise__](CreatedWindowInfo&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendCreateWindowInDifferentProcess(
        mozilla::NotNull<PBrowserChild*> aThisTab,
        const MaybeDiscardedBrowsingContext& aParent,
        const uint32_t& aChromeFlags,
        const bool& aCalledFromJS,
        const bool& aTopLevelCreatedByContent,
        nsIURI* aURIToLoad,
        const nsACString& aFeatures,
        const Modifiers& aModifiers,
        const nsAString& aName,
        nsIPrincipal* aTriggeringPrincipal,
        nsIPolicyContainer* aPolicyContainer,
        nsIReferrerInfo* aReferrerInfo,
        const OriginAttributes& aOriginAttributes,
        const bool& aUserActivation,
        const bool& aTextDirectiveUserActivation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateWindowInDifferentProcess(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aThisTab);
    // Sentinel = 'aThisTab'
    ((&(writer__)))->WriteSentinel(231015185);
    IPC::WriteParam((&(writer__)), aParent);
    // Sentinel = 'aParent'
    ((&(writer__)))->WriteSentinel(179962572);
    IPC::WriteParam((&(writer__)), aChromeFlags);
    // Sentinel = 'aChromeFlags'
    ((&(writer__)))->WriteSentinel(500040877);
    IPC::WriteParam((&(writer__)), aCalledFromJS);
    // Sentinel = 'aCalledFromJS'
    ((&(writer__)))->WriteSentinel(569967832);
    IPC::WriteParam((&(writer__)), aTopLevelCreatedByContent);
    // Sentinel = 'aTopLevelCreatedByContent'
    ((&(writer__)))->WriteSentinel(2117143003);
    IPC::WriteParam((&(writer__)), aURIToLoad);
    // Sentinel = 'aURIToLoad'
    ((&(writer__)))->WriteSentinel(321258389);
    IPC::WriteParam((&(writer__)), aFeatures);
    // Sentinel = 'aFeatures'
    ((&(writer__)))->WriteSentinel(290849697);
    IPC::WriteParam((&(writer__)), aModifiers);
    // Sentinel = 'aModifiers'
    ((&(writer__)))->WriteSentinel(358286340);
    IPC::WriteParam((&(writer__)), aName);
    // Sentinel = 'aName'
    ((&(writer__)))->WriteSentinel(92537315);
    IPC::WriteParam((&(writer__)), aTriggeringPrincipal);
    // Sentinel = 'aTriggeringPrincipal'
    ((&(writer__)))->WriteSentinel(1413089302);
    IPC::WriteParam((&(writer__)), aPolicyContainer);
    // Sentinel = 'aPolicyContainer'
    ((&(writer__)))->WriteSentinel(903939701);
    IPC::WriteParam((&(writer__)), aReferrerInfo);
    // Sentinel = 'aReferrerInfo'
    ((&(writer__)))->WriteSentinel(597755179);
    IPC::WriteParam((&(writer__)), aOriginAttributes);
    // Sentinel = 'aOriginAttributes'
    ((&(writer__)))->WriteSentinel(1021839089);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);
    IPC::WriteParam((&(writer__)), aTextDirectiveUserActivation);
    // Sentinel = 'aTextDirectiveUserActivation'
    ((&(writer__)))->WriteSentinel(2721450839);


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

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

auto PContentChild::SendNotifyPushObservers(
        const nsACString& scope,
        nsIPrincipal* principal,
        const nsAString& messageId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushObservers(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), scope);
    // Sentinel = 'scope'
    ((&(writer__)))->WriteSentinel(107086363);
    IPC::WriteParam((&(writer__)), principal);
    // Sentinel = 'principal'
    ((&(writer__)))->WriteSentinel(319620035);
    IPC::WriteParam((&(writer__)), messageId);
    // Sentinel = 'messageId'
    ((&(writer__)))->WriteSentinel(310576019);


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

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

auto PContentChild::SendNotifyPushObserversWithData(
        const nsACString& scope,
        nsIPrincipal* principal,
        const nsAString& messageId,
        mozilla::Span<uint8_t const> data) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushObserversWithData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), scope);
    // Sentinel = 'scope'
    ((&(writer__)))->WriteSentinel(107086363);
    IPC::WriteParam((&(writer__)), principal);
    // Sentinel = 'principal'
    ((&(writer__)))->WriteSentinel(319620035);
    IPC::WriteParam((&(writer__)), messageId);
    // Sentinel = 'messageId'
    ((&(writer__)))->WriteSentinel(310576019);
    IPC::WriteParam((&(writer__)), data);
    // Sentinel = 'data'
    ((&(writer__)))->WriteSentinel(67109275);


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

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

auto PContentChild::SendGetFilesRequest(
        const nsID& aID,
        mozilla::Span<nsString const> aDirectories,
        const bool& aRecursiveFlag) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetFilesRequest(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aID);
    // Sentinel = 'aID'
    ((&(writer__)))->WriteSentinel(33292527);
    IPC::WriteParam((&(writer__)), aDirectories);
    // Sentinel = 'aDirectories'
    ((&(writer__)))->WriteSentinel(513803487);
    IPC::WriteParam((&(writer__)), aRecursiveFlag);
    // Sentinel = 'aRecursiveFlag'
    ((&(writer__)))->WriteSentinel(701498772);


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

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

auto PContentChild::SendDeleteGetFilesRequest(const nsID& aID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DeleteGetFilesRequest(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendStoreAndBroadcastBlobURLRegistration(
        const nsACString& url,
        const IPCBlob& blob,
        nsIPrincipal* principal,
        const nsACString& aPartitionKey) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_StoreAndBroadcastBlobURLRegistration(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), url);
    // Sentinel = 'url'
    ((&(writer__)))->WriteSentinel(45220180);
    IPC::WriteParam((&(writer__)), blob);
    // Sentinel = 'blob'
    ((&(writer__)))->WriteSentinel(68157856);
    IPC::WriteParam((&(writer__)), principal);
    // Sentinel = 'principal'
    ((&(writer__)))->WriteSentinel(319620035);
    IPC::WriteParam((&(writer__)), aPartitionKey);
    // Sentinel = 'aPartitionKey'
    ((&(writer__)))->WriteSentinel(610141509);


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

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

auto PContentChild::SendUnstoreAndBroadcastBlobURLUnregistration(mozilla::Span<BroadcastBlobURLUnregistrationRequest const> aRequests) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRecordPageLoadEvent(
        const PageloadEventData& event,
        const TimeStamp& navigationStartTime,
        const uint64_t& aAndroidAppLinkLoadIdentifier) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RecordPageLoadEvent(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendAccumulateChildHistograms(mozilla::Span<HistogramAccumulation const> accumulations) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AccumulateChildHistograms(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendAccumulateChildKeyedHistograms(mozilla::Span<KeyedHistogramAccumulation const> accumulations) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AccumulateChildKeyedHistograms(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendUpdateChildScalars(mozilla::Span<ScalarAction const> updates) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateChildScalars(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendUpdateChildKeyedScalars(mozilla::Span<KeyedScalarAction const> updates) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateChildKeyedScalars(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRecordChildEvents(mozilla::Span<ChildEventData const> events) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RecordChildEvents(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRecordDiscardedData(const DiscardedData& data) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RecordDiscardedData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendAddMemoryReport(const MemoryReport& aReport) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddMemoryReport(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendBHRThreadHang(const HangDetails& aHangDetails) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BHRThreadHang(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendAddCertException(
        nsIX509Cert* aCert,
        const nsACString& aHostName,
        const int32_t& aPort,
        const OriginAttributes& aOriginAttributes,
        const bool& aIsTemporary,
        mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddCertException(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aCert);
    // Sentinel = 'aCert'
    ((&(writer__)))->WriteSentinel(92078576);
    IPC::WriteParam((&(writer__)), aHostName);
    // Sentinel = 'aHostName'
    ((&(writer__)))->WriteSentinel(290128769);
    IPC::WriteParam((&(writer__)), aPort);
    // Sentinel = 'aPort'
    ((&(writer__)))->WriteSentinel(97452551);
    IPC::WriteParam((&(writer__)), aOriginAttributes);
    // Sentinel = 'aOriginAttributes'
    ((&(writer__)))->WriteSentinel(1021839089);
    IPC::WriteParam((&(writer__)), aIsTemporary);
    // Sentinel = 'aIsTemporary'
    ((&(writer__)))->WriteSentinel(509805793);


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendAddCertException(
        nsIX509Cert* aCert,
        const nsACString& aHostName,
        const int32_t& aPort,
        const OriginAttributes& aOriginAttributes,
        const bool& aIsTemporary) -> RefPtr<AddCertExceptionPromise>
{
    RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendAddCertException(std::move(aCert), std::move(aHostName), std::move(aPort), std::move(aOriginAttributes), std::move(aIsTemporary), [promise__](nsresult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendAutomaticStorageAccessPermissionCanBeGranted(
        nsIPrincipal* aPrincipal,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendAutomaticStorageAccessPermissionCanBeGranted(nsIPrincipal* aPrincipal) -> RefPtr<AutomaticStorageAccessPermissionCanBeGrantedPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendAutomaticStorageAccessPermissionCanBeGranted(std::move(aPrincipal), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendStorageAccessPermissionGrantedForOrigin(
        const uint64_t& aTopLevelWindowId,
        const MaybeDiscardedBrowsingContext& aParentContext,
        nsIPrincipal* aTrackingPrincipal,
        const nsACString& aTrackingOrigin,
        const int& aAllowMode,
        const mozilla::Maybe<StorageAccessPermissionGrantedReason>& aReason,
        const bool& aFrameOnly,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_StorageAccessPermissionGrantedForOrigin(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTopLevelWindowId);
    // Sentinel = 'aTopLevelWindowId'
    ((&(writer__)))->WriteSentinel(1006700210);
    IPC::WriteParam((&(writer__)), aParentContext);
    // Sentinel = 'aParentContext'
    ((&(writer__)))->WriteSentinel(692454833);
    IPC::WriteParam((&(writer__)), aTrackingPrincipal);
    // Sentinel = 'aTrackingPrincipal'
    ((&(writer__)))->WriteSentinel(1135609655);
    IPC::WriteParam((&(writer__)), aTrackingOrigin);
    // Sentinel = 'aTrackingOrigin'
    ((&(writer__)))->WriteSentinel(792331773);
    IPC::WriteParam((&(writer__)), aAllowMode);
    // Sentinel = 'aAllowMode'
    ((&(writer__)))->WriteSentinel(353108966);
    IPC::WriteParam((&(writer__)), aReason);
    // Sentinel = 'aReason'
    ((&(writer__)))->WriteSentinel(180093642);
    IPC::WriteParam((&(writer__)), aFrameOnly);
    // Sentinel = 'aFrameOnly'
    ((&(writer__)))->WriteSentinel(350159855);


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendStorageAccessPermissionGrantedForOrigin(
        const uint64_t& aTopLevelWindowId,
        const MaybeDiscardedBrowsingContext& aParentContext,
        nsIPrincipal* aTrackingPrincipal,
        const nsACString& aTrackingOrigin,
        const int& aAllowMode,
        const mozilla::Maybe<StorageAccessPermissionGrantedReason>& aReason,
        const bool& aFrameOnly) -> RefPtr<StorageAccessPermissionGrantedForOriginPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendStorageAccessPermissionGrantedForOrigin(std::move(aTopLevelWindowId), std::move(aParentContext), std::move(aTrackingPrincipal), std::move(aTrackingOrigin), std::move(aAllowMode), std::move(aReason), std::move(aFrameOnly), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendCompleteAllowAccessFor(
        const MaybeDiscardedBrowsingContext& aParentContext,
        const uint64_t& aTopLevelWindowId,
        nsIPrincipal* aTrackingPrincipal,
        const nsACString& aTrackingOrigin,
        const uint32_t& aCookieBehavior,
        const StorageAccessPermissionGrantedReason& aReason,
        mozilla::ipc::ResolveCallback<mozilla::Maybe<StorageAccessPromptChoices>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CompleteAllowAccessFor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aParentContext);
    // Sentinel = 'aParentContext'
    ((&(writer__)))->WriteSentinel(692454833);
    IPC::WriteParam((&(writer__)), aTopLevelWindowId);
    // Sentinel = 'aTopLevelWindowId'
    ((&(writer__)))->WriteSentinel(1006700210);
    IPC::WriteParam((&(writer__)), aTrackingPrincipal);
    // Sentinel = 'aTrackingPrincipal'
    ((&(writer__)))->WriteSentinel(1135609655);
    IPC::WriteParam((&(writer__)), aTrackingOrigin);
    // Sentinel = 'aTrackingOrigin'
    ((&(writer__)))->WriteSentinel(792331773);
    IPC::WriteParam((&(writer__)), aCookieBehavior);
    // Sentinel = 'aCookieBehavior'
    ((&(writer__)))->WriteSentinel(772408812);
    IPC::WriteParam((&(writer__)), aReason);
    // Sentinel = 'aReason'
    ((&(writer__)))->WriteSentinel(180093642);


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

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

            }
            auto& choice = *maybe__choice;
            // Sentinel = 'choice'
            if ((!((aReader)->ReadSentinel(142738028)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPromptChoices?'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendCompleteAllowAccessFor(
        const MaybeDiscardedBrowsingContext& aParentContext,
        const uint64_t& aTopLevelWindowId,
        nsIPrincipal* aTrackingPrincipal,
        const nsACString& aTrackingOrigin,
        const uint32_t& aCookieBehavior,
        const StorageAccessPermissionGrantedReason& aReason) -> RefPtr<CompleteAllowAccessForPromise>
{
    RefPtr<MozPromise<mozilla::Maybe<StorageAccessPromptChoices>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<StorageAccessPromptChoices>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendCompleteAllowAccessFor(std::move(aParentContext), std::move(aTopLevelWindowId), std::move(aTrackingPrincipal), std::move(aTrackingOrigin), std::move(aCookieBehavior), std::move(aReason), [promise__](mozilla::Maybe<StorageAccessPromptChoices>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendSetAllowStorageAccessRequestFlag(
        nsIPrincipal* aEmbeddingPrincipal,
        nsIURI* aEmbeddedOrigin,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetAllowStorageAccessRequestFlag(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEmbeddingPrincipal);
    // Sentinel = 'aEmbeddingPrincipal'
    ((&(writer__)))->WriteSentinel(1233389443);
    IPC::WriteParam((&(writer__)), aEmbeddedOrigin);
    // Sentinel = 'aEmbeddedOrigin'
    ((&(writer__)))->WriteSentinel(762906068);


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendSetAllowStorageAccessRequestFlag(
        nsIPrincipal* aEmbeddingPrincipal,
        nsIURI* aEmbeddedOrigin) -> RefPtr<SetAllowStorageAccessRequestFlagPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendSetAllowStorageAccessRequestFlag(std::move(aEmbeddingPrincipal), std::move(aEmbeddedOrigin), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendTestAllowStorageAccessRequestFlag(
        nsIPrincipal* aEmbeddedPrincipal,
        nsIURI* aEmbeddingOrigin,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_TestAllowStorageAccessRequestFlag(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEmbeddedPrincipal);
    // Sentinel = 'aEmbeddedPrincipal'
    ((&(writer__)))->WriteSentinel(1098123022);
    IPC::WriteParam((&(writer__)), aEmbeddingOrigin);
    // Sentinel = 'aEmbeddingOrigin'
    ((&(writer__)))->WriteSentinel(875169353);


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendTestAllowStorageAccessRequestFlag(
        nsIPrincipal* aEmbeddedPrincipal,
        nsIURI* aEmbeddingOrigin) -> RefPtr<TestAllowStorageAccessRequestFlagPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendTestAllowStorageAccessRequestFlag(std::move(aEmbeddedPrincipal), std::move(aEmbeddingOrigin), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendStoreUserInteractionAsPermission(nsIPrincipal* aPrincipal) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_StoreUserInteractionAsPermission(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendTestCookiePermissionDecided(
        const MaybeDiscardedBrowsingContext& aContext,
        nsIPrincipal* aPrincipal,
        mozilla::ipc::ResolveCallback<mozilla::Maybe<bool>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_TestCookiePermissionDecided(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendTestCookiePermissionDecided(
        const MaybeDiscardedBrowsingContext& aContext,
        nsIPrincipal* aPrincipal) -> RefPtr<TestCookiePermissionDecidedPromise>
{
    RefPtr<MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendTestCookiePermissionDecided(std::move(aContext), std::move(aPrincipal), [promise__](mozilla::Maybe<bool>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendTestStorageAccessPermission(
        nsIPrincipal* aEmbeddingPrincipal,
        const nsACString& aEmbeddedOrigin,
        mozilla::ipc::ResolveCallback<mozilla::Maybe<bool>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_TestStorageAccessPermission(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aEmbeddingPrincipal);
    // Sentinel = 'aEmbeddingPrincipal'
    ((&(writer__)))->WriteSentinel(1233389443);
    IPC::WriteParam((&(writer__)), aEmbeddedOrigin);
    // Sentinel = 'aEmbeddedOrigin'
    ((&(writer__)))->WriteSentinel(762906068);


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendTestStorageAccessPermission(
        nsIPrincipal* aEmbeddingPrincipal,
        const nsACString& aEmbeddedOrigin) -> RefPtr<TestStorageAccessPermissionPromise>
{
    RefPtr<MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<bool>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendTestStorageAccessPermission(std::move(aEmbeddingPrincipal), std::move(aEmbeddedOrigin), [promise__](mozilla::Maybe<bool>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendNotifyMediaPlaybackChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const MediaPlaybackState& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaPlaybackChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendNotifyMediaAudibleChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const MediaAudibleState& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaAudibleChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendNotifyPictureInPictureModeChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aEnabled) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPictureInPictureModeChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendNotifyMediaSessionUpdated(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aIsCreated) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaSessionUpdated(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aIsCreated);
    // Sentinel = 'aIsCreated'
    ((&(writer__)))->WriteSentinel(344261590);


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

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

auto PContentChild::SendNotifyUpdateMediaMetadata(
        const MaybeDiscardedBrowsingContext& aContext,
        const mozilla::Maybe<MediaMetadataBase>& aMetadata) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyUpdateMediaMetadata(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aMetadata);
    // Sentinel = 'aMetadata'
    ((&(writer__)))->WriteSentinel(288752515);


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

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

auto PContentChild::SendNotifyMediaSessionPlaybackStateChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const MediaSessionPlaybackState& aMetadata) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaSessionPlaybackStateChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aMetadata);
    // Sentinel = 'aMetadata'
    ((&(writer__)))->WriteSentinel(288752515);


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

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

auto PContentChild::SendNotifyMediaSessionSupportedActionChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const MediaSessionAction& aAction,
        const bool& aEnabled) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaSessionSupportedActionChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendNotifyMediaFullScreenState(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aIsInFullScreen) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyMediaFullScreenState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aIsInFullScreen);
    // Sentinel = 'aIsInFullScreen'
    ((&(writer__)))->WriteSentinel(754320840);


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

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

auto PContentChild::SendNotifyPositionStateChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const mozilla::Maybe<PositionState>& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPositionStateChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendNotifyGuessedPositionStateChanged(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsID& aMediaId,
        const mozilla::Maybe<PositionState>& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyGuessedPositionStateChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendAddOrRemovePageAwakeRequest(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aShouldAddCount) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddOrRemovePageAwakeRequest(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aShouldAddCount);
    // Sentinel = 'aShouldAddCount'
    ((&(writer__)))->WriteSentinel(777848291);


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

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

auto PContentChild::SendReportServiceWorkerShutdownProgress(
        const uint32_t& aShutdownStateId,
        const Progress& aProgress) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReportServiceWorkerShutdownProgress(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aShutdownStateId);
    // Sentinel = 'aShutdownStateId'
    ((&(writer__)))->WriteSentinel(925238892);
    IPC::WriteParam((&(writer__)), aProgress);
    // Sentinel = 'aProgress'
    ((&(writer__)))->WriteSentinel(301794231);


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

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

auto PContentChild::SendAbortOtherOrientationPendingPromises(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AbortOtherOrientationPendingPromises(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendHistoryReload(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint32_t& aReloadFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryReload(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aReloadFlags);
    // Sentinel = 'aReloadFlags'
    ((&(writer__)))->WriteSentinel(499451046);


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

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

auto PContentChild::SendNotifyOnHistoryReload(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aForceReload,
        mozilla::ipc::ResolveCallback<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyOnHistoryReload(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aForceReload);
    // Sentinel = 'aForceReload'
    ((&(writer__)))->WriteSentinel(500499624);


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

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

            }
            auto& canReload = *maybe__canReload;
            // Sentinel = 'canReload'
            if ((!((aReader)->ReadSentinel(295043978)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__loadState = IPC::ReadParam<mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>>(aReader);
            if (!maybe__loadState) {
                (aReader)->FatalError("Error deserializing 'NotNull<nsDocShellLoadState>?'");
                return MsgValueError;

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

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


            aReader->EndRead();

            resolve(std::make_tuple(std::move(canReload), std::move(loadState), std::move(reloadActiveEntry)));
            return MsgProcessed;
        }, std::move(aReject));
    }
    else {
        aReject(::mozilla::ipc::ResponseRejectReason::SendError);
    }
    return;
}

auto PContentChild::SendNotifyOnHistoryReload(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aForceReload) -> RefPtr<NotifyOnHistoryReloadPromise>
{
    RefPtr<MozPromise<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendNotifyOnHistoryReload(std::move(aContext), std::move(aForceReload), [promise__](std::tuple<bool, mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>, mozilla::Maybe<bool>>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendHistoryCommit(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint64_t& aLoadID,
        const nsID& aChangeID,
        const uint32_t& aLoadType,
        const bool& aCloneEntryChildren,
        const bool& aChannelExpired,
        const uint32_t& aCacheKey) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryCommit(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aLoadID);
    // Sentinel = 'aLoadID'
    ((&(writer__)))->WriteSentinel(170328687);
    IPC::WriteParam((&(writer__)), aChangeID);
    // Sentinel = 'aChangeID'
    ((&(writer__)))->WriteSentinel(275710773);
    IPC::WriteParam((&(writer__)), aLoadType);
    // Sentinel = 'aLoadType'
    ((&(writer__)))->WriteSentinel(286589828);
    IPC::WriteParam((&(writer__)), aCloneEntryChildren);
    // Sentinel = 'aCloneEntryChildren'
    ((&(writer__)))->WriteSentinel(1242171278);
    IPC::WriteParam((&(writer__)), aChannelExpired);
    // Sentinel = 'aChannelExpired'
    ((&(writer__)))->WriteSentinel(775554540);
    IPC::WriteParam((&(writer__)), aCacheKey);
    // Sentinel = 'aCacheKey'
    ((&(writer__)))->WriteSentinel(272827231);


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

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

auto PContentChild::SendHistoryGo(
        const MaybeDiscardedBrowsingContext& aContext,
        const int32_t& aOffset,
        const uint64_t& aHistoryEpoch,
        const bool& aRequireUserInteraction,
        const bool& aUserActivation,
        const bool& aCheckForCancelation,
        mozilla::ipc::ResolveCallback<mozilla::Maybe<int32_t>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryGo(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aOffset);
    // Sentinel = 'aOffset'
    ((&(writer__)))->WriteSentinel(179634889);
    IPC::WriteParam((&(writer__)), aHistoryEpoch);
    // Sentinel = 'aHistoryEpoch'
    ((&(writer__)))->WriteSentinel(611255619);
    IPC::WriteParam((&(writer__)), aRequireUserInteraction);
    // Sentinel = 'aRequireUserInteraction'
    ((&(writer__)))->WriteSentinel(1862076766);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);
    IPC::WriteParam((&(writer__)), aCheckForCancelation);
    // Sentinel = 'aCheckForCancelation'
    ((&(writer__)))->WriteSentinel(1326581704);


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

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

            }
            auto& requestedIndex = *maybe__requestedIndex;
            // Sentinel = 'requestedIndex'
            if ((!((aReader)->ReadSentinel(738788811)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendHistoryGo(
        const MaybeDiscardedBrowsingContext& aContext,
        const int32_t& aOffset,
        const uint64_t& aHistoryEpoch,
        const bool& aRequireUserInteraction,
        const bool& aUserActivation,
        const bool& aCheckForCancelation) -> RefPtr<HistoryGoPromise>
{
    RefPtr<MozPromise<mozilla::Maybe<int32_t>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<int32_t>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendHistoryGo(std::move(aContext), std::move(aOffset), std::move(aHistoryEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation), std::move(aCheckForCancelation), [promise__](mozilla::Maybe<int32_t>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendNavigationTraverse(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsID& aKey,
        const uint64_t& aHistoryEpoch,
        const bool& aUserActivation,
        const bool& aCheckForCancelation,
        mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NavigationTraverse(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aKey);
    // Sentinel = 'aKey'
    ((&(writer__)))->WriteSentinel(61604235);
    IPC::WriteParam((&(writer__)), aHistoryEpoch);
    // Sentinel = 'aHistoryEpoch'
    ((&(writer__)))->WriteSentinel(611255619);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);
    IPC::WriteParam((&(writer__)), aCheckForCancelation);
    // Sentinel = 'aCheckForCancelation'
    ((&(writer__)))->WriteSentinel(1326581704);


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

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

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


            aReader->EndRead();

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

auto PContentChild::SendNavigationTraverse(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsID& aKey,
        const uint64_t& aHistoryEpoch,
        const bool& aUserActivation,
        const bool& aCheckForCancelation) -> RefPtr<NavigationTraversePromise>
{
    RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendNavigationTraverse(std::move(aContext), std::move(aKey), std::move(aHistoryEpoch), std::move(aUserActivation), std::move(aCheckForCancelation), [promise__](nsresult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendBlobURLDataRequest(
        const nsACString& aBlobURL,
        mozilla::NotNull<nsIPrincipal*> aTriggeringPrincipal,
        nsIPrincipal* aLoadingPrincipal,
        const OriginAttributes& aOriginAttributes,
        const uint64_t& aInnerWindowId,
        const nsACString& aPartitionKey,
        mozilla::ipc::ResolveCallback<BlobURLDataRequestResult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BlobURLDataRequest(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aBlobURL);
    // Sentinel = 'aBlobURL'
    ((&(writer__)))->WriteSentinel(218628820);
    IPC::WriteParam((&(writer__)), aTriggeringPrincipal);
    // Sentinel = 'aTriggeringPrincipal'
    ((&(writer__)))->WriteSentinel(1413089302);
    IPC::WriteParam((&(writer__)), aLoadingPrincipal);
    // Sentinel = 'aLoadingPrincipal'
    ((&(writer__)))->WriteSentinel(1001719490);
    IPC::WriteParam((&(writer__)), aOriginAttributes);
    // Sentinel = 'aOriginAttributes'
    ((&(writer__)))->WriteSentinel(1021839089);
    IPC::WriteParam((&(writer__)), aInnerWindowId);
    // Sentinel = 'aInnerWindowId'
    ((&(writer__)))->WriteSentinel(689767811);
    IPC::WriteParam((&(writer__)), aPartitionKey);
    // Sentinel = 'aPartitionKey'
    ((&(writer__)))->WriteSentinel(610141509);


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

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

            }
            auto& aResult = *maybe__aResult;
            // Sentinel = 'aResult'
            if ((!((aReader)->ReadSentinel(185205473)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BlobURLDataRequestResult'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendBlobURLDataRequest(
        const nsACString& aBlobURL,
        mozilla::NotNull<nsIPrincipal*> aTriggeringPrincipal,
        nsIPrincipal* aLoadingPrincipal,
        const OriginAttributes& aOriginAttributes,
        const uint64_t& aInnerWindowId,
        const nsACString& aPartitionKey) -> RefPtr<BlobURLDataRequestPromise>
{
    RefPtr<MozPromise<BlobURLDataRequestResult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<BlobURLDataRequestResult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendBlobURLDataRequest(std::move(aBlobURL), std::move(aTriggeringPrincipal), std::move(aLoadingPrincipal), std::move(aOriginAttributes), std::move(aInnerWindowId), std::move(aPartitionKey), [promise__](BlobURLDataRequestResult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendSetActiveSessionHistoryEntry(
        const MaybeDiscardedBrowsingContext& context,
        const mozilla::Maybe<nsPoint>& previousScrollPosition,
        const SessionHistoryInfo& info,
        const uint32_t& loadType,
        const uint32_t& updatedCacheKey,
        const nsID& changeID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetActiveSessionHistoryEntry(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), context);
    // Sentinel = 'context'
    ((&(writer__)))->WriteSentinel(199164678);
    IPC::WriteParam((&(writer__)), previousScrollPosition);
    // Sentinel = 'previousScrollPosition'
    ((&(writer__)))->WriteSentinel(1792346434);
    IPC::WriteParam((&(writer__)), info);
    // Sentinel = 'info'
    ((&(writer__)))->WriteSentinel(70058413);
    IPC::WriteParam((&(writer__)), loadType);
    // Sentinel = 'loadType'
    ((&(writer__)))->WriteSentinel(246088515);
    IPC::WriteParam((&(writer__)), updatedCacheKey);
    // Sentinel = 'updatedCacheKey'
    ((&(writer__)))->WriteSentinel(804062693);
    IPC::WriteParam((&(writer__)), changeID);
    // Sentinel = 'changeID'
    ((&(writer__)))->WriteSentinel(235209460);


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

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

auto PContentChild::SendReplaceActiveSessionHistoryEntry(
        const MaybeDiscardedBrowsingContext& context,
        const SessionHistoryInfo& info) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReplaceActiveSessionHistoryEntry(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRemoveDynEntriesFromActiveSessionHistoryEntry(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRemoveFromSessionHistory(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsID& changeID) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveFromSessionHistory(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), changeID);
    // Sentinel = 'changeID'
    ((&(writer__)))->WriteSentinel(235209460);


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

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

auto PContentChild::SendCleanupPendingLoadState(const uint64_t& aLoadIdentifier) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CleanupPendingLoadState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendScriptError(
        const nsAString& message,
        const nsACString& sourceName,
        const uint32_t& lineNumber,
        const uint32_t& colNumber,
        const uint32_t& flags,
        const nsACString& category,
        const bool& isFromPrivateWindow,
        const uint64_t& innerWindowId,
        const bool& isFromChromeContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ScriptError(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), message);
    // Sentinel = 'message'
    ((&(writer__)))->WriteSentinel(197198566);
    IPC::WriteParam((&(writer__)), sourceName);
    // Sentinel = 'sourceName'
    ((&(writer__)))->WriteSentinel(387580947);
    IPC::WriteParam((&(writer__)), lineNumber);
    // Sentinel = 'lineNumber'
    ((&(writer__)))->WriteSentinel(374932498);
    IPC::WriteParam((&(writer__)), colNumber);
    // Sentinel = 'colNumber'
    ((&(writer__)))->WriteSentinel(304284584);
    IPC::WriteParam((&(writer__)), flags);
    // Sentinel = 'flags'
    ((&(writer__)))->WriteSentinel(102171150);
    IPC::WriteParam((&(writer__)), category);
    // Sentinel = 'category'
    ((&(writer__)))->WriteSentinel(247333727);
    IPC::WriteParam((&(writer__)), isFromPrivateWindow);
    // Sentinel = 'isFromPrivateWindow'
    ((&(writer__)))->WriteSentinel(1288964036);
    IPC::WriteParam((&(writer__)), innerWindowId);
    // Sentinel = 'innerWindowId'
    ((&(writer__)))->WriteSentinel(627967298);
    IPC::WriteParam((&(writer__)), isFromChromeContext);
    // Sentinel = 'isFromChromeContext'
    ((&(writer__)))->WriteSentinel(1269368756);


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

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

auto PContentChild::SendReportFrameTimingData(
        const LoadInfoArgs& loadInfo,
        const nsAString& entryName,
        const nsAString& initiatorType,
        const UniquePtr<PerformanceTimingData>& aData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReportFrameTimingData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), loadInfo);
    // Sentinel = 'loadInfo'
    ((&(writer__)))->WriteSentinel(240386861);
    IPC::WriteParam((&(writer__)), entryName);
    // Sentinel = 'entryName'
    ((&(writer__)))->WriteSentinel(315950004);
    IPC::WriteParam((&(writer__)), initiatorType);
    // Sentinel = 'initiatorType'
    ((&(writer__)))->WriteSentinel(642647414);
    IPC::WriteParam((&(writer__)), aData);
    // Sentinel = 'aData'
    ((&(writer__)))->WriteSentinel(90571228);


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

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

auto PContentChild::SendCommitBrowsingContextTransaction(
        const MaybeDiscardedBrowsingContext& aContext,
        const BrowsingContextTransaction& aTransaction,
        const uint64_t& aEpoch) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CommitBrowsingContextTransaction(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aTransaction);
    // Sentinel = 'aTransaction'
    ((&(writer__)))->WriteSentinel(523371752);
    IPC::WriteParam((&(writer__)), aEpoch);
    // Sentinel = 'aEpoch'
    ((&(writer__)))->WriteSentinel(132121169);


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

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

auto PContentChild::SendAsyncMessage(
        const nsAString& aMessage,
        const ClonedMessageData& aData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AsyncMessage(MSG_ROUTING_CONTROL);
    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("PContent", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_AsyncMessage", OTHER);

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

auto PContentChild::SendNotifyPushSubscriptionModifiedObservers(
        const nsACString& scope,
        nsIPrincipal* principal) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyPushSubscriptionModifiedObservers(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendPushError(
        const nsACString& scope,
        nsIPrincipal* principal,
        const nsAString& message,
        const uint32_t& flags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PushError(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), scope);
    // Sentinel = 'scope'
    ((&(writer__)))->WriteSentinel(107086363);
    IPC::WriteParam((&(writer__)), principal);
    // Sentinel = 'principal'
    ((&(writer__)))->WriteSentinel(319620035);
    IPC::WriteParam((&(writer__)), message);
    // Sentinel = 'message'
    ((&(writer__)))->WriteSentinel(197198566);
    IPC::WriteParam((&(writer__)), flags);
    // Sentinel = 'flags'
    ((&(writer__)))->WriteSentinel(102171150);


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

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

auto PContentChild::SendCreateBrowsingContext(
        const uint64_t& aGroupId,
        const BrowsingContextInitializer& aInit) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGroupId);
    // Sentinel = 'aGroupId'
    ((&(writer__)))->WriteSentinel(233964316);
    IPC::WriteParam((&(writer__)), aInit);
    // Sentinel = 'aInit'
    ((&(writer__)))->WriteSentinel(94241270);


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

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

auto PContentChild::SendDiscardBrowsingContext(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aDoDiscard,
        mozilla::ipc::ResolveCallback<uint64_t>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DiscardBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aDoDiscard);
    // Sentinel = 'aDoDiscard'
    ((&(writer__)))->WriteSentinel(339215311);


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

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

            }
            auto& unused = *maybe__unused;
            // Sentinel = 'unused'
            if ((!((aReader)->ReadSentinel(155517589)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendDiscardBrowsingContext(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aDoDiscard) -> RefPtr<DiscardBrowsingContextPromise>
{
    RefPtr<MozPromise<uint64_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint64_t, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendDiscardBrowsingContext(std::move(aContext), std::move(aDoDiscard), [promise__](uint64_t&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendAdjustWindowFocus(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aIsVisible,
        const uint64_t& aActionId,
        const bool& aShouldClearAncestorFocus,
        const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AdjustWindowFocus(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aIsVisible);
    // Sentinel = 'aIsVisible'
    ((&(writer__)))->WriteSentinel(353567724);
    IPC::WriteParam((&(writer__)), aActionId);
    // Sentinel = 'aActionId'
    ((&(writer__)))->WriteSentinel(284164973);
    IPC::WriteParam((&(writer__)), aShouldClearAncestorFocus);
    // Sentinel = 'aShouldClearAncestorFocus'
    ((&(writer__)))->WriteSentinel(2138442231);
    IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocus);
    // Sentinel = 'aAncestorBrowsingContextToFocus'
    ((&(writer__)))->WriteSentinel(3344239764);


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

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

auto PContentChild::SendWindowClose(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aTrustedCaller) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowClose(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aTrustedCaller);
    // Sentinel = 'aTrustedCaller'
    ((&(writer__)))->WriteSentinel(706479520);


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

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

auto PContentChild::SendWindowFocus(
        const MaybeDiscardedBrowsingContext& aContext,
        const CallerType& aCallerType,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowFocus(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendWindowBlur(
        const MaybeDiscardedBrowsingContext& aContext,
        const CallerType& aCallerType) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowBlur(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendRaiseWindow(
        const MaybeDiscardedBrowsingContext& aContext,
        const CallerType& aCallerType,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RaiseWindow(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendClearFocus(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearFocus(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSetFocusedBrowsingContext(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetFocusedBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSetActiveBrowsingContext(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetActiveBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendUnsetActiveBrowsingContext(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UnsetActiveBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSetFocusedElement(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aNeedsFocus) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetFocusedElement(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aNeedsFocus);
    // Sentinel = 'aNeedsFocus'
    ((&(writer__)))->WriteSentinel(419759185);


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

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

auto PContentChild::SendFinalizeFocusOuter(
        const MaybeDiscardedBrowsingContext& aContext,
        const bool& aCanFocus,
        const CallerType& aCallerType) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FinalizeFocusOuter(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aCanFocus);
    // Sentinel = 'aCanFocus'
    ((&(writer__)))->WriteSentinel(275055476);
    IPC::WriteParam((&(writer__)), aCallerType);
    // Sentinel = 'aCallerType'
    ((&(writer__)))->WriteSentinel(422118487);


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

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

auto PContentChild::SendInsertNewFocusActionId(const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InsertNewFocusActionId(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendBlurToParent(
        const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
        const MaybeDiscardedBrowsingContext& aBrowsingContextToClear,
        const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus,
        const bool& aIsLeavingDocument,
        const bool& aAdjustWidget,
        const bool& aBrowsingContextToClearHandled,
        const bool& aAncestorBrowsingContextToFocusHandled,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BlurToParent(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFocusedBrowsingContext);
    // Sentinel = 'aFocusedBrowsingContext'
    ((&(writer__)))->WriteSentinel(1842153819);
    IPC::WriteParam((&(writer__)), aBrowsingContextToClear);
    // Sentinel = 'aBrowsingContextToClear'
    ((&(writer__)))->WriteSentinel(1859127612);
    IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocus);
    // Sentinel = 'aAncestorBrowsingContextToFocus'
    ((&(writer__)))->WriteSentinel(3344239764);
    IPC::WriteParam((&(writer__)), aIsLeavingDocument);
    // Sentinel = 'aIsLeavingDocument'
    ((&(writer__)))->WriteSentinel(1103169315);
    IPC::WriteParam((&(writer__)), aAdjustWidget);
    // Sentinel = 'aAdjustWidget'
    ((&(writer__)))->WriteSentinel(594609457);
    IPC::WriteParam((&(writer__)), aBrowsingContextToClearHandled);
    // Sentinel = 'aBrowsingContextToClearHandled'
    ((&(writer__)))->WriteSentinel(3118074860);
    IPC::WriteParam((&(writer__)), aAncestorBrowsingContextToFocusHandled);
    // Sentinel = 'aAncestorBrowsingContextToFocusHandled'
    ((&(writer__)))->WriteSentinel(701894468);
    IPC::WriteParam((&(writer__)), aActionId);
    // Sentinel = 'aActionId'
    ((&(writer__)))->WriteSentinel(284164973);


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

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

auto PContentChild::SendMaybeExitFullscreen(const MaybeDiscardedBrowsingContext& aContext) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_MaybeExitFullscreen(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendWindowPostMessage(
        const MaybeDiscardedBrowsingContext& aContext,
        const ClonedOrErrorMessageData& aMessage,
        const PostMessageData& aData) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_WindowPostMessage(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendCommitWindowContextTransaction(
        const MaybeDiscardedWindowContext& aContext,
        const WindowContextTransaction& aTransaction,
        const uint64_t& aEpoch) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CommitWindowContextTransaction(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aTransaction);
    // Sentinel = 'aTransaction'
    ((&(writer__)))->WriteSentinel(523371752);
    IPC::WriteParam((&(writer__)), aEpoch);
    // Sentinel = 'aEpoch'
    ((&(writer__)))->WriteSentinel(132121169);


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

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

auto PContentChild::SendFOGData(ByteBuf&& buf) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FOGData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendGeckoTraceExport(ByteBuf&& aBuf) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GeckoTraceExport(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentChild::SendSetContainerFeaturePolicy(
        const MaybeDiscardedBrowsingContext& aContainerContext,
        const MaybeFeaturePolicyInfo& aContainerFeaturePolicyInfo) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetContainerFeaturePolicy(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContainerContext);
    // Sentinel = 'aContainerContext'
    ((&(writer__)))->WriteSentinel(1015744234);
    IPC::WriteParam((&(writer__)), aContainerFeaturePolicyInfo);
    // Sentinel = 'aContainerFeaturePolicyInfo'
    ((&(writer__)))->WriteSentinel(2516585165);


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

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

auto PContentChild::SendGetSystemIcon(
        nsIURI* aURI,
        mozilla::ipc::ResolveCallback<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetSystemIcon(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

            }
            auto& aResult = *maybe__aResult;
            // Sentinel = 'aResult'
            if ((!((aReader)->ReadSentinel(185205473)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<mozilla::Maybe<ByteBuf>>(aReader);
            if (!maybe__aData) {
                (aReader)->FatalError("Error deserializing 'ByteBuf?'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!((aReader)->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf?'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendGetSystemIcon(nsIURI* aURI) -> RefPtr<GetSystemIconPromise>
{
    RefPtr<MozPromise<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<nsresult, mozilla::Maybe<ByteBuf>>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetSystemIcon(std::move(aURI), [promise__](std::tuple<nsresult, mozilla::Maybe<ByteBuf>>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendGetSystemGeolocationPermissionBehavior(
        mozilla::ipc::ResolveCallback<SystemGeolocationPermissionBehavior>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetSystemGeolocationPermissionBehavior(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

            }
            auto& permission = *maybe__permission;
            // Sentinel = 'permission'
            if ((!((aReader)->ReadSentinel(394921034)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SystemGeolocationPermissionBehavior'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendGetSystemGeolocationPermissionBehavior() -> RefPtr<GetSystemGeolocationPermissionBehaviorPromise>
{
    RefPtr<MozPromise<SystemGeolocationPermissionBehavior, ResponseRejectReason, true>::Private> promise__ = new MozPromise<SystemGeolocationPermissionBehavior, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetSystemGeolocationPermissionBehavior([promise__](SystemGeolocationPermissionBehavior&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendRequestGeolocationPermissionFromUser(
        const MaybeDiscardedBrowsingContext& aBrowsingContext,
        mozilla::ipc::ResolveCallback<GeolocationPermissionStatus>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RequestGeolocationPermissionFromUser(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

            }
            auto& aStatus = *maybe__aStatus;
            // Sentinel = 'aStatus'
            if ((!((aReader)->ReadSentinel(186712806)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GeolocationPermissionStatus'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentChild::SendRequestGeolocationPermissionFromUser(const MaybeDiscardedBrowsingContext& aBrowsingContext) -> RefPtr<RequestGeolocationPermissionFromUserPromise>
{
    RefPtr<MozPromise<GeolocationPermissionStatus, ResponseRejectReason, true>::Private> promise__ = new MozPromise<GeolocationPermissionStatus, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRequestGeolocationPermissionFromUser(std::move(aBrowsingContext), [promise__](GeolocationPermissionStatus&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentChild::SendAttributionEvent(
        const nsACString& aSourceHost,
        const PrivateAttributionImpressionType& aType,
        const uint32_t& aIndex,
        const nsAString& aAd,
        const nsACString& aTargetHost) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AttributionEvent(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aSourceHost);
    // Sentinel = 'aSourceHost'
    ((&(writer__)))->WriteSentinel(439551089);
    IPC::WriteParam((&(writer__)), aType);
    // Sentinel = 'aType'
    ((&(writer__)))->WriteSentinel(99222020);
    IPC::WriteParam((&(writer__)), aIndex);
    // Sentinel = 'aIndex'
    ((&(writer__)))->WriteSentinel(132055642);
    IPC::WriteParam((&(writer__)), aAd);
    // Sentinel = 'aAd'
    ((&(writer__)))->WriteSentinel(34341127);
    IPC::WriteParam((&(writer__)), aTargetHost);
    // Sentinel = 'aTargetHost'
    ((&(writer__)))->WriteSentinel(431031399);


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

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

auto PContentChild::SendAttributionConversion(
        const nsACString& aTargetHost,
        const nsAString& aTask,
        const uint32_t& aHistogramSize,
        const mozilla::Maybe<uint32_t>& aLookbackDays,
        const mozilla::Maybe<PrivateAttributionImpressionType>& aImpressionType,
        mozilla::Span<nsString const> aAds,
        mozilla::Span<nsCString const> aImpressionSourceHosts) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AttributionConversion(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aTargetHost);
    // Sentinel = 'aTargetHost'
    ((&(writer__)))->WriteSentinel(431031399);
    IPC::WriteParam((&(writer__)), aTask);
    // Sentinel = 'aTask'
    ((&(writer__)))->WriteSentinel(95289845);
    IPC::WriteParam((&(writer__)), aHistogramSize);
    // Sentinel = 'aHistogramSize'
    ((&(writer__)))->WriteSentinel(703399339);
    IPC::WriteParam((&(writer__)), aLookbackDays);
    // Sentinel = 'aLookbackDays'
    ((&(writer__)))->WriteSentinel(589301017);
    IPC::WriteParam((&(writer__)), aImpressionType);
    // Sentinel = 'aImpressionType'
    ((&(writer__)))->WriteSentinel(815728173);
    IPC::WriteParam((&(writer__)), aAds);
    // Sentinel = 'aAds'
    ((&(writer__)))->WriteSentinel(59113850);
    IPC::WriteParam((&(writer__)), aImpressionSourceHosts);
    // Sentinel = 'aImpressionSourceHosts'
    ((&(writer__)))->WriteSentinel(1726679309);


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

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

auto PContentChild::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PContentPermissionRequestMsgStart:
        static_cast<ContentChild*>(this)->DeallocPContentPermissionRequestChild(static_cast<PContentPermissionRequestChild*>(aListener));
        return;
    case PCycleCollectWithLogsMsgStart:
        static_cast<ContentChild*>(this)->DeallocPCycleCollectWithLogsChild(static_cast<PCycleCollectWithLogsChild*>(aListener));
        return;
    case PHalMsgStart:
        static_cast<ContentChild*>(this)->DeallocPHalChild(static_cast<PHalChild*>(aListener));
        return;
    case PHeapSnapshotTempFileHelperMsgStart:
        static_cast<ContentChild*>(this)->DeallocPHeapSnapshotTempFileHelperChild(static_cast<PHeapSnapshotTempFileHelperChild*>(aListener));
        return;
    case PMediaMsgStart:
        static_cast<ContentChild*>(this)->DeallocPMediaChild(static_cast<PMediaChild*>(aListener));
        return;
    case PRemoteSpellcheckEngineMsgStart:
        static_cast<ContentChild*>(this)->DeallocPRemoteSpellcheckEngineChild(static_cast<PRemoteSpellcheckEngineChild*>(aListener));
        return;
    case PURLClassifierMsgStart:
        static_cast<ContentChild*>(this)->DeallocPURLClassifierChild(static_cast<PURLClassifierChild*>(aListener));
        return;
    case PURLClassifierLocalMsgStart:
        static_cast<ContentChild*>(this)->DeallocPURLClassifierLocalChild(static_cast<PURLClassifierLocalChild*>(aListener));
        return;
    case PURLClassifierLocalByNameMsgStart:
        static_cast<ContentChild*>(this)->DeallocPURLClassifierLocalByNameChild(static_cast<PURLClassifierLocalByNameChild*>(aListener));
        return;
    case PScriptCacheMsgStart:
        static_cast<ContentChild*>(this)->DeallocPScriptCacheChild(static_cast<PScriptCacheChild*>(aListener));
        return;
    case PSessionStorageObserverMsgStart:
        static_cast<ContentChild*>(this)->DeallocPSessionStorageObserverChild(static_cast<PSessionStorageObserverChild*>(aListener));
        return;
    default:
        FatalError("unreached");
        return;
    }
}

auto PContentChild::OnMessageReceived(const Message& msg__) -> PContentChild::Result
{
    IPC::Message::routeid_t route__ = msg__.routing_id();
    if (MSG_ROUTING_CONTROL != route__) {
        IProtocol* routed__ = Lookup(route__);
        if (!routed__ || !routed__->GetLifecycleProxy()) {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Ignored message for dead actor",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;

        }

        RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
            routed__->GetLifecycleProxy();
        return proxy__->Get()->OnMessageReceived(msg__);
    }

    switch (msg__.type()) {
    case PContent::Reply_PExtensionsConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_ConstructBrowser__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ConstructBrowser", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& browserEp = *maybe__browserEp;
            // Sentinel = 'browserEp'
            if ((!(((&(reader__)))->ReadSentinel(318833594)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserChild>'");
                return MsgValueError;
            }
            auto maybe__windowEp = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>>((&(reader__)));
            if (!maybe__windowEp) {
                FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>'");
                return MsgValueError;

            }
            auto& windowEp = *maybe__windowEp;
            // Sentinel = 'windowEp'
            if ((!(((&(reader__)))->ReadSentinel(255984462)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>'");
                return MsgValueError;
            }
            auto maybe__tabId = IPC::ReadParam<TabId>((&(reader__)));
            if (!maybe__tabId) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;

            }
            auto& tabId = *maybe__tabId;
            // Sentinel = 'tabId'
            if ((!(((&(reader__)))->ReadSentinel(99156453)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            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;
            }
            auto maybe__windowInit = IPC::ReadParam<WindowGlobalInit>((&(reader__)));
            if (!maybe__windowInit) {
                FatalError("Error deserializing 'WindowGlobalInit'");
                return MsgValueError;

            }
            auto& windowInit = *maybe__windowInit;
            // Sentinel = 'windowInit'
            if ((!(((&(reader__)))->ReadSentinel(388891693)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WindowGlobalInit'");
                return MsgValueError;
            }
            auto maybe__chromeFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__chromeFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& chromeFlags = *maybe__chromeFlags;
            // Sentinel = 'chromeFlags'
            if ((!(((&(reader__)))->ReadSentinel(446760044)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__cpId = IPC::ReadParam<ContentParentId>((&(reader__)));
            if (!maybe__cpId) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;

            }
            auto& cpId = *maybe__cpId;
            // Sentinel = 'cpId'
            if ((!(((&(reader__)))->ReadSentinel(64356737)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            auto maybe__isForBrowser = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__isForBrowser) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            }
            auto& isTopLevel = *maybe__isTopLevel;
            // Sentinel = 'isTopLevel'
            if ((!(((&(reader__)))->ReadSentinel(371196936)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvConstructBrowser(std::move(browserEp), std::move(windowEp), std::move(tabId), std::move(context), std::move(windowInit), std::move(chromeFlags), std::move(cpId), std::move(isForBrowser), std::move(isTopLevel));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Reply_PWebBrowserPersistDocumentConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_PWebBrowserPersistDocumentConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aBrowser = *maybe__aBrowser;
            // Sentinel = 'aBrowser'
            if ((!(((&(reader__)))->ReadSentinel(237372230)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowser'");
                return MsgValueError;
            }
            auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aContext) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            RefPtr<PWebBrowserPersistDocumentChild> actor = (static_cast<ContentChild*>(this))->AllocPWebBrowserPersistDocumentChild(aBrowser, aContext);
            if (!actor) {
                NS_WARNING("Cannot bind null PWebBrowserPersistDocumentChild actor");
                return MsgValueError;
            }

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

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

            return MsgProcessed;
        }
    case PContent::Msg_RawMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RawMessage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_InitGMPService__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitGMPService", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__service = IPC::ReadParam<Endpoint<::mozilla::gmp::PGMPServiceChild>>((&(reader__)));
            if (!maybe__service) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gmp::PGMPServiceChild>'");
                return MsgValueError;

            }
            auto& service = *maybe__service;
            // Sentinel = 'service'
            if ((!(((&(reader__)))->ReadSentinel(201458418)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gmp::PGMPServiceChild>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitGMPService(std::move(service));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitProcessHangMonitor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitProcessHangMonitor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__hangMonitor = IPC::ReadParam<Endpoint<::mozilla::PProcessHangMonitorChild>>((&(reader__)));
            if (!maybe__hangMonitor) {
                FatalError("Error deserializing 'Endpoint<::mozilla::PProcessHangMonitorChild>'");
                return MsgValueError;

            }
            auto& hangMonitor = *maybe__hangMonitor;
            // Sentinel = 'hangMonitor'
            if ((!(((&(reader__)))->ReadSentinel(445514887)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PProcessHangMonitorChild>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitProcessHangMonitor(std::move(hangMonitor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitProfiler__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitProfiler", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PProfilerChild>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitProfiler(std::move(aEndpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__compositor = IPC::ReadParam<Endpoint<::mozilla::layers::PCompositorManagerChild>>((&(reader__)));
            if (!maybe__compositor) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
                return MsgValueError;

            }
            auto& compositor = *maybe__compositor;
            // Sentinel = 'compositor'
            if ((!(((&(reader__)))->ReadSentinel(393217104)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
                return MsgValueError;
            }
            auto maybe__imageBridge = IPC::ReadParam<Endpoint<::mozilla::layers::PImageBridgeChild>>((&(reader__)));
            if (!maybe__imageBridge) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
                return MsgValueError;

            }
            auto& imageBridge = *maybe__imageBridge;
            // Sentinel = 'imageBridge'
            if ((!(((&(reader__)))->ReadSentinel(436012113)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
                return MsgValueError;
            }
            auto maybe__vr = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRManagerChild>>((&(reader__)));
            if (!maybe__vr) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
                return MsgValueError;

            }
            auto& vr = *maybe__vr;
            // Sentinel = 'vr'
            if ((!(((&(reader__)))->ReadSentinel(23068905)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
                return MsgValueError;
            }
            auto maybe__video = IPC::ReadParam<Endpoint<::mozilla::PRemoteMediaManagerChild>>((&(reader__)));
            if (!maybe__video) {
                FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'");
                return MsgValueError;

            }
            auto& video = *maybe__video;
            // Sentinel = 'video'
            if ((!(((&(reader__)))->ReadSentinel(106693144)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'");
                return MsgValueError;
            }
            auto maybe__namespaces = IPC::ReadParam<nsTArray<uint32_t>>((&(reader__)));
            if (!maybe__namespaces) {
                FatalError("Error deserializing 'uint32_t[]'");
                return MsgValueError;

            }
            auto& namespaces = *maybe__namespaces;
            // Sentinel = 'namespaces'
            if ((!(((&(reader__)))->ReadSentinel(381027361)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitRendering(std::move(compositor), std::move(imageBridge), std::move(vr), std::move(video), std::move(namespaces));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReinitRendering__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReinitRendering", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__compositor = IPC::ReadParam<Endpoint<::mozilla::layers::PCompositorManagerChild>>((&(reader__)));
            if (!maybe__compositor) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
                return MsgValueError;

            }
            auto& compositor = *maybe__compositor;
            // Sentinel = 'compositor'
            if ((!(((&(reader__)))->ReadSentinel(393217104)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerChild>'");
                return MsgValueError;
            }
            auto maybe__bridge = IPC::ReadParam<Endpoint<::mozilla::layers::PImageBridgeChild>>((&(reader__)));
            if (!maybe__bridge) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
                return MsgValueError;

            }
            auto& bridge = *maybe__bridge;
            // Sentinel = 'bridge'
            if ((!(((&(reader__)))->ReadSentinel(143589998)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeChild>'");
                return MsgValueError;
            }
            auto maybe__vr = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRManagerChild>>((&(reader__)));
            if (!maybe__vr) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
                return MsgValueError;

            }
            auto& vr = *maybe__vr;
            // Sentinel = 'vr'
            if ((!(((&(reader__)))->ReadSentinel(23068905)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerChild>'");
                return MsgValueError;
            }
            auto maybe__video = IPC::ReadParam<Endpoint<::mozilla::PRemoteMediaManagerChild>>((&(reader__)));
            if (!maybe__video) {
                FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'");
                return MsgValueError;

            }
            auto& video = *maybe__video;
            // Sentinel = 'video'
            if ((!(((&(reader__)))->ReadSentinel(106693144)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerChild>'");
                return MsgValueError;
            }
            auto maybe__namespaces = IPC::ReadParam<nsTArray<uint32_t>>((&(reader__)));
            if (!maybe__namespaces) {
                FatalError("Error deserializing 'uint32_t[]'");
                return MsgValueError;

            }
            auto& namespaces = *maybe__namespaces;
            // Sentinel = 'namespaces'
            if ((!(((&(reader__)))->ReadSentinel(381027361)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReinitRendering(std::move(compositor), std::move(bridge), std::move(vr), std::move(video), std::move(namespaces));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NetworkLinkTypeChange__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NetworkLinkTypeChange", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SocketProcessCrashed__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SocketProcessCrashed", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_ReinitRenderingForDeviceReset__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReinitRenderingForDeviceReset", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_SetProcessSandbox__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetProcessSandbox", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBroker = *maybe__aBroker;
            // Sentinel = 'aBroker'
            if ((!(((&(reader__)))->ReadSentinel(179110599)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetProcessSandbox(std::move(aBroker));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RequestMemoryReport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RequestMemoryReport", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& minimizeMemoryUsage = *maybe__minimizeMemoryUsage;
            // Sentinel = 'minimizeMemoryUsage'
            if ((!(((&(reader__)))->ReadSentinel(1321600977)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__DMDFile = IPC::ReadParam<mozilla::Maybe<FileDescriptor>>((&(reader__)));
            if (!maybe__DMDFile) {
                FatalError("Error deserializing 'FileDescriptor?'");
                return MsgValueError;

            }
            auto& DMDFile = *maybe__DMDFile;
            // Sentinel = 'DMDFile'
            if ((!(((&(reader__)))->ReadSentinel(143983190)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_RequestMemoryReport(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRequestMemoryReport(std::move(generation), std::move(anonymize), std::move(minimizeMemoryUsage), std::move(DMDFile), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DecodeImage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DecodeImage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aSize = *maybe__aSize;
            // Sentinel = 'aSize'
            if ((!(((&(reader__)))->ReadSentinel(97124861)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ImageIntSize'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_DecodeImage(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_BidiKeyboardNotify__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BidiKeyboardNotify", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& haveBidiKeyboards = *maybe__haveBidiKeyboards;
            // Sentinel = 'haveBidiKeyboards'
            if ((!(((&(reader__)))->ReadSentinel(1003161281)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvBidiKeyboardNotify(std::move(isLangRTL), std::move(haveBidiKeyboards));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PCycleCollectWithLogsConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PCycleCollectWithLogsConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& dumpAllTraces = *maybe__dumpAllTraces;
            // Sentinel = 'dumpAllTraces'
            if ((!(((&(reader__)))->ReadSentinel(610600242)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__gcLog = IPC::ReadParam<FileDescriptor>((&(reader__)));
            if (!maybe__gcLog) {
                FatalError("Error deserializing 'FileDescriptor'");
                return MsgValueError;

            }
            auto& gcLog = *maybe__gcLog;
            // Sentinel = 'gcLog'
            if ((!(((&(reader__)))->ReadSentinel(96272877)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            auto maybe__ccLog = IPC::ReadParam<FileDescriptor>((&(reader__)));
            if (!maybe__ccLog) {
                FatalError("Error deserializing 'FileDescriptor'");
                return MsgValueError;

            }
            auto& ccLog = *maybe__ccLog;
            // Sentinel = 'ccLog'
            if ((!(((&(reader__)))->ReadSentinel(94962153)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            reader__.EndRead();
            PCycleCollectWithLogsChild* actor = (static_cast<ContentChild*>(this))->AllocPCycleCollectWithLogsChild(dumpAllTraces, gcLog, ccLog);
            if (!actor) {
                NS_WARNING("Cannot bind null PCycleCollectWithLogsChild actor");
                return MsgValueError;
            }

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

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

            return MsgProcessed;
        }
    case PContent::Msg_PTestShellConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PTestShellConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_PScriptCacheConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PScriptCacheConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& cacheFile = *maybe__cacheFile;
            // Sentinel = 'cacheFile'
            if ((!(((&(reader__)))->ReadSentinel(289014645)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'");
                return MsgValueError;
            }
            auto maybe__wantCacheData = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__wantCacheData) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& wantCacheData = *maybe__wantCacheData;
            // Sentinel = 'wantCacheData'
            if ((!(((&(reader__)))->ReadSentinel(602080521)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            PScriptCacheChild* actor = (static_cast<ContentChild*>(this))->AllocPScriptCacheChild(cacheFile, wantCacheData);
            if (!actor) {
                NS_WARNING("Cannot bind null PScriptCacheChild actor");
                return MsgValueError;
            }

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

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

            return MsgProcessed;
        }
    case PContent::Msg_RegisterChrome__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RegisterChrome", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& packages = *maybe__packages;
            // Sentinel = 'packages'
            if ((!(((&(reader__)))->ReadSentinel(244187968)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ChromePackage[]'");
                return MsgValueError;
            }
            auto maybe__substitutions = IPC::ReadParam<nsTArray<SubstitutionMapping>>((&(reader__)));
            if (!maybe__substitutions) {
                FatalError("Error deserializing 'SubstitutionMapping[]'");
                return MsgValueError;

            }
            auto& substitutions = *maybe__substitutions;
            // Sentinel = 'substitutions'
            if ((!(((&(reader__)))->ReadSentinel(668861873)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SubstitutionMapping[]'");
                return MsgValueError;
            }
            auto maybe__overrides = IPC::ReadParam<nsTArray<OverrideMapping>>((&(reader__)));
            if (!maybe__overrides) {
                FatalError("Error deserializing 'OverrideMapping[]'");
                return MsgValueError;

            }
            auto& overrides = *maybe__overrides;
            // Sentinel = 'overrides'
            if ((!(((&(reader__)))->ReadSentinel(324404180)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OverrideMapping[]'");
                return MsgValueError;
            }
            auto maybe__locale = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__locale) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

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

            }
            auto& reset = *maybe__reset;
            // Sentinel = 'reset'
            if ((!(((&(reader__)))->ReadSentinel(107610660)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterChrome(std::move(packages), std::move(substitutions), std::move(overrides), std::move(locale), std::move(reset));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RegisterChromeItem__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RegisterChromeItem", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& item = *maybe__item;
            // Sentinel = 'item'
            if ((!(((&(reader__)))->ReadSentinel(70975920)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ChromeRegistryItem'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterChromeItem(std::move(item));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ClearImageCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCache", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& privateLoader = *maybe__privateLoader;
            // Sentinel = 'privateLoader'
            if ((!(((&(reader__)))->ReadSentinel(635372883)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
                return MsgValueError;
            }
            auto maybe__aChrome = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
            if (!maybe__aChrome) {
                FatalError("Error deserializing 'bool?'");
                return MsgValueError;

            }
            auto& aChrome = *maybe__aChrome;
            // Sentinel = 'aChrome'
            if ((!(((&(reader__)))->ReadSentinel(177996480)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
                return MsgValueError;
            }
            auto maybe__aPrincipal = IPC::ReadParam<mozilla::Maybe<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__aSchemelessSite = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
            if (!maybe__aSchemelessSite) {
                FatalError("Error deserializing 'nsCString?'");
                return MsgValueError;

            }
            auto& aSchemelessSite = *maybe__aSchemelessSite;
            // Sentinel = 'aSchemelessSite'
            if ((!(((&(reader__)))->ReadSentinel(792528387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
                return MsgValueError;
            }
            auto maybe__aPattern = IPC::ReadParam<mozilla::Maybe<OriginAttributesPattern>>((&(reader__)));
            if (!maybe__aPattern) {
                FatalError("Error deserializing 'OriginAttributesPattern?'");
                return MsgValueError;

            }
            auto& aPattern = *maybe__aPattern;
            // Sentinel = 'aPattern'
            if ((!(((&(reader__)))->ReadSentinel(236651328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributesPattern?'");
                return MsgValueError;
            }
            auto maybe__aURL = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
            if (!maybe__aURL) {
                FatalError("Error deserializing 'nsCString?'");
                return MsgValueError;

            }
            auto& aURL = *maybe__aURL;
            // Sentinel = 'aURL'
            if ((!(((&(reader__)))->ReadSentinel(58130773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearImageCache(std::move(privateLoader), std::move(aChrome), std::move(aPrincipal), std::move(aSchemelessSite), std::move(aPattern), std::move(aURL));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ClearStyleSheetCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClearStyleSheetCache", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aChrome = *maybe__aChrome;
            // Sentinel = 'aChrome'
            if ((!(((&(reader__)))->ReadSentinel(177996480)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
                return MsgValueError;
            }
            auto maybe__aPrincipal = IPC::ReadParam<mozilla::Maybe<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__aSchemelessSite = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
            if (!maybe__aSchemelessSite) {
                FatalError("Error deserializing 'nsCString?'");
                return MsgValueError;

            }
            auto& aSchemelessSite = *maybe__aSchemelessSite;
            // Sentinel = 'aSchemelessSite'
            if ((!(((&(reader__)))->ReadSentinel(792528387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
                return MsgValueError;
            }
            auto maybe__aPattern = IPC::ReadParam<mozilla::Maybe<OriginAttributesPattern>>((&(reader__)));
            if (!maybe__aPattern) {
                FatalError("Error deserializing 'OriginAttributesPattern?'");
                return MsgValueError;

            }
            auto& aPattern = *maybe__aPattern;
            // Sentinel = 'aPattern'
            if ((!(((&(reader__)))->ReadSentinel(236651328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributesPattern?'");
                return MsgValueError;
            }
            auto maybe__aURL = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
            if (!maybe__aURL) {
                FatalError("Error deserializing 'nsCString?'");
                return MsgValueError;

            }
            auto& aURL = *maybe__aURL;
            // Sentinel = 'aURL'
            if ((!(((&(reader__)))->ReadSentinel(58130773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearStyleSheetCache(std::move(aChrome), std::move(aPrincipal), std::move(aSchemelessSite), std::move(aPattern), std::move(aURL));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ClearScriptCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClearScriptCache", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aChrome = *maybe__aChrome;
            // Sentinel = 'aChrome'
            if ((!(((&(reader__)))->ReadSentinel(177996480)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
                return MsgValueError;
            }
            auto maybe__aPrincipal = IPC::ReadParam<mozilla::Maybe<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__aSchemelessSite = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
            if (!maybe__aSchemelessSite) {
                FatalError("Error deserializing 'nsCString?'");
                return MsgValueError;

            }
            auto& aSchemelessSite = *maybe__aSchemelessSite;
            // Sentinel = 'aSchemelessSite'
            if ((!(((&(reader__)))->ReadSentinel(792528387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
                return MsgValueError;
            }
            auto maybe__aPattern = IPC::ReadParam<mozilla::Maybe<OriginAttributesPattern>>((&(reader__)));
            if (!maybe__aPattern) {
                FatalError("Error deserializing 'OriginAttributesPattern?'");
                return MsgValueError;

            }
            auto& aPattern = *maybe__aPattern;
            // Sentinel = 'aPattern'
            if ((!(((&(reader__)))->ReadSentinel(236651328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributesPattern?'");
                return MsgValueError;
            }
            auto maybe__aURL = IPC::ReadParam<mozilla::Maybe<nsCString>>((&(reader__)));
            if (!maybe__aURL) {
                FatalError("Error deserializing 'nsCString?'");
                return MsgValueError;

            }
            auto& aURL = *maybe__aURL;
            // Sentinel = 'aURL'
            if ((!(((&(reader__)))->ReadSentinel(58130773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvClearScriptCache(std::move(aChrome), std::move(aPrincipal), std::move(aSchemelessSite), std::move(aPattern), std::move(aURL));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InvalidateScriptCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InvalidateScriptCache", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_SetOffline__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetOffline", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SetConnectivity__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetConnectivity", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SetCaptivePortalState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetCaptivePortalState", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SetTRRMode__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetTRRMode", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aModeFromPref = *maybe__aModeFromPref;
            // Sentinel = 'aModeFromPref'
            if ((!(((&(reader__)))->ReadSentinel(580846856)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ResolverMode'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetTRRMode(std::move(aMode), std::move(aModeFromPref));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyVisited__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyVisited", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& uri = *maybe__uri;
            // Sentinel = 'uri'
            if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'VisitedQueryResult[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyVisited(std::move(uri));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ThemeChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ThemeChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& lookAndFeelData = *maybe__lookAndFeelData;
            // Sentinel = 'lookAndFeelData'
            if ((!(((&(reader__)))->ReadSentinel(782239167)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FullLookAndFeel'");
                return MsgValueError;
            }
            auto maybe__aKind = IPC::ReadParam<ThemeChangeKind>((&(reader__)));
            if (!maybe__aKind) {
                FatalError("Error deserializing 'ThemeChangeKind'");
                return MsgValueError;

            }
            auto& aKind = *maybe__aKind;
            // Sentinel = 'aKind'
            if ((!(((&(reader__)))->ReadSentinel(93389288)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ThemeChangeKind'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvThemeChanged(std::move(lookAndFeelData), std::move(aKind));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PreferenceUpdate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PreferenceUpdate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_VarUpdate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_VarUpdate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& var = *maybe__var;
            // Sentinel = 'var'
            if ((!(((&(reader__)))->ReadSentinel(43581770)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GfxVarUpdate[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvVarUpdate(std::move(var));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdatePerfStatsCollectionMask__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdatePerfStatsCollectionMask", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_CollectPerfStatsJSON__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CollectPerfStatsJSON", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_CollectPerfStatsJSON(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_CollectScrollingMetrics__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CollectScrollingMetrics", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_CollectScrollingMetrics(id__));
            reply__->set_seqno(msg__.seqno());

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

            CollectScrollingMetricsResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const uint32_t&, const uint32_t&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'pixelsScrolled'
                    ((&(writer__)))->WriteSentinel(738395598);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'scrollDurationMS'
                    ((&(writer__)))->WriteSentinel(945030774);

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

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

            return MsgProcessed;
        }
    case PContent::Msg_GeolocationUpdate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GeolocationUpdate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPosition = *maybe__aPosition;
            // Sentinel = 'aPosition'
            if ((!(((&(reader__)))->ReadSentinel(303104951)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIDOMGeoPosition'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGeolocationUpdate(aPosition);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GeolocationError__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GeolocationError", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& errorCode = *maybe__errorCode;
            // Sentinel = 'errorCode'
            if ((!(((&(reader__)))->ReadSentinel(312345510)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint16_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGeolocationError(std::move(errorCode));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateDictionaryList__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateDictionaryList", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& dictionaries = *maybe__dictionaries;
            // Sentinel = 'dictionaries'
            if ((!(((&(reader__)))->ReadSentinel(540738815)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateDictionaryList(std::move(dictionaries));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateFontList__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateFontList", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& fontList = *maybe__fontList;
            // Sentinel = 'fontList'
            if ((!(((&(reader__)))->ReadSentinel(249430868)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SystemFontList'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateFontList(std::move(fontList));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RebuildFontList__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RebuildFontList", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_ForceGlobalReflow__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ForceGlobalReflow", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFlags = *maybe__aFlags;
            // Sentinel = 'aFlags'
            if ((!(((&(reader__)))->ReadSentinel(129892943)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GlobalReflowFlags'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvForceGlobalReflow(std::move(aFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FontListShmBlockAdded__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FontListShmBlockAdded", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aIndex = *maybe__aIndex;
            // Sentinel = 'aIndex'
            if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aHandle = IPC::ReadParam<ReadOnlySharedMemoryHandle>((&(reader__)));
            if (!maybe__aHandle) {
                FatalError("Error deserializing 'ReadOnlySharedMemoryHandle'");
                return MsgValueError;

            }
            auto& aHandle = *maybe__aHandle;
            // Sentinel = 'aHandle'
            if ((!(((&(reader__)))->ReadSentinel(174326446)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFontListShmBlockAdded(std::move(aGeneration), std::move(aIndex), std::move(aHandle));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateAppLocales__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateAppLocales", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& appLocales = *maybe__appLocales;
            // Sentinel = 'appLocales'
            if ((!(((&(reader__)))->ReadSentinel(367395845)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateAppLocales(std::move(appLocales));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateRequestedLocales__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateRequestedLocales", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& requestedLocales = *maybe__requestedLocales;
            // Sentinel = 'requestedLocales'
            if ((!(((&(reader__)))->ReadSentinel(951977622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateRequestedLocales(std::move(requestedLocales));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SystemTimezoneChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SystemTimezoneChanged", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_UpdateL10nFileSources__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateL10nFileSources", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& sources = *maybe__sources;
            // Sentinel = 'sources'
            if ((!(((&(reader__)))->ReadSentinel(205325061)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'L10nFileSourceDescriptor[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateL10nFileSources(std::move(sources));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RegisterStringBundles__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RegisterStringBundles", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& stringBundles = *maybe__stringBundles;
            // Sentinel = 'stringBundles'
            if ((!(((&(reader__)))->ReadSentinel(640484709)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StringBundleDescriptor[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterStringBundles(std::move(stringBundles));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SimpleURIUnknownRemoteSchemes__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SimpleURIUnknownRemoteSchemes", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& remoteSchemes = *maybe__remoteSchemes;
            // Sentinel = 'remoteSchemes'
            if ((!(((&(reader__)))->ReadSentinel(629867861)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSimpleURIUnknownRemoteSchemes(std::move(remoteSchemes));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateSharedData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateSharedData", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aMapHandle = *maybe__aMapHandle;
            // Sentinel = 'aMapHandle'
            if ((!(((&(reader__)))->ReadSentinel(341246924)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle'");
                return MsgValueError;
            }
            auto maybe__blobs = IPC::ReadParam<nsTArray<IPCBlob>>((&(reader__)));
            if (!maybe__blobs) {
                FatalError("Error deserializing 'IPCBlob[]'");
                return MsgValueError;

            }
            auto& blobs = *maybe__blobs;
            // Sentinel = 'blobs'
            if ((!(((&(reader__)))->ReadSentinel(102957587)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob[]'");
                return MsgValueError;
            }
            auto maybe__changedKeys = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
            if (!maybe__changedKeys) {
                FatalError("Error deserializing 'nsCString[]'");
                return MsgValueError;

            }
            auto& changedKeys = *maybe__changedKeys;
            // Sentinel = 'changedKeys'
            if ((!(((&(reader__)))->ReadSentinel(437781607)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateSharedData(std::move(aMapHandle), std::move(blobs), std::move(changedKeys));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AddPermission__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddPermission", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_RemoveAllPermissions__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveAllPermissions", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_FlushMemory__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FlushMemory", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_ApplicationBackground__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ApplicationBackground", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_ApplicationForeground__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ApplicationForeground", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_GarbageCollect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GarbageCollect", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_CycleCollect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CycleCollect", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_UnlinkGhosts__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnlinkGhosts", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_ActivateA11y__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ActivateA11y", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_ShutdownA11y__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ShutdownA11y", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_SetCacheDomains__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetCacheDomains", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_AppInfo__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AppInfo", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& version = *maybe__version;
            // Sentinel = 'version'
            if ((!(((&(reader__)))->ReadSentinel(204210951)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__buildID = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__buildID) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& buildID = *maybe__buildID;
            // Sentinel = 'buildID'
            if ((!(((&(reader__)))->ReadSentinel(187826846)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__name = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__name) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& name = *maybe__name;
            // Sentinel = 'name'
            if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__UAName = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__UAName) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& UAName = *maybe__UAName;
            // Sentinel = 'UAName'
            if ((!(((&(reader__)))->ReadSentinel(115540504)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__ID = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__ID) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& ID = *maybe__ID;
            // Sentinel = 'ID'
            if ((!(((&(reader__)))->ReadSentinel(14155918)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__vendor = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__vendor) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& vendor = *maybe__vendor;
            // Sentinel = 'vendor'
            if ((!(((&(reader__)))->ReadSentinel(150405775)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__sourceURL = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__sourceURL) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& sourceURL = *maybe__sourceURL;
            // Sentinel = 'sourceURL'
            if ((!(((&(reader__)))->ReadSentinel(316474245)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__updateURL = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__updateURL) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& updateURL = *maybe__updateURL;
            // Sentinel = 'updateURL'
            if ((!(((&(reader__)))->ReadSentinel(309265271)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAppInfo(std::move(version), std::move(buildID), std::move(name), std::move(UAName), std::move(ID), std::move(vendor), std::move(sourceURL), std::move(updateURL));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RemoteType__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoteType", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aRemoteType = *maybe__aRemoteType;
            // Sentinel = 'aRemoteType'
            if ((!(((&(reader__)))->ReadSentinel(437847152)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__aProfile = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__aProfile) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& aProfile = *maybe__aProfile;
            // Sentinel = 'aProfile'
            if ((!(((&(reader__)))->ReadSentinel(237437747)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRemoteType(std::move(aRemoteType), std::move(aProfile));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitRemoteWorkerService__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitRemoteWorkerService", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aDebuggerChildEp = *maybe__aDebuggerChildEp;
            // Sentinel = 'aDebuggerChildEp'
            if ((!(((&(reader__)))->ReadSentinel(869271072)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::dom::PRemoteWorkerDebuggerManagerChild>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitRemoteWorkerService(std::move(aEndpoint), std::move(aDebuggerChildEp));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitBlobURLs__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitBlobURLs", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& registrations = *maybe__registrations;
            // Sentinel = 'registrations'
            if ((!(((&(reader__)))->ReadSentinel(648873359)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BlobURLRegistrationData[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitBlobURLs(std::move(registrations));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitJSActorInfos__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitJSActorInfos", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContentInfos = *maybe__aContentInfos;
            // Sentinel = 'aContentInfos'
            if ((!(((&(reader__)))->ReadSentinel(600638780)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'JSProcessActorInfo[]'");
                return MsgValueError;
            }
            auto maybe__aWindowInfos = IPC::ReadParam<nsTArray<JSWindowActorInfo>>((&(reader__)));
            if (!maybe__aWindowInfos) {
                FatalError("Error deserializing 'JSWindowActorInfo[]'");
                return MsgValueError;

            }
            auto& aWindowInfos = *maybe__aWindowInfos;
            // Sentinel = 'aWindowInfos'
            if ((!(((&(reader__)))->ReadSentinel(518522073)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'JSWindowActorInfo[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvInitJSActorInfos(std::move(aContentInfos), std::move(aWindowInfos));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UnregisterJSWindowActor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnregisterJSWindowActor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& name = *maybe__name;
            // Sentinel = 'name'
            if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnregisterJSWindowActor(std::move(name));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UnregisterJSProcessActor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnregisterJSProcessActor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& name = *maybe__name;
            // Sentinel = 'name'
            if ((!(((&(reader__)))->ReadSentinel(69075362)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUnregisterJSProcessActor(std::move(name));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetXPCOMProcessAttributes__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetXPCOMProcessAttributes", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& xpcomInit = *maybe__xpcomInit;
            // Sentinel = 'xpcomInit'
            if ((!(((&(reader__)))->ReadSentinel(316998588)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'XPCOMInitData'");
                return MsgValueError;
            }
            auto maybe__initialData = IPC::ReadParam<UniquePtr<StructuredCloneData>>((&(reader__)));
            if (!maybe__initialData) {
                FatalError("Error deserializing 'UniquePtr<StructuredCloneData>'");
                return MsgValueError;

            }
            auto& initialData = *maybe__initialData;
            // Sentinel = 'initialData'
            if ((!(((&(reader__)))->ReadSentinel(451413093)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'UniquePtr<StructuredCloneData>'");
                return MsgValueError;
            }
            auto maybe__lookAndFeeldata = IPC::ReadParam<FullLookAndFeel>((&(reader__)));
            if (!maybe__lookAndFeeldata) {
                FatalError("Error deserializing 'FullLookAndFeel'");
                return MsgValueError;

            }
            auto& lookAndFeeldata = *maybe__lookAndFeeldata;
            // Sentinel = 'lookAndFeeldata'
            if ((!(((&(reader__)))->ReadSentinel(790627807)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FullLookAndFeel'");
                return MsgValueError;
            }
            auto maybe__systemFontList = IPC::ReadParam<SystemFontList>((&(reader__)));
            if (!maybe__systemFontList) {
                FatalError("Error deserializing 'SystemFontList'");
                return MsgValueError;

            }
            auto& systemFontList = *maybe__systemFontList;
            // Sentinel = 'systemFontList'
            if ((!(((&(reader__)))->ReadSentinel(746194393)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SystemFontList'");
                return MsgValueError;
            }
            auto maybe__sharedUASheetHandle = IPC::ReadParam<mozilla::Maybe<ReadOnlySharedMemoryHandle>>((&(reader__)));
            if (!maybe__sharedUASheetHandle) {
                FatalError("Error deserializing 'ReadOnlySharedMemoryHandle?'");
                return MsgValueError;

            }
            auto& sharedUASheetHandle = *maybe__sharedUASheetHandle;
            // Sentinel = 'sharedUASheetHandle'
            if ((!(((&(reader__)))->ReadSentinel(1232406355)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle?'");
                return MsgValueError;
            }
            auto maybe__sharedUASheetAddress = IPC::ReadParam<uintptr_t>((&(reader__)));
            if (!maybe__sharedUASheetAddress) {
                FatalError("Error deserializing 'uintptr_t'");
                return MsgValueError;

            }
            auto& sharedUASheetAddress = *maybe__sharedUASheetAddress;
            // Sentinel = 'sharedUASheetAddress'
            if ((!(((&(reader__)))->ReadSentinel(1361643469)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uintptr_t'");
                return MsgValueError;
            }
            auto maybe__sharedFontListBlocks = IPC::ReadParam<nsTArray<ReadOnlySharedMemoryHandle>>((&(reader__)));
            if (!maybe__sharedFontListBlocks) {
                FatalError("Error deserializing 'ReadOnlySharedMemoryHandle[]'");
                return MsgValueError;

            }
            auto& sharedFontListBlocks = *maybe__sharedFontListBlocks;
            // Sentinel = 'sharedFontListBlocks'
            if ((!(((&(reader__)))->ReadSentinel(1412827145)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ReadOnlySharedMemoryHandle[]'");
                return MsgValueError;
            }
            auto maybe__aIsStartingUp = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsStartingUp) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsStartingUp = *maybe__aIsStartingUp;
            // Sentinel = 'aIsStartingUp'
            if ((!(((&(reader__)))->ReadSentinel(597361967)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetXPCOMProcessAttributes(std::move(xpcomInit), std::move(initialData), std::move(lookAndFeeldata), std::move(systemFontList), std::move(sharedUASheetHandle), std::move(sharedUASheetAddress), std::move(sharedFontListBlocks), std::move(aIsStartingUp));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_LastPrivateDocShellDestroyed__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_LastPrivateDocShellDestroyed", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_NotifyProcessPriorityChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyProcessPriorityChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& priority = *maybe__priority;
            // Sentinel = 'priority'
            if ((!(((&(reader__)))->ReadSentinel(262865795)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ProcessPriority'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyProcessPriorityChanged(std::move(priority));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_MinimizeMemoryUsage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_MinimizeMemoryUsage", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_LoadAndRegisterSheet__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_LoadAndRegisterSheet", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_UnregisterSheet__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnregisterSheet", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_NotifyIdleObserver__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyIdleObserver", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& observerId = *maybe__observerId;
            // Sentinel = 'observerId'
            if ((!(((&(reader__)))->ReadSentinel(386335766)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__topic = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__topic) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& topic = *maybe__topic;
            // Sentinel = 'topic'
            if ((!(((&(reader__)))->ReadSentinel(109707808)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__str = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__str) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& str = *maybe__str;
            // Sentinel = 'str'
            if ((!(((&(reader__)))->ReadSentinel(45482330)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyIdleObserver(std::move(observerId), std::move(topic), std::move(str));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DomainSetChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DomainSetChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aChangeType = *maybe__aChangeType;
            // Sentinel = 'aChangeType'
            if ((!(((&(reader__)))->ReadSentinel(417924170)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aDomain = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__aDomain) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_Shutdown__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_Shutdown", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_LoadProcessScript__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_LoadProcessScript", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_UpdateWindow__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateWindow", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_NotifyEmptyHTTPCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyEmptyHTTPCache", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_Push__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_Push", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& messageId = *maybe__messageId;
            // Sentinel = 'messageId'
            if ((!(((&(reader__)))->ReadSentinel(310576019)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPush(std::move(scope), principal, std::move(messageId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PushWithData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PushWithData", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& messageId = *maybe__messageId;
            // Sentinel = 'messageId'
            if ((!(((&(reader__)))->ReadSentinel(310576019)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__data = IPC::ReadParam<nsTArray<uint8_t>>((&(reader__)));
            if (!maybe__data) {
                FatalError("Error deserializing 'uint8_t[]'");
                return MsgValueError;

            }
            auto& data = *maybe__data;
            // Sentinel = 'data'
            if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint8_t[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPushWithData(std::move(scope), principal, std::move(messageId), std::move(data));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GetFilesResponse__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetFilesResponse", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aID = *maybe__aID;
            // Sentinel = 'aID'
            if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__aResult = IPC::ReadParam<GetFilesResponseResult>((&(reader__)));
            if (!maybe__aResult) {
                FatalError("Error deserializing 'GetFilesResponseResult'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_BlobURLRegistration__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BlobURLRegistration", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aBlob = *maybe__aBlob;
            // Sentinel = 'aBlob'
            if ((!(((&(reader__)))->ReadSentinel(91619809)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
                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__aPartitionKey = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__aPartitionKey) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& aPartitionKey = *maybe__aPartitionKey;
            // Sentinel = 'aPartitionKey'
            if ((!(((&(reader__)))->ReadSentinel(610141509)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvBlobURLRegistration(std::move(aURI), std::move(aBlob), aPrincipal, std::move(aPartitionKey));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_BlobURLUnregistration__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BlobURLUnregistration", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_GMPsChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GMPsChanged", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& capabilities = *maybe__capabilities;
            // Sentinel = 'capabilities'
            if ((!(((&(reader__)))->ReadSentinel(527434987)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GMPCapabilityData[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGMPsChanged(std::move(capabilities));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ProvideAnonymousTemporaryFile__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ProvideAnonymousTemporaryFile", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aID = *maybe__aID;
            // Sentinel = 'aID'
            if ((!(((&(reader__)))->ReadSentinel(33292527)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aFD = IPC::ReadParam<FileDescOrError>((&(reader__)));
            if (!maybe__aFD) {
                FatalError("Error deserializing 'FileDescOrError'");
                return MsgValueError;

            }
            auto& aFD = *maybe__aFD;
            // Sentinel = 'aFD'
            if ((!(((&(reader__)))->ReadSentinel(32899308)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescOrError'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvProvideAnonymousTemporaryFile(std::move(aID), std::move(aFD));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetPermissionsWithKey__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetPermissionsWithKey", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPermissionKey = *maybe__aPermissionKey;
            // Sentinel = 'aPermissionKey'
            if ((!(((&(reader__)))->ReadSentinel(708511156)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__aPermissions = IPC::ReadParam<nsTArray<Permission>>((&(reader__)));
            if (!maybe__aPermissions) {
                FatalError("Error deserializing 'Permission[]'");
                return MsgValueError;

            }
            auto& aPermissions = *maybe__aPermissions;
            // Sentinel = 'aPermissions'
            if ((!(((&(reader__)))->ReadSentinel(527697150)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Permission[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetPermissionsWithKey(std::move(aPermissionKey), std::move(aPermissions));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RefreshScreens__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RefreshScreens", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aScreens = *maybe__aScreens;
            // Sentinel = 'aScreens'
            if ((!(((&(reader__)))->ReadSentinel(234029877)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScreenDetails[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRefreshScreens(std::move(aScreens));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ShareCodeCoverageMutex__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ShareCodeCoverageMutex", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& handle = *maybe__handle;
            // Sentinel = 'handle'
            if ((!(((&(reader__)))->ReadSentinel(142344813)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CrossProcessMutexHandle'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvShareCodeCoverageMutex(std::move(handle));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FlushCodeCoverageCounters__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FlushCodeCoverageCounters", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_FlushCodeCoverageCounters(id__));
            reply__->set_seqno(msg__.seqno());

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

            FlushCodeCoverageCountersResolver 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 = 'unused'
                    ((&(writer__)))->WriteSentinel(155517589);

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SetInputEventQueueEnabled__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetInputEventQueueEnabled", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_FlushInputEventQueue__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FlushInputEventQueue", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_ResumeInputEventQueue__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ResumeInputEventQueue", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_SuspendInputEventQueue__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SuspendInputEventQueue", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_AddDynamicScalars__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddDynamicScalars", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& definitions = *maybe__definitions;
            // Sentinel = 'definitions'
            if ((!(((&(reader__)))->ReadSentinel(455279773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DynamicScalarDefinition[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAddDynamicScalars(std::move(definitions));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CrossProcessRedirect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CrossProcessRedirect", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& args = *maybe__args;
            // Sentinel = 'args'
            if ((!(((&(reader__)))->ReadSentinel(69140910)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RedirectToRealChannelArgs'");
                return MsgValueError;
            }
            auto maybe__aEndpoint = IPC::ReadParam<nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>>((&(reader__)));
            if (!maybe__aEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterParent>[]'");
                return MsgValueError;

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::extensions::PStreamFilterParent>[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_CrossProcessRedirect(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_StartDelayedAutoplayMediaComponents__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StartDelayedAutoplayMediaComponents", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_UpdateMediaControlAction__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateMediaControlAction", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aAction = IPC::ReadParam<MediaControlAction>((&(reader__)));
            if (!maybe__aAction) {
                FatalError("Error deserializing 'MediaControlAction'");
                return MsgValueError;

            }
            auto& aAction = *maybe__aAction;
            // Sentinel = 'aAction'
            if ((!(((&(reader__)))->ReadSentinel(175768256)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MediaControlAction'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateMediaControlAction(std::move(aContext), std::move(aAction));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RegisterBrowsingContextGroup__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RegisterBrowsingContextGroup", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aGroupId = *maybe__aGroupId;
            // Sentinel = 'aGroupId'
            if ((!(((&(reader__)))->ReadSentinel(233964316)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aInits = IPC::ReadParam<nsTArray<SyncedContextInitializer>>((&(reader__)));
            if (!maybe__aInits) {
                FatalError("Error deserializing 'SyncedContextInitializer[]'");
                return MsgValueError;

            }
            auto& aInits = *maybe__aInits;
            // Sentinel = 'aInits'
            if ((!(((&(reader__)))->ReadSentinel(134677097)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SyncedContextInitializer[]'");
                return MsgValueError;
            }
            auto maybe__aUseOriginAgentCluster = IPC::ReadParam<nsTArray<OriginAgentClusterInitializer>>((&(reader__)));
            if (!maybe__aUseOriginAgentCluster) {
                FatalError("Error deserializing 'OriginAgentClusterInitializer[]'");
                return MsgValueError;

            }
            auto& aUseOriginAgentCluster = *maybe__aUseOriginAgentCluster;
            // Sentinel = 'aUseOriginAgentCluster'
            if ((!(((&(reader__)))->ReadSentinel(1658849480)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAgentClusterInitializer[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvRegisterBrowsingContextGroup(std::move(aGroupId), std::move(aInits), std::move(aUseOriginAgentCluster));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DestroyBrowsingContextGroup__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DestroyBrowsingContextGroup", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SetUseOriginAgentCluster__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetUseOriginAgentCluster", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aUseOriginAgentCluster = *maybe__aUseOriginAgentCluster;
            // Sentinel = 'aUseOriginAgentCluster'
            if ((!(((&(reader__)))->ReadSentinel(1658849480)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetUseOriginAgentCluster(std::move(aGroupId), aPrincipal, std::move(aUseOriginAgentCluster));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aSetNavigating = *maybe__aSetNavigating;
            // Sentinel = 'aSetNavigating'
            if ((!(((&(reader__)))->ReadSentinel(686556566)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_LoadURI(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_DisplayLoadError__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DisplayLoadError", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aURI = *maybe__aURI;
            // Sentinel = 'aURI'
            if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDisplayLoadError(std::move(aContext), std::move(aURI));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GoBack__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GoBack", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aCancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
            if (!maybe__aCancelContentJSEpoch) {
                FatalError("Error deserializing 'int32_t?'");
                return MsgValueError;

            }
            auto& aCancelContentJSEpoch = *maybe__aCancelContentJSEpoch;
            // Sentinel = 'aCancelContentJSEpoch'
            if ((!(((&(reader__)))->ReadSentinel(1473841167)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
                return MsgValueError;
            }
            auto maybe__aRequireUserInteraction = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aRequireUserInteraction) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            }
            auto& aUserActivation = *maybe__aUserActivation;
            // Sentinel = 'aUserActivation'
            if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGoBack(std::move(aContext), std::move(aCancelContentJSEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GoForward__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GoForward", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aCancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
            if (!maybe__aCancelContentJSEpoch) {
                FatalError("Error deserializing 'int32_t?'");
                return MsgValueError;

            }
            auto& aCancelContentJSEpoch = *maybe__aCancelContentJSEpoch;
            // Sentinel = 'aCancelContentJSEpoch'
            if ((!(((&(reader__)))->ReadSentinel(1473841167)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
                return MsgValueError;
            }
            auto maybe__aRequireUserInteraction = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aRequireUserInteraction) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            }
            auto& aUserActivation = *maybe__aUserActivation;
            // Sentinel = 'aUserActivation'
            if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGoForward(std::move(aContext), std::move(aCancelContentJSEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GoToIndex__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GoToIndex", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aIndex = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aIndex) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

            }
            auto& aIndex = *maybe__aIndex;
            // Sentinel = 'aIndex'
            if ((!(((&(reader__)))->ReadSentinel(132055642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            auto maybe__aCancelContentJSEpoch = IPC::ReadParam<mozilla::Maybe<int32_t>>((&(reader__)));
            if (!maybe__aCancelContentJSEpoch) {
                FatalError("Error deserializing 'int32_t?'");
                return MsgValueError;

            }
            auto& aCancelContentJSEpoch = *maybe__aCancelContentJSEpoch;
            // Sentinel = 'aCancelContentJSEpoch'
            if ((!(((&(reader__)))->ReadSentinel(1473841167)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t?'");
                return MsgValueError;
            }
            auto maybe__aUserActivation = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aUserActivation) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aUserActivation = *maybe__aUserActivation;
            // Sentinel = 'aUserActivation'
            if ((!(((&(reader__)))->ReadSentinel(794887699)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvGoToIndex(std::move(aContext), std::move(aIndex), std::move(aCancelContentJSEpoch), std::move(aUserActivation));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_Reload__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_Reload", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aReloadFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aReloadFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aReloadFlags = *maybe__aReloadFlags;
            // Sentinel = 'aReloadFlags'
            if ((!(((&(reader__)))->ReadSentinel(499451046)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReload(std::move(aContext), std::move(aReloadFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_StopLoad__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StopLoad", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aStopFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aStopFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aStopFlags = *maybe__aStopFlags;
            // Sentinel = 'aStopFlags'
            if ((!(((&(reader__)))->ReadSentinel(360317941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvStopLoad(std::move(aContext), std::move(aStopFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_OnAllowAccessFor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_OnAllowAccessFor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aCookieBehavior = *maybe__aCookieBehavior;
            // Sentinel = 'aCookieBehavior'
            if ((!(((&(reader__)))->ReadSentinel(772408812)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aReason = IPC::ReadParam<StorageAccessPermissionGrantedReason>((&(reader__)));
            if (!maybe__aReason) {
                FatalError("Error deserializing 'StorageAccessPermissionGrantedReason'");
                return MsgValueError;

            }
            auto& aReason = *maybe__aReason;
            // Sentinel = 'aReason'
            if ((!(((&(reader__)))->ReadSentinel(180093642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StorageAccessPermissionGrantedReason'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvOnAllowAccessFor(std::move(aParentContext), std::move(aTrackingOrigin), std::move(aCookieBehavior), std::move(aReason));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_OnContentBlockingDecision__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_OnContentBlockingDecision", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aReason = IPC::ReadParam<BlockingDecision>((&(reader__)));
            if (!maybe__aReason) {
                FatalError("Error deserializing 'BlockingDecision'");
                return MsgValueError;

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

            }
            auto& aRejectedReason = *maybe__aRejectedReason;
            // Sentinel = 'aRejectedReason'
            if ((!(((&(reader__)))->ReadSentinel(781059568)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvOnContentBlockingDecision(std::move(aContext), std::move(aReason), std::move(aRejectedReason));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AbortOrientationPendingPromises__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AbortOrientationPendingPromises", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_HistoryCommitIndexAndLength__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_HistoryCommitIndexAndLength", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aIndex = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aIndex) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

            }
            auto& aLength = *maybe__aLength;
            // Sentinel = 'aLength'
            if ((!(((&(reader__)))->ReadSentinel(179045060)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aChangeID = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__aChangeID) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& aChangeID = *maybe__aChangeID;
            // Sentinel = 'aChangeID'
            if ((!(((&(reader__)))->ReadSentinel(275710773)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvHistoryCommitIndexAndLength(std::move(aContext), std::move(aIndex), std::move(aLength), std::move(aChangeID));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GetLayoutHistoryState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetLayoutHistoryState", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_GetLayoutHistoryState(id__));
            reply__->set_seqno(msg__.seqno());

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

            GetLayoutHistoryStateResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<nsILayoutHistoryState*, const mozilla::Maybe<Wireframe>&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'aState'
                    ((&(writer__)))->WriteSentinel(137036387);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'aWireframe'
                    ((&(writer__)))->WriteSentinel(365888516);

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

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

            return MsgProcessed;
        }
    case PContent::Msg_DispatchLocationChangeEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DispatchLocationChangeEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_DispatchBeforeUnloadToSubtree__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DispatchBeforeUnloadToSubtree", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aStartingAt = *maybe__aStartingAt;
            // Sentinel = 'aStartingAt'
            if ((!(((&(reader__)))->ReadSentinel(441844835)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__info = IPC::ReadParam<mozilla::Maybe<SessionHistoryInfo>>((&(reader__)));
            if (!maybe__info) {
                FatalError("Error deserializing 'SessionHistoryInfo?'");
                return MsgValueError;

            }
            auto& info = *maybe__info;
            // Sentinel = 'info'
            if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SessionHistoryInfo?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_DispatchBeforeUnloadToSubtree(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_DispatchNavigateToTraversable__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DispatchNavigateToTraversable", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTraversable = *maybe__aTraversable;
            // Sentinel = 'aTraversable'
            if ((!(((&(reader__)))->ReadSentinel(525731037)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__info = IPC::ReadParam<mozilla::Maybe<SessionHistoryInfo>>((&(reader__)));
            if (!maybe__info) {
                FatalError("Error deserializing 'SessionHistoryInfo?'");
                return MsgValueError;

            }
            auto& info = *maybe__info;
            // Sentinel = 'info'
            if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SessionHistoryInfo?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_DispatchNavigateToTraversable(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_UpdateMediaCodecsSupported__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateMediaCodecsSupported", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aSupported = *maybe__aSupported;
            // Sentinel = 'aSupported'
            if ((!(((&(reader__)))->ReadSentinel(378799144)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MediaCodecsSupported'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvUpdateMediaCodecsSupported(std::move(aLocation), std::move(aSupported));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitNextGenLocalStorageEnabled__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitNextGenLocalStorageEnabled", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_PRemotePrintJobConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PRemotePrintJobConstructor", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_ConsumeHistoryActivation__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ConsumeHistoryActivation", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            AUTO_PROFILER_LABEL("PContent::Msg_GetLoadingSessionHistoryInfoFromParent", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_InitStreamFilter", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_PRemoteSpellcheckEngineConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PHalConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PHeapSnapshotTempFileHelperConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PNeckoConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PSpeechSynthesisConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PMediaConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_CreateAudioIPCConnection__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_CreateAudioIPCConnection", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_PURLClassifierLocalConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PURLClassifierLocalByNameConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PSessionStorageObserverConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PExternalHelperAppConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PHandlerServiceConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_GetClipboardDataSnapshot__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshot", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_PClipboardWriteRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_FindImageText__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_FindImageText", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_PContentPermissionRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_CreateWindow__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_CreateWindow", OTHER);


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

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


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

            AUTO_PROFILER_LABEL("PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_StorageAccessPermissionGrantedForOrigin", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_CompleteAllowAccessFor", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_SetAllowStorageAccessRequestFlag", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_TestAllowStorageAccessRequestFlag", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_TestCookiePermissionDecided", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_TestStorageAccessPermission", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_NotifyOnHistoryReload", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_HistoryGo", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_NavigationTraverse", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_BlobURLDataRequest", OTHER);


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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

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

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

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

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

            }
            auto& isFromChromeContext = *maybe__isFromChromeContext;
            // Sentinel = 'isFromChromeContext'
            if ((!(((&(reader__)))->ReadSentinel(1269368756)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvScriptError(std::move(message), std::move(sourceName), std::move(lineNumber), std::move(colNumber), std::move(flags), std::move(category), std::move(isFromPrivateWindow), std::move(innerWindowId), std::move(isFromChromeContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReportFrameTimingData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReportFrameTimingData", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& loadInfo = *maybe__loadInfo;
            // Sentinel = 'loadInfo'
            if ((!(((&(reader__)))->ReadSentinel(240386861)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LoadInfoArgs'");
                return MsgValueError;
            }
            auto maybe__entryName = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__entryName) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

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

            }
            auto& initiatorType = *maybe__initiatorType;
            // Sentinel = 'initiatorType'
            if ((!(((&(reader__)))->ReadSentinel(642647414)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<UniquePtr<PerformanceTimingData>>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'UniquePtr<PerformanceTimingData>'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_CommitBrowsingContextTransaction__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CommitBrowsingContextTransaction", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aTransaction = IPC::ReadParam<BrowsingContextTransaction>((&(reader__)));
            if (!maybe__aTransaction) {
                FatalError("Error deserializing 'BrowsingContextTransaction'");
                return MsgValueError;

            }
            auto& aTransaction = *maybe__aTransaction;
            // Sentinel = 'aTransaction'
            if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextTransaction'");
                return MsgValueError;
            }
            auto maybe__aEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aEpoch) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aEpoch = *maybe__aEpoch;
            // Sentinel = 'aEpoch'
            if ((!(((&(reader__)))->ReadSentinel(132121169)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCommitBrowsingContextTransaction(std::move(aContext), std::move(aTransaction), std::move(aEpoch));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AsyncMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::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<ContentChild*>(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 PContent::Msg_NotifyPushSubscriptionModifiedObservers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& principal = *maybe__principal;
            // Sentinel = 'principal'
            if ((!(((&(reader__)))->ReadSentinel(319620035)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvNotifyPushSubscriptionModifiedObservers(std::move(scope), principal);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PushError__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PushError", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

            }
            auto& flags = *maybe__flags;
            // Sentinel = 'flags'
            if ((!(((&(reader__)))->ReadSentinel(102171150)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvPushError(std::move(scope), principal, std::move(message), std::move(flags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CreateBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateBrowsingContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aGroupId = *maybe__aGroupId;
            // Sentinel = 'aGroupId'
            if ((!(((&(reader__)))->ReadSentinel(233964316)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aInit = IPC::ReadParam<BrowsingContextInitializer>((&(reader__)));
            if (!maybe__aInit) {
                FatalError("Error deserializing 'BrowsingContextInitializer'");
                return MsgValueError;

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

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

            AUTO_PROFILER_LABEL("PContent::Msg_DiscardBrowsingContext", OTHER);


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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aDoDiscard = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aDoDiscard) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aDoDiscard = *maybe__aDoDiscard;
            // Sentinel = 'aDoDiscard'
            if ((!(((&(reader__)))->ReadSentinel(339215311)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_DiscardBrowsingContext(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_AdjustWindowFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AdjustWindowFocus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aIsVisible = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsVisible) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsVisible = *maybe__aIsVisible;
            // Sentinel = 'aIsVisible'
            if ((!(((&(reader__)))->ReadSentinel(353567724)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            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;
            }
            auto maybe__aShouldClearAncestorFocus = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aShouldClearAncestorFocus) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aShouldClearAncestorFocus = *maybe__aShouldClearAncestorFocus;
            // Sentinel = 'aShouldClearAncestorFocus'
            if ((!(((&(reader__)))->ReadSentinel(2138442231)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aAncestorBrowsingContextToFocus = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aAncestorBrowsingContextToFocus) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aAncestorBrowsingContextToFocus = *maybe__aAncestorBrowsingContextToFocus;
            // Sentinel = 'aAncestorBrowsingContextToFocus'
            if ((!(((&(reader__)))->ReadSentinel(3344239764)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvAdjustWindowFocus(std::move(aContext), std::move(aIsVisible), std::move(aActionId), std::move(aShouldClearAncestorFocus), std::move(aAncestorBrowsingContextToFocus));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_WindowClose__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_WindowClose", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aTrustedCaller = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aTrustedCaller) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aTrustedCaller = *maybe__aTrustedCaller;
            // Sentinel = 'aTrustedCaller'
            if ((!(((&(reader__)))->ReadSentinel(706479520)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvWindowClose(std::move(aContext), std::move(aTrustedCaller));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_WindowFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_WindowFocus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aCallerType = *maybe__aCallerType;
            // Sentinel = 'aCallerType'
            if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvWindowFocus(std::move(aContext), std::move(aCallerType), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_WindowBlur__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_WindowBlur", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_RaiseWindow__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RaiseWindow", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aCallerType = *maybe__aCallerType;
            // Sentinel = 'aCallerType'
            if ((!(((&(reader__)))->ReadSentinel(422118487)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CallerType'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvRaiseWindow(std::move(aContext), std::move(aCallerType), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ClearFocus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClearFocus", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_SetFocusedBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedBrowsingContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvSetFocusedBrowsingContext(std::move(aContext), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetActiveBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetActiveBrowsingContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvSetActiveBrowsingContext(std::move(aContext), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UnsetActiveBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnsetActiveBrowsingContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvUnsetActiveBrowsingContext(std::move(aContext), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetFocusedElement__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetFocusedElement", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aNeedsFocus = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aNeedsFocus) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aNeedsFocus = *maybe__aNeedsFocus;
            // Sentinel = 'aNeedsFocus'
            if ((!(((&(reader__)))->ReadSentinel(419759185)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvSetFocusedElement(std::move(aContext), std::move(aNeedsFocus));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FinalizeFocusOuter__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FinalizeFocusOuter", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aCanFocus = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aCanFocus) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

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

            return MsgProcessed;
        }
    case PContent::Msg_BlurToChild__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BlurToChild", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aFocusedBrowsingContext = *maybe__aFocusedBrowsingContext;
            // Sentinel = 'aFocusedBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(1842153819)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aBrowsingContextToClear = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aBrowsingContextToClear) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aBrowsingContextToClear = *maybe__aBrowsingContextToClear;
            // Sentinel = 'aBrowsingContextToClear'
            if ((!(((&(reader__)))->ReadSentinel(1859127612)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aAncestorBrowsingContextToFocus = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aAncestorBrowsingContextToFocus) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aAncestorBrowsingContextToFocus = *maybe__aAncestorBrowsingContextToFocus;
            // Sentinel = 'aAncestorBrowsingContextToFocus'
            if ((!(((&(reader__)))->ReadSentinel(3344239764)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aIsLeavingDocument = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsLeavingDocument) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            }
            auto& aAdjustWidget = *maybe__aAdjustWidget;
            // Sentinel = 'aAdjustWidget'
            if ((!(((&(reader__)))->ReadSentinel(594609457)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvBlurToChild(std::move(aFocusedBrowsingContext), std::move(aBrowsingContextToClear), std::move(aAncestorBrowsingContextToFocus), std::move(aIsLeavingDocument), std::move(aAdjustWidget), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetupFocusedAndActive__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetupFocusedAndActive", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aActiveBrowsingContext = *maybe__aActiveBrowsingContext;
            // Sentinel = 'aActiveBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(1678444782)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            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<ContentChild*>(this))->RecvSetupFocusedAndActive(std::move(aFocusedBrowsingContext), std::move(aActionIdForFocused), std::move(aActiveBrowsingContext), std::move(aActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReviseActiveBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReviseActiveBrowsingContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aNewActionId = *maybe__aNewActionId;
            // Sentinel = 'aNewActionId'
            if ((!(((&(reader__)))->ReadSentinel(496043159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReviseActiveBrowsingContext(std::move(aOldActionId), std::move(aActiveBrowsingContext), std::move(aNewActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReviseFocusedBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReviseFocusedBrowsingContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aNewActionId = *maybe__aNewActionId;
            // Sentinel = 'aNewActionId'
            if ((!(((&(reader__)))->ReadSentinel(496043159)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvReviseFocusedBrowsingContext(std::move(aOldActionId), std::move(aFocusedBrowsingContext), std::move(aNewActionId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_MaybeExitFullscreen__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_MaybeExitFullscreen", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_WindowPostMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_WindowPostMessage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aContext) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aMessage = IPC::ReadParam<ClonedOrErrorMessageData>((&(reader__)));
            if (!maybe__aMessage) {
                FatalError("Error deserializing 'ClonedOrErrorMessageData'");
                return MsgValueError;

            }
            auto& aMessage = *maybe__aMessage;
            // Sentinel = 'aMessage'
            if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedOrErrorMessageData'");
                return MsgValueError;
            }
            auto maybe__aData = IPC::ReadParam<PostMessageData>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'PostMessageData'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PostMessageData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvWindowPostMessage(std::move(aContext), 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 PContent::Msg_CommitWindowContextTransaction__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CommitWindowContextTransaction", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aContext = *maybe__aContext;
            // Sentinel = 'aContext'
            if ((!(((&(reader__)))->ReadSentinel(235406151)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            auto maybe__aTransaction = IPC::ReadParam<WindowContextTransaction>((&(reader__)));
            if (!maybe__aTransaction) {
                FatalError("Error deserializing 'WindowContextTransaction'");
                return MsgValueError;

            }
            auto& aTransaction = *maybe__aTransaction;
            // Sentinel = 'aTransaction'
            if ((!(((&(reader__)))->ReadSentinel(523371752)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WindowContextTransaction'");
                return MsgValueError;
            }
            auto maybe__aEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aEpoch) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aEpoch = *maybe__aEpoch;
            // Sentinel = 'aEpoch'
            if ((!(((&(reader__)))->ReadSentinel(132121169)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCommitWindowContextTransaction(std::move(aContext), std::move(aTransaction), std::move(aEpoch));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CreateWindowContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateWindowContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aInit = IPC::ReadParam<WindowContextInitializer>((&(reader__)));
            if (!maybe__aInit) {
                FatalError("Error deserializing 'WindowContextInitializer'");
                return MsgValueError;

            }
            auto& aInit = *maybe__aInit;
            // Sentinel = 'aInit'
            if ((!(((&(reader__)))->ReadSentinel(94241270)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'WindowContextInitializer'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvCreateWindowContext(std::move(aInit));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DiscardWindowContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DiscardWindowContext", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aContextId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aContextId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aContextId = *maybe__aContextId;
            // Sentinel = 'aContextId'
            if ((!(((&(reader__)))->ReadSentinel(361497588)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_DiscardWindowContext(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            DiscardWindowContextResolver 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 = 'unused'
                    ((&(writer__)))->WriteSentinel(155517589);

                    if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PContentChild",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvDiscardWindowContext(std::move(aContextId), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FlushFOGData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FlushFOGData", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_FlushFOGData(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            FlushFOGDataResolver resolver = [resolver__ = std::move(resolver__)](ByteBuf&& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::move(aParam));
                    // Sentinel = 'buf'
                    ((&(writer__)))->WriteSentinel(41484606);

                    if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PContentChild",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<ContentChild*>(this))->RecvFlushFOGData(std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Reply_GetSystemIcon__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_GetSystemIcon", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_GetSystemGeolocationPermissionBehavior__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_GetSystemGeolocationPermissionBehavior", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_RequestGeolocationPermissionFromUser__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_RequestGeolocationPermissionFromUser", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    default:
        return MsgNotKnown;
    case SHMEM_CREATED_MESSAGE_TYPE:
        {
            if (!ShmemCreated(msg__)) {
                return MsgPayloadError;
            }
            return MsgProcessed;
        }
    case SHMEM_DESTROYED_MESSAGE_TYPE:
        {
            if (!ShmemDestroyed(msg__)) {
                return MsgPayloadError;
            }
            return MsgProcessed;
        }
    }
}

auto PContentChild::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PContentChild::Result
{
    IPC::Message::routeid_t route__ = msg__.routing_id();
    if (MSG_ROUTING_CONTROL != route__) {
        IProtocol* routed__ = Lookup(route__);
        if (!routed__ || !routed__->GetLifecycleProxy()) {
            return MsgDropped;

        }

        RefPtr<mozilla::ipc::ActorLifecycleProxy> proxy__ =
            routed__->GetLifecycleProxy();
        return proxy__->Get()->OnMessageReceived(msg__, reply__);
    }

    return MsgNotKnown;
}



} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::PContentChild*>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, static_cast<mozilla::ipc::IProtocol*>(aVar));
    // Sentinel = 'PContent'
    (aWriter)->WriteSentinel(225182508);
}

auto ParamTraits<::mozilla::dom::PContentChild*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe__actor = IPC::ReadParam<mozilla::ipc::IProtocol*>(aReader);
    if (!maybe__actor) {
        aReader->FatalError("Error deserializing managed PContent actor");
        return {};

    }
    auto& actor = *maybe__actor;
    // Sentinel = 'PContent'
    if ((!((aReader)->ReadSentinel(225182508)))) {
        mozilla::ipc::SentinelReadError("Error deserializing managed PContent actor");
        return {};
    }

    if (actor && actor->GetProtocolId() != PContentMsgStart) {
        aReader->FatalError("Unexpected actor type (expected PContent)");

        return {};
    }
    return static_cast<::mozilla::dom::PContentChild*>(actor);
}

} // namespace IPC
