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


#include "mozilla/dom/PContentParent.h"
#include "ProfileAdditionalInformation.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/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/ConsoleReportIPCUtils.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/DomSecurityIPCUtils.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/PermissionsPolicyUtils.h"
#include "mozilla/dom/PolicyContainerMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/RemoteType.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/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/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 "nsIURI.h"
#include "nsIVariant.h"
#include "nsPoint.h"
#include "nsStructuredCloneContainer.h"

#include "mozilla/ipc/PBackgroundStarterParent.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/PClipboardContentAnalysisParent.h"
#include "mozilla/PClipboardReadRequestParent.h"
#include "mozilla/PClipboardWriteRequestParent.h"
#include "mozilla/layers/PCompositorManagerParent.h"
#include "mozilla/dom/PContentPermissionRequestParent.h"
#include "mozilla/dom/PCycleCollectWithLogsParent.h"
#include "mozilla/net/PDocumentChannelParent.h"
#include "mozilla/extensions/PExtensionsParent.h"
#include "mozilla/dom/PExternalHelperAppParent.h"
#include "mozilla/glean/PFOGTransportParent.h"
#include "mozilla/dom/PHandlerServiceParent.h"
#include "mozilla/hal_sandbox/PHalParent.h"
#include "mozilla/devtools/PHeapSnapshotTempFileHelperParent.h"
#include "mozilla/PProcessHangMonitorParent.h"
#include "mozilla/layers/PImageBridgeParent.h"
#include "mozilla/layout/PRemotePrintJobParent.h"
#include "mozilla/media/PMediaParent.h"
#include "mozilla/net/PNeckoParent.h"
#include "mozilla/extensions/PStreamFilterParent.h"
#include "mozilla/gmp/PGMPContentParent.h"
#include "mozilla/gmp/PGMPServiceParent.h"
#include "mozilla/gmp/PGMPParent.h"
#include "mozilla/dom/PSpeechSynthesisParent.h"
#include "mozilla/ipc/PTestShellParent.h"
#include "mozilla/PRemoteSpellcheckEngineParent.h"
#include "mozilla/PWebBrowserPersistDocumentParent.h"
#include "mozilla/dom/PWindowGlobalParent.h"
#include "mozilla/dom/PURLClassifierParent.h"
#include "mozilla/dom/PURLClassifierLocalParent.h"
#include "mozilla/dom/PURLClassifierLocalByNameParent.h"
#include "mozilla/gfx/PVRManagerParent.h"
#include "mozilla/PRemoteMediaManagerParent.h"
#include "mozilla/hwinference/PSpeechRecognitionParent.h"
#include "mozilla/dom/PRemoteWorkerDebuggerManagerParent.h"
#include "mozilla/dom/PRemoteWorkerServiceParent.h"
#include "mozilla/PProfilerParent.h"
#include "mozilla/loader/PScriptCacheParent.h"
#include "mozilla/dom/PSessionStorageObserverParent.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 PContentParent::RecvPExtensionsConstructor(PExtensionsParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPWebBrowserPersistDocumentConstructor(
        PWebBrowserPersistDocumentParent* actor,
        PBrowserParent* aBrowser,
        const MaybeDiscardedBrowsingContext& aContext) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPRemoteSpellcheckEngineConstructor(PRemoteSpellcheckEngineParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPHalConstructor(PHalParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPHeapSnapshotTempFileHelperConstructor(PHeapSnapshotTempFileHelperParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPNeckoConstructor(PNeckoParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPSpeechSynthesisConstructor(PSpeechSynthesisParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPMediaConstructor(PMediaParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPURLClassifierConstructor(
        PURLClassifierParent* actor,
        nsIPrincipal* principal,
        bool* success) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPURLClassifierLocalConstructor(
        PURLClassifierLocalParent* actor,
        nsIURI* uri,
        nsTArray<IPCURLClassifierFeature>&& features) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPURLClassifierLocalByNameConstructor(
        PURLClassifierLocalByNameParent* actor,
        nsIURI* uri,
        nsTArray<nsCString>&& featureNames,
        const listType& aListType) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPSessionStorageObserverConstructor(PSessionStorageObserverParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPExternalHelperAppConstructor(
        PExternalHelperAppParent* 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,
        nsIURI* aReferrer,
        const MaybeDiscardedBrowsingContext& aContext) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPHandlerServiceConstructor(PHandlerServiceParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPClipboardWriteRequestConstructor(
        PClipboardWriteRequestParent* actor,
        const ClipboardType& aClipboardType,
        const MaybeDiscardedWindowContext& aSettingWindowContext) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPContentPermissionRequestConstructor(
        PContentPermissionRequestParent* actor,
        nsTArray<PermissionRequest>&& aRequests,
        nsIPrincipal* aPrincipal,
        nsIPrincipal* aTopLevelPrincipal,
        const bool& aIsHandlingUserInput,
        const bool& aMaybeUnsafePermissionDelegate,
        const TabId& tabId,
        const bool& aIgnoreAllowSitePermission) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

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

MOZ_IMPLICIT PContentParent::PContentParent() :
    mozilla::ipc::IToplevelProtocol("PContentParent", kProtocolId, mozilla::ipc::ParentSide)
{
    MOZ_COUNT_CTOR(PContentParent);
}

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

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

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

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

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

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

auto PContentParent::ManagedPBrowserParent(nsTArray<PBrowserParent*>& aArr) const -> void
{
    mManagedPBrowserParent.ToArray(aArr);
}

auto PContentParent::ManagedPBrowserParent() const -> const ManagedContainer<PBrowserParent>&
{
    return mManagedPBrowserParent;
}

auto PContentParent::ManagedPClipboardReadRequestParent(nsTArray<PClipboardReadRequestParent*>& aArr) const -> void
{
    mManagedPClipboardReadRequestParent.ToArray(aArr);
}

auto PContentParent::ManagedPClipboardReadRequestParent() const -> const ManagedContainer<PClipboardReadRequestParent>&
{
    return mManagedPClipboardReadRequestParent;
}

auto PContentParent::ManagedPClipboardWriteRequestParent(nsTArray<PClipboardWriteRequestParent*>& aArr) const -> void
{
    mManagedPClipboardWriteRequestParent.ToArray(aArr);
}

auto PContentParent::ManagedPClipboardWriteRequestParent() const -> const ManagedContainer<PClipboardWriteRequestParent>&
{
    return mManagedPClipboardWriteRequestParent;
}

auto PContentParent::ManagedPContentPermissionRequestParent(nsTArray<PContentPermissionRequestParent*>& aArr) const -> void
{
    mManagedPContentPermissionRequestParent.ToArray(aArr);
}

auto PContentParent::ManagedPContentPermissionRequestParent() const -> const ManagedContainer<PContentPermissionRequestParent>&
{
    return mManagedPContentPermissionRequestParent;
}

auto PContentParent::ManagedPCycleCollectWithLogsParent(nsTArray<PCycleCollectWithLogsParent*>& aArr) const -> void
{
    mManagedPCycleCollectWithLogsParent.ToArray(aArr);
}

auto PContentParent::ManagedPCycleCollectWithLogsParent() const -> const ManagedContainer<PCycleCollectWithLogsParent>&
{
    return mManagedPCycleCollectWithLogsParent;
}

auto PContentParent::ManagedPExtensionsParent(nsTArray<PExtensionsParent*>& aArr) const -> void
{
    mManagedPExtensionsParent.ToArray(aArr);
}

auto PContentParent::ManagedPExtensionsParent() const -> const ManagedContainer<PExtensionsParent>&
{
    return mManagedPExtensionsParent;
}

auto PContentParent::ManagedPExternalHelperAppParent(nsTArray<PExternalHelperAppParent*>& aArr) const -> void
{
    mManagedPExternalHelperAppParent.ToArray(aArr);
}

auto PContentParent::ManagedPExternalHelperAppParent() const -> const ManagedContainer<PExternalHelperAppParent>&
{
    return mManagedPExternalHelperAppParent;
}

auto PContentParent::ManagedPHalParent(nsTArray<PHalParent*>& aArr) const -> void
{
    mManagedPHalParent.ToArray(aArr);
}

auto PContentParent::ManagedPHalParent() const -> const ManagedContainer<PHalParent>&
{
    return mManagedPHalParent;
}

auto PContentParent::ManagedPHandlerServiceParent(nsTArray<PHandlerServiceParent*>& aArr) const -> void
{
    mManagedPHandlerServiceParent.ToArray(aArr);
}

auto PContentParent::ManagedPHandlerServiceParent() const -> const ManagedContainer<PHandlerServiceParent>&
{
    return mManagedPHandlerServiceParent;
}

auto PContentParent::ManagedPHeapSnapshotTempFileHelperParent(nsTArray<PHeapSnapshotTempFileHelperParent*>& aArr) const -> void
{
    mManagedPHeapSnapshotTempFileHelperParent.ToArray(aArr);
}

auto PContentParent::ManagedPHeapSnapshotTempFileHelperParent() const -> const ManagedContainer<PHeapSnapshotTempFileHelperParent>&
{
    return mManagedPHeapSnapshotTempFileHelperParent;
}

auto PContentParent::ManagedPRemotePrintJobParent(nsTArray<PRemotePrintJobParent*>& aArr) const -> void
{
    mManagedPRemotePrintJobParent.ToArray(aArr);
}

auto PContentParent::ManagedPRemotePrintJobParent() const -> const ManagedContainer<PRemotePrintJobParent>&
{
    return mManagedPRemotePrintJobParent;
}

auto PContentParent::ManagedPMediaParent(nsTArray<PMediaParent*>& aArr) const -> void
{
    mManagedPMediaParent.ToArray(aArr);
}

auto PContentParent::ManagedPMediaParent() const -> const ManagedContainer<PMediaParent>&
{
    return mManagedPMediaParent;
}

auto PContentParent::ManagedPNeckoParent(nsTArray<PNeckoParent*>& aArr) const -> void
{
    mManagedPNeckoParent.ToArray(aArr);
}

auto PContentParent::ManagedPNeckoParent() const -> const ManagedContainer<PNeckoParent>&
{
    return mManagedPNeckoParent;
}

auto PContentParent::ManagedPSpeechSynthesisParent(nsTArray<PSpeechSynthesisParent*>& aArr) const -> void
{
    mManagedPSpeechSynthesisParent.ToArray(aArr);
}

auto PContentParent::ManagedPSpeechSynthesisParent() const -> const ManagedContainer<PSpeechSynthesisParent>&
{
    return mManagedPSpeechSynthesisParent;
}

auto PContentParent::ManagedPTestShellParent(nsTArray<PTestShellParent*>& aArr) const -> void
{
    mManagedPTestShellParent.ToArray(aArr);
}

auto PContentParent::ManagedPTestShellParent() const -> const ManagedContainer<PTestShellParent>&
{
    return mManagedPTestShellParent;
}

auto PContentParent::ManagedPRemoteSpellcheckEngineParent(nsTArray<PRemoteSpellcheckEngineParent*>& aArr) const -> void
{
    mManagedPRemoteSpellcheckEngineParent.ToArray(aArr);
}

auto PContentParent::ManagedPRemoteSpellcheckEngineParent() const -> const ManagedContainer<PRemoteSpellcheckEngineParent>&
{
    return mManagedPRemoteSpellcheckEngineParent;
}

auto PContentParent::ManagedPWebBrowserPersistDocumentParent(nsTArray<PWebBrowserPersistDocumentParent*>& aArr) const -> void
{
    mManagedPWebBrowserPersistDocumentParent.ToArray(aArr);
}

auto PContentParent::ManagedPWebBrowserPersistDocumentParent() const -> const ManagedContainer<PWebBrowserPersistDocumentParent>&
{
    return mManagedPWebBrowserPersistDocumentParent;
}

auto PContentParent::ManagedPURLClassifierParent(nsTArray<PURLClassifierParent*>& aArr) const -> void
{
    mManagedPURLClassifierParent.ToArray(aArr);
}

auto PContentParent::ManagedPURLClassifierParent() const -> const ManagedContainer<PURLClassifierParent>&
{
    return mManagedPURLClassifierParent;
}

auto PContentParent::ManagedPURLClassifierLocalParent(nsTArray<PURLClassifierLocalParent*>& aArr) const -> void
{
    mManagedPURLClassifierLocalParent.ToArray(aArr);
}

auto PContentParent::ManagedPURLClassifierLocalParent() const -> const ManagedContainer<PURLClassifierLocalParent>&
{
    return mManagedPURLClassifierLocalParent;
}

auto PContentParent::ManagedPURLClassifierLocalByNameParent(nsTArray<PURLClassifierLocalByNameParent*>& aArr) const -> void
{
    mManagedPURLClassifierLocalByNameParent.ToArray(aArr);
}

auto PContentParent::ManagedPURLClassifierLocalByNameParent() const -> const ManagedContainer<PURLClassifierLocalByNameParent>&
{
    return mManagedPURLClassifierLocalByNameParent;
}

auto PContentParent::ManagedPScriptCacheParent(nsTArray<PScriptCacheParent*>& aArr) const -> void
{
    mManagedPScriptCacheParent.ToArray(aArr);
}

auto PContentParent::ManagedPScriptCacheParent() const -> const ManagedContainer<PScriptCacheParent>&
{
    return mManagedPScriptCacheParent;
}

auto PContentParent::ManagedPSessionStorageObserverParent(nsTArray<PSessionStorageObserverParent*>& aArr) const -> void
{
    mManagedPSessionStorageObserverParent.ToArray(aArr);
}

auto PContentParent::ManagedPSessionStorageObserverParent() const -> const ManagedContainer<PSessionStorageObserverParent>&
{
    return mManagedPSessionStorageObserverParent;
}

auto PContentParent::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 PContentParent::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    case PBrowserMsgStart:
        return (&(mManagedPBrowserParent));
    case PClipboardReadRequestMsgStart:
        return (&(mManagedPClipboardReadRequestParent));
    case PClipboardWriteRequestMsgStart:
        return (&(mManagedPClipboardWriteRequestParent));
    case PContentPermissionRequestMsgStart:
        return (&(mManagedPContentPermissionRequestParent));
    case PCycleCollectWithLogsMsgStart:
        return (&(mManagedPCycleCollectWithLogsParent));
    case PExtensionsMsgStart:
        return (&(mManagedPExtensionsParent));
    case PExternalHelperAppMsgStart:
        return (&(mManagedPExternalHelperAppParent));
    case PHalMsgStart:
        return (&(mManagedPHalParent));
    case PHandlerServiceMsgStart:
        return (&(mManagedPHandlerServiceParent));
    case PHeapSnapshotTempFileHelperMsgStart:
        return (&(mManagedPHeapSnapshotTempFileHelperParent));
    case PRemotePrintJobMsgStart:
        return (&(mManagedPRemotePrintJobParent));
    case PMediaMsgStart:
        return (&(mManagedPMediaParent));
    case PNeckoMsgStart:
        return (&(mManagedPNeckoParent));
    case PSpeechSynthesisMsgStart:
        return (&(mManagedPSpeechSynthesisParent));
    case PTestShellMsgStart:
        return (&(mManagedPTestShellParent));
    case PRemoteSpellcheckEngineMsgStart:
        return (&(mManagedPRemoteSpellcheckEngineParent));
    case PWebBrowserPersistDocumentMsgStart:
        return (&(mManagedPWebBrowserPersistDocumentParent));
    case PURLClassifierMsgStart:
        return (&(mManagedPURLClassifierParent));
    case PURLClassifierLocalMsgStart:
        return (&(mManagedPURLClassifierLocalParent));
    case PURLClassifierLocalByNameMsgStart:
        return (&(mManagedPURLClassifierLocalByNameParent));
    case PScriptCacheMsgStart:
        return (&(mManagedPScriptCacheParent));
    case PSessionStorageObserverMsgStart:
        return (&(mManagedPSessionStorageObserverParent));
    default:
        return nullptr;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

auto PContentParent::SendConstructBrowser(
        ManagedEndpoint<::mozilla::dom::PBrowserChild>&& browserEp,
        ManagedEndpoint<::mozilla::dom::PWindowGlobalChild>&& windowEp,
        const TabId& tabId,
        const IPCTabContext& context,
        const WindowGlobalInit& windowInit,
        const uint32_t& chromeFlags,
        const ContentParentId& cpId,
        const bool& isForBrowser,
        const bool& isTopLevel) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ConstructBrowser(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);
    IPC::WriteParam((&(writer__)), cpId);
    // Sentinel = 'cpId'
    ((&(writer__)))->WriteSentinel(64356737);
    IPC::WriteParam((&(writer__)), isForBrowser);
    // Sentinel = 'isForBrowser'
    ((&(writer__)))->WriteSentinel(523371752);
    IPC::WriteParam((&(writer__)), isTopLevel);
    // Sentinel = 'isTopLevel'
    ((&(writer__)))->WriteSentinel(371196936);


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

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

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

    if (!actor->SetManagerAndRegister(this)) {
        NS_WARNING("Failed to bind PWebBrowserPersistDocumentParent 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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PWebBrowserPersistDocumentParent constructor");
        actor->ActorDisconnected(FailedConstructor);

        return nullptr;
    }
    return actor;
}

auto PContentParent::SendRawMessage(
        const JSActorMessageMeta& aMetadata,
        const JSIPCValue& aData,
        StructuredCloneData* 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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::SendInitGMPService(Endpoint<::mozilla::gmp::PGMPServiceChild>&& service) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitGMPService(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendInitProcessHangMonitor(Endpoint<::mozilla::PProcessHangMonitorChild>&& hangMonitor) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitProcessHangMonitor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendInitProfiler(Endpoint<::mozilla::PProfilerChild>&& aEndpoint) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitProfiler(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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitProfiler", OTHER);

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

auto PContentParent::SendInitRendering(
        Endpoint<::mozilla::layers::PCompositorManagerChild>&& compositor,
        Endpoint<::mozilla::layers::PImageBridgeChild>&& imageBridge,
        Endpoint<::mozilla::gfx::PVRManagerChild>&& vr,
        Endpoint<::mozilla::PRemoteMediaManagerChild>&& video,
        mozilla::Span<uint32_t const> namespaces) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitRendering(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(compositor));
    // Sentinel = 'compositor'
    ((&(writer__)))->WriteSentinel(393217104);
    IPC::WriteParam((&(writer__)), std::move(imageBridge));
    // Sentinel = 'imageBridge'
    ((&(writer__)))->WriteSentinel(436012113);
    IPC::WriteParam((&(writer__)), std::move(vr));
    // Sentinel = 'vr'
    ((&(writer__)))->WriteSentinel(23068905);
    IPC::WriteParam((&(writer__)), std::move(video));
    // Sentinel = 'video'
    ((&(writer__)))->WriteSentinel(106693144);
    IPC::WriteParam((&(writer__)), namespaces);
    // Sentinel = 'namespaces'
    ((&(writer__)))->WriteSentinel(381027361);


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

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

auto PContentParent::SendReinitRendering(
        Endpoint<::mozilla::layers::PCompositorManagerChild>&& compositor,
        Endpoint<::mozilla::layers::PImageBridgeChild>&& bridge,
        Endpoint<::mozilla::gfx::PVRManagerChild>&& vr,
        Endpoint<::mozilla::PRemoteMediaManagerChild>&& video,
        mozilla::Span<uint32_t const> namespaces) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReinitRendering(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(compositor));
    // Sentinel = 'compositor'
    ((&(writer__)))->WriteSentinel(393217104);
    IPC::WriteParam((&(writer__)), std::move(bridge));
    // Sentinel = 'bridge'
    ((&(writer__)))->WriteSentinel(143589998);
    IPC::WriteParam((&(writer__)), std::move(vr));
    // Sentinel = 'vr'
    ((&(writer__)))->WriteSentinel(23068905);
    IPC::WriteParam((&(writer__)), std::move(video));
    // Sentinel = 'video'
    ((&(writer__)))->WriteSentinel(106693144);
    IPC::WriteParam((&(writer__)), namespaces);
    // Sentinel = 'namespaces'
    ((&(writer__)))->WriteSentinel(381027361);


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

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

auto PContentParent::SendNetworkLinkTypeChange(const uint32_t& type) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NetworkLinkTypeChange(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSocketProcessCrashed() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SocketProcessCrashed(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendReinitRenderingForDeviceReset() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReinitRenderingForDeviceReset(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendSetProcessSandbox(const mozilla::Maybe<FileDescriptor>& aBroker) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetProcessSandbox(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendRequestMemoryReport(
        const uint32_t& generation,
        const bool& anonymize,
        const bool& minimizeMemoryUsage,
        const mozilla::Maybe<FileDescriptor>& DMDFile,
        mozilla::ipc::ResolveCallback<uint32_t>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RequestMemoryReport(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), generation);
    // Sentinel = 'generation'
    ((&(writer__)))->WriteSentinel(381158445);
    IPC::WriteParam((&(writer__)), anonymize);
    // Sentinel = 'anonymize'
    ((&(writer__)))->WriteSentinel(321127387);
    IPC::WriteParam((&(writer__)), minimizeMemoryUsage);
    // Sentinel = 'minimizeMemoryUsage'
    ((&(writer__)))->WriteSentinel(1321600977);
    IPC::WriteParam((&(writer__)), DMDFile);
    // Sentinel = 'DMDFile'
    ((&(writer__)))->WriteSentinel(143983190);


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

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

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


            aReader->EndRead();

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

auto PContentParent::SendRequestMemoryReport(
        const uint32_t& generation,
        const bool& anonymize,
        const bool& minimizeMemoryUsage,
        const mozilla::Maybe<FileDescriptor>& DMDFile) -> RefPtr<RequestMemoryReportPromise>
{
    RefPtr<MozPromise<uint32_t, ResponseRejectReason, true>::Private> promise__ = new MozPromise<uint32_t, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendRequestMemoryReport(std::forward<const uint32_t&>(generation), std::forward<const bool&>(anonymize), std::forward<const bool&>(minimizeMemoryUsage), std::forward<const mozilla::Maybe<FileDescriptor>&>(DMDFile), [promise__](uint32_t&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendDecodeImage(
        mozilla::NotNull<nsIURI*> aURI,
        const ImageIntSize& aSize,
        const bool& aStretch,
        const ColorScheme& aColorScheme,
        mozilla::ipc::ResolveCallback<std::tuple<nsresult, mozilla::Maybe<IPCImage>>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DecodeImage(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aURI);
    // Sentinel = 'aURI'
    ((&(writer__)))->WriteSentinel(57934162);
    IPC::WriteParam((&(writer__)), aSize);
    // Sentinel = 'aSize'
    ((&(writer__)))->WriteSentinel(97124861);
    IPC::WriteParam((&(writer__)), aStretch);
    // Sentinel = 'aStretch'
    ((&(writer__)))->WriteSentinel(241500991);
    IPC::WriteParam((&(writer__)), aColorScheme);
    // Sentinel = 'aColorScheme'
    ((&(writer__)))->WriteSentinel(505414838);


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

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

            }
            auto& rv = *maybe__rv;
            // Sentinel = 'rv'
            if ((!((aReader)->ReadSentinel(22806761)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            auto maybe__image = IPC::ReadParam<mozilla::Maybe<IPCImage>>(aReader);
            if (!maybe__image) {
                (aReader)->FatalError("Error deserializing 'IPCImage?'");
                return MsgValueError;

            }
            auto& image = *maybe__image;
            // Sentinel = 'image'
            if ((!((aReader)->ReadSentinel(102498820)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCImage?'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentParent::SendDecodeImage(
        mozilla::NotNull<nsIURI*> aURI,
        const ImageIntSize& aSize,
        const bool& aStretch,
        const ColorScheme& aColorScheme) -> RefPtr<DecodeImagePromise>
{
    RefPtr<MozPromise<std::tuple<nsresult, mozilla::Maybe<IPCImage>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<nsresult, mozilla::Maybe<IPCImage>>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendDecodeImage(std::forward<mozilla::NotNull<nsIURI*>>(aURI), std::forward<const ImageIntSize&>(aSize), std::forward<const bool&>(aStretch), std::forward<const ColorScheme&>(aColorScheme), [promise__](std::tuple<nsresult, mozilla::Maybe<IPCImage>>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendBidiKeyboardNotify(
        const bool& isLangRTL,
        const bool& haveBidiKeyboards) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BidiKeyboardNotify(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), isLangRTL);
    // Sentinel = 'isLangRTL'
    ((&(writer__)))->WriteSentinel(290980689);
    IPC::WriteParam((&(writer__)), haveBidiKeyboards);
    // Sentinel = 'haveBidiKeyboards'
    ((&(writer__)))->WriteSentinel(1003161281);


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

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

auto PContentParent::SendPCycleCollectWithLogsConstructor(
        const bool& dumpAllTraces,
        const FileDescriptor& gcLog,
        const FileDescriptor& ccLog) -> PCycleCollectWithLogsParent*
{
    PCycleCollectWithLogsParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPCycleCollectWithLogsParent(dumpAllTraces, gcLog, ccLog);
    return SendPCycleCollectWithLogsConstructor(std::forward<PCycleCollectWithLogsParent*>(actor), std::forward<const bool&>(dumpAllTraces), std::forward<const FileDescriptor&>(gcLog), std::forward<const FileDescriptor&>(ccLog));
}

auto PContentParent::SendPCycleCollectWithLogsConstructor(
        PCycleCollectWithLogsParent* actor,
        const bool& dumpAllTraces,
        const FileDescriptor& gcLog,
        const FileDescriptor& ccLog) -> PCycleCollectWithLogsParent*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PCycleCollectWithLogsParent actor");
        return nullptr;
    }

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


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

    IPC::WriteParam((&(writer__)), (actor)->Id());
    // Sentinel = 'actorid'
    ((&(writer__)))->WriteSentinel(193725159);
    IPC::WriteParam((&(writer__)), dumpAllTraces);
    // Sentinel = 'dumpAllTraces'
    ((&(writer__)))->WriteSentinel(610600242);
    IPC::WriteParam((&(writer__)), gcLog);
    // Sentinel = 'gcLog'
    ((&(writer__)))->WriteSentinel(96272877);
    IPC::WriteParam((&(writer__)), ccLog);
    // Sentinel = 'ccLog'
    ((&(writer__)))->WriteSentinel(94962153);


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

        return nullptr;
    }
    return actor;
}

auto PContentParent::SendPTestShellConstructor(PTestShellParent* actor) -> PTestShellParent*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PTestShellParent actor");
        return nullptr;
    }

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


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

        return nullptr;
    }
    return actor;
}

auto PContentParent::SendPScriptCacheConstructor(
        const FileDescOrError& cacheFile,
        const bool& wantCacheData) -> PScriptCacheParent*
{
    PScriptCacheParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPScriptCacheParent(cacheFile, wantCacheData);
    return SendPScriptCacheConstructor(std::forward<PScriptCacheParent*>(actor), std::forward<const FileDescOrError&>(cacheFile), std::forward<const bool&>(wantCacheData));
}

auto PContentParent::SendPScriptCacheConstructor(
        PScriptCacheParent* actor,
        const FileDescOrError& cacheFile,
        const bool& wantCacheData) -> PScriptCacheParent*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PScriptCacheParent actor");
        return nullptr;
    }

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


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

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


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

        return nullptr;
    }
    return actor;
}

auto PContentParent::SendRegisterChrome(
        mozilla::Span<ChromePackage const> packages,
        mozilla::Span<SubstitutionMapping const> substitutions,
        mozilla::Span<OverrideMapping const> overrides,
        const nsACString& locale,
        const bool& reset) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterChrome(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), packages);
    // Sentinel = 'packages'
    ((&(writer__)))->WriteSentinel(244187968);
    IPC::WriteParam((&(writer__)), substitutions);
    // Sentinel = 'substitutions'
    ((&(writer__)))->WriteSentinel(668861873);
    IPC::WriteParam((&(writer__)), overrides);
    // Sentinel = 'overrides'
    ((&(writer__)))->WriteSentinel(324404180);
    IPC::WriteParam((&(writer__)), locale);
    // Sentinel = 'locale'
    ((&(writer__)))->WriteSentinel(145031793);
    IPC::WriteParam((&(writer__)), reset);
    // Sentinel = 'reset'
    ((&(writer__)))->WriteSentinel(107610660);


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

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

auto PContentParent::SendRegisterChromeItem(const ChromeRegistryItem& item) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterChromeItem(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendClearImageCache(
        const mozilla::Maybe<bool>& privateLoader,
        const mozilla::Maybe<bool>& aChrome,
        const mozilla::Maybe<RefPtr<nsIPrincipal>>& aPrincipal,
        const mozilla::Maybe<nsCString>& aSchemelessSite,
        const mozilla::Maybe<OriginAttributesPattern>& aPattern,
        const mozilla::Maybe<nsCString>& aURL) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearImageCache(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), privateLoader);
    // Sentinel = 'privateLoader'
    ((&(writer__)))->WriteSentinel(635372883);
    IPC::WriteParam((&(writer__)), aChrome);
    // Sentinel = 'aChrome'
    ((&(writer__)))->WriteSentinel(177996480);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), aSchemelessSite);
    // Sentinel = 'aSchemelessSite'
    ((&(writer__)))->WriteSentinel(792528387);
    IPC::WriteParam((&(writer__)), aPattern);
    // Sentinel = 'aPattern'
    ((&(writer__)))->WriteSentinel(236651328);
    IPC::WriteParam((&(writer__)), aURL);
    // Sentinel = 'aURL'
    ((&(writer__)))->WriteSentinel(58130773);


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

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

auto PContentParent::SendClearStyleSheetCache(
        const mozilla::Maybe<bool>& aChrome,
        const mozilla::Maybe<RefPtr<nsIPrincipal>>& aPrincipal,
        const mozilla::Maybe<nsCString>& aSchemelessSite,
        const mozilla::Maybe<OriginAttributesPattern>& aPattern,
        const mozilla::Maybe<nsCString>& aURL) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearStyleSheetCache(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aChrome);
    // Sentinel = 'aChrome'
    ((&(writer__)))->WriteSentinel(177996480);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), aSchemelessSite);
    // Sentinel = 'aSchemelessSite'
    ((&(writer__)))->WriteSentinel(792528387);
    IPC::WriteParam((&(writer__)), aPattern);
    // Sentinel = 'aPattern'
    ((&(writer__)))->WriteSentinel(236651328);
    IPC::WriteParam((&(writer__)), aURL);
    // Sentinel = 'aURL'
    ((&(writer__)))->WriteSentinel(58130773);


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

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

auto PContentParent::SendClearScriptCache(
        const mozilla::Maybe<bool>& aChrome,
        const mozilla::Maybe<RefPtr<nsIPrincipal>>& aPrincipal,
        const mozilla::Maybe<nsCString>& aSchemelessSite,
        const mozilla::Maybe<OriginAttributesPattern>& aPattern,
        const mozilla::Maybe<nsCString>& aURL) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearScriptCache(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aChrome);
    // Sentinel = 'aChrome'
    ((&(writer__)))->WriteSentinel(177996480);
    IPC::WriteParam((&(writer__)), aPrincipal);
    // Sentinel = 'aPrincipal'
    ((&(writer__)))->WriteSentinel(364381188);
    IPC::WriteParam((&(writer__)), aSchemelessSite);
    // Sentinel = 'aSchemelessSite'
    ((&(writer__)))->WriteSentinel(792528387);
    IPC::WriteParam((&(writer__)), aPattern);
    // Sentinel = 'aPattern'
    ((&(writer__)))->WriteSentinel(236651328);
    IPC::WriteParam((&(writer__)), aURL);
    // Sentinel = 'aURL'
    ((&(writer__)))->WriteSentinel(58130773);


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

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

auto PContentParent::SendInvalidateScriptCache() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InvalidateScriptCache(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendSetOffline(const bool& offline) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetOffline(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSetConnectivity(const bool& connectivity) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetConnectivity(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSetCaptivePortalState(const int32_t& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetCaptivePortalState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSetTRRMode(
        const ResolverMode& aMode,
        const ResolverMode& aModeFromPref) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetTRRMode(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aMode);
    // Sentinel = 'aMode'
    ((&(writer__)))->WriteSentinel(93848039);
    IPC::WriteParam((&(writer__)), aModeFromPref);
    // Sentinel = 'aModeFromPref'
    ((&(writer__)))->WriteSentinel(580846856);


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

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

auto PContentParent::SendNotifyVisited(mozilla::Span<VisitedQueryResult const> uri) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyVisited(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendThemeChanged(
        const FullLookAndFeel& lookAndFeelData,
        const ThemeChangeKind& aKind) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ThemeChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), lookAndFeelData);
    // Sentinel = 'lookAndFeelData'
    ((&(writer__)))->WriteSentinel(782239167);
    IPC::WriteParam((&(writer__)), aKind);
    // Sentinel = 'aKind'
    ((&(writer__)))->WriteSentinel(93389288);


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

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

auto PContentParent::SendPreferenceUpdate(const Pref& pref) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_PreferenceUpdate(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendVarUpdate(mozilla::Span<GfxVarUpdate const> var) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_VarUpdate(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUpdatePerfStatsCollectionMask(const uint64_t& aMask) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdatePerfStatsCollectionMask(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendCollectPerfStatsJSON(
        mozilla::ipc::ResolveCallback<nsCString>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CollectPerfStatsJSON(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

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


            aReader->EndRead();

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

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

auto PContentParent::SendCollectScrollingMetrics(
        mozilla::ipc::ResolveCallback<std::tuple<uint32_t, uint32_t>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CollectScrollingMetrics(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

            }
            auto& pixelsScrolled = *maybe__pixelsScrolled;
            // Sentinel = 'pixelsScrolled'
            if ((!((aReader)->ReadSentinel(738395598)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__scrollDurationMS = IPC::ReadParam<uint32_t>(aReader);
            if (!maybe__scrollDurationMS) {
                (aReader)->FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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


            aReader->EndRead();

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

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

auto PContentParent::SendGeolocationUpdate(nsIDOMGeoPosition* aPosition) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GeolocationUpdate(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendGeolocationError(const uint16_t& errorCode) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GeolocationError(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUpdateDictionaryList(mozilla::Span<nsCString const> dictionaries) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateDictionaryList(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUpdateFontList(const SystemFontList& fontList) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateFontList(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendRebuildFontList(const bool& aFullRebuild) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RebuildFontList(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendForceGlobalReflow(const GlobalReflowFlags& aFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ForceGlobalReflow(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendFontListShmBlockAdded(
        const uint32_t& aGeneration,
        const uint32_t& aIndex,
        ReadOnlySharedMemoryHandle&& aHandle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FontListShmBlockAdded(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);
    IPC::WriteParam((&(writer__)), std::move(aHandle));
    // Sentinel = 'aHandle'
    ((&(writer__)))->WriteSentinel(174326446);


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

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

auto PContentParent::SendUpdateAppLocales(mozilla::Span<nsCString const> appLocales) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateAppLocales(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUpdateRequestedLocales(mozilla::Span<nsCString const> requestedLocales) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateRequestedLocales(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSystemTimezoneChanged() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SystemTimezoneChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendUpdateL10nFileSources(mozilla::Span<L10nFileSourceDescriptor const> sources) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateL10nFileSources(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendRegisterStringBundles(nsTArray<StringBundleDescriptor>&& stringBundles) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterStringBundles(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSimpleURIUnknownRemoteSchemes(mozilla::Span<nsCString const> remoteSchemes) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SimpleURIUnknownRemoteSchemes(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUpdateSharedData(
        ReadOnlySharedMemoryHandle&& aMapHandle,
        mozilla::Span<IPCBlob const> blobs,
        mozilla::Span<nsCString const> changedKeys) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateSharedData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(aMapHandle));
    // Sentinel = 'aMapHandle'
    ((&(writer__)))->WriteSentinel(341246924);
    IPC::WriteParam((&(writer__)), blobs);
    // Sentinel = 'blobs'
    ((&(writer__)))->WriteSentinel(102957587);
    IPC::WriteParam((&(writer__)), changedKeys);
    // Sentinel = 'changedKeys'
    ((&(writer__)))->WriteSentinel(437781607);


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

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

auto PContentParent::SendAddPermission(const Permission& permission) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddPermission(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendRemoveAllPermissions() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RemoveAllPermissions(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendSetBrowserPermission(
        const nsACString& origin,
        const nsACString& type,
        const uint32_t& action,
        const uint64_t& browserId,
        const bool& isRemoval) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetBrowserPermission(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), origin);
    // Sentinel = 'origin'
    ((&(writer__)))->WriteSentinel(150143625);
    IPC::WriteParam((&(writer__)), type);
    // Sentinel = 'type'
    ((&(writer__)))->WriteSentinel(75760067);
    IPC::WriteParam((&(writer__)), action);
    // Sentinel = 'action'
    ((&(writer__)))->WriteSentinel(143786623);
    IPC::WriteParam((&(writer__)), browserId);
    // Sentinel = 'browserId'
    ((&(writer__)))->WriteSentinel(318571442);
    IPC::WriteParam((&(writer__)), isRemoval);
    // Sentinel = 'isRemoval'
    ((&(writer__)))->WriteSentinel(307954611);


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

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

auto PContentParent::SendClearBrowserPermissions(
        const uint64_t& browserId,
        const uint32_t& actionFilter) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ClearBrowserPermissions(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), browserId);
    // Sentinel = 'browserId'
    ((&(writer__)))->WriteSentinel(318571442);
    IPC::WriteParam((&(writer__)), actionFilter);
    // Sentinel = 'actionFilter'
    ((&(writer__)))->WriteSentinel(528811237);


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

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

auto PContentParent::SendMemoryPressure(const nsAString& reason) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_MemoryPressure(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendMemoryPressureStop() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_MemoryPressureStop(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendApplicationBackground() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ApplicationBackground(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendApplicationForeground() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ApplicationForeground(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendGarbageCollect() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GarbageCollect(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendCycleCollect() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CycleCollect(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendUnlinkGhosts() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UnlinkGhosts(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendActivateA11y(const uint64_t& aDomains) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ActivateA11y(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendShutdownA11y() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ShutdownA11y(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendSetCacheDomains(const uint64_t& aCacheDomains) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetCacheDomains(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendAppInfo(
        const nsACString& version,
        const nsACString& buildID,
        const nsACString& name,
        const nsACString& UAName,
        const nsACString& ID,
        const nsACString& vendor,
        const nsACString& sourceURL,
        const nsACString& updateURL) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AppInfo(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), version);
    // Sentinel = 'version'
    ((&(writer__)))->WriteSentinel(204210951);
    IPC::WriteParam((&(writer__)), buildID);
    // Sentinel = 'buildID'
    ((&(writer__)))->WriteSentinel(187826846);
    IPC::WriteParam((&(writer__)), name);
    // Sentinel = 'name'
    ((&(writer__)))->WriteSentinel(69075362);
    IPC::WriteParam((&(writer__)), UAName);
    // Sentinel = 'UAName'
    ((&(writer__)))->WriteSentinel(115540504);
    IPC::WriteParam((&(writer__)), ID);
    // Sentinel = 'ID'
    ((&(writer__)))->WriteSentinel(14155918);
    IPC::WriteParam((&(writer__)), vendor);
    // Sentinel = 'vendor'
    ((&(writer__)))->WriteSentinel(150405775);
    IPC::WriteParam((&(writer__)), sourceURL);
    // Sentinel = 'sourceURL'
    ((&(writer__)))->WriteSentinel(316474245);
    IPC::WriteParam((&(writer__)), updateURL);
    // Sentinel = 'updateURL'
    ((&(writer__)))->WriteSentinel(309265271);


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

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

auto PContentParent::SendSetRemoteType(
        const RemoteType& aRemoteType,
        const nsACString& aProfile) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetRemoteType(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendAddLoadedOrigin(mozilla::NotNull<nsIPrincipal*> aPrincipal) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddLoadedOrigin(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendInitRemoteWorkerService(
        Endpoint<::mozilla::dom::PRemoteWorkerServiceChild>&& aEndpoint,
        Endpoint<::mozilla::dom::PRemoteWorkerDebuggerManagerChild>&& aDebuggerChildEp) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitRemoteWorkerService(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendInitBlobURLs(mozilla::Span<BlobURLRegistrationData const> registrations) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitBlobURLs(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendInitJSActorInfos(
        mozilla::Span<JSProcessActorInfo const> aContentInfos,
        mozilla::Span<JSWindowActorInfo const> aWindowInfos) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitJSActorInfos(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContentInfos);
    // Sentinel = 'aContentInfos'
    ((&(writer__)))->WriteSentinel(600638780);
    IPC::WriteParam((&(writer__)), aWindowInfos);
    // Sentinel = 'aWindowInfos'
    ((&(writer__)))->WriteSentinel(518522073);


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

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

auto PContentParent::SendUnregisterJSWindowActor(const nsACString& name) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UnregisterJSWindowActor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUnregisterJSProcessActor(const nsACString& name) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UnregisterJSProcessActor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSetXPCOMProcessAttributes(
        const XPCOMInitData& xpcomInit,
        mozilla::NotNull<StructuredCloneData*> initialData,
        const FullLookAndFeel& lookAndFeeldata,
        const SystemFontList& systemFontList,
        mozilla::Maybe<ReadOnlySharedMemoryHandle>&& sharedUASheetHandle,
        const uintptr_t& sharedUASheetAddress,
        nsTArray<ReadOnlySharedMemoryHandle>&& sharedFontListBlocks,
        const bool& aIsStartingUp) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetXPCOMProcessAttributes(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), xpcomInit);
    // Sentinel = 'xpcomInit'
    ((&(writer__)))->WriteSentinel(316998588);
    IPC::WriteParam((&(writer__)), initialData);
    // Sentinel = 'initialData'
    ((&(writer__)))->WriteSentinel(451413093);
    IPC::WriteParam((&(writer__)), lookAndFeeldata);
    // Sentinel = 'lookAndFeeldata'
    ((&(writer__)))->WriteSentinel(790627807);
    IPC::WriteParam((&(writer__)), systemFontList);
    // Sentinel = 'systemFontList'
    ((&(writer__)))->WriteSentinel(746194393);
    IPC::WriteParam((&(writer__)), std::move(sharedUASheetHandle));
    // Sentinel = 'sharedUASheetHandle'
    ((&(writer__)))->WriteSentinel(1232406355);
    IPC::WriteParam((&(writer__)), sharedUASheetAddress);
    // Sentinel = 'sharedUASheetAddress'
    ((&(writer__)))->WriteSentinel(1361643469);
    IPC::WriteParam((&(writer__)), std::move(sharedFontListBlocks));
    // Sentinel = 'sharedFontListBlocks'
    ((&(writer__)))->WriteSentinel(1412827145);
    IPC::WriteParam((&(writer__)), aIsStartingUp);
    // Sentinel = 'aIsStartingUp'
    ((&(writer__)))->WriteSentinel(597361967);


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

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

auto PContentParent::SendLastPrivateDocShellDestroyed() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_LastPrivateDocShellDestroyed(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendNotifyProcessPriorityChanged(const ProcessPriority& priority) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyProcessPriorityChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendMinimizeMemoryUsage() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_MinimizeMemoryUsage(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendLoadAndRegisterSheet(
        nsIURI* uri,
        const uint32_t& type) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadAndRegisterSheet(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUnregisterSheet(
        nsIURI* uri,
        const uint32_t& type) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UnregisterSheet(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendNotifyIdleObserver(
        const uint64_t& observerId,
        const nsACString& topic,
        const nsAString& str) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyIdleObserver(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), observerId);
    // Sentinel = 'observerId'
    ((&(writer__)))->WriteSentinel(386335766);
    IPC::WriteParam((&(writer__)), topic);
    // Sentinel = 'topic'
    ((&(writer__)))->WriteSentinel(109707808);
    IPC::WriteParam((&(writer__)), str);
    // Sentinel = 'str'
    ((&(writer__)))->WriteSentinel(45482330);


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

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

auto PContentParent::SendDomainSetChanged(
        const uint32_t& aSetType,
        const uint32_t& aChangeType,
        nsIURI* aDomain) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DomainSetChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendShutdown() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_Shutdown(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendLoadProcessScript(const nsAString& url) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadProcessScript(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendUpdateWindow(const uintptr_t& aChildId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateWindow(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendNotifyEmptyHTTPCache() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_NotifyEmptyHTTPCache(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendGetFilesResponse(
        const nsID& aID,
        const GetFilesResponseResult& aResult) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetFilesResponse(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendBlobURLRegistration(
        const nsACString& aURI,
        nsIPrincipal* aPrincipal,
        const nsACString& aPartitionKey) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BlobURLRegistration(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendBlobURLUnregistration(mozilla::Span<nsCString const> aURIs) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BlobURLUnregistration(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendGMPsChanged(mozilla::Span<GMPCapabilityData const> capabilities) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GMPsChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendProvideAnonymousTemporaryFile(
        const uint64_t& aID,
        const FileDescOrError& aFD) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ProvideAnonymousTemporaryFile(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSetPermissionsWithKey(
        const nsACString& aPermissionKey,
        mozilla::Span<Permission const> aPermissions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetPermissionsWithKey(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aPermissionKey);
    // Sentinel = 'aPermissionKey'
    ((&(writer__)))->WriteSentinel(708511156);
    IPC::WriteParam((&(writer__)), aPermissions);
    // Sentinel = 'aPermissions'
    ((&(writer__)))->WriteSentinel(527697150);


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

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

auto PContentParent::SendRefreshScreens(mozilla::Span<ScreenDetails const> aScreens) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RefreshScreens(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendShareCodeCoverageMutex(CrossProcessMutexHandle&& handle) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ShareCodeCoverageMutex(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendFlushCodeCoverageCounters(
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushCodeCoverageCounters(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_FlushCodeCoverageCounters__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 PContentParent::SendFlushCodeCoverageCounters() -> RefPtr<FlushCodeCoverageCountersPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendFlushCodeCoverageCounters([promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendSetInputEventQueueEnabled() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetInputEventQueueEnabled(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendFlushInputEventQueue() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushInputEventQueue(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendResumeInputEventQueue() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ResumeInputEventQueue(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendSuspendInputEventQueue() -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SuspendInputEventQueue(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PContentParent::SendAddDynamicScalars(mozilla::Span<DynamicScalarDefinition const> definitions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_AddDynamicScalars(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendCrossProcessRedirect(
        const RedirectToRealChannelArgs& args,
        nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>&& aEndpoint,
        mozilla::ipc::ResolveCallback<nsresult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CrossProcessRedirect(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PContentParent::SendCrossProcessRedirect(
        const RedirectToRealChannelArgs& args,
        nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>&& aEndpoint) -> RefPtr<CrossProcessRedirectPromise>
{
    RefPtr<MozPromise<nsresult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<nsresult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendCrossProcessRedirect(std::forward<const RedirectToRealChannelArgs&>(args), std::forward<nsTArray<Endpoint<::mozilla::extensions::PStreamFilterParent>>&&>(aEndpoint), [promise__](nsresult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

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

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


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

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

auto PContentParent::SendUpdateMediaControlAction(
        const MaybeDiscardedBrowsingContext& aContext,
        const MediaControlAction& aAction) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateMediaControlAction(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);


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

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

auto PContentParent::SendUpdateMediaSessionInterrupt(
        const MaybeDiscardedBrowsingContext& aContext,
        const AudioFocusInterruptAction& aAction) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateMediaSessionInterrupt(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);


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

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

auto PContentParent::SendRegisterBrowsingContextGroup(
        const uint64_t& aGroupId,
        mozilla::Span<SyncedContextInitializer const> aInits,
        mozilla::Span<OriginAgentClusterInitializer const> aUseOriginAgentCluster) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_RegisterBrowsingContextGroup(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aGroupId);
    // Sentinel = 'aGroupId'
    ((&(writer__)))->WriteSentinel(233964316);
    IPC::WriteParam((&(writer__)), aInits);
    // Sentinel = 'aInits'
    ((&(writer__)))->WriteSentinel(134677097);
    IPC::WriteParam((&(writer__)), aUseOriginAgentCluster);
    // Sentinel = 'aUseOriginAgentCluster'
    ((&(writer__)))->WriteSentinel(1658849480);


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

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

auto PContentParent::SendDestroyBrowsingContextGroup(const uint64_t& aGroupId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DestroyBrowsingContextGroup(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendSetUseOriginAgentCluster(
        const uint64_t& aGroupId,
        mozilla::NotNull<nsIPrincipal*> aPrincipal,
        const bool& aUseOriginAgentCluster) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetUseOriginAgentCluster(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendLoadURI(
        const MaybeDiscardedBrowsingContext& aContext,
        mozilla::NotNull<nsDocShellLoadState*> aLoadState,
        const bool& aSetNavigating) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_LoadURI(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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

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


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

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

auto PContentParent::SendDisplayLoadError(
        const MaybeDiscardedBrowsingContext& aContext,
        const nsAString& aURI) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DisplayLoadError(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendGoBack(
        const MaybeDiscardedBrowsingContext& aContext,
        const mozilla::Maybe<int32_t>& aCancelContentJSEpoch,
        const bool& aRequireUserInteraction,
        const bool& aUserActivation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GoBack(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aCancelContentJSEpoch);
    // Sentinel = 'aCancelContentJSEpoch'
    ((&(writer__)))->WriteSentinel(1473841167);
    IPC::WriteParam((&(writer__)), aRequireUserInteraction);
    // Sentinel = 'aRequireUserInteraction'
    ((&(writer__)))->WriteSentinel(1862076766);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);


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

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

auto PContentParent::SendGoForward(
        const MaybeDiscardedBrowsingContext& aContext,
        const mozilla::Maybe<int32_t>& aCancelContentJSEpoch,
        const bool& aRequireUserInteraction,
        const bool& aUserActivation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GoForward(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aCancelContentJSEpoch);
    // Sentinel = 'aCancelContentJSEpoch'
    ((&(writer__)))->WriteSentinel(1473841167);
    IPC::WriteParam((&(writer__)), aRequireUserInteraction);
    // Sentinel = 'aRequireUserInteraction'
    ((&(writer__)))->WriteSentinel(1862076766);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);


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

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

auto PContentParent::SendGoToIndex(
        const MaybeDiscardedBrowsingContext& aContext,
        const int32_t& aIndex,
        const mozilla::Maybe<int32_t>& aCancelContentJSEpoch,
        const bool& aUserActivation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GoToIndex(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aIndex);
    // Sentinel = 'aIndex'
    ((&(writer__)))->WriteSentinel(132055642);
    IPC::WriteParam((&(writer__)), aCancelContentJSEpoch);
    // Sentinel = 'aCancelContentJSEpoch'
    ((&(writer__)))->WriteSentinel(1473841167);
    IPC::WriteParam((&(writer__)), aUserActivation);
    // Sentinel = 'aUserActivation'
    ((&(writer__)))->WriteSentinel(794887699);


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

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

auto PContentParent::SendReload(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint32_t& aReloadFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_Reload(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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_Reload", OTHER);

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

auto PContentParent::SendStopLoad(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint32_t& aStopFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_StopLoad(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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

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


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

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

auto PContentParent::SendReactivateDocuments(
        const MaybeDiscardedBrowsingContext& aContext,
        const mozilla::Maybe<SessionHistoryInfo>& aReactivatedEntry,
        mozilla::Span<SessionHistoryInfo const> aNewSHEs,
        const mozilla::Maybe<PreviousSessionHistoryInfo>& aPreviousEntryForActivation) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReactivateDocuments(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aReactivatedEntry);
    // Sentinel = 'aReactivatedEntry'
    ((&(writer__)))->WriteSentinel(1012860640);
    IPC::WriteParam((&(writer__)), aNewSHEs);
    // Sentinel = 'aNewSHEs'
    ((&(writer__)))->WriteSentinel(218366687);
    IPC::WriteParam((&(writer__)), aPreviousEntryForActivation);
    // Sentinel = 'aPreviousEntryForActivation'
    ((&(writer__)))->WriteSentinel(2572684042);


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

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

auto PContentParent::SendOnAllowAccessFor(
        const MaybeDiscardedBrowsingContext& aParentContext,
        const nsACString& aTrackingOrigin,
        const uint32_t& aCookieBehavior,
        const StorageAccessPermissionGrantedReason& aReason) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_OnAllowAccessFor(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aParentContext);
    // Sentinel = 'aParentContext'
    ((&(writer__)))->WriteSentinel(692454833);
    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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_OnAllowAccessFor", OTHER);

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

auto PContentParent::SendOnContentBlockingDecision(
        const MaybeDiscardedBrowsingContext& aContext,
        const BlockingDecision& aReason,
        const uint32_t& aRejectedReason) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_OnContentBlockingDecision(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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

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


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

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

auto PContentParent::SendHistoryCommitIndexAndLength(
        const MaybeDiscardedBrowsingContext& aContext,
        const uint32_t& aIndex,
        const uint32_t& aLength,
        const nsID& aChangeID,
        mozilla::Span<NavigationEntriesTruncation const> aTruncations) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_HistoryCommitIndexAndLength(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aContext);
    // Sentinel = 'aContext'
    ((&(writer__)))->WriteSentinel(235406151);
    IPC::WriteParam((&(writer__)), aIndex);
    // Sentinel = 'aIndex'
    ((&(writer__)))->WriteSentinel(132055642);
    IPC::WriteParam((&(writer__)), aLength);
    // Sentinel = 'aLength'
    ((&(writer__)))->WriteSentinel(179045060);
    IPC::WriteParam((&(writer__)), aChangeID);
    // Sentinel = 'aChangeID'
    ((&(writer__)))->WriteSentinel(275710773);
    IPC::WriteParam((&(writer__)), aTruncations);
    // Sentinel = 'aTruncations'
    ((&(writer__)))->WriteSentinel(531891452);


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

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

auto PContentParent::SendGetLayoutHistoryState(
        const MaybeDiscardedBrowsingContext& aContext,
        mozilla::ipc::ResolveCallback<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_GetLayoutHistoryState(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

            }
            auto& aState = *maybe__aState;
            // Sentinel = 'aState'
            if ((!((aReader)->ReadSentinel(137036387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsILayoutHistoryState'");
                return MsgValueError;
            }
            auto maybe__aWireframe = IPC::ReadParam<mozilla::Maybe<Wireframe>>(aReader);
            if (!maybe__aWireframe) {
                (aReader)->FatalError("Error deserializing 'Wireframe?'");
                return MsgValueError;

            }
            auto& aWireframe = *maybe__aWireframe;
            // Sentinel = 'aWireframe'
            if ((!((aReader)->ReadSentinel(365888516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Wireframe?'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentParent::SendGetLayoutHistoryState(const MaybeDiscardedBrowsingContext& aContext) -> RefPtr<GetLayoutHistoryStatePromise>
{
    RefPtr<MozPromise<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendGetLayoutHistoryState(std::forward<const MaybeDiscardedBrowsingContext&>(aContext), [promise__](std::tuple<RefPtr<nsILayoutHistoryState>, mozilla::Maybe<Wireframe>>&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

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

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


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

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

auto PContentParent::SendDispatchBeforeUnloadToSubtree(
        const MaybeDiscardedBrowsingContext& aStartingAt,
        const mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>& info,
        mozilla::ipc::ResolveCallback<PermitUnloadResult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DispatchBeforeUnloadToSubtree(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PContentParent::SendDispatchBeforeUnloadToSubtree(
        const MaybeDiscardedBrowsingContext& aStartingAt,
        const mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>& info) -> RefPtr<DispatchBeforeUnloadToSubtreePromise>
{
    RefPtr<MozPromise<PermitUnloadResult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PermitUnloadResult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendDispatchBeforeUnloadToSubtree(std::forward<const MaybeDiscardedBrowsingContext&>(aStartingAt), std::forward<const mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>&>(info), [promise__](PermitUnloadResult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendDispatchNavigateToTraversable(
        const MaybeDiscardedBrowsingContext& aTraversable,
        mozilla::NotNull<nsDocShellLoadState*> info,
        mozilla::ipc::ResolveCallback<PermitUnloadResult>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DispatchNavigateToTraversable(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

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


            aReader->EndRead();

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

auto PContentParent::SendDispatchNavigateToTraversable(
        const MaybeDiscardedBrowsingContext& aTraversable,
        mozilla::NotNull<nsDocShellLoadState*> info) -> RefPtr<DispatchNavigateToTraversablePromise>
{
    RefPtr<MozPromise<PermitUnloadResult, ResponseRejectReason, true>::Private> promise__ = new MozPromise<PermitUnloadResult, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendDispatchNavigateToTraversable(std::forward<const MaybeDiscardedBrowsingContext&>(aTraversable), std::forward<mozilla::NotNull<nsDocShellLoadState*>>(info), [promise__](PermitUnloadResult&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendUpdateMediaCodecsSupported(
        const RemoteMediaIn& aLocation,
        const MediaCodecsSupported& aSupported) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_UpdateMediaCodecsSupported(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aLocation);
    // Sentinel = 'aLocation'
    ((&(writer__)))->WriteSentinel(292094875);
    IPC::WriteParam((&(writer__)), aSupported);
    // Sentinel = 'aSupported'
    ((&(writer__)))->WriteSentinel(378799144);


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

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

auto PContentParent::SendInitNextGenLocalStorageEnabled(const bool& enabled) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_InitNextGenLocalStorageEnabled(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendPRemotePrintJobConstructor(PRemotePrintJobParent* actor) -> PRemotePrintJobParent*
{
    if (!actor) {
        NS_WARNING("Cannot bind null PRemotePrintJobParent actor");
        return nullptr;
    }

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


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

        return nullptr;
    }
    return actor;
}

auto PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::SendAsyncMessage(
        const nsAString& aMessage,
        mozilla::NotNull<StructuredCloneData*> 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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::forward<const MaybeDiscardedBrowsingContext&>(aContext), std::forward<const bool&>(aDoDiscard), [promise__](uint64_t&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::SendBlurToChild(
        const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
        const MaybeDiscardedBrowsingContext& aBrowsingContextToClear,
        const MaybeDiscardedBrowsingContext& aAncestorBrowsingContextToFocus,
        const bool& aIsLeavingDocument,
        const bool& aAdjustWidget,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_BlurToChild(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__)), aActionId);
    // Sentinel = 'aActionId'
    ((&(writer__)))->WriteSentinel(284164973);


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

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

auto PContentParent::SendSetupFocusedAndActive(
        const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
        const uint64_t& aActionIdForFocused,
        const MaybeDiscardedBrowsingContext& aActiveBrowsingContext,
        const uint64_t& aActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SetupFocusedAndActive(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFocusedBrowsingContext);
    // Sentinel = 'aFocusedBrowsingContext'
    ((&(writer__)))->WriteSentinel(1842153819);
    IPC::WriteParam((&(writer__)), aActionIdForFocused);
    // Sentinel = 'aActionIdForFocused'
    ((&(writer__)))->WriteSentinel(1211303773);
    IPC::WriteParam((&(writer__)), aActiveBrowsingContext);
    // Sentinel = 'aActiveBrowsingContext'
    ((&(writer__)))->WriteSentinel(1678444782);
    IPC::WriteParam((&(writer__)), aActionId);
    // Sentinel = 'aActionId'
    ((&(writer__)))->WriteSentinel(284164973);


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

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

auto PContentParent::SendReviseActiveBrowsingContext(
        const uint64_t& aOldActionId,
        const MaybeDiscardedBrowsingContext& aActiveBrowsingContext,
        const uint64_t& aNewActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReviseActiveBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aOldActionId);
    // Sentinel = 'aOldActionId'
    ((&(writer__)))->WriteSentinel(490144908);
    IPC::WriteParam((&(writer__)), aActiveBrowsingContext);
    // Sentinel = 'aActiveBrowsingContext'
    ((&(writer__)))->WriteSentinel(1678444782);
    IPC::WriteParam((&(writer__)), aNewActionId);
    // Sentinel = 'aNewActionId'
    ((&(writer__)))->WriteSentinel(496043159);


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

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

auto PContentParent::SendReviseFocusedBrowsingContext(
        const uint64_t& aOldActionId,
        const MaybeDiscardedBrowsingContext& aFocusedBrowsingContext,
        const uint64_t& aNewActionId) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_ReviseFocusedBrowsingContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aOldActionId);
    // Sentinel = 'aOldActionId'
    ((&(writer__)))->WriteSentinel(490144908);
    IPC::WriteParam((&(writer__)), aFocusedBrowsingContext);
    // Sentinel = 'aFocusedBrowsingContext'
    ((&(writer__)))->WriteSentinel(1842153819);
    IPC::WriteParam((&(writer__)), aNewActionId);
    // Sentinel = 'aNewActionId'
    ((&(writer__)))->WriteSentinel(496043159);


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

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

auto PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::SendWindowPostMessage(
        const MaybeDiscardedBrowsingContext& aContext,
        StructuredCloneData* 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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::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::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PContentParent",
            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 PContentParent::SendCreateWindowContext(const WindowContextInitializer& aInit) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateWindowContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendDiscardWindowContext(
        const uint64_t& aContextId,
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_DiscardWindowContext(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

    IPC::Message::seqno_t seqno__ = 0;
    if (ChannelSend(std::move(msg__), (&(seqno__)))) {
        mAsyncCallbacks.AddCallback(seqno__, PContent::Reply_DiscardWindowContext__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 PContentParent::SendDiscardWindowContext(const uint64_t& aContextId) -> RefPtr<DiscardWindowContextPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendDiscardWindowContext(std::forward<const uint64_t&>(aContextId), [promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendCreateFOGTransport(Endpoint<::mozilla::glean::PFOGTransportChild>&& aChildEndpoint) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_CreateFOGTransport(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::SendFlushFOGData(
        mozilla::ipc::ResolveCallback<ByteBuf>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_FlushFOGData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

            }
            auto& buf = *maybe__buf;
            // Sentinel = 'buf'
            if ((!((aReader)->ReadSentinel(41484606)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PContentParent::SendFlushFOGData() -> RefPtr<FlushFOGDataPromise>
{
    RefPtr<MozPromise<ByteBuf, ResponseRejectReason, true>::Private> promise__ = new MozPromise<ByteBuf, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendFlushFOGData([promise__](ByteBuf&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PContentParent::SendSystemPermissionChanged(
        const PermissionName& aName,
        const PermissionState& aState) -> bool
{
    UniquePtr<IPC::Message> msg__ = PContent::Msg_SystemPermissionChanged(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


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

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

auto PContentParent::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PContentPermissionRequestMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPContentPermissionRequestParent(static_cast<PContentPermissionRequestParent*>(aListener));
        return;
    case PCycleCollectWithLogsMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPCycleCollectWithLogsParent(static_cast<PCycleCollectWithLogsParent*>(aListener));
        return;
    case PHalMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPHalParent(static_cast<PHalParent*>(aListener));
        return;
    case PHeapSnapshotTempFileHelperMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPHeapSnapshotTempFileHelperParent(static_cast<PHeapSnapshotTempFileHelperParent*>(aListener));
        return;
    case PMediaMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPMediaParent(static_cast<PMediaParent*>(aListener));
        return;
    case PRemoteSpellcheckEngineMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPRemoteSpellcheckEngineParent(static_cast<PRemoteSpellcheckEngineParent*>(aListener));
        return;
    case PURLClassifierMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPURLClassifierParent(static_cast<PURLClassifierParent*>(aListener));
        return;
    case PURLClassifierLocalMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPURLClassifierLocalParent(static_cast<PURLClassifierLocalParent*>(aListener));
        return;
    case PURLClassifierLocalByNameMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPURLClassifierLocalByNameParent(static_cast<PURLClassifierLocalByNameParent*>(aListener));
        return;
    case PScriptCacheMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPScriptCacheParent(static_cast<PScriptCacheParent*>(aListener));
        return;
    case PSessionStorageObserverMsgStart:
        static_cast<::mozilla::dom::ContentParent*>(this)->DeallocPSessionStorageObserverParent(static_cast<PSessionStorageObserverParent*>(aListener));
        return;
    default:
        FatalError("unreached");
        return;
    }
}

auto PContentParent::OnMessageReceived(const Message& msg__) -> PContentParent::Result
{
    if (!CanSend()) {
        if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
            mozilla::ipc::LogMessageForProtocol(
                "PContentParent",
                this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                "Ignored message for dead actor",
                (&(msg__))->type(),
                mozilla::ipc::MessageDirection::eSending);
        }
        return MsgProcessed;

    }
    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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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::Msg_ConstructPopupBrowser__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ConstructPopupBrowser", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& browserEp = *maybe__browserEp;
            // Sentinel = 'browserEp'
            if ((!(((&(reader__)))->ReadSentinel(318833594)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PBrowserParent>'");
                return MsgValueError;
            }
            auto maybe__windowEp = IPC::ReadParam<ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>>((&(reader__)));
            if (!maybe__windowEp) {
                FatalError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
                return MsgValueError;

            }
            auto& windowEp = *maybe__windowEp;
            // Sentinel = 'windowEp'
            if ((!(((&(reader__)))->ReadSentinel(255984462)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ManagedEndpoint<::mozilla::dom::PWindowGlobalParent>'");
                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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvConstructPopupBrowser(std::move(browserEp), std::move(windowEp), std::move(tabId), std::move(context), std::move(windowInit), std::move(chromeFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CloneDocumentTreeInto__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CloneDocumentTreeInto", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aSourceBc = *maybe__aSourceBc;
            // Sentinel = 'aSourceBc'
            if ((!(((&(reader__)))->ReadSentinel(296551288)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aTargetBc = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aTargetBc) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

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

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

            return MsgProcessed;
        }
    case PContent::Msg_UpdateRemotePrintSettings__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateRemotePrintSettings", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            return MsgProcessed;
        }
    case PContent::Msg_PExtensionsConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PExtensionsConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PExtensionsParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPExtensionsParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPExtensionsConstructor(actor);
            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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<PBrowserParent*>((&(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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PWebBrowserPersistDocumentParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPWebBrowserPersistDocumentParent(aBrowser, aContext);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<RefPtr<StructuredCloneData>>((&(reader__)));
            if (!maybe__aStack) {
                FatalError("Error deserializing 'StructuredCloneData'");
                return MsgValueError;

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

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

            AUTO_PROFILER_LABEL("PContent::Msg_RequestMemoryReport", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_DecodeImage", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_PCycleCollectWithLogsConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PTestShellConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PScriptCacheConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_UpdateScriptCacheEverHitTelemetry__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateScriptCacheEverHitTelemetry", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aRate = *maybe__aRate;
            // Sentinel = 'aRate'
            if ((!(((&(reader__)))->ReadSentinel(94503406)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvUpdateScriptCacheEverHitTelemetry(std::move(aChildId), std::move(aRate));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_BecomeUntrusted__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BecomeUntrusted", OTHER);

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

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

            AUTO_PROFILER_LABEL("PContent::Msg_CollectPerfStatsJSON", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_CollectScrollingMetrics", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_FlushCodeCoverageCounters", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_CrossProcessRedirect", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_GetLayoutHistoryState", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_DispatchBeforeUnloadToSubtree", OTHER);


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

            AUTO_PROFILER_LABEL("PContent::Msg_DispatchNavigateToTraversable", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PContent::Reply_PRemotePrintJobConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_ConsumeHistoryActivation__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::Msg_SynchronizeLayoutHistoryState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SynchronizeLayoutHistoryState", 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__aState = IPC::ReadParam<RefPtr<nsILayoutHistoryState>>((&(reader__)));
            if (!maybe__aState) {
                FatalError("Error deserializing 'nsILayoutHistoryState'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_SessionHistoryEntryTitle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryTitle", 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__aTitle = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aTitle) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_SessionHistoryEntryScrollRestorationIsManual__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryScrollRestorationIsManual", 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__aIsManual = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsManual) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsManual = *maybe__aIsManual;
            // Sentinel = 'aIsManual'
            if ((!(((&(reader__)))->ReadSentinel(282526588)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSessionHistoryEntryScrollRestorationIsManual(std::move(aContext), std::move(aIsManual));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SessionHistoryEntryScrollPosition__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryScrollPosition", 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__aX = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aX) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

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

            }
            auto& aY = *maybe__aY;
            // Sentinel = 'aY'
            if ((!(((&(reader__)))->ReadSentinel(18677947)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSessionHistoryEntryScrollPosition(std::move(aContext), std::move(aX), std::move(aY));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SessionHistoryEntryCacheKey__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryCacheKey", 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__aCacheKey = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aCacheKey) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aCacheKey = *maybe__aCacheKey;
            // Sentinel = 'aCacheKey'
            if ((!(((&(reader__)))->ReadSentinel(272827231)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSessionHistoryEntryCacheKey(std::move(aContext), std::move(aCacheKey));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryStoreWindowNameInContiguousEntries", 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__aName = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__aName) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& aName = *maybe__aName;
            // Sentinel = 'aName'
            if ((!(((&(reader__)))->ReadSentinel(92537315)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSessionHistoryEntryStoreWindowNameInContiguousEntries(std::move(aContext), std::move(aName));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SessionHistoryEntryWireframe__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SessionHistoryEntryWireframe", 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__aWireframe = IPC::ReadParam<Wireframe>((&(reader__)));
            if (!maybe__aWireframe) {
                FatalError("Error deserializing 'Wireframe'");
                return MsgValueError;

            }
            auto& aWireframe = *maybe__aWireframe;
            // Sentinel = 'aWireframe'
            if ((!(((&(reader__)))->ReadSentinel(365888516)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Wireframe'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSessionHistoryEntryWireframe(std::move(aContext), std::move(aWireframe));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AdoptChildSHEntry__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AdoptChildSHEntry", 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_AdoptChildSHEntry(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAdoptChildSHEntry(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_SynchronizeNavigationAPIState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SynchronizeNavigationAPIState", 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__aState = IPC::ReadParam<mozilla::NotNull<RefPtr<nsStructuredCloneContainer>>>((&(reader__)));
            if (!maybe__aState) {
                FatalError("Error deserializing 'NotNull<nsStructuredCloneContainer>'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_RemoveFromBFCache__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveFromBFCache", 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<::mozilla::dom::ContentParent*>(this))->RecvRemoveFromBFCache(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_InitBackground__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitBackground", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aEndpoint = *maybe__aEndpoint;
            // Sentinel = 'aEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(292225955)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::ipc::PBackgroundStarterParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvInitBackground(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_CreateGMPService__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateGMPService", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_CreateClipboardContentAnalysis__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateClipboardContentAnalysis", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aParentEndpoint = IPC::ReadParam<Endpoint<::mozilla::PClipboardContentAnalysisParent>>((&(reader__)));
            if (!maybe__aParentEndpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::PClipboardContentAnalysisParent>'");
                return MsgValueError;

            }
            auto& aParentEndpoint = *maybe__aParentEndpoint;
            // Sentinel = 'aParentEndpoint'
            if ((!(((&(reader__)))->ReadSentinel(789775885)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PClipboardContentAnalysisParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvCreateClipboardContentAnalysis(std::move(aParentEndpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitStreamFilter__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitStreamFilter", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& channelId = *maybe__channelId;
            // Sentinel = 'channelId'
            if ((!(((&(reader__)))->ReadSentinel(301138823)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__addonId = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__addonId) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& addonId = *maybe__addonId;
            // Sentinel = 'addonId'
            if ((!(((&(reader__)))->ReadSentinel(183894708)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_InitStreamFilter(id__));
            reply__->set_seqno(msg__.seqno());

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

            InitStreamFilterResolver resolver = [resolver__ = std::move(resolver__)](Endpoint<::mozilla::extensions::PStreamFilterChild>&& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::move(aParam));
                    // Sentinel = 'aEndpoint'
                    ((&(writer__)))->WriteSentinel(292225955);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvInitStreamFilter(std::move(channelId), std::move(addonId), 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_PRemoteSpellcheckEngineConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PRemoteSpellcheckEngineConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PRemoteSpellcheckEngineParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPRemoteSpellcheckEngineParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPRemoteSpellcheckEngineConstructor(std::move(actor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_InitCrashReporter__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitCrashReporter", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aInitArgs = *maybe__aInitArgs;
            // Sentinel = 'aInitArgs'
            if ((!(((&(reader__)))->ReadSentinel(286327683)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CrashReporterInitArgs'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvInitCrashReporter(std::move(aInitArgs));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AccumulateMixedContentHSTS__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AccumulateMixedContentHSTS", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aActive = *maybe__aActive;
            // Sentinel = 'aActive'
            if ((!(((&(reader__)))->ReadSentinel(176095934)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
            if (!maybe__aOriginAttributes) {
                FatalError("Error deserializing 'OriginAttributes'");
                return MsgValueError;

            }
            auto& aOriginAttributes = *maybe__aOriginAttributes;
            // Sentinel = 'aOriginAttributes'
            if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAccumulateMixedContentHSTS(aURI, std::move(aActive), std::move(aOriginAttributes));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PHalConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PHalConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PHalParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPHalParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPHalConstructor(std::move(actor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PHeapSnapshotTempFileHelperConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PHeapSnapshotTempFileHelperConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PHeapSnapshotTempFileHelperParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPHeapSnapshotTempFileHelperParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPHeapSnapshotTempFileHelperConstructor(std::move(actor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PNeckoConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PNeckoConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PNeckoParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPNeckoParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPNeckoConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PSpeechSynthesisConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PSpeechSynthesisConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PSpeechSynthesisParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPSpeechSynthesisParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPSpeechSynthesisConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PMediaConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PMediaConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PMediaParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPMediaParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPMediaConstructor(std::move(actor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CreateAudioIPCConnection__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateAudioIPCConnection", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_CreateAudioIPCConnection(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvCreateAudioIPCConnection(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_AcquireHWInferenceProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AcquireHWInferenceProcess", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_CreateSpeechRecognition__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateSpeechRecognition", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::hwinference::PSpeechRecognitionParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::hwinference::PSpeechRecognitionParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::hwinference::PSpeechRecognitionParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvCreateSpeechRecognition(std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReleaseHWInferenceConnection__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReleaseHWInferenceConnection", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_PURLClassifierLocalConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalConstructor", 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__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__features = IPC::ReadParam<nsTArray<IPCURLClassifierFeature>>((&(reader__)));
            if (!maybe__features) {
                FatalError("Error deserializing 'IPCURLClassifierFeature[]'");
                return MsgValueError;

            }
            auto& features = *maybe__features;
            // Sentinel = 'features'
            if ((!(((&(reader__)))->ReadSentinel(250348384)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCURLClassifierFeature[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PURLClassifierLocalParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPURLClassifierLocalParent(uri, features);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPURLClassifierLocalConstructor(std::move(actor), uri, std::move(features));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PURLClassifierLocalByNameConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalByNameConstructor", 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__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__featureNames = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
            if (!maybe__featureNames) {
                FatalError("Error deserializing 'nsCString[]'");
                return MsgValueError;

            }
            auto& featureNames = *maybe__featureNames;
            // Sentinel = 'featureNames'
            if ((!(((&(reader__)))->ReadSentinel(532350177)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aListType = IPC::ReadParam<listType>((&(reader__)));
            if (!maybe__aListType) {
                FatalError("Error deserializing 'listType'");
                return MsgValueError;

            }
            auto& aListType = *maybe__aListType;
            // Sentinel = 'aListType'
            if ((!(((&(reader__)))->ReadSentinel(296158112)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'listType'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PURLClassifierLocalByNameParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPURLClassifierLocalByNameParent(uri, featureNames, aListType);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPURLClassifierLocalByNameConstructor(std::move(actor), uri, std::move(featureNames), std::move(aListType));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PSessionStorageObserverConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PSessionStorageObserverConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PSessionStorageObserverParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPSessionStorageObserverParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPSessionStorageObserverConstructor(std::move(actor));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_StartVisitedQueries__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StartVisitedQueries", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__uri = IPC::ReadParam<nsTArray<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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvStartVisitedQueries(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_SetURITitle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetURITitle", 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__title = IPC::ReadParam<nsString>((&(reader__)));
            if (!maybe__title) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;

            }
            auto& title = *maybe__title;
            // Sentinel = 'title'
            if ((!(((&(reader__)))->ReadSentinel(109445667)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetURITitle(uri, std::move(title));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_LoadURIExternal__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_LoadURIExternal", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& uri = *maybe__uri;
            // Sentinel = 'uri'
            if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIURI>'");
                return MsgValueError;
            }
            auto maybe__triggeringPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__triggeringPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& triggeringPrincipal = *maybe__triggeringPrincipal;
            // Sentinel = 'triggeringPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1325729749)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            auto maybe__redirectPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__redirectPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& redirectPrincipal = *maybe__redirectPrincipal;
            // Sentinel = 'redirectPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1052772085)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__browsingContext = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__browsingContext) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& browsingContext = *maybe__browsingContext;
            // Sentinel = 'browsingContext'
            if ((!(((&(reader__)))->ReadSentinel(844695121)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__wasExternallyTriggered = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__wasExternallyTriggered) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

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

            }
            auto& newWindowTarget = *maybe__newWindowTarget;
            // Sentinel = 'newWindowTarget'
            if ((!(((&(reader__)))->ReadSentinel(826934826)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvLoadURIExternal(uri, triggeringPrincipal, redirectPrincipal, std::move(browsingContext), std::move(wasExternallyTriggered), std::move(hasValidUserGestureActivation), std::move(newWindowTarget));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ExtProtocolChannelConnectParent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ExtProtocolChannelConnectParent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_AddSecurityState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddSecurityState", 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__aStateFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aStateFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aStateFlags = *maybe__aStateFlags;
            // Sentinel = 'aStateFlags'
            if ((!(((&(reader__)))->ReadSentinel(428606544)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAddSecurityState(std::move(aContext), std::move(aStateFlags));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PExternalHelperAppConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PExternalHelperAppConstructor", 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__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__loadInfoArgs = IPC::ReadParam<LoadInfoArgs>((&(reader__)));
            if (!maybe__loadInfoArgs) {
                FatalError("Error deserializing 'LoadInfoArgs'");
                return MsgValueError;

            }
            auto& loadInfoArgs = *maybe__loadInfoArgs;
            // Sentinel = 'loadInfoArgs'
            if ((!(((&(reader__)))->ReadSentinel(514000058)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LoadInfoArgs'");
                return MsgValueError;
            }
            auto maybe__aMimeContentType = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__aMimeContentType) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

            }
            auto& aMimeContentType = *maybe__aMimeContentType;
            // Sentinel = 'aMimeContentType'
            if ((!(((&(reader__)))->ReadSentinel(888538727)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__aContentDisposition = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__aContentDisposition) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

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

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

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

            }
            auto& aForceSave = *maybe__aForceSave;
            // Sentinel = 'aForceSave'
            if ((!(((&(reader__)))->ReadSentinel(350946272)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aContentLength = IPC::ReadParam<int64_t>((&(reader__)));
            if (!maybe__aContentLength) {
                FatalError("Error deserializing 'int64_t'");
                return MsgValueError;

            }
            auto& aContentLength = *maybe__aContentLength;
            // Sentinel = 'aContentLength'
            if ((!(((&(reader__)))->ReadSentinel(694158751)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int64_t'");
                return MsgValueError;
            }
            auto maybe__aReferrer = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__aReferrer) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& aReferrer = *maybe__aReferrer;
            // Sentinel = 'aReferrer'
            if ((!(((&(reader__)))->ReadSentinel(293340063)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PExternalHelperAppParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPExternalHelperAppParent(uri, loadInfoArgs, aMimeContentType, aContentDisposition, aContentDispositionHint, aContentDispositionFilename, aForceSave, aContentLength, aReferrer, aContext);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPExternalHelperAppConstructor(actor, uri, std::move(loadInfoArgs), std::move(aMimeContentType), std::move(aContentDisposition), std::move(aContentDispositionHint), std::move(aContentDispositionFilename), std::move(aForceSave), std::move(aContentLength), aReferrer, 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_PHandlerServiceConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PHandlerServiceConstructor", 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();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PHandlerServiceParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPHandlerServiceParent();

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPHandlerServiceConstructor(actor);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AddGeolocationListener__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddGeolocationListener", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_RemoveGeolocationListener__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveGeolocationListener", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_SetGeolocationHigherAccuracy__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetGeolocationHigherAccuracy", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_ConsoleMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ConsoleMessage", 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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvConsoleMessage(std::move(message));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ScriptErrorWithStack__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ScriptErrorWithStack", 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__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;
            }
            auto maybe__stack = IPC::ReadParam<mozilla::NotNull<RefPtr<StructuredCloneData>>>((&(reader__)));
            if (!maybe__stack) {
                FatalError("Error deserializing 'NotNull<StructuredCloneData>'");
                return MsgValueError;

            }
            auto& stack = *maybe__stack;
            // Sentinel = 'stack'
            if ((!(((&(reader__)))->ReadSentinel(107479575)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<StructuredCloneData>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvScriptErrorWithStack(std::move(message), std::move(sourceName), std::move(lineNumber), std::move(colNumber), std::move(flags), std::move(category), std::move(isFromPrivateWindow), std::move(isFromChromeContext), stack);
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetClipboard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetClipboard", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTransferable = *maybe__aTransferable;
            // Sentinel = 'aTransferable'
            if ((!(((&(reader__)))->ReadSentinel(609813819)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCTransferable'");
                return MsgValueError;
            }
            auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aWhichClipboard) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aRequestingWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
            // Sentinel = 'aRequestingWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetClipboard(std::move(aTransferable), std::move(aWhichClipboard), std::move(aRequestingWindowContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GetClipboardDataIfSmallerThan__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataIfSmallerThan", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTypes = *maybe__aTypes;
            // Sentinel = 'aTypes'
            if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aThreshold = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aThreshold) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aThreshold = *maybe__aThreshold;
            // Sentinel = 'aThreshold'
            if ((!(((&(reader__)))->ReadSentinel(367789071)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aWhichClipboard) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aRequestingWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
            // Sentinel = 'aRequestingWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_GetClipboardDataIfSmallerThan(id__));
            reply__->set_seqno(msg__.seqno());

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

            GetClipboardDataIfSmallerThanResolver resolver = [resolver__ = std::move(resolver__)](IPCTransferableDataOrError&& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::move(aParam));
                    // Sentinel = 'aResult'
                    ((&(writer__)))->WriteSentinel(185205473);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetClipboardDataIfSmallerThan(std::move(aTypes), std::move(aThreshold), std::move(aWhichClipboard), std::move(aRequestingWindowContext), 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_GetClipboardDataSnapshot__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshot", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTypes = *maybe__aTypes;
            // Sentinel = 'aTypes'
            if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aWhichClipboard) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aRequestingWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
            // Sentinel = 'aRequestingWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            auto maybe__aRequestingPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aRequestingPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aRequestingPrincipal = *maybe__aRequestingPrincipal;
            // Sentinel = 'aRequestingPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1431439403)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_GetClipboardDataSnapshot(id__));
            reply__->set_seqno(msg__.seqno());

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

            GetClipboardDataSnapshotResolver resolver = [resolver__ = std::move(resolver__)](ClipboardReadRequestOrError&& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::move(aParam));
                    // Sentinel = 'aClipboardReadRequestOrError'
                    ((&(writer__)))->WriteSentinel(2662402850);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetClipboardDataSnapshot(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), aRequestingPrincipal, 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_EmptyClipboard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_EmptyClipboard", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvEmptyClipboard(std::move(aWhichClipboard));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PClipboardWriteRequestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PClipboardWriteRequestConstructor", 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__aClipboardType = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aClipboardType) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aClipboardType = *maybe__aClipboardType;
            // Sentinel = 'aClipboardType'
            if ((!(((&(reader__)))->ReadSentinel(686228884)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            auto maybe__aSettingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aSettingWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aSettingWindowContext = *maybe__aSettingWindowContext;
            // Sentinel = 'aSettingWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(1561659549)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            RefPtr<PClipboardWriteRequestParent> actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPClipboardWriteRequestParent(aClipboardType, aSettingWindowContext);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPClipboardWriteRequestConstructor(actor, std::move(aClipboardType), std::move(aSettingWindowContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FirstIdle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FirstIdle", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_CopyFavicon__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CopyFavicon", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& isPrivate = *maybe__isPrivate;
            // Sentinel = 'isPrivate'
            if ((!(((&(reader__)))->ReadSentinel(310576056)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvCopyFavicon(oldURI, newURI, std::move(isPrivate));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FindImageText__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FindImageText", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& image = *maybe__image;
            // Sentinel = 'image'
            if ((!(((&(reader__)))->ReadSentinel(102498820)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCImage'");
                return MsgValueError;
            }
            auto maybe__languages = IPC::ReadParam<nsTArray<nsCString>>((&(reader__)));
            if (!maybe__languages) {
                FatalError("Error deserializing 'nsCString[]'");
                return MsgValueError;

            }
            auto& languages = *maybe__languages;
            // Sentinel = 'languages'
            if ((!(((&(reader__)))->ReadSentinel(310903736)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_FindImageText(id__));
            reply__->set_seqno(msg__.seqno());

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

            FindImageTextResolver resolver = [resolver__ = std::move(resolver__)](const TextRecognitionResultOrError& 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::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PContentParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvFindImageText(std::move(image), std::move(languages), 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_GraphicsError__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GraphicsError", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aError = *maybe__aError;
            // Sentinel = 'aError'
            if ((!(((&(reader__)))->ReadSentinel(135463532)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGraphicsError(std::move(aError));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AddIdleObserver__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddIdleObserver", 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__idleTimeInS = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__idleTimeInS) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& idleTimeInS = *maybe__idleTimeInS;
            // Sentinel = 'idleTimeInS'
            if ((!(((&(reader__)))->ReadSentinel(434832440)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAddIdleObserver(std::move(observerId), std::move(idleTimeInS));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RemoveIdleObserver__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveIdleObserver", 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__idleTimeInS = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__idleTimeInS) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& idleTimeInS = *maybe__idleTimeInS;
            // Sentinel = 'idleTimeInS'
            if ((!(((&(reader__)))->ReadSentinel(434832440)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvRemoveIdleObserver(std::move(observerId), std::move(idleTimeInS));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_BackUpXResources__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BackUpXResources", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aXSocketFd = *maybe__aXSocketFd;
            // Sentinel = 'aXSocketFd'
            if ((!(((&(reader__)))->ReadSentinel(349569997)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvBackUpXResources(std::move(aXSocketFd));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RequestAnonymousTemporaryFile__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RequestAnonymousTemporaryFile", 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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvRequestAnonymousTemporaryFile(std::move(aID));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyShutdownSuccess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyShutdownSuccess", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_FinishShutdown__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FinishShutdown", OTHER);

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

            return MsgProcessed;
        }
    case PContent::Msg_PContentPermissionRequestConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PContentPermissionRequestConstructor", 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__aRequests = IPC::ReadParam<nsTArray<PermissionRequest>>((&(reader__)));
            if (!maybe__aRequests) {
                FatalError("Error deserializing 'PermissionRequest[]'");
                return MsgValueError;

            }
            auto& aRequests = *maybe__aRequests;
            // Sentinel = 'aRequests'
            if ((!(((&(reader__)))->ReadSentinel(301728702)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PermissionRequest[]'");
                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__aTopLevelPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aTopLevelPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& aTopLevelPrincipal = *maybe__aTopLevelPrincipal;
            // Sentinel = 'aTopLevelPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1128007471)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__aIsHandlingUserInput = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsHandlingUserInput) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            }
            auto& aMaybeUnsafePermissionDelegate = *maybe__aMaybeUnsafePermissionDelegate;
            // Sentinel = 'aMaybeUnsafePermissionDelegate'
            if ((!(((&(reader__)))->ReadSentinel(3078949878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                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__aIgnoreAllowSitePermission = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIgnoreAllowSitePermission) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIgnoreAllowSitePermission = *maybe__aIgnoreAllowSitePermission;
            // Sentinel = 'aIgnoreAllowSitePermission'
            if ((!(((&(reader__)))->ReadSentinel(2328693379)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PContentPermissionRequestParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPContentPermissionRequestParent(aRequests, aPrincipal, aTopLevelPrincipal, aIsHandlingUserInput, aMaybeUnsafePermissionDelegate, tabId, aIgnoreAllowSitePermission);

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPContentPermissionRequestConstructor(std::move(actor), std::move(aRequests), aPrincipal, aTopLevelPrincipal, std::move(aIsHandlingUserInput), std::move(aMaybeUnsafePermissionDelegate), std::move(tabId), std::move(aIgnoreAllowSitePermission));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ShutdownProfile__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ShutdownProfile", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aProfileAndAdditionalInformation = *maybe__aProfileAndAdditionalInformation;
            // Sentinel = 'aProfileAndAdditionalInformation'
            if ((!(((&(reader__)))->ReadSentinel(3466529989)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ProfileAndAdditionalInformation'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvShutdownProfile(std::move(aProfileAndAdditionalInformation));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ShutdownPerfStats__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ShutdownPerfStats", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPerfStats = *maybe__aPerfStats;
            // Sentinel = 'aPerfStats'
            if ((!(((&(reader__)))->ReadSentinel(356189182)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvShutdownPerfStats(std::move(aPerfStats));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetCharacterMap__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetCharacterMap", 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__aFamilyIndex = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aFamilyIndex) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

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

            }
            auto& aFaceIndex = *maybe__aFaceIndex;
            // Sentinel = 'aFaceIndex'
            if ((!(((&(reader__)))->ReadSentinel(335021001)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aMap = IPC::ReadParam<gfxSparseBitSet>((&(reader__)));
            if (!maybe__aMap) {
                FatalError("Error deserializing 'gfxSparseBitSet'");
                return MsgValueError;

            }
            auto& aMap = *maybe__aMap;
            // Sentinel = 'aMap'
            if ((!(((&(reader__)))->ReadSentinel(60883328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'gfxSparseBitSet'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetCharacterMap(std::move(aGeneration), std::move(aFamilyIndex), std::move(aAlias), std::move(aFaceIndex), std::move(aMap));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetupFamilyCharMap__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetupFamilyCharMap", 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__aFamilyIndex = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aFamilyIndex) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

            }
            auto& aAlias = *maybe__aAlias;
            // Sentinel = 'aAlias'
            if ((!(((&(reader__)))->ReadSentinel(129040972)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetupFamilyCharMap(std::move(aGeneration), std::move(aFamilyIndex), std::move(aAlias));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_StartCmapLoading__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StartCmapLoading", 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__aStartIndex = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aStartIndex) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aStartIndex = *maybe__aStartIndex;
            // Sentinel = 'aStartIndex'
            if ((!(((&(reader__)))->ReadSentinel(435749992)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvStartCmapLoading(std::move(aGeneration), std::move(aStartIndex));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DropParentProcessChannelHandle__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DropParentProcessChannelHandle", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aUuid = *maybe__aUuid;
            // Sentinel = 'aUuid'
            if ((!(((&(reader__)))->ReadSentinel(97714681)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvDropParentProcessChannelHandle(std::move(aUuid));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CreateWindow__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateWindow", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__aThisTab = IPC::ReadParam<mozilla::NotNull<PBrowserParent*>>((&(reader__)));
            if (!maybe__aThisTab) {
                FatalError("Error deserializing 'NotNull<PBrowser>'");
                return MsgValueError;

            }
            auto& aThisTab = *maybe__aThisTab;
            // Sentinel = 'aThisTab'
            if ((!(((&(reader__)))->ReadSentinel(231015185)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PBrowser>'");
                return MsgValueError;
            }
            auto maybe__aParent = IPC::ReadParam<MaybeDiscardedBrowsingContext>((&(reader__)));
            if (!maybe__aParent) {
                FatalError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;

            }
            auto& aParent = *maybe__aParent;
            // Sentinel = 'aParent'
            if ((!(((&(reader__)))->ReadSentinel(179962572)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aNewTab = IPC::ReadParam<mozilla::NotNull<PBrowserParent*>>((&(reader__)));
            if (!maybe__aNewTab) {
                FatalError("Error deserializing 'NotNull<PBrowser>'");
                return MsgValueError;

            }
            auto& aNewTab = *maybe__aNewTab;
            // Sentinel = 'aNewTab'
            if ((!(((&(reader__)))->ReadSentinel(175571619)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<PBrowser>'");
                return MsgValueError;
            }
            auto maybe__aChromeFlags = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aChromeFlags) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

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

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

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

            }
            auto& aTopLevelCreatedByContent = *maybe__aTopLevelCreatedByContent;
            // Sentinel = 'aTopLevelCreatedByContent'
            if ((!(((&(reader__)))->ReadSentinel(2117143003)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__aURIToLoad = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
            if (!maybe__aURIToLoad) {
                FatalError("Error deserializing 'nsIURI'");
                return MsgValueError;

            }
            auto& aURIToLoad = *maybe__aURIToLoad;
            // Sentinel = 'aURIToLoad'
            if ((!(((&(reader__)))->ReadSentinel(321258389)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            auto maybe__aFeatures = IPC::ReadParam<nsCString>((&(reader__)));
            if (!maybe__aFeatures) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;

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

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

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

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

            }
            auto& aReferrerInfo = *maybe__aReferrerInfo;
            // Sentinel = 'aReferrerInfo'
            if ((!(((&(reader__)))->ReadSentinel(597755179)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIReferrerInfo'");
                return MsgValueError;
            }
            auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
            if (!maybe__aOriginAttributes) {
                FatalError("Error deserializing 'OriginAttributes'");
                return MsgValueError;

            }
            auto& aOriginAttributes = *maybe__aOriginAttributes;
            // Sentinel = 'aOriginAttributes'
            if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                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;
            }
            auto maybe__aTextDirectiveUserActivation = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aTextDirectiveUserActivation) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aTextDirectiveUserActivation = *maybe__aTextDirectiveUserActivation;
            // Sentinel = 'aTextDirectiveUserActivation'
            if ((!(((&(reader__)))->ReadSentinel(2721450839)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_CreateWindow(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvCreateWindow(aThisTab, std::move(aParent), aNewTab, std::move(aChromeFlags), std::move(aCalledFromJS), std::move(aForPrinting), std::move(aForWindowDotPrint), std::move(aTopLevelCreatedByContent), aURIToLoad, std::move(aFeatures), std::move(aModifiers), aTriggeringPrincipal, aPolicyContainer, aReferrerInfo, std::move(aOriginAttributes), std::move(aUserActivation), std::move(aTextDirectiveUserActivation), 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_GetFilesRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetFilesRequest", 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__aDirectories = IPC::ReadParam<nsTArray<nsString>>((&(reader__)));
            if (!maybe__aDirectories) {
                FatalError("Error deserializing 'nsString[]'");
                return MsgValueError;

            }
            auto& aDirectories = *maybe__aDirectories;
            // Sentinel = 'aDirectories'
            if ((!(((&(reader__)))->ReadSentinel(513803487)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString[]'");
                return MsgValueError;
            }
            auto maybe__aRecursiveFlag = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aRecursiveFlag) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aRecursiveFlag = *maybe__aRecursiveFlag;
            // Sentinel = 'aRecursiveFlag'
            if ((!(((&(reader__)))->ReadSentinel(701498772)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetFilesRequest(std::move(aID), std::move(aDirectories), std::move(aRecursiveFlag));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DeleteGetFilesRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DeleteGetFilesRequest", 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;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvDeleteGetFilesRequest(std::move(aID));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_StoreAndBroadcastBlobURLRegistration__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StoreAndBroadcastBlobURLRegistration", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& url = *maybe__url;
            // Sentinel = 'url'
            if ((!(((&(reader__)))->ReadSentinel(45220180)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__blob = IPC::ReadParam<IPCBlob>((&(reader__)));
            if (!maybe__blob) {
                FatalError("Error deserializing 'IPCBlob'");
                return MsgValueError;

            }
            auto& blob = *maybe__blob;
            // Sentinel = 'blob'
            if ((!(((&(reader__)))->ReadSentinel(68157856)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
                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__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<::mozilla::dom::ContentParent*>(this))->RecvStoreAndBroadcastBlobURLRegistration(std::move(url), std::move(blob), principal, 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_UnstoreAndBroadcastBlobURLUnregistration__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aRequests = *maybe__aRequests;
            // Sentinel = 'aRequests'
            if ((!(((&(reader__)))->ReadSentinel(301728702)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BroadcastBlobURLUnregistrationRequest[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvUnstoreAndBroadcastBlobURLUnregistration(std::move(aRequests));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RecordPageLoadEvent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RecordPageLoadEvent", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

            }
            auto& aBrowsingContext = *maybe__aBrowsingContext;
            // Sentinel = 'aBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvRecordPageLoadEvent(std::move(event), std::move(navigationStartTime), std::move(aBrowsingContext));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AccumulateChildHistograms__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildHistograms", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& accumulations = *maybe__accumulations;
            // Sentinel = 'accumulations'
            if ((!(((&(reader__)))->ReadSentinel(632030585)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'HistogramAccumulation[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAccumulateChildHistograms(std::move(accumulations));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AccumulateChildKeyedHistograms__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildKeyedHistograms", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& accumulations = *maybe__accumulations;
            // Sentinel = 'accumulations'
            if ((!(((&(reader__)))->ReadSentinel(632030585)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'KeyedHistogramAccumulation[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAccumulateChildKeyedHistograms(std::move(accumulations));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateChildScalars__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildScalars", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& updates = *maybe__updates;
            // Sentinel = 'updates'
            if ((!(((&(reader__)))->ReadSentinel(199951095)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ScalarAction[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvUpdateChildScalars(std::move(updates));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateChildKeyedScalars__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildKeyedScalars", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& updates = *maybe__updates;
            // Sentinel = 'updates'
            if ((!(((&(reader__)))->ReadSentinel(199951095)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'KeyedScalarAction[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvUpdateChildKeyedScalars(std::move(updates));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RecordChildEvents__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RecordChildEvents", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& events = *maybe__events;
            // Sentinel = 'events'
            if ((!(((&(reader__)))->ReadSentinel(149619350)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ChildEventData[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvRecordChildEvents(std::move(events));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RecordDiscardedData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RecordDiscardedData", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& data = *maybe__data;
            // Sentinel = 'data'
            if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DiscardedData'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvRecordDiscardedData(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_AddMemoryReport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddMemoryReport", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aReport = *maybe__aReport;
            // Sentinel = 'aReport'
            if ((!(((&(reader__)))->ReadSentinel(184025822)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MemoryReport'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAddMemoryReport(std::move(aReport));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_BHRThreadHang__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BHRThreadHang", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aHangDetails = *maybe__aHangDetails;
            // Sentinel = 'aHangDetails'
            if ((!(((&(reader__)))->ReadSentinel(488113318)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'HangDetails'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvBHRThreadHang(std::move(aHangDetails));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AutomaticStorageAccessPermissionCanBeGranted", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aPrincipal = *maybe__aPrincipal;
            // Sentinel = 'aPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(364381188)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_AutomaticStorageAccessPermissionCanBeGranted(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAutomaticStorageAccessPermissionCanBeGranted(aPrincipal, 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_StorageAccessPermissionGrantedForOrigin__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StorageAccessPermissionGrantedForOrigin", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTopLevelWindowId = *maybe__aTopLevelWindowId;
            // Sentinel = 'aTopLevelWindowId'
            if ((!(((&(reader__)))->ReadSentinel(1006700210)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            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__aTrackingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aTrackingPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& aTrackingPrincipal = *maybe__aTrackingPrincipal;
            // Sentinel = 'aTrackingPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1135609655)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                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__aAllowMode = IPC::ReadParam<StorageAccessPromptChoices>((&(reader__)));
            if (!maybe__aAllowMode) {
                FatalError("Error deserializing 'StorageAccessPromptChoices'");
                return MsgValueError;

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

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

            }
            auto& aFrameOnly = *maybe__aFrameOnly;
            // Sentinel = 'aFrameOnly'
            if ((!(((&(reader__)))->ReadSentinel(350159855)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_StorageAccessPermissionGrantedForOrigin(id__));
            reply__->set_seqno(msg__.seqno());

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

            StorageAccessPermissionGrantedForOriginResolver 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 = 'granted'
                    ((&(writer__)))->WriteSentinel(195756774);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvStorageAccessPermissionGrantedForOrigin(std::move(aTopLevelWindowId), std::move(aParentContext), aTrackingPrincipal, std::move(aTrackingOrigin), std::move(aAllowMode), std::move(aReason), std::move(aFrameOnly), 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_CompleteAllowAccessFor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CompleteAllowAccessFor", 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__aTopLevelWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aTopLevelWindowId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aTopLevelWindowId = *maybe__aTopLevelWindowId;
            // Sentinel = 'aTopLevelWindowId'
            if ((!(((&(reader__)))->ReadSentinel(1006700210)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            auto maybe__aTrackingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aTrackingPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& aTrackingPrincipal = *maybe__aTrackingPrincipal;
            // Sentinel = 'aTrackingPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1135609655)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                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;
            }
            auto maybe__aHadPriorUserInteraction = IPC::ReadParam<mozilla::Maybe<bool>>((&(reader__)));
            if (!maybe__aHadPriorUserInteraction) {
                FatalError("Error deserializing 'bool?'");
                return MsgValueError;

            }
            auto& aHadPriorUserInteraction = *maybe__aHadPriorUserInteraction;
            // Sentinel = 'aHadPriorUserInteraction'
            if ((!(((&(reader__)))->ReadSentinel(1960577434)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_CompleteAllowAccessFor(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvCompleteAllowAccessFor(std::move(aParentContext), std::move(aTopLevelWindowId), aTrackingPrincipal, std::move(aTrackingOrigin), std::move(aCookieBehavior), std::move(aReason), std::move(aHadPriorUserInteraction), 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_StoreUserInteractionAsPermission__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StoreUserInteractionAsPermission", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_TestCookiePermissionDecided__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_TestCookiePermissionDecided", 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__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;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_TestCookiePermissionDecided(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvTestCookiePermissionDecided(std::move(aContext), aPrincipal, 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_NotifyMediaPlaybackChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaPlaybackChanged", 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__aState = IPC::ReadParam<MediaPlaybackState>((&(reader__)));
            if (!maybe__aState) {
                FatalError("Error deserializing 'MediaPlaybackState'");
                return MsgValueError;

            }
            auto& aState = *maybe__aState;
            // Sentinel = 'aState'
            if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MediaPlaybackState'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyMediaPlaybackChanged(std::move(aContext), 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_NotifyMediaAudibleChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaAudibleChanged", 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__aState = IPC::ReadParam<MediaAudibleState>((&(reader__)));
            if (!maybe__aState) {
                FatalError("Error deserializing 'MediaAudibleState'");
                return MsgValueError;

            }
            auto& aState = *maybe__aState;
            // Sentinel = 'aState'
            if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MediaAudibleState'");
                return MsgValueError;
            }
            auto maybe__aType = IPC::ReadParam<ControlType>((&(reader__)));
            if (!maybe__aType) {
                FatalError("Error deserializing 'ControlType'");
                return MsgValueError;

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

            }
            auto& aSessionType = *maybe__aSessionType;
            // Sentinel = 'aSessionType'
            if ((!(((&(reader__)))->ReadSentinel(526189800)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'AudioSessionType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyMediaAudibleChanged(std::move(aContext), std::move(aState), std::move(aType), std::move(aSessionType));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyPictureInPictureModeChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPictureInPictureModeChanged", 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__aEnabled = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aEnabled) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            return MsgProcessed;
        }
    case PContent::Msg_NotifyMediaSessionUpdated__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionUpdated", 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__aIsCreated = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsCreated) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsCreated = *maybe__aIsCreated;
            // Sentinel = 'aIsCreated'
            if ((!(((&(reader__)))->ReadSentinel(344261590)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyMediaSessionUpdated(std::move(aContext), std::move(aIsCreated));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyUpdateMediaMetadata__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyUpdateMediaMetadata", 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__aMetadata = IPC::ReadParam<mozilla::Maybe<MediaMetadataBase>>((&(reader__)));
            if (!maybe__aMetadata) {
                FatalError("Error deserializing 'MediaMetadataBase?'");
                return MsgValueError;

            }
            auto& aMetadata = *maybe__aMetadata;
            // Sentinel = 'aMetadata'
            if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MediaMetadataBase?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyUpdateMediaMetadata(std::move(aContext), std::move(aMetadata));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyMediaSessionPlaybackStateChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionPlaybackStateChanged", 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__aMetadata = IPC::ReadParam<MediaSessionPlaybackState>((&(reader__)));
            if (!maybe__aMetadata) {
                FatalError("Error deserializing 'MediaSessionPlaybackState'");
                return MsgValueError;

            }
            auto& aMetadata = *maybe__aMetadata;
            // Sentinel = 'aMetadata'
            if ((!(((&(reader__)))->ReadSentinel(288752515)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MediaSessionPlaybackState'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyMediaSessionPlaybackStateChanged(std::move(aContext), std::move(aMetadata));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyMediaSessionSupportedActionChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaSessionSupportedActionChanged", 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<MediaSessionAction>((&(reader__)));
            if (!maybe__aAction) {
                FatalError("Error deserializing 'MediaSessionAction'");
                return MsgValueError;

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

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

            return MsgProcessed;
        }
    case PContent::Msg_NotifyMediaFullScreenState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyMediaFullScreenState", 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__aIsInFullScreen = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aIsInFullScreen) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aIsInFullScreen = *maybe__aIsInFullScreen;
            // Sentinel = 'aIsInFullScreen'
            if ((!(((&(reader__)))->ReadSentinel(754320840)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyMediaFullScreenState(std::move(aContext), std::move(aIsInFullScreen));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyPositionStateChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPositionStateChanged", 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__aState = IPC::ReadParam<mozilla::Maybe<PositionState>>((&(reader__)));
            if (!maybe__aState) {
                FatalError("Error deserializing 'PositionState?'");
                return MsgValueError;

            }
            auto& aState = *maybe__aState;
            // Sentinel = 'aState'
            if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PositionState?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyPositionStateChanged(std::move(aContext), 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_NotifyGuessedPositionStateChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyGuessedPositionStateChanged", 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__aMediaId = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__aMediaId) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& aMediaId = *maybe__aMediaId;
            // Sentinel = 'aMediaId'
            if ((!(((&(reader__)))->ReadSentinel(221905647)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__aState = IPC::ReadParam<mozilla::Maybe<PositionState>>((&(reader__)));
            if (!maybe__aState) {
                FatalError("Error deserializing 'PositionState?'");
                return MsgValueError;

            }
            auto& aState = *maybe__aState;
            // Sentinel = 'aState'
            if ((!(((&(reader__)))->ReadSentinel(137036387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PositionState?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyGuessedPositionStateChanged(std::move(aContext), std::move(aMediaId), 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_AddOrRemovePageAwakeRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddOrRemovePageAwakeRequest", 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__aShouldAddCount = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aShouldAddCount) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aShouldAddCount = *maybe__aShouldAddCount;
            // Sentinel = 'aShouldAddCount'
            if ((!(((&(reader__)))->ReadSentinel(777848291)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAddOrRemovePageAwakeRequest(std::move(aContext), std::move(aShouldAddCount));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReportServiceWorkerShutdownProgress__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReportServiceWorkerShutdownProgress", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aShutdownStateId = *maybe__aShutdownStateId;
            // Sentinel = 'aShutdownStateId'
            if ((!(((&(reader__)))->ReadSentinel(925238892)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__aProgress = IPC::ReadParam<Progress>((&(reader__)));
            if (!maybe__aProgress) {
                FatalError("Error deserializing 'Progress'");
                return MsgValueError;

            }
            auto& aProgress = *maybe__aProgress;
            // Sentinel = 'aProgress'
            if ((!(((&(reader__)))->ReadSentinel(301794231)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Progress'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvReportServiceWorkerShutdownProgress(std::move(aShutdownStateId), std::move(aProgress));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AbortOtherOrientationPendingPromises__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AbortOtherOrientationPendingPromises", 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<::mozilla::dom::ContentParent*>(this))->RecvAbortOtherOrientationPendingPromises(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_HistoryReload__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_HistoryReload", 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<::mozilla::dom::ContentParent*>(this))->RecvHistoryReload(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_NotifyOnHistoryReload__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyOnHistoryReload", 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::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_NotifyOnHistoryReload(id__));
            reply__->set_seqno(msg__.seqno());

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

            NotifyOnHistoryReloadResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const bool&, const mozilla::Maybe<mozilla::NotNull<RefPtr<nsDocShellLoadState>>>&, const mozilla::Maybe<bool>&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'canReload'
                    ((&(writer__)))->WriteSentinel(295043978);
                    IPC::WriteParam((&(writer__)), std::get<1>(aParam));
                    // Sentinel = 'loadState'
                    ((&(writer__)))->WriteSentinel(304808866);
                    IPC::WriteParam((&(writer__)), std::get<2>(aParam));
                    // Sentinel = 'reloadActiveEntry'
                    ((&(writer__)))->WriteSentinel(1029506790);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNotifyOnHistoryReload(std::move(aContext), std::move(aReloadFlags), 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_HistoryCommit__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_HistoryCommit", 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__aLoadID = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aLoadID) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aLoadID = *maybe__aLoadID;
            // Sentinel = 'aLoadID'
            if ((!(((&(reader__)))->ReadSentinel(170328687)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_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;
            }
            auto maybe__aLoadType = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aLoadType) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

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

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

            }
            auto& aCacheKey = *maybe__aCacheKey;
            // Sentinel = 'aCacheKey'
            if ((!(((&(reader__)))->ReadSentinel(272827231)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvHistoryCommit(std::move(aContext), std::move(aLoadID), std::move(aChangeID), std::move(aLoadType), std::move(aCloneEntryChildren), std::move(aChannelExpired), std::move(aCacheKey));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_HistoryGo__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_HistoryGo", 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__aOffset = IPC::ReadParam<int32_t>((&(reader__)));
            if (!maybe__aOffset) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;

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

            }
            auto& aHistoryEpoch = *maybe__aHistoryEpoch;
            // Sentinel = 'aHistoryEpoch'
            if ((!(((&(reader__)))->ReadSentinel(611255619)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_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;
            }
            auto maybe__aCheckForCancelation = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aCheckForCancelation) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aCheckForCancelation = *maybe__aCheckForCancelation;
            // Sentinel = 'aCheckForCancelation'
            if ((!(((&(reader__)))->ReadSentinel(1326581704)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_HistoryGo(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvHistoryGo(std::move(aContext), std::move(aOffset), std::move(aHistoryEpoch), std::move(aRequireUserInteraction), std::move(aUserActivation), std::move(aCheckForCancelation), 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_NavigationTraverse__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NavigationTraverse", 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__aKey = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__aKey) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& aKey = *maybe__aKey;
            // Sentinel = 'aKey'
            if ((!(((&(reader__)))->ReadSentinel(61604235)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            auto maybe__aHistoryEpoch = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aHistoryEpoch) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aHistoryEpoch = *maybe__aHistoryEpoch;
            // Sentinel = 'aHistoryEpoch'
            if ((!(((&(reader__)))->ReadSentinel(611255619)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_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;
            }
            auto maybe__aCheckForCancelation = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aCheckForCancelation) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aCheckForCancelation = *maybe__aCheckForCancelation;
            // Sentinel = 'aCheckForCancelation'
            if ((!(((&(reader__)))->ReadSentinel(1326581704)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_NavigationTraverse(id__));
            reply__->set_seqno(msg__.seqno());

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

            NavigationTraverseResolver 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 = 'result'
                    ((&(writer__)))->WriteSentinel(153223840);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvNavigationTraverse(std::move(aContext), std::move(aKey), std::move(aHistoryEpoch), std::move(aUserActivation), std::move(aCheckForCancelation), 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_BlobURLDataRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BlobURLDataRequest", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBlobURL = *maybe__aBlobURL;
            // Sentinel = 'aBlobURL'
            if ((!(((&(reader__)))->ReadSentinel(218628820)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            auto maybe__aTriggeringPrincipal = IPC::ReadParam<mozilla::NotNull<RefPtr<nsIPrincipal>>>((&(reader__)));
            if (!maybe__aTriggeringPrincipal) {
                FatalError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;

            }
            auto& aTriggeringPrincipal = *maybe__aTriggeringPrincipal;
            // Sentinel = 'aTriggeringPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1413089302)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<nsIPrincipal>'");
                return MsgValueError;
            }
            auto maybe__aLoadingPrincipal = IPC::ReadParam<RefPtr<nsIPrincipal>>((&(reader__)));
            if (!maybe__aLoadingPrincipal) {
                FatalError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;

            }
            auto& aLoadingPrincipal = *maybe__aLoadingPrincipal;
            // Sentinel = 'aLoadingPrincipal'
            if ((!(((&(reader__)))->ReadSentinel(1001719490)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIPrincipal'");
                return MsgValueError;
            }
            auto maybe__aOriginAttributes = IPC::ReadParam<OriginAttributes>((&(reader__)));
            if (!maybe__aOriginAttributes) {
                FatalError("Error deserializing 'OriginAttributes'");
                return MsgValueError;

            }
            auto& aOriginAttributes = *maybe__aOriginAttributes;
            // Sentinel = 'aOriginAttributes'
            if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            auto maybe__aInnerWindowId = IPC::ReadParam<uint64_t>((&(reader__)));
            if (!maybe__aInnerWindowId) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;

            }
            auto& aInnerWindowId = *maybe__aInnerWindowId;
            // Sentinel = 'aInnerWindowId'
            if ((!(((&(reader__)))->ReadSentinel(689767811)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                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::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_BlobURLDataRequest(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvBlobURLDataRequest(std::move(aBlobURL), aTriggeringPrincipal, aLoadingPrincipal, std::move(aOriginAttributes), std::move(aInnerWindowId), std::move(aPartitionKey), 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_SetActiveSessionHistoryEntry__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetActiveSessionHistoryEntry", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& previousScrollPosition = *maybe__previousScrollPosition;
            // Sentinel = 'previousScrollPosition'
            if ((!(((&(reader__)))->ReadSentinel(1792346434)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsPoint?'");
                return MsgValueError;
            }
            auto maybe__info = IPC::ReadParam<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;
            }
            auto maybe__loadType = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__loadType) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

            }
            auto& updatedCacheKey = *maybe__updatedCacheKey;
            // Sentinel = 'updatedCacheKey'
            if ((!(((&(reader__)))->ReadSentinel(804062693)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__changeID = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__changeID) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& changeID = *maybe__changeID;
            // Sentinel = 'changeID'
            if ((!(((&(reader__)))->ReadSentinel(235209460)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetActiveSessionHistoryEntry(std::move(context), std::move(previousScrollPosition), std::move(info), std::move(loadType), std::move(updatedCacheKey), std::move(changeID));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ReplaceActiveSessionHistoryEntry__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReplaceActiveSessionHistoryEntry", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& context = *maybe__context;
            // Sentinel = 'context'
            if ((!(((&(reader__)))->ReadSentinel(199164678)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__info = IPC::ReadParam<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::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvReplaceActiveSessionHistoryEntry(std::move(context), std::move(info));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveDynEntriesFromActiveSessionHistoryEntry", 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<::mozilla::dom::ContentParent*>(this))->RecvRemoveDynEntriesFromActiveSessionHistoryEntry(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_RemoveFromSessionHistory__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveFromSessionHistory", 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__changeID = IPC::ReadParam<nsID>((&(reader__)));
            if (!maybe__changeID) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;

            }
            auto& changeID = *maybe__changeID;
            // Sentinel = 'changeID'
            if ((!(((&(reader__)))->ReadSentinel(235209460)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvRemoveFromSessionHistory(std::move(aContext), std::move(changeID));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CleanupPendingLoadState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CleanupPendingLoadState", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            return MsgProcessed;
        }
    case PContent::Msg_ScriptError__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<mozilla::NotNull<RefPtr<StructuredCloneData>>>((&(reader__)));
            if (!maybe__aData) {
                FatalError("Error deserializing 'NotNull<StructuredCloneData>'");
                return MsgValueError;

            }
            auto& aData = *maybe__aData;
            // Sentinel = 'aData'
            if ((!(((&(reader__)))->ReadSentinel(90571228)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NotNull<StructuredCloneData>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvAsyncMessage(std::move(aMessage), aData);
            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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PContentParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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_InsertNewFocusActionId__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InsertNewFocusActionId", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aActionId = *maybe__aActionId;
            // Sentinel = 'aActionId'
            if ((!(((&(reader__)))->ReadSentinel(284164973)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvInsertNewFocusActionId(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_BlurToParent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BlurToParent", 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__aBrowsingContextToClearHandled = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aBrowsingContextToClearHandled) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

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

            }
            auto& aAncestorBrowsingContextToFocusHandled = *maybe__aAncestorBrowsingContextToFocusHandled;
            // Sentinel = 'aAncestorBrowsingContextToFocusHandled'
            if ((!(((&(reader__)))->ReadSentinel(701894468)))) {
                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<::mozilla::dom::ContentParent*>(this))->RecvBlurToParent(std::move(aFocusedBrowsingContext), std::move(aBrowsingContextToClear), std::move(aAncestorBrowsingContextToFocus), std::move(aIsLeavingDocument), std::move(aAdjustWidget), std::move(aBrowsingContextToClearHandled), std::move(aAncestorBrowsingContextToFocusHandled), 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_MaybeExitFullscreen__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<RefPtr<StructuredCloneData>>((&(reader__)));
            if (!maybe__aMessage) {
                FatalError("Error deserializing 'StructuredCloneData'");
                return MsgValueError;

            }
            auto& aMessage = *maybe__aMessage;
            // Sentinel = 'aMessage'
            if ((!(((&(reader__)))->ReadSentinel(233440039)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'StructuredCloneData'");
                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<::mozilla::dom::ContentParent*>(this))->RecvWindowPostMessage(std::move(aContext), 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::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    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<::mozilla::dom::ContentParent*>(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::Reply_DiscardWindowContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PContent::Msg_DiscardWindowContext", OTHER);


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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& buf = *maybe__buf;
            // Sentinel = 'buf'
            if ((!(((&(reader__)))->ReadSentinel(41484606)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvFOGData(std::move(buf));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GeckoTraceExport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GeckoTraceExport", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBuf = *maybe__aBuf;
            // Sentinel = 'aBuf'
            if ((!(((&(reader__)))->ReadSentinel(60686719)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ByteBuf'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGeckoTraceExport(std::move(aBuf));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            AUTO_PROFILER_LABEL("PContent::Msg_FlushFOGData", OTHER);


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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aContainerContext = *maybe__aContainerContext;
            // Sentinel = 'aContainerContext'
            if ((!(((&(reader__)))->ReadSentinel(1015744234)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            auto maybe__aContainerPermissionsPolicyInfo = IPC::ReadParam<MaybePermissionsPolicyInfo>((&(reader__)));
            if (!maybe__aContainerPermissionsPolicyInfo) {
                FatalError("Error deserializing 'MaybePermissionsPolicyInfo'");
                return MsgValueError;

            }
            auto& aContainerPermissionsPolicyInfo = *maybe__aContainerPermissionsPolicyInfo;
            // Sentinel = 'aContainerPermissionsPolicyInfo'
            if ((!(((&(reader__)))->ReadSentinel(3362458781)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybePermissionsPolicyInfo'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetContainerPermissionsPolicy(std::move(aContainerContext), std::move(aContainerPermissionsPolicyInfo));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateAncestorOriginsList__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateAncestorOriginsList", 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<::mozilla::dom::ContentParent*>(this))->RecvUpdateAncestorOriginsList(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_SetReferrerPolicyForEmbedderFrame__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetReferrerPolicyForEmbedderFrame", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aPolicy = *maybe__aPolicy;
            // Sentinel = 'aPolicy'
            if ((!(((&(reader__)))->ReadSentinel(182649554)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ReferrerPolicy'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvSetReferrerPolicyForEmbedderFrame(std::move(aBrowsingContext), std::move(aPolicy));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_GetSystemIcon__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetSystemIcon", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aURI = *maybe__aURI;
            // Sentinel = 'aURI'
            if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_GetSystemIcon(id__));
            reply__->set_seqno(msg__.seqno());

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

            GetSystemIconResolver resolver = [resolver__ = std::move(resolver__)](std::tuple<const nsresult&, mozilla::Maybe<ByteBuf>&&> aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::get<0>(aParam));
                    // Sentinel = 'aResult'
                    ((&(writer__)))->WriteSentinel(185205473);
                    IPC::WriteParam((&(writer__)), std::move(std::get<1>(aParam)));
                    // Sentinel = 'aData'
                    ((&(writer__)))->WriteSentinel(90571228);

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetSystemIcon(aURI, 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_GetSystemGeolocationPermissionBehavior__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetSystemGeolocationPermissionBehavior", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_GetSystemGeolocationPermissionBehavior(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetSystemGeolocationPermissionBehavior(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_RequestGeolocationPermissionFromUser__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RequestGeolocationPermissionFromUser", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBrowsingContext = *maybe__aBrowsingContext;
            // Sentinel = 'aBrowsingContext'
            if ((!(((&(reader__)))->ReadSentinel(915015314)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedBrowsingContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PContent::Reply_RequestGeolocationPermissionFromUser(id__));
            reply__->set_seqno(msg__.seqno());

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

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

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

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

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    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 PContentParent::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PContentParent::Result
{
    if (!CanSend()) {
        return MsgDropped;

    }
    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__);
    }

    switch (msg__.type()) {
    case PContent::Msg_IsSecureURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_IsSecureURI", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aOriginAttributes = *maybe__aOriginAttributes;
            // Sentinel = 'aOriginAttributes'
            if ((!(((&(reader__)))->ReadSentinel(1021839089)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            bool isSecureURI{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvIsSecureURI(aURI, std::move(aOriginAttributes), (&(isSecureURI)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_IsSecureURI(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), isSecureURI);
            // Sentinel = 'isSecureURI'
            ((&(writer__)))->WriteSentinel(441189428);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_PURLClassifierConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierConstructor", 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__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();
            bool success{};
            // Ensure the ID which was sent to us is valid, and reserve a spot
            // in the table for the new actor before we bother to alloc it.
            if (!ToplevelProtocol()->TryReserve(actorid__)) {
                NS_WARNING("Failed to reserve ActorId for constructor");
                return MsgValueError;
            }

            PURLClassifierParent* actor = (static_cast<::mozilla::dom::ContentParent*>(this))->AllocPURLClassifierParent(principal, (&(success)));

            if (!actor) {
                NS_WARNING("Alloc function returned null");
                // Clean up the reservation taken above if this fails, to avoid
                // leaving zombie entries in the map.
                ToplevelProtocol()->ClearReservation(actorid__);
                return MsgValueError;
            }

            // NOTE: SetManagerAndRegister unconditionally consumes the
            // reservation taken by TryReserve, so we don't need to clear it on
            // failure.
            if (!actor->SetManagerAndRegister(this, actorid__)) {
                NS_WARNING("Failed to set manager for constructor");
                return MsgValueError;
            }
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvPURLClassifierConstructor(std::move(actor), principal, (&(success)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }
            reply__ = PContent::Reply_PURLClassifierConstructor(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), success);
            // Sentinel = 'success'
            ((&(writer__)))->WriteSentinel(200082170);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }

            return MsgProcessed;
        }
    case PContent::Msg_SyncMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SyncMessage", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

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

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

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

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTypes = *maybe__aTypes;
            // Sentinel = 'aTypes'
            if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aWhichClipboard) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aRequestingWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
            // Sentinel = 'aRequestingWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            IPCTransferableDataOrError transferableDataOrError{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetClipboard(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), (&(transferableDataOrError)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetClipboard(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), std::move(transferableDataOrError));
            // Sentinel = 'transferableDataOrError'
            ((&(writer__)))->WriteSentinel(1880557887);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetClipboardDataSnapshotSync__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetClipboardDataSnapshotSync", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTypes = *maybe__aTypes;
            // Sentinel = 'aTypes'
            if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aWhichClipboard) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            auto maybe__aRequestingWindowContext = IPC::ReadParam<MaybeDiscardedWindowContext>((&(reader__)));
            if (!maybe__aRequestingWindowContext) {
                FatalError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;

            }
            auto& aRequestingWindowContext = *maybe__aRequestingWindowContext;
            // Sentinel = 'aRequestingWindowContext'
            if ((!(((&(reader__)))->ReadSentinel(2049051110)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeDiscardedWindowContext'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            ClipboardReadRequestOrError aClipboardReadRequestOrError{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetClipboardDataSnapshotSync(std::move(aTypes), std::move(aWhichClipboard), std::move(aRequestingWindowContext), (&(aClipboardReadRequestOrError)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetClipboardDataSnapshotSync(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), std::move(aClipboardReadRequestOrError));
            // Sentinel = 'aClipboardReadRequestOrError'
            ((&(writer__)))->WriteSentinel(2662402850);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_ClipboardHasType__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClipboardHasType", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTypes = *maybe__aTypes;
            // Sentinel = 'aTypes'
            if ((!(((&(reader__)))->ReadSentinel(140575351)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString[]'");
                return MsgValueError;
            }
            auto maybe__aWhichClipboard = IPC::ReadParam<ClipboardType>((&(reader__)));
            if (!maybe__aWhichClipboard) {
                FatalError("Error deserializing 'ClipboardType'");
                return MsgValueError;

            }
            auto& aWhichClipboard = *maybe__aWhichClipboard;
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(reader__)))->ReadSentinel(776996325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClipboardType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            bool hasType{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvClipboardHasType(std::move(aTypes), std::move(aWhichClipboard), (&(hasType)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_ClipboardHasType(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), hasType);
            // Sentinel = 'hasType'
            ((&(writer__)))->WriteSentinel(191103711);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetIconForExtension__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetIconForExtension", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

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

            }
            auto& aIconSize = *maybe__aIconSize;
            // Sentinel = 'aIconSize'
            if ((!(((&(reader__)))->ReadSentinel(286196614)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            nsTArray<uint8_t> bits{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetIconForExtension(std::move(aFileExt), std::move(aIconSize), (&(bits)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetIconForExtension(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), bits);
            // Sentinel = 'bits'
            ((&(writer__)))->WriteSentinel(69337523);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_BeginDriverCrashGuard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BeginDriverCrashGuard", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aGuardType = *maybe__aGuardType;
            // Sentinel = 'aGuardType'
            if ((!(((&(reader__)))->ReadSentinel(356647927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CrashGuardType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            bool crashDetected{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvBeginDriverCrashGuard(std::move(aGuardType), (&(crashDetected)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_BeginDriverCrashGuard(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), crashDetected);
            // Sentinel = 'crashDetected'
            ((&(writer__)))->WriteSentinel(610731316);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_EndDriverCrashGuard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_EndDriverCrashGuard", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aGuardType = *maybe__aGuardType;
            // Sentinel = 'aGuardType'
            if ((!(((&(reader__)))->ReadSentinel(356647927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CrashGuardType'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvEndDriverCrashGuard(std::move(aGuardType));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_EndDriverCrashGuard(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetFontListShmBlock__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetFontListShmBlock", 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;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            ReadOnlySharedMemoryHandle aHandle{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetFontListShmBlock(std::move(aGeneration), std::move(aIndex), (&(aHandle)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetFontListShmBlock(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), std::move(aHandle));
            // Sentinel = 'aHandle'
            ((&(writer__)))->WriteSentinel(174326446);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_InitializeFamily__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitializeFamily", 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__aFamilyIndex = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aFamilyIndex) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

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

            }
            auto& aLoadCmaps = *maybe__aLoadCmaps;
            // Sentinel = 'aLoadCmaps'
            if ((!(((&(reader__)))->ReadSentinel(342885334)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvInitializeFamily(std::move(aGeneration), std::move(aFamilyIndex), std::move(aLoadCmaps));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_InitializeFamily(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_InitOtherFamilyNames__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitOtherFamilyNames", 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__aDefer = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__aDefer) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& aDefer = *maybe__aDefer;
            // Sentinel = 'aDefer'
            if ((!(((&(reader__)))->ReadSentinel(128057928)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            bool aLoaded{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvInitOtherFamilyNames(std::move(aGeneration), std::move(aDefer), (&(aLoaded)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_InitOtherFamilyNames(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), aLoaded);
            // Sentinel = 'aLoaded'
            ((&(writer__)))->WriteSentinel(176095915);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetHyphDict__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetHyphDict", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aURI = *maybe__aURI;
            // Sentinel = 'aURI'
            if ((!(((&(reader__)))->ReadSentinel(57934162)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            ReadOnlySharedMemoryHandle aHandle{};
            mozilla::ipc::IPCResult __ok = (static_cast<::mozilla::dom::ContentParent*>(this))->RecvGetHyphDict(aURI, (&(aHandle)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetHyphDict(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), std::move(aHandle));
            // Sentinel = 'aHandle'
            ((&(writer__)))->WriteSentinel(174326446);
            if (mozilla::ipc::LoggingEnabledFor("PContent", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PContentParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}



} // namespace dom
} // namespace mozilla