/work/obj-fuzz/ipc/ipdl/PContentParent.cpp

Source (jump to first uncovered line)
//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/dom/PContentParent.h"
#include "ipc/IPCMessageUtils.h"
#include "mozilla/AlertNotificationIPCSerializer.h"
#include "mozilla/chrome/RegistryMessageUtils.h"
#include "mozilla/dom/MessagePort.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/ipc/StructuredCloneData.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/widget/WidgetMessageUtils.h"
#include "nsGeoPositionIPCSerialiser.h"

#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PClientOpenWindowOpParent.h"
#include "mozilla/layers/PCompositorManagerParent.h"
#include "mozilla/dom/PContentBridgeParent.h"
#include "mozilla/dom/PContentPermissionRequestParent.h"
#include "mozilla/dom/PCycleCollectWithLogsParent.h"
#include "mozilla/psm/PPSMContentDownloaderParent.h"
#include "mozilla/dom/PExternalHelperAppParent.h"
#include "mozilla/dom/PHandlerServiceParent.h"
#include "mozilla/ipc/PFileDescriptorSetParent.h"
#include "mozilla/hal_sandbox/PHalParent.h"
#include "mozilla/devtools/PHeapSnapshotTempFileHelperParent.h"
#include "mozilla/PProcessHangMonitorParent.h"
#include "mozilla/layers/PImageBridgeParent.h"
#include "mozilla/ipc/PIPCBlobInputStreamParent.h"
#include "mozilla/dom/PLoginReputationParent.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/plugins/PPluginModuleParent.h"
#include "mozilla/gmp/PGMPParent.h"
#include "mozilla/embedding/PPrintingParent.h"
#include "mozilla/ipc/PChildToParentStreamParent.h"
#include "mozilla/ipc/PParentToChildStreamParent.h"
#include "mozilla/docshell/POfflineCacheUpdateParent.h"
#include "mozilla/layout/PRenderFrameParent.h"
#include "mozilla/dom/PSpeechSynthesisParent.h"
#include "mozilla/ipc/PTestShellParent.h"
#include "mozilla/jsipc/PJavaScriptParent.h"
#include "mozilla/PRemoteSpellcheckEngineParent.h"
#include "mozilla/PWebBrowserPersistDocumentParent.h"
#include "mozilla/dom/PWebrtcGlobalParent.h"
#include "mozilla/dom/PPresentationParent.h"
#include "mozilla/dom/PURLClassifierParent.h"
#include "mozilla/dom/PURLClassifierLocalParent.h"
#include "mozilla/gfx/PVRManagerParent.h"
#include "mozilla/dom/PVideoDecoderManagerParent.h"
#include "mozilla/PProfilerParent.h"
#include "mozilla/loader/PScriptCacheParent.h"

#include "nsIFile.h"
#include "GeckoProfiler.h"

namespace mozilla {
namespace dom {


auto PContentParent::RecvPBrowserConstructor(
        PBrowserParent* actor,
        const TabId& tabId,
        const TabId& sameTabGroupAs,
        const IPCTabContext& context,
        const uint32_t& chromeFlags,
        const ContentParentId& cpId,
        const bool& isForBrowser) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPFileDescriptorSetConstructor(
        PFileDescriptorSetParent* actor,
        const FileDescriptor& fd) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PContentParent::RecvPJavaScriptConstructor(PJavaScriptParent* actor) -> 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::RecvPPrintingConstructor(PPrintingParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPChildToParentStreamConstructor(PChildToParentStreamParent* 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::RecvPWebrtcGlobalConstructor(PWebrtcGlobalParent* actor) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

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

auto PContentParent::RecvPURLClassifierLocalConstructor(
        PURLClassifierLocalParent* actor,
        const URIParams& uri,
        const nsCString& tables) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPLoginReputationConstructor(
        PLoginReputationParent* actor,
        const URIParams& formURI) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPPSMContentDownloaderConstructor(
        PPSMContentDownloaderParent* actor,
        const uint32_t& aCertType) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PContentParent::RecvPExternalHelperAppConstructor(
        PExternalHelperAppParent* actor,
        const OptionalURIParams& uri,
        const nsCString& aMimeContentType,
        const nsCString& aContentDisposition,
        const uint32_t& aContentDispositionHint,
        const nsString& aContentDispositionFilename,
        const bool& aForceSave,
        const int64_t& aContentLength,
        const bool& aWasFileChannel,
        const OptionalURIParams& aReferrer,
        PBrowserParent* aBrowser) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PContentParent::RecvPOfflineCacheUpdateConstructor(
        POfflineCacheUpdateParent* actor,
        const URIParams& manifestURI,
        const URIParams& documentURI,
        const PrincipalInfo& loadingPrincipal,
        const bool& stickDocument) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

auto PContentParent::ActorDestroy(ActorDestroyReason aWhy) -> void
{
}

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

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

auto PContentParent::EnteredCxxStack() -> void
{
}

auto PContentParent::ExitedCxxStack() -> void
{
}

auto PContentParent::EnteredCall() -> void
{
}

auto PContentParent::ExitedCall() -> void
{
}

MOZ_IMPLICIT PContentParent::PContentParent() :
    mozilla::ipc::IToplevelProtocol("PContentParent", PContentMsgStart, mozilla::ipc::ParentSide),
    mLivenessState(mozilla::ipc::LivenessState::Start)
{
    MOZ_COUNT_CTOR(PContentParent);
}

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

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

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

auto PContentParent::ManagedPClientOpenWindowOpParent(nsTArray<PClientOpenWindowOpParent*>& aArr) const -> void
{
    (mManagedPClientOpenWindowOpParent).ToArray(aArr);
}

auto PContentParent::ManagedPClientOpenWindowOpParent() const -> const ManagedContainer<PClientOpenWindowOpParent>&
{
    return mManagedPClientOpenWindowOpParent;
}

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::ManagedPPSMContentDownloaderParent(nsTArray<PPSMContentDownloaderParent*>& aArr) const -> void
{
    (mManagedPPSMContentDownloaderParent).ToArray(aArr);
}

auto PContentParent::ManagedPPSMContentDownloaderParent() const -> const ManagedContainer<PPSMContentDownloaderParent>&
{
    return mManagedPPSMContentDownloaderParent;
}

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

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

auto PContentParent::ManagedPFileDescriptorSetParent(nsTArray<PFileDescriptorSetParent*>& aArr) const -> void
{
    (mManagedPFileDescriptorSetParent).ToArray(aArr);
}

auto PContentParent::ManagedPFileDescriptorSetParent() const -> const ManagedContainer<PFileDescriptorSetParent>&
{
    return mManagedPFileDescriptorSetParent;
}

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::ManagedPIPCBlobInputStreamParent(nsTArray<PIPCBlobInputStreamParent*>& aArr) const -> void
{
    (mManagedPIPCBlobInputStreamParent).ToArray(aArr);
}

auto PContentParent::ManagedPIPCBlobInputStreamParent() const -> const ManagedContainer<PIPCBlobInputStreamParent>&
{
    return mManagedPIPCBlobInputStreamParent;
}

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::ManagedPOfflineCacheUpdateParent(nsTArray<POfflineCacheUpdateParent*>& aArr) const -> void
{
    (mManagedPOfflineCacheUpdateParent).ToArray(aArr);
}

auto PContentParent::ManagedPOfflineCacheUpdateParent() const -> const ManagedContainer<POfflineCacheUpdateParent>&
{
    return mManagedPOfflineCacheUpdateParent;
}

auto PContentParent::ManagedPPrintingParent(nsTArray<PPrintingParent*>& aArr) const -> void
{
    (mManagedPPrintingParent).ToArray(aArr);
}

auto PContentParent::ManagedPPrintingParent() const -> const ManagedContainer<PPrintingParent>&
{
    return mManagedPPrintingParent;
}

auto PContentParent::ManagedPChildToParentStreamParent(nsTArray<PChildToParentStreamParent*>& aArr) const -> void
{
    (mManagedPChildToParentStreamParent).ToArray(aArr);
}

auto PContentParent::ManagedPChildToParentStreamParent() const -> const ManagedContainer<PChildToParentStreamParent>&
{
    return mManagedPChildToParentStreamParent;
}

auto PContentParent::ManagedPParentToChildStreamParent(nsTArray<PParentToChildStreamParent*>& aArr) const -> void
{
    (mManagedPParentToChildStreamParent).ToArray(aArr);
}

auto PContentParent::ManagedPParentToChildStreamParent() const -> const ManagedContainer<PParentToChildStreamParent>&
{
    return mManagedPParentToChildStreamParent;
}

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::ManagedPJavaScriptParent(nsTArray<PJavaScriptParent*>& aArr) const -> void
{
    (mManagedPJavaScriptParent).ToArray(aArr);
}

auto PContentParent::ManagedPJavaScriptParent() const -> const ManagedContainer<PJavaScriptParent>&
{
    return mManagedPJavaScriptParent;
}

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::ManagedPWebrtcGlobalParent(nsTArray<PWebrtcGlobalParent*>& aArr) const -> void
{
    (mManagedPWebrtcGlobalParent).ToArray(aArr);
}

auto PContentParent::ManagedPWebrtcGlobalParent() const -> const ManagedContainer<PWebrtcGlobalParent>&
{
    return mManagedPWebrtcGlobalParent;
}

auto PContentParent::ManagedPPresentationParent(nsTArray<PPresentationParent*>& aArr) const -> void
{
    (mManagedPPresentationParent).ToArray(aArr);
}

auto PContentParent::ManagedPPresentationParent() const -> const ManagedContainer<PPresentationParent>&
{
    return mManagedPPresentationParent;
}

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::ManagedPScriptCacheParent(nsTArray<PScriptCacheParent*>& aArr) const -> void
{
    (mManagedPScriptCacheParent).ToArray(aArr);
}

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

auto PContentParent::ManagedPLoginReputationParent(nsTArray<PLoginReputationParent*>& aArr) const -> void
{
    (mManagedPLoginReputationParent).ToArray(aArr);
}

auto PContentParent::ManagedPLoginReputationParent() const -> const ManagedContainer<PLoginReputationParent>&
{
    return mManagedPLoginReputationParent;
}

auto PContentParent::SendPBrowserConstructor(
        const TabId& tabId,
        const TabId& sameTabGroupAs,
        const IPCTabContext& context,
        const uint32_t& chromeFlags,
        const ContentParentId& cpId,
        const bool& isForBrowser) -> PBrowserParent*
{
    return SendPBrowserConstructor(AllocPBrowserParent(tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser), tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser);
}

auto PContentParent::SendPBrowserConstructor(
        PBrowserParent* actor,
        const TabId& tabId,
        const TabId& sameTabGroupAs,
        const IPCTabContext& context,
        const uint32_t& chromeFlags,
        const ContentParentId& cpId,
        const bool& isForBrowser) -> PBrowserParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PBrowserParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPBrowserParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PBrowserConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, tabId);
    // Sentinel = 'tabId'
    (msg__)->WriteSentinel(3419081923);
    WriteIPDLParam(msg__, this, sameTabGroupAs);
    // Sentinel = 'sameTabGroupAs'
    (msg__)->WriteSentinel(3969365410);
    WriteIPDLParam(msg__, this, context);
    // Sentinel = 'context'
    (msg__)->WriteSentinel(3514529014);
    WriteIPDLParam(msg__, this, chromeFlags);
    // Sentinel = 'chromeFlags'
    (msg__)->WriteSentinel(299515804);
    WriteIPDLParam(msg__, this, cpId);
    // Sentinel = 'cpId'
    (msg__)->WriteSentinel(2452595622);
    WriteIPDLParam(msg__, this, isForBrowser);
    // Sentinel = 'isForBrowser'
    (msg__)->WriteSentinel(2051565587);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PBrowserConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PBrowserMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendPFileDescriptorSetConstructor(const FileDescriptor& fd) -> PFileDescriptorSetParent*
{
    return SendPFileDescriptorSetConstructor(AllocPFileDescriptorSetParent(fd), fd);
}

auto PContentParent::SendPFileDescriptorSetConstructor(
        PFileDescriptorSetParent* actor,
        const FileDescriptor& fd) -> PFileDescriptorSetParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PFileDescriptorSetParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPFileDescriptorSetParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PFileDescriptorSetConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, fd);
    // Sentinel = 'fd'
    (msg__)->WriteSentinel(628535764);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PFileDescriptorSetConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PFileDescriptorSetMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendPWebBrowserPersistDocumentConstructor(
        PBrowserParent* aBrowser,
        const uint64_t& aOuterWindowID) -> PWebBrowserPersistDocumentParent*
{
    return SendPWebBrowserPersistDocumentConstructor(AllocPWebBrowserPersistDocumentParent(aBrowser, aOuterWindowID), aBrowser, aOuterWindowID);
}

auto PContentParent::SendPWebBrowserPersistDocumentConstructor(
        PWebBrowserPersistDocumentParent* actor,
        PBrowserParent* aBrowser,
        const uint64_t& aOuterWindowID) -> PWebBrowserPersistDocumentParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PWebBrowserPersistDocumentParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPWebBrowserPersistDocumentParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PWebBrowserPersistDocumentConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, aBrowser);
    // Sentinel = 'aBrowser'
    (msg__)->WriteSentinel(3086016059);
    WriteIPDLParam(msg__, this, aOuterWindowID);
    // Sentinel = 'aOuterWindowID'
    (msg__)->WriteSentinel(3438169907);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PWebBrowserPersistDocumentMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendInitGMPService(const Endpoint<mozilla::gmp::PGMPServiceChild>& service) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitGMPService(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, service);
    // Sentinel = 'service'
    (msg__)->WriteSentinel(4064038);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitGMPService", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInitProcessHangMonitor(const Endpoint<mozilla::PProcessHangMonitorChild>& hangMonitor) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitProcessHangMonitor(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, hangMonitor);
    // Sentinel = 'hangMonitor'
    (msg__)->WriteSentinel(1135728705);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitProcessHangMonitor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInitContentBridgeChild(const Endpoint<mozilla::dom::PContentBridgeChild>& endpoint) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitContentBridgeChild(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitContentBridgeChild", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInitProfiler(const Endpoint<mozilla::PProfilerChild>& aEndpoint) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitProfiler(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aEndpoint);
    // Sentinel = 'aEndpoint'
    (msg__)->WriteSentinel(2457438235);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitProfiler", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInitRendering(
        const Endpoint<mozilla::layers::PCompositorManagerChild>& compositor,
        const Endpoint<mozilla::layers::PImageBridgeChild>& imageBridge,
        const Endpoint<mozilla::gfx::PVRManagerChild>& vr,
        const Endpoint<mozilla::dom::PVideoDecoderManagerChild>& video,
        const nsTArray<uint32_t>& namespaces) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitRendering(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, compositor);
    // Sentinel = 'compositor'
    (msg__)->WriteSentinel(2766138585);
    WriteIPDLParam(msg__, this, imageBridge);
    // Sentinel = 'imageBridge'
    (msg__)->WriteSentinel(390565091);
    WriteIPDLParam(msg__, this, vr);
    // Sentinel = 'vr'
    (msg__)->WriteSentinel(727129490);
    WriteIPDLParam(msg__, this, video);
    // Sentinel = 'video'
    (msg__)->WriteSentinel(1200625812);
    WriteIPDLParam(msg__, this, namespaces);
    // Sentinel = 'namespaces'
    (msg__)->WriteSentinel(331300950);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitRendering", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendReinitRendering(
        const Endpoint<mozilla::layers::PCompositorManagerChild>& compositor,
        const Endpoint<mozilla::layers::PImageBridgeChild>& bridge,
        const Endpoint<mozilla::gfx::PVRManagerChild>& vr,
        const Endpoint<mozilla::dom::PVideoDecoderManagerChild>& video,
        const nsTArray<uint32_t>& namespaces) -> bool
{
    IPC::Message* msg__ = PContent::Msg_ReinitRendering(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, compositor);
    // Sentinel = 'compositor'
    (msg__)->WriteSentinel(2766138585);
    WriteIPDLParam(msg__, this, bridge);
    // Sentinel = 'bridge'
    (msg__)->WriteSentinel(1159488385);
    WriteIPDLParam(msg__, this, vr);
    // Sentinel = 'vr'
    (msg__)->WriteSentinel(727129490);
    WriteIPDLParam(msg__, this, video);
    // Sentinel = 'video'
    (msg__)->WriteSentinel(1200625812);
    WriteIPDLParam(msg__, this, namespaces);
    // Sentinel = 'namespaces'
    (msg__)->WriteSentinel(331300950);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ReinitRendering", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendAudioDefaultDeviceChange() -> bool
{
    IPC::Message* msg__ = PContent::Msg_AudioDefaultDeviceChange(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_AudioDefaultDeviceChange", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendReinitRenderingForDeviceReset() -> bool
{
    IPC::Message* msg__ = PContent::Msg_ReinitRenderingForDeviceReset(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ReinitRenderingForDeviceReset", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetProcessSandbox(const MaybeFileDesc& aBroker) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetProcessSandbox(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aBroker);
    // Sentinel = 'aBroker'
    (msg__)->WriteSentinel(2424547965);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetProcessSandbox", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRequestMemoryReport(
        const uint32_t& generation,
        const bool& anonymize,
        const bool& minimizeMemoryUsage,
        const MaybeFileDesc& DMDFile) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RequestMemoryReport(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, generation);
    // Sentinel = 'generation'
    (msg__)->WriteSentinel(1396961928);
    WriteIPDLParam(msg__, this, anonymize);
    // Sentinel = 'anonymize'
    (msg__)->WriteSentinel(3334711915);
    WriteIPDLParam(msg__, this, minimizeMemoryUsage);
    // Sentinel = 'minimizeMemoryUsage'
    (msg__)->WriteSentinel(3442464661);
    WriteIPDLParam(msg__, this, DMDFile);
    // Sentinel = 'DMDFile'
    (msg__)->WriteSentinel(3739167222);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RequestMemoryReport", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRequestPerformanceMetrics(const nsID& aID) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RequestPerformanceMetrics(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RequestPerformanceMetrics", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

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

    WriteIPDLParam(msg__, this, isLangRTL);
    // Sentinel = 'isLangRTL'
    (msg__)->WriteSentinel(1112035623);
    WriteIPDLParam(msg__, this, haveBidiKeyboards);
    // Sentinel = 'haveBidiKeyboards'
    (msg__)->WriteSentinel(4121278935);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_BidiKeyboardNotify", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPCycleCollectWithLogsConstructor(
        const bool& dumpAllTraces,
        const FileDescriptor& gcLog,
        const FileDescriptor& ccLog) -> PCycleCollectWithLogsParent*
{
    return SendPCycleCollectWithLogsConstructor(AllocPCycleCollectWithLogsParent(dumpAllTraces, gcLog, ccLog), dumpAllTraces, gcLog, ccLog);
}

auto PContentParent::SendPCycleCollectWithLogsConstructor(
        PCycleCollectWithLogsParent* actor,
        const bool& dumpAllTraces,
        const FileDescriptor& gcLog,
        const FileDescriptor& ccLog) -> PCycleCollectWithLogsParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCycleCollectWithLogsParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCycleCollectWithLogsParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PCycleCollectWithLogsConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, dumpAllTraces);
    // Sentinel = 'dumpAllTraces'
    (msg__)->WriteSentinel(1185678160);
    WriteIPDLParam(msg__, this, gcLog);
    // Sentinel = 'gcLog'
    (msg__)->WriteSentinel(1153400941);
    WriteIPDLParam(msg__, this, ccLog);
    // Sentinel = 'ccLog'
    (msg__)->WriteSentinel(2494741865);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PCycleCollectWithLogsConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PCycleCollectWithLogsMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendPTestShellConstructor() -> PTestShellParent*
{
    return SendPTestShellConstructor(AllocPTestShellParent());
}

auto PContentParent::SendPTestShellConstructor(PTestShellParent* actor) -> PTestShellParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PTestShellParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPTestShellParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PTestShellConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PTestShellConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PTestShellMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendPScriptCacheConstructor(
        const FileDescOrError& cacheFile,
        const bool& wantCacheData) -> PScriptCacheParent*
{
    return SendPScriptCacheConstructor(AllocPScriptCacheParent(cacheFile, wantCacheData), cacheFile, wantCacheData);
}

auto PContentParent::SendPScriptCacheConstructor(
        PScriptCacheParent* actor,
        const FileDescOrError& cacheFile,
        const bool& wantCacheData) -> PScriptCacheParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PScriptCacheParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPScriptCacheParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PScriptCacheConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, cacheFile);
    // Sentinel = 'cacheFile'
    (msg__)->WriteSentinel(1159637773);
    WriteIPDLParam(msg__, this, wantCacheData);
    // Sentinel = 'wantCacheData'
    (msg__)->WriteSentinel(2349173833);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PScriptCacheConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PScriptCacheMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendRegisterChrome(
        const nsTArray<ChromePackage>& packages,
        const nsTArray<SubstitutionMapping>& substitutions,
        const nsTArray<OverrideMapping>& overrides,
        const nsCString& locale,
        const bool& reset) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RegisterChrome(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, packages);
    // Sentinel = 'packages'
    (msg__)->WriteSentinel(2544542939);
    WriteIPDLParam(msg__, this, substitutions);
    // Sentinel = 'substitutions'
    (msg__)->WriteSentinel(1650827567);
    WriteIPDLParam(msg__, this, overrides);
    // Sentinel = 'overrides'
    (msg__)->WriteSentinel(3491981546);
    WriteIPDLParam(msg__, this, locale);
    // Sentinel = 'locale'
    (msg__)->WriteSentinel(779891848);
    WriteIPDLParam(msg__, this, reset);
    // Sentinel = 'reset'
    (msg__)->WriteSentinel(2509547360);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RegisterChrome", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRegisterChromeItem(const ChromeRegistryItem& item) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RegisterChromeItem(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, item);
    // Sentinel = 'item'
    (msg__)->WriteSentinel(3785181297);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RegisterChromeItem", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendClearImageCache(
        const bool& privateLoader,
        const bool& chrome) -> bool
{
    IPC::Message* msg__ = PContent::Msg_ClearImageCache(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, privateLoader);
    // Sentinel = 'privateLoader'
    (msg__)->WriteSentinel(3222654805);
    WriteIPDLParam(msg__, this, chrome);
    // Sentinel = 'chrome'
    (msg__)->WriteSentinel(2631435560);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ClearImageCache", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetOffline(const bool& offline) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetOffline(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, offline);
    // Sentinel = 'offline'
    (msg__)->WriteSentinel(3136819898);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetOffline", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetConnectivity(const bool& connectivity) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetConnectivity(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, connectivity);
    // Sentinel = 'connectivity'
    (msg__)->WriteSentinel(3733639633);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetConnectivity", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetCaptivePortalState(const int32_t& aState) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetCaptivePortalState(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aState);
    // Sentinel = 'aState'
    (msg__)->WriteSentinel(3694751962);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetCaptivePortalState", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyVisited(const nsTArray<URIParams>& uri) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyVisited(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, uri);
    // Sentinel = 'uri'
    (msg__)->WriteSentinel(1453210605);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyVisited", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPreferenceUpdate(const Pref& pref) -> bool
{
    IPC::Message* msg__ = PContent::Msg_PreferenceUpdate(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, pref);
    // Sentinel = 'pref'
    (msg__)->WriteSentinel(3089393963);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PreferenceUpdate", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendVarUpdate(const GfxVarUpdate& var) -> bool
{
    IPC::Message* msg__ = PContent::Msg_VarUpdate(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, var);
    // Sentinel = 'var'
    (msg__)->WriteSentinel(2283110200);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_VarUpdate", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendDataStoragePut(
        const nsString& aFilename,
        const DataStorageItem& aItem) -> bool
{
    IPC::Message* msg__ = PContent::Msg_DataStoragePut(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aFilename);
    // Sentinel = 'aFilename'
    (msg__)->WriteSentinel(2942409315);
    WriteIPDLParam(msg__, this, aItem);
    // Sentinel = 'aItem'
    (msg__)->WriteSentinel(3914436313);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_DataStoragePut", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendDataStorageRemove(
        const nsString& aFilename,
        const nsCString& aKey,
        const DataStorageType& aType) -> bool
{
    IPC::Message* msg__ = PContent::Msg_DataStorageRemove(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aFilename);
    // Sentinel = 'aFilename'
    (msg__)->WriteSentinel(2942409315);
    WriteIPDLParam(msg__, this, aKey);
    // Sentinel = 'aKey'
    (msg__)->WriteSentinel(3415890794);
    WriteIPDLParam(msg__, this, aType);
    // Sentinel = 'aType'
    (msg__)->WriteSentinel(1819585676);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_DataStorageRemove", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendDataStorageClear(const nsString& aFilename) -> bool
{
    IPC::Message* msg__ = PContent::Msg_DataStorageClear(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aFilename);
    // Sentinel = 'aFilename'
    (msg__)->WriteSentinel(2942409315);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_DataStorageClear", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyAlertsObserver(
        const nsCString& topic,
        const nsString& data) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyAlertsObserver(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, topic);
    // Sentinel = 'topic'
    (msg__)->WriteSentinel(261826960);
    WriteIPDLParam(msg__, this, data);
    // Sentinel = 'data'
    (msg__)->WriteSentinel(843352540);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyAlertsObserver", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendGeolocationUpdate(nsIDOMGeoPosition* aPosition) -> bool
{
    IPC::Message* msg__ = PContent::Msg_GeolocationUpdate(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aPosition);
    // Sentinel = 'aPosition'
    (msg__)->WriteSentinel(2753958473);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_GeolocationUpdate", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendGeolocationError(const uint16_t& errorCode) -> bool
{
    IPC::Message* msg__ = PContent::Msg_GeolocationError(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, errorCode);
    // Sentinel = 'errorCode'
    (msg__)->WriteSentinel(262143504);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_GeolocationError", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUpdateDictionaryList(const nsTArray<nsString>& dictionaries) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UpdateDictionaryList(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, dictionaries);
    // Sentinel = 'dictionaries'
    (msg__)->WriteSentinel(3810082412);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UpdateDictionaryList", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUpdateFontList(const nsTArray<SystemFontListEntry>& fontList) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UpdateFontList(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, fontList);
    // Sentinel = 'fontList'
    (msg__)->WriteSentinel(2258084427);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UpdateFontList", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUpdateAppLocales(const nsTArray<nsCString>& appLocales) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UpdateAppLocales(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, appLocales);
    // Sentinel = 'appLocales'
    (msg__)->WriteSentinel(2758913044);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UpdateAppLocales", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUpdateRequestedLocales(const nsTArray<nsCString>& requestedLocales) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UpdateRequestedLocales(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, requestedLocales);
    // Sentinel = 'requestedLocales'
    (msg__)->WriteSentinel(2758015985);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UpdateRequestedLocales", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendClearSiteDataReloadNeeded(const nsString& origin) -> bool
{
    IPC::Message* msg__ = PContent::Msg_ClearSiteDataReloadNeeded(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, origin);
    // Sentinel = 'origin'
    (msg__)->WriteSentinel(1429924608);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ClearSiteDataReloadNeeded", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRegisterStringBundles(const nsTArray<StringBundleDescriptor>& stringBundles) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RegisterStringBundles(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, stringBundles);
    // Sentinel = 'stringBundles'
    (msg__)->WriteSentinel(4148729023);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RegisterStringBundles", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUpdateSharedData(
        const FileDescriptor& mapFile,
        const uint32_t& aSize,
        const nsTArray<IPCBlob>& blobs,
        const nsTArray<nsCString>& changedKeys) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UpdateSharedData(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, mapFile);
    // Sentinel = 'mapFile'
    (msg__)->WriteSentinel(66221031);
    WriteIPDLParam(msg__, this, aSize);
    // Sentinel = 'aSize'
    (msg__)->WriteSentinel(2556665555);
    WriteIPDLParam(msg__, this, blobs);
    // Sentinel = 'blobs'
    (msg__)->WriteSentinel(635500709);
    WriteIPDLParam(msg__, this, changedKeys);
    // Sentinel = 'changedKeys'
    (msg__)->WriteSentinel(2842182427);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UpdateSharedData", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendAddPermission(const Permission& permission) -> bool
{
    IPC::Message* msg__ = PContent::Msg_AddPermission(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, permission);
    // Sentinel = 'permission'
    (msg__)->WriteSentinel(22860871);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_AddPermission", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRemoveAllPermissions() -> bool
{
    IPC::Message* msg__ = PContent::Msg_RemoveAllPermissions(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RemoveAllPermissions", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendFlushMemory(const nsString& reason) -> bool
{
    IPC::Message* msg__ = PContent::Msg_FlushMemory(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, reason);
    // Sentinel = 'reason'
    (msg__)->WriteSentinel(4151390930);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_FlushMemory", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendGarbageCollect() -> bool
{
    IPC::Message* msg__ = PContent::Msg_GarbageCollect(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_GarbageCollect", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendCycleCollect() -> bool
{
    IPC::Message* msg__ = PContent::Msg_CycleCollect(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_CycleCollect", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUnlinkGhosts() -> bool
{
    IPC::Message* msg__ = PContent::Msg_UnlinkGhosts(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UnlinkGhosts", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendActivateA11y(
        const uint32_t& aMainChromeTid,
        const uint32_t& aMsaaID) -> bool
{
    IPC::Message* msg__ = PContent::Msg_ActivateA11y(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aMainChromeTid);
    // Sentinel = 'aMainChromeTid'
    (msg__)->WriteSentinel(3575603341);
    WriteIPDLParam(msg__, this, aMsaaID);
    // Sentinel = 'aMsaaID'
    (msg__)->WriteSentinel(645559775);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ActivateA11y", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendShutdownA11y() -> bool
{
    IPC::Message* msg__ = PContent::Msg_ShutdownA11y(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ShutdownA11y", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendAppInfo(
        const nsCString& version,
        const nsCString& buildID,
        const nsCString& name,
        const nsCString& UAName,
        const nsCString& ID,
        const nsCString& vendor,
        const nsCString& sourceURL) -> bool
{
    IPC::Message* msg__ = PContent::Msg_AppInfo(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, version);
    // Sentinel = 'version'
    (msg__)->WriteSentinel(4003360947);
    WriteIPDLParam(msg__, this, buildID);
    // Sentinel = 'buildID'
    (msg__)->WriteSentinel(1387208200);
    WriteIPDLParam(msg__, this, name);
    // Sentinel = 'name'
    (msg__)->WriteSentinel(15034981);
    WriteIPDLParam(msg__, this, UAName);
    // Sentinel = 'UAName'
    (msg__)->WriteSentinel(1769178349);
    WriteIPDLParam(msg__, this, ID);
    // Sentinel = 'ID'
    (msg__)->WriteSentinel(2597318109);
    WriteIPDLParam(msg__, this, vendor);
    // Sentinel = 'vendor'
    (msg__)->WriteSentinel(461600324);
    WriteIPDLParam(msg__, this, sourceURL);
    // Sentinel = 'sourceURL'
    (msg__)->WriteSentinel(3017222275);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_AppInfo", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRemoteType(const nsString& aRemoteType) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RemoteType(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aRemoteType);
    // Sentinel = 'aRemoteType'
    (msg__)->WriteSentinel(4113166544);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RemoteType", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInitServiceWorkers(const ServiceWorkerConfiguration& aConfig) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitServiceWorkers(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aConfig);
    // Sentinel = 'aConfig'
    (msg__)->WriteSentinel(3808514188);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitServiceWorkers", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInitBlobURLs(const nsTArray<BlobURLRegistrationData>& registrations) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InitBlobURLs(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, registrations);
    // Sentinel = 'registrations'
    (msg__)->WriteSentinel(2559949423);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InitBlobURLs", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetXPCOMProcessAttributes(
        const XPCOMInitData& xpcomInit,
        const StructuredCloneData& initialData,
        const nsTArray<LookAndFeelInt>& lookAndFeelIntCache,
        const nsTArray<SystemFontListEntry>& systemFontList) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetXPCOMProcessAttributes(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, xpcomInit);
    // Sentinel = 'xpcomInit'
    (msg__)->WriteSentinel(1191505416);
    WriteIPDLParam(msg__, this, initialData);
    // Sentinel = 'initialData'
    (msg__)->WriteSentinel(3214224943);
    WriteIPDLParam(msg__, this, lookAndFeelIntCache);
    // Sentinel = 'lookAndFeelIntCache'
    (msg__)->WriteSentinel(4279224656);
    WriteIPDLParam(msg__, this, systemFontList);
    // Sentinel = 'systemFontList'
    (msg__)->WriteSentinel(3715584146);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetXPCOMProcessAttributes", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendLastPrivateDocShellDestroyed() -> bool
{
    IPC::Message* msg__ = PContent::Msg_LastPrivateDocShellDestroyed(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_LastPrivateDocShellDestroyed", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyProcessPriorityChanged(const ProcessPriority& priority) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyProcessPriorityChanged(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, priority);
    // Sentinel = 'priority'
    (msg__)->WriteSentinel(558136112);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyProcessPriorityChanged", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendMinimizeMemoryUsage() -> bool
{
    IPC::Message* msg__ = PContent::Msg_MinimizeMemoryUsage(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_MinimizeMemoryUsage", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendLoadAndRegisterSheet(
        const URIParams& uri,
        const uint32_t& type) -> bool
{
    IPC::Message* msg__ = PContent::Msg_LoadAndRegisterSheet(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, uri);
    // Sentinel = 'uri'
    (msg__)->WriteSentinel(1453210605);
    WriteIPDLParam(msg__, this, type);
    // Sentinel = 'type'
    (msg__)->WriteSentinel(2982068540);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_LoadAndRegisterSheet", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUnregisterSheet(
        const URIParams& uri,
        const uint32_t& type) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UnregisterSheet(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, uri);
    // Sentinel = 'uri'
    (msg__)->WriteSentinel(1453210605);
    WriteIPDLParam(msg__, this, type);
    // Sentinel = 'type'
    (msg__)->WriteSentinel(2982068540);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UnregisterSheet", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyIdleObserver(
        const uint64_t& observerId,
        const nsCString& topic,
        const nsString& str) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyIdleObserver(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, observerId);
    // Sentinel = 'observerId'
    (msg__)->WriteSentinel(2815026823);
    WriteIPDLParam(msg__, this, topic);
    // Sentinel = 'topic'
    (msg__)->WriteSentinel(261826960);
    WriteIPDLParam(msg__, this, str);
    // Sentinel = 'str'
    (msg__)->WriteSentinel(3748377462);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyIdleObserver", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendInvokeDragSession(
        const nsTArray<IPCDataTransfer>& transfers,
        const uint32_t& action) -> bool
{
    IPC::Message* msg__ = PContent::Msg_InvokeDragSession(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, transfers);
    // Sentinel = 'transfers'
    (msg__)->WriteSentinel(3048523737);
    WriteIPDLParam(msg__, this, action);
    // Sentinel = 'action'
    (msg__)->WriteSentinel(991072504);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_InvokeDragSession", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendEndDragSession(
        const bool& aDoneDrag,
        const bool& aUserCancelled,
        const LayoutDeviceIntPoint& aDragEndPoint,
        const uint32_t& aKeyModifiers) -> bool
{
    IPC::Message* msg__ = PContent::Msg_EndDragSession(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDoneDrag);
    // Sentinel = 'aDoneDrag'
    (msg__)->WriteSentinel(3406977382);
    WriteIPDLParam(msg__, this, aUserCancelled);
    // Sentinel = 'aUserCancelled'
    (msg__)->WriteSentinel(3762723247);
    WriteIPDLParam(msg__, this, aDragEndPoint);
    // Sentinel = 'aDragEndPoint'
    (msg__)->WriteSentinel(2254135269);
    WriteIPDLParam(msg__, this, aKeyModifiers);
    // Sentinel = 'aKeyModifiers'
    (msg__)->WriteSentinel(838210057);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_EndDragSession", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendDomainSetChanged(
        const uint32_t& aSetType,
        const uint32_t& aChangeType,
        const OptionalURIParams& aDomain) -> bool
{
    IPC::Message* msg__ = PContent::Msg_DomainSetChanged(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aSetType);
    // Sentinel = 'aSetType'
    (msg__)->WriteSentinel(3577437707);
    WriteIPDLParam(msg__, this, aChangeType);
    // Sentinel = 'aChangeType'
    (msg__)->WriteSentinel(3383103566);
    WriteIPDLParam(msg__, this, aDomain);
    // Sentinel = 'aDomain'
    (msg__)->WriteSentinel(115381882);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_DomainSetChanged", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendShutdown() -> bool
{
    IPC::Message* msg__ = PContent::Msg_Shutdown(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_Shutdown", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendLoadProcessScript(const nsString& url) -> bool
{
    IPC::Message* msg__ = PContent::Msg_LoadProcessScript(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, url);
    // Sentinel = 'url'
    (msg__)->WriteSentinel(1453210600);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_LoadProcessScript", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendUpdateWindow(const uintptr_t& aChildId) -> bool
{
    IPC::Message* msg__ = PContent::Msg_UpdateWindow(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aChildId);
    // Sentinel = 'aChildId'
    (msg__)->WriteSentinel(328267498);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_UpdateWindow", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyPresentationReceiverLaunched(
        PBrowserParent* aIframe,
        const nsString& aSessionId) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyPresentationReceiverLaunched(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(aIframe, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, aIframe);
    // Sentinel = 'aIframe'
    (msg__)->WriteSentinel(161927714);
    WriteIPDLParam(msg__, this, aSessionId);
    // Sentinel = 'aSessionId'
    (msg__)->WriteSentinel(725794242);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyPresentationReceiverLaunched", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyPresentationReceiverCleanUp(const nsString& aSessionId) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyPresentationReceiverCleanUp(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aSessionId);
    // Sentinel = 'aSessionId'
    (msg__)->WriteSentinel(725794242);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyPresentationReceiverCleanUp", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyEmptyHTTPCache() -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyEmptyHTTPCache(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyEmptyHTTPCache", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPush(
        const nsCString& scope,
        const Principal& principal,
        const nsString& messageId) -> bool
{
    IPC::Message* msg__ = PContent::Msg_Push(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, scope);
    // Sentinel = 'scope'
    (msg__)->WriteSentinel(2191984953);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);
    WriteIPDLParam(msg__, this, messageId);
    // Sentinel = 'messageId'
    (msg__)->WriteSentinel(2887269495);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_Push", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPushWithData(
        const nsCString& scope,
        const Principal& principal,
        const nsString& messageId,
        const nsTArray<uint8_t>& data) -> bool
{
    IPC::Message* msg__ = PContent::Msg_PushWithData(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, scope);
    // Sentinel = 'scope'
    (msg__)->WriteSentinel(2191984953);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);
    WriteIPDLParam(msg__, this, messageId);
    // Sentinel = 'messageId'
    (msg__)->WriteSentinel(2887269495);
    WriteIPDLParam(msg__, this, data);
    // Sentinel = 'data'
    (msg__)->WriteSentinel(843352540);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PushWithData", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPushSubscriptionChange(
        const nsCString& scope,
        const Principal& principal) -> bool
{
    IPC::Message* msg__ = PContent::Msg_PushSubscriptionChange(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, scope);
    // Sentinel = 'scope'
    (msg__)->WriteSentinel(2191984953);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PushSubscriptionChange", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPushError(
        const nsCString& scope,
        const Principal& principal,
        const nsString& message,
        const uint32_t& flags) -> bool
{
    IPC::Message* msg__ = PContent::Msg_PushError(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, scope);
    // Sentinel = 'scope'
    (msg__)->WriteSentinel(2191984953);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);
    WriteIPDLParam(msg__, this, message);
    // Sentinel = 'message'
    (msg__)->WriteSentinel(1366108954);
    WriteIPDLParam(msg__, this, flags);
    // Sentinel = 'flags'
    (msg__)->WriteSentinel(2550519284);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PushError", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetAudioSessionData(
        const nsID& aID,
        const nsString& aDisplayName,
        const nsString& aIconPath) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetAudioSessionData(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aDisplayName);
    // Sentinel = 'aDisplayName'
    (msg__)->WriteSentinel(531102644);
    WriteIPDLParam(msg__, this, aIconPath);
    // Sentinel = 'aIconPath'
    (msg__)->WriteSentinel(2359874914);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetAudioSessionData", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

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

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aResult);
    // Sentinel = 'aResult'
    (msg__)->WriteSentinel(3888726089);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_GetFilesResponse", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendBlobURLRegistration(
        const nsCString& aURI,
        const IPCBlob& aBlob,
        const Principal& aPrincipal) -> bool
{
    IPC::Message* msg__ = PContent::Msg_BlobURLRegistration(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aURI);
    // Sentinel = 'aURI'
    (msg__)->WriteSentinel(2075506333);
    WriteIPDLParam(msg__, this, aBlob);
    // Sentinel = 'aBlob'
    (msg__)->WriteSentinel(3425660321);
    WriteIPDLParam(msg__, this, aPrincipal);
    // Sentinel = 'aPrincipal'
    (msg__)->WriteSentinel(4097511);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_BlobURLRegistration", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendBlobURLUnregistration(const nsCString& aURI) -> bool
{
    IPC::Message* msg__ = PContent::Msg_BlobURLUnregistration(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aURI);
    // Sentinel = 'aURI'
    (msg__)->WriteSentinel(2075506333);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_BlobURLUnregistration", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendGMPsChanged(const nsTArray<GMPCapabilityData>& capabilities) -> bool
{
    IPC::Message* msg__ = PContent::Msg_GMPsChanged(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, capabilities);
    // Sentinel = 'capabilities'
    (msg__)->WriteSentinel(4197121582);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_GMPsChanged", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendFileCreationResponse(
        const nsID& aID,
        const FileCreationResult& aResult) -> bool
{
    IPC::Message* msg__ = PContent::Msg_FileCreationResponse(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aResult);
    // Sentinel = 'aResult'
    (msg__)->WriteSentinel(3888726089);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_FileCreationResponse", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendActivate(PBrowserParent* aTab) -> bool
{
    IPC::Message* msg__ = PContent::Msg_Activate(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(aTab, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, aTab);
    // Sentinel = 'aTab'
    (msg__)->WriteSentinel(1179125994);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_Activate", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendDeactivate(PBrowserParent* aTab) -> bool
{
    IPC::Message* msg__ = PContent::Msg_Deactivate(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(aTab, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, aTab);
    // Sentinel = 'aTab'
    (msg__)->WriteSentinel(1179125994);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_Deactivate", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPParentToChildStreamConstructor() -> PParentToChildStreamParent*
{
    return SendPParentToChildStreamConstructor(AllocPParentToChildStreamParent());
}

auto PContentParent::SendPParentToChildStreamConstructor(PParentToChildStreamParent* actor) -> PParentToChildStreamParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PParentToChildStreamParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPParentToChildStreamParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PParentToChildStreamConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PParentToChildStreamConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PParentToChildStreamMsgStart, actor);
        return nullptr;
    }
    return actor;
}

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

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aFD);
    // Sentinel = 'aFD'
    (msg__)->WriteSentinel(2730041960);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ProvideAnonymousTemporaryFile", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSetPermissionsWithKey(
        const nsCString& aPermissionKey,
        const nsTArray<Permission>& aPermissions) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetPermissionsWithKey(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aPermissionKey);
    // Sentinel = 'aPermissionKey'
    (msg__)->WriteSentinel(1655133647);
    WriteIPDLParam(msg__, this, aPermissions);
    // Sentinel = 'aPermissions'
    (msg__)->WriteSentinel(1882836443);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetPermissionsWithKey", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendRefreshScreens(const nsTArray<ScreenDetails>& aScreens) -> bool
{
    IPC::Message* msg__ = PContent::Msg_RefreshScreens(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aScreens);
    // Sentinel = 'aScreens'
    (msg__)->WriteSentinel(2322625764);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_RefreshScreens", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPIPCBlobInputStreamConstructor(
        const nsID& aID,
        const uint64_t& aSize) -> PIPCBlobInputStreamParent*
{
    return SendPIPCBlobInputStreamConstructor(AllocPIPCBlobInputStreamParent(aID, aSize), aID, aSize);
}

auto PContentParent::SendPIPCBlobInputStreamConstructor(
        PIPCBlobInputStreamParent* actor,
        const nsID& aID,
        const uint64_t& aSize) -> PIPCBlobInputStreamParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PIPCBlobInputStreamParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPIPCBlobInputStreamParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PIPCBlobInputStreamConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aSize);
    // Sentinel = 'aSize'
    (msg__)->WriteSentinel(2556665555);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PIPCBlobInputStreamConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PIPCBlobInputStreamMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendSetPluginList(
        const uint32_t& pluginEpoch,
        const nsTArray<PluginTag>& plugins,
        const nsTArray<FakePluginTag>& fakePlugins) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetPluginList(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, pluginEpoch);
    // Sentinel = 'pluginEpoch'
    (msg__)->WriteSentinel(2162950827);
    WriteIPDLParam(msg__, this, plugins);
    // Sentinel = 'plugins'
    (msg__)->WriteSentinel(2745061527);
    WriteIPDLParam(msg__, this, fakePlugins);
    // Sentinel = 'fakePlugins'
    (msg__)->WriteSentinel(3769647974);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetPluginList", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendShareCodeCoverageMutex(const CrossProcessMutexHandle& handle) -> bool
{
    IPC::Message* msg__ = PContent::Msg_ShareCodeCoverageMutex(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, handle);
    // Sentinel = 'handle'
    (msg__)->WriteSentinel(453975108);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ShareCodeCoverageMutex", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendDumpCodeCoverageCounters(
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    IPC::Message* msg__ = PContent::Msg_DumpCodeCoverageCounters(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_DumpCodeCoverageCounters", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    (GetIPCChannel())->Send(msg__, this, std::move(aResolve), std::move(aReject));
    return;
}

auto PContentParent::SendDumpCodeCoverageCounters() -> RefPtr<DumpCodeCoverageCountersPromise>
{

    RefPtr<MozPromise<bool, ResponseRejectReason, false>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, false>::Private(__func__);

    SendDumpCodeCoverageCounters([promise__](bool&& aValue) {
        (promise__)->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason aReason) {
        (promise__)->Reject(aReason, __func__);
    });
    return promise__;
}

auto PContentParent::SendResetCodeCoverageCounters(
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    IPC::Message* msg__ = PContent::Msg_ResetCodeCoverageCounters(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ResetCodeCoverageCounters", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    (GetIPCChannel())->Send(msg__, this, std::move(aResolve), std::move(aReject));
    return;
}

auto PContentParent::SendResetCodeCoverageCounters() -> RefPtr<ResetCodeCoverageCountersPromise>
{

    RefPtr<MozPromise<bool, ResponseRejectReason, false>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, false>::Private(__func__);

    SendResetCodeCoverageCounters([promise__](bool&& aValue) {
        (promise__)->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason aReason) {
        (promise__)->Reject(aReason, __func__);
    });
    return promise__;
}

auto PContentParent::SendSetInputEventQueueEnabled() -> bool
{
    IPC::Message* msg__ = PContent::Msg_SetInputEventQueueEnabled(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SetInputEventQueueEnabled", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendFlushInputEventQueue() -> bool
{
    IPC::Message* msg__ = PContent::Msg_FlushInputEventQueue(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_FlushInputEventQueue", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendResumeInputEventQueue() -> bool
{
    IPC::Message* msg__ = PContent::Msg_ResumeInputEventQueue(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_ResumeInputEventQueue", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendSuspendInputEventQueue() -> bool
{
    IPC::Message* msg__ = PContent::Msg_SuspendInputEventQueue(MSG_ROUTING_CONTROL);





    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SuspendInputEventQueue", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendAddDynamicScalars(const nsTArray<DynamicScalarDefinition>& definitions) -> bool
{
    IPC::Message* msg__ = PContent::Msg_AddDynamicScalars(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, definitions);
    // Sentinel = 'definitions'
    (msg__)->WriteSentinel(1873316345);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_AddDynamicScalars", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendPClientOpenWindowOpConstructor(const ClientOpenWindowArgs& aArgs) -> PClientOpenWindowOpParent*
{
    return SendPClientOpenWindowOpConstructor(AllocPClientOpenWindowOpParent(aArgs), aArgs);
}

auto PContentParent::SendPClientOpenWindowOpConstructor(
        PClientOpenWindowOpParent* actor,
        const ClientOpenWindowArgs& aArgs) -> PClientOpenWindowOpParent*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PClientOpenWindowOpParent");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPClientOpenWindowOpParent).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PContent::Msg_PClientOpenWindowOpConstructor(MSG_ROUTING_CONTROL);

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, aArgs);
    // Sentinel = 'aArgs'
    (msg__)->WriteSentinel(424150951);



    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_PClientOpenWindowOpConstructor", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        IProtocol* mgr = (actor)->Manager();
        (actor)->DestroySubtree(FailedConstructor);
        (actor)->DeallocSubtree();
        (mgr)->RemoveManagee(PClientOpenWindowOpMsgStart, actor);
        return nullptr;
    }
    return actor;
}

auto PContentParent::SendSaveRecording(const FileDescriptor& file) -> bool
{
    IPC::Message* msg__ = PContent::Msg_SaveRecording(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, file);
    // Sentinel = 'file'
    (msg__)->WriteSentinel(224874390);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_SaveRecording", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendAsyncMessage(
        const nsString& aMessage,
        const nsTArray<CpowEntry>& aCpows,
        const Principal& aPrincipal,
        const ClonedMessageData& aData) -> bool
{
    IPC::Message* msg__ = PContent::Msg_AsyncMessage(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aMessage);
    // Sentinel = 'aMessage'
    (msg__)->WriteSentinel(3453110902);
    WriteIPDLParam(msg__, this, aCpows);
    // Sentinel = 'aCpows'
    (msg__)->WriteSentinel(2178221451);
    WriteIPDLParam(msg__, this, aPrincipal);
    // Sentinel = 'aPrincipal'
    (msg__)->WriteSentinel(4097511);
    WriteIPDLParam(msg__, this, aData);
    // Sentinel = 'aData'
    (msg__)->WriteSentinel(3285075324);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_AsyncMessage", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::SendNotifyPushSubscriptionModifiedObservers(
        const nsCString& scope,
        const Principal& principal) -> bool
{
    IPC::Message* msg__ = PContent::Msg_NotifyPushSubscriptionModifiedObservers(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, scope);
    // Sentinel = 'scope'
    (msg__)->WriteSentinel(2191984953);
    WriteIPDLParam(msg__, this, principal);
    // Sentinel = 'principal'
    (msg__)->WriteSentinel(732240927);




    if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
        mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PContentParent::RemoveManagee(
        int32_t aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PBrowserMsgStart:
        {
            PBrowserParent* actor = static_cast<PBrowserParent*>(aListener);
            auto& container = mManagedPBrowserParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPBrowserParent(actor);
            return;
        }
    case PClientOpenWindowOpMsgStart:
        {
            PClientOpenWindowOpParent* actor = static_cast<PClientOpenWindowOpParent*>(aListener);
            auto& container = mManagedPClientOpenWindowOpParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPClientOpenWindowOpParent(actor);
            return;
        }
    case PContentPermissionRequestMsgStart:
        {
            PContentPermissionRequestParent* actor = static_cast<PContentPermissionRequestParent*>(aListener);
            auto& container = mManagedPContentPermissionRequestParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPContentPermissionRequestParent(actor);
            return;
        }
    case PCycleCollectWithLogsMsgStart:
        {
            PCycleCollectWithLogsParent* actor = static_cast<PCycleCollectWithLogsParent*>(aListener);
            auto& container = mManagedPCycleCollectWithLogsParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCycleCollectWithLogsParent(actor);
            return;
        }
    case PPSMContentDownloaderMsgStart:
        {
            PPSMContentDownloaderParent* actor = static_cast<PPSMContentDownloaderParent*>(aListener);
            auto& container = mManagedPPSMContentDownloaderParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPPSMContentDownloaderParent(actor);
            return;
        }
    case PExternalHelperAppMsgStart:
        {
            PExternalHelperAppParent* actor = static_cast<PExternalHelperAppParent*>(aListener);
            auto& container = mManagedPExternalHelperAppParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPExternalHelperAppParent(actor);
            return;
        }
    case PFileDescriptorSetMsgStart:
        {
            PFileDescriptorSetParent* actor = static_cast<PFileDescriptorSetParent*>(aListener);
            auto& container = mManagedPFileDescriptorSetParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPFileDescriptorSetParent(actor);
            return;
        }
    case PHalMsgStart:
        {
            PHalParent* actor = static_cast<PHalParent*>(aListener);
            auto& container = mManagedPHalParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPHalParent(actor);
            return;
        }
    case PHandlerServiceMsgStart:
        {
            PHandlerServiceParent* actor = static_cast<PHandlerServiceParent*>(aListener);
            auto& container = mManagedPHandlerServiceParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPHandlerServiceParent(actor);
            return;
        }
    case PHeapSnapshotTempFileHelperMsgStart:
        {
            PHeapSnapshotTempFileHelperParent* actor = static_cast<PHeapSnapshotTempFileHelperParent*>(aListener);
            auto& container = mManagedPHeapSnapshotTempFileHelperParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPHeapSnapshotTempFileHelperParent(actor);
            return;
        }
    case PIPCBlobInputStreamMsgStart:
        {
            PIPCBlobInputStreamParent* actor = static_cast<PIPCBlobInputStreamParent*>(aListener);
            auto& container = mManagedPIPCBlobInputStreamParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPIPCBlobInputStreamParent(actor);
            return;
        }
    case PMediaMsgStart:
        {
            PMediaParent* actor = static_cast<PMediaParent*>(aListener);
            auto& container = mManagedPMediaParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPMediaParent(actor);
            return;
        }
    case PNeckoMsgStart:
        {
            PNeckoParent* actor = static_cast<PNeckoParent*>(aListener);
            auto& container = mManagedPNeckoParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPNeckoParent(actor);
            return;
        }
    case POfflineCacheUpdateMsgStart:
        {
            POfflineCacheUpdateParent* actor = static_cast<POfflineCacheUpdateParent*>(aListener);
            auto& container = mManagedPOfflineCacheUpdateParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPOfflineCacheUpdateParent(actor);
            return;
        }
    case PPrintingMsgStart:
        {
            PPrintingParent* actor = static_cast<PPrintingParent*>(aListener);
            auto& container = mManagedPPrintingParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPPrintingParent(actor);
            return;
        }
    case PChildToParentStreamMsgStart:
        {
            PChildToParentStreamParent* actor = static_cast<PChildToParentStreamParent*>(aListener);
            auto& container = mManagedPChildToParentStreamParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPChildToParentStreamParent(actor);
            return;
        }
    case PParentToChildStreamMsgStart:
        {
            PParentToChildStreamParent* actor = static_cast<PParentToChildStreamParent*>(aListener);
            auto& container = mManagedPParentToChildStreamParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPParentToChildStreamParent(actor);
            return;
        }
    case PSpeechSynthesisMsgStart:
        {
            PSpeechSynthesisParent* actor = static_cast<PSpeechSynthesisParent*>(aListener);
            auto& container = mManagedPSpeechSynthesisParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPSpeechSynthesisParent(actor);
            return;
        }
    case PTestShellMsgStart:
        {
            PTestShellParent* actor = static_cast<PTestShellParent*>(aListener);
            auto& container = mManagedPTestShellParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPTestShellParent(actor);
            return;
        }
    case PJavaScriptMsgStart:
        {
            PJavaScriptParent* actor = static_cast<PJavaScriptParent*>(aListener);
            auto& container = mManagedPJavaScriptParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPJavaScriptParent(actor);
            return;
        }
    case PRemoteSpellcheckEngineMsgStart:
        {
            PRemoteSpellcheckEngineParent* actor = static_cast<PRemoteSpellcheckEngineParent*>(aListener);
            auto& container = mManagedPRemoteSpellcheckEngineParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPRemoteSpellcheckEngineParent(actor);
            return;
        }
    case PWebBrowserPersistDocumentMsgStart:
        {
            PWebBrowserPersistDocumentParent* actor = static_cast<PWebBrowserPersistDocumentParent*>(aListener);
            auto& container = mManagedPWebBrowserPersistDocumentParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPWebBrowserPersistDocumentParent(actor);
            return;
        }
    case PWebrtcGlobalMsgStart:
        {
            PWebrtcGlobalParent* actor = static_cast<PWebrtcGlobalParent*>(aListener);
            auto& container = mManagedPWebrtcGlobalParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPWebrtcGlobalParent(actor);
            return;
        }
    case PPresentationMsgStart:
        {
            PPresentationParent* actor = static_cast<PPresentationParent*>(aListener);
            auto& container = mManagedPPresentationParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPPresentationParent(actor);
            return;
        }
    case PURLClassifierMsgStart:
        {
            PURLClassifierParent* actor = static_cast<PURLClassifierParent*>(aListener);
            auto& container = mManagedPURLClassifierParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPURLClassifierParent(actor);
            return;
        }
    case PURLClassifierLocalMsgStart:
        {
            PURLClassifierLocalParent* actor = static_cast<PURLClassifierLocalParent*>(aListener);
            auto& container = mManagedPURLClassifierLocalParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPURLClassifierLocalParent(actor);
            return;
        }
    case PScriptCacheMsgStart:
        {
            PScriptCacheParent* actor = static_cast<PScriptCacheParent*>(aListener);
            auto& container = mManagedPScriptCacheParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPScriptCacheParent(actor);
            return;
        }
    case PLoginReputationMsgStart:
        {
            PLoginReputationParent* actor = static_cast<PLoginReputationParent*>(aListener);
            auto& container = mManagedPLoginReputationParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPLoginReputationParent(actor);
            return;
        }
    default:
        {
            FatalError("unreached");
            return;
        }
    }
}

auto PContentParent::OnMessageReceived(const Message& msg__) -> PContentParent::Result
{
    int32_t route__ = (msg__).routing_id();
    if ((MSG_ROUTING_CONTROL) != (route__)) {
        IProtocol* routed__ = Lookup(route__);
        if ((!(routed__))) {
            return MsgRouteError;
        }
        return (routed__)->OnMessageReceived(msg__);
    }

    switch ((msg__).type()) {
    case PContent::Reply_PBrowserConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_PBrowserConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PBrowserConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PBrowserParent* actor;
            TabId tabId;
            TabId sameTabGroupAs;
            IPCTabContext context;
            uint32_t chromeFlags;
            ContentParentId cpId;
            bool isForBrowser;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'tabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sameTabGroupAs)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'sameTabGroupAs'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3969365410)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(context)))))) {
                FatalError("Error deserializing 'IPCTabContext'");
                return MsgValueError;
            }
            // Sentinel = 'context'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3514529014)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(chromeFlags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'chromeFlags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 299515804)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cpId)))))) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            // Sentinel = 'cpId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(isForBrowser)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'isForBrowser'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2051565587)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPBrowserParent(tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PBrowserParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPBrowserParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPBrowserConstructor(actor, tabId, sameTabGroupAs, context, chromeFlags, cpId, isForBrowser)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Reply_PFileDescriptorSetConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_PFileDescriptorSetConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PFileDescriptorSetConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PFileDescriptorSetParent* actor;
            FileDescriptor fd;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(fd)))))) {
                FatalError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            // Sentinel = 'fd'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 628535764)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPFileDescriptorSetParent(fd);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PFileDescriptorSetParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPFileDescriptorSetParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPFileDescriptorSetConstructor(actor, fd)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PWebBrowserPersistDocumentConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PWebBrowserPersistDocumentParent* actor;
            PBrowserParent* aBrowser;
            uint64_t aOuterWindowID;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBrowser)))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            // Sentinel = 'aBrowser'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3086016059)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aOuterWindowID)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aOuterWindowID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3438169907)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPWebBrowserPersistDocumentParent(aBrowser, aOuterWindowID);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PWebBrowserPersistDocumentParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPWebBrowserPersistDocumentParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPWebBrowserPersistDocumentConstructor(actor, aBrowser, aOuterWindowID)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Reply_PCycleCollectWithLogsConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PTestShellConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PScriptCacheConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PParentToChildStreamConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_PIPCBlobInputStreamConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Reply_DumpCodeCoverageCounters__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DumpCodeCoverageCounters", OTHER);

            PickleIterator iter__(msg__);
            bool resolve__;
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(resolve__)))))) {
                FatalError("Error deserializing 'resolve__'");
                return MsgValueError;
            }
            // Sentinel = 'resolve__'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3997392463)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'resolve__'");
                return MsgValueError;
            }

            UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback = (GetIPCChannel())->PopCallback(msg__);
            MessageChannel::CallbackHolder<bool>* callback = static_cast<MessageChannel::CallbackHolder<bool>*>((untypedCallback).get());
            if ((!(callback))) {
                FatalError("Error unknown callback");
                return MsgProcessingError;
            }
            if (resolve__) {
                bool unused;

                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(unused)))))) {
                    FatalError("Error deserializing 'bool'");
                    return MsgValueError;
                }
                // Sentinel = 'unused'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1885311952)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Resolve(std::move(unused));
            }
            else {
                ResponseRejectReason reason__;
                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(reason__)))))) {
                    FatalError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                // Sentinel = 'reason__'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 913452670)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Reject(reason__);
            }
            return MsgProcessed;
        }
    case PContent::Reply_ResetCodeCoverageCounters__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ResetCodeCoverageCounters", OTHER);

            PickleIterator iter__(msg__);
            bool resolve__;
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(resolve__)))))) {
                FatalError("Error deserializing 'resolve__'");
                return MsgValueError;
            }
            // Sentinel = 'resolve__'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3997392463)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'resolve__'");
                return MsgValueError;
            }

            UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback = (GetIPCChannel())->PopCallback(msg__);
            MessageChannel::CallbackHolder<bool>* callback = static_cast<MessageChannel::CallbackHolder<bool>*>((untypedCallback).get());
            if ((!(callback))) {
                FatalError("Error unknown callback");
                return MsgProcessingError;
            }
            if (resolve__) {
                bool unused;

                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(unused)))))) {
                    FatalError("Error deserializing 'bool'");
                    return MsgValueError;
                }
                // Sentinel = 'unused'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1885311952)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Resolve(std::move(unused));
            }
            else {
                ResponseRejectReason reason__;
                if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(reason__)))))) {
                    FatalError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                // Sentinel = 'reason__'
                if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 913452670)))) {
                    mozilla::ipc::SentinelReadError("Error deserializing 'reason__'");
                    return MsgValueError;
                }
                (msg__).EndRead(iter__, (msg__).type());
                (callback)->Reject(reason__);
            }
            return MsgProcessed;
        }
    case PContent::Reply_PClientOpenWindowOpConstructor__ID:
        {
            return MsgProcessed;
        }
    case PContent::Msg_InitBackground__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitBackground", OTHER);

            PickleIterator iter__(msg__);
            Endpoint<mozilla::ipc::PBackgroundParent> aEndpoint;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aEndpoint)))))) {
                FatalError("Error deserializing 'Endpoint<mozilla::ipc::PBackgroundParent>'");
                return MsgValueError;
            }
            // Sentinel = 'aEndpoint'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2457438235)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<mozilla::ipc::PBackgroundParent>'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvInitBackground(std::move(aEndpoint))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CreateReplayingProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateReplayingProcess", OTHER);

            PickleIterator iter__(msg__);
            uint32_t channelId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(channelId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'channelId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 6854027)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCreateReplayingProcess(channelId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_TerminateReplayingProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_TerminateReplayingProcess", OTHER);

            PickleIterator iter__(msg__);
            uint32_t channelId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(channelId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'channelId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 6854027)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvTerminateReplayingProcess(channelId)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateGMPService", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCreateGMPService()))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitStreamFilter", OTHER);

            PickleIterator iter__(msg__);
            uint64_t channelId;
            nsString addonId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(channelId)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'channelId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 6854027)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(addonId)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'addonId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4000132214)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;

            int32_t seqno__ = (msg__).seqno();
            WeakPtr<PContentParent> self__ = this;
            InitStreamFilterResolver resolver = [this, self__, id__, seqno__](Endpoint<mozilla::extensions::PStreamFilterChild>&& aParam) {
                if ((!(self__))) {
                    NS_WARNING("Not resolving response because actor is dead.");
                    return;
                }
                if ((mLivenessState) == (mozilla::ipc::LivenessState::Dead)) {
                    NS_WARNING("Not resolving response because actor is destroyed.");
                    return;
                }
                bool resolve__ = true;
                Endpoint<mozilla::extensions::PStreamFilterChild> aEndpoint;
                aEndpoint = std::move(aParam);
                IPC::Message* reply__ = PContent::Reply_InitStreamFilter(id__);
                WriteIPDLParam(reply__, self__, resolve__);
                // Sentinel = 'resolve__'
                (reply__)->WriteSentinel(3997392463);
                WriteIPDLParam(reply__, self__, aEndpoint);
                // Sentinel = 'aEndpoint'
                (reply__)->WriteSentinel(2457438235);
                (reply__)->set_seqno(seqno__);

                if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                    mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
                }
                bool sendok__ = (GetIPCChannel())->Send(reply__);
                if ((!(sendok__))) {
                    NS_WARNING("Error sending reply");
                }
            };
            if ((!(RecvInitStreamFilter(channelId, addonId, std::move(resolver))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PJavaScriptConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PJavaScriptConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PJavaScriptParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPJavaScriptParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PJavaScriptParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPJavaScriptParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPJavaScriptConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PRemoteSpellcheckEngineConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PRemoteSpellcheckEngineParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPRemoteSpellcheckEngineParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PRemoteSpellcheckEngineParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPRemoteSpellcheckEngineParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPRemoteSpellcheckEngineConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_InitCrashReporter", OTHER);

            PickleIterator iter__(msg__);
            Shmem shmem;
            NativeThreadId tid;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(shmem)))))) {
                FatalError("Error deserializing 'Shmem'");
                return MsgValueError;
            }
            // Sentinel = 'shmem'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4252604405)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Shmem'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tid)))))) {
                FatalError("Error deserializing 'NativeThreadId'");
                return MsgValueError;
            }
            // Sentinel = 'tid'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 333309880)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'NativeThreadId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvInitCrashReporter(std::move(shmem), tid)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AccumulateMixedContentHSTS", OTHER);

            PickleIterator iter__(msg__);
            URIParams aURI;
            bool aActive;
            OriginAttributes aOriginAttributes;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'aURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2075506333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aActive)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aActive'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1215369048)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aOriginAttributes)))))) {
                FatalError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            // Sentinel = 'aOriginAttributes'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2175998517)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAccumulateMixedContentHSTS(aURI, aActive, aOriginAttributes)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PHalConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PHalParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPHalParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PHalParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPHalParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPHalConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PHeapSnapshotTempFileHelperConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PHeapSnapshotTempFileHelperParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPHeapSnapshotTempFileHelperParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PHeapSnapshotTempFileHelperParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPHeapSnapshotTempFileHelperParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPHeapSnapshotTempFileHelperConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PNeckoConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PNeckoParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPNeckoParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PNeckoParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPNeckoParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPNeckoConstructor(actor)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PPrintingConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PPrintingConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PPrintingParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPPrintingParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PPrintingParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPPrintingParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPPrintingConstructor(actor)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PChildToParentStreamConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PChildToParentStreamConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PChildToParentStreamParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPChildToParentStreamParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PChildToParentStreamParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPChildToParentStreamParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPChildToParentStreamConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PSpeechSynthesisConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PSpeechSynthesisParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPSpeechSynthesisParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PSpeechSynthesisParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPSpeechSynthesisParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPSpeechSynthesisConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PMediaConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PMediaParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPMediaParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PMediaParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPMediaParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPMediaConstructor(actor)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PWebrtcGlobalConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PWebrtcGlobalConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PWebrtcGlobalParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPWebrtcGlobalParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PWebrtcGlobalParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPWebrtcGlobalParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPWebrtcGlobalConstructor(actor)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PPresentationConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PPresentationConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PPresentationParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPPresentationParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PPresentationParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPPresentationParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPPresentationConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateAudioIPCConnection", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;

            int32_t seqno__ = (msg__).seqno();
            WeakPtr<PContentParent> self__ = this;
            CreateAudioIPCConnectionResolver resolver = [this, self__, id__, seqno__](const FileDescriptor& aParam) {
                if ((!(self__))) {
                    NS_WARNING("Not resolving response because actor is dead.");
                    return;
                }
                if ((mLivenessState) == (mozilla::ipc::LivenessState::Dead)) {
                    NS_WARNING("Not resolving response because actor is destroyed.");
                    return;
                }
                bool resolve__ = true;
                FileDescriptor fd;
                fd = std::move(aParam);
                IPC::Message* reply__ = PContent::Reply_CreateAudioIPCConnection(id__);
                WriteIPDLParam(reply__, self__, resolve__);
                // Sentinel = 'resolve__'
                (reply__)->WriteSentinel(3997392463);
                WriteIPDLParam(reply__, self__, fd);
                // Sentinel = 'fd'
                (reply__)->WriteSentinel(628535764);
                (reply__)->set_seqno(seqno__);

                if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                    mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
                }
                bool sendok__ = (GetIPCChannel())->Send(reply__);
                if ((!(sendok__))) {
                    NS_WARNING("Error sending reply");
                }
            };
            if ((!(RecvCreateAudioIPCConnection(std::move(resolver))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierLocalConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PURLClassifierLocalParent* actor;
            URIParams uri;
            nsCString tables;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tables)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'tables'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1212380705)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPURLClassifierLocalParent(uri, tables);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PURLClassifierLocalParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPURLClassifierLocalParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPURLClassifierLocalConstructor(actor, uri, tables)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PLoginReputationConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PLoginReputationConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PLoginReputationParent* actor;
            URIParams formURI;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(formURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'formURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 333511311)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPLoginReputationParent(formURI);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PLoginReputationParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPLoginReputationParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPLoginReputationConstructor(actor, formURI)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_StartVisitedQuery__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StartVisitedQuery", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvStartVisitedQuery(uri)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_VisitURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_VisitURI", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;
            OptionalURIParams referrer;
            uint32_t flags;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(referrer)))))) {
                FatalError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            // Sentinel = 'referrer'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3770987113)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(flags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'flags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2550519284)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvVisitURI(uri, referrer, flags)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetURITitle", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;
            nsString title;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(title)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'title'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4272139303)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSetURITitle(uri, title)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_LoadURIExternal", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;
            PBrowserParent* windowContext;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(windowContext)))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!((*((&(windowContext))))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            // Sentinel = 'windowContext'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3429612728)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvLoadURIExternal(uri, windowContext)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ExtProtocolChannelConnectParent", OTHER);

            PickleIterator iter__(msg__);
            uint32_t registrarId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(registrarId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'registrarId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3202787989)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvExtProtocolChannelConnectParent(registrarId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_ShowAlert__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ShowAlert", OTHER);

            PickleIterator iter__(msg__);
            RefPtr<nsIAlertNotification> alert;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(alert)))))) {
                FatalError("Error deserializing 'RefPtr'");
                return MsgValueError;
            }
            // Sentinel = 'alert'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3087341007)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'RefPtr'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvShowAlert(alert)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CloseAlert__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CloseAlert", OTHER);

            PickleIterator iter__(msg__);
            nsString name;
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(name)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'name'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 15034981)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCloseAlert(name, principal)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DisableNotifications__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DisableNotifications", OTHER);

            PickleIterator iter__(msg__);
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDisableNotifications(principal)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_OpenNotificationSettings__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_OpenNotificationSettings", OTHER);

            PickleIterator iter__(msg__);
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvOpenNotificationSettings(principal)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PPSMContentDownloaderConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PPSMContentDownloaderConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PPSMContentDownloaderParent* actor;
            uint32_t aCertType;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCertType)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aCertType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 919891650)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPPSMContentDownloaderParent(aCertType);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PPSMContentDownloaderParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPPSMContentDownloaderParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPPSMContentDownloaderConstructor(actor, aCertType)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PExternalHelperAppConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PExternalHelperAppParent* actor;
            OptionalURIParams uri;
            nsCString aMimeContentType;
            nsCString aContentDisposition;
            uint32_t aContentDispositionHint;
            nsString aContentDispositionFilename;
            bool aForceSave;
            int64_t aContentLength;
            bool aWasFileChannel;
            OptionalURIParams aReferrer;
            PBrowserParent* aBrowser;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMimeContentType)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aMimeContentType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1001170972)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContentDisposition)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aContentDisposition'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2499070154)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContentDispositionHint)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aContentDispositionHint'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4044281289)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContentDispositionFilename)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aContentDispositionFilename'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3976510585)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aForceSave)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aForceSave'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1729926259)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContentLength)))))) {
                FatalError("Error deserializing 'int64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aContentLength'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 773059686)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aWasFileChannel)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aWasFileChannel'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2398731776)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReferrer)))))) {
                FatalError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            // Sentinel = 'aReferrer'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1461587361)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBrowser)))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            // Sentinel = 'aBrowser'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3086016059)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPExternalHelperAppParent(uri, aMimeContentType, aContentDisposition, aContentDispositionHint, aContentDispositionFilename, aForceSave, aContentLength, aWasFileChannel, aReferrer, aBrowser);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PExternalHelperAppParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPExternalHelperAppParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPExternalHelperAppConstructor(actor, uri, aMimeContentType, aContentDisposition, aContentDispositionHint, aContentDispositionFilename, aForceSave, aContentLength, aWasFileChannel, aReferrer, aBrowser)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PHandlerServiceConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PHandlerServiceParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPHandlerServiceParent();
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PHandlerServiceParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPHandlerServiceParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPHandlerServiceConstructor(actor)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddGeolocationListener", OTHER);

            PickleIterator iter__(msg__);
            Principal principal;
            bool highAccuracy;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(highAccuracy)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'highAccuracy'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 369486639)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAddGeolocationListener(principal, highAccuracy)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveGeolocationListener", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvRemoveGeolocationListener()))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetGeolocationHigherAccuracy", OTHER);

            PickleIterator iter__(msg__);
            bool enable;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(enable)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'enable'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 399314243)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSetGeolocationHigherAccuracy(enable)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ConsoleMessage", OTHER);

            PickleIterator iter__(msg__);
            nsString message;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(message)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'message'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1366108954)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvConsoleMessage(message)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ScriptError", OTHER);

            PickleIterator iter__(msg__);
            nsString message;
            nsString sourceName;
            nsString sourceLine;
            uint32_t lineNumber;
            uint32_t colNumber;
            uint32_t flags;
            nsCString category;
            bool privateWindow;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(message)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'message'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1366108954)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sourceName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'sourceName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 725837832)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sourceLine)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'sourceLine'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2099440551)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(lineNumber)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'lineNumber'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1005376855)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(colNumber)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'colNumber'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1714268980)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(flags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'flags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2550519284)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(category)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'category'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1962932896)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(privateWindow)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'privateWindow'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3677713676)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvScriptError(message, sourceName, sourceLine, lineNumber, colNumber, flags, category, privateWindow)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ScriptErrorWithStack", OTHER);

            PickleIterator iter__(msg__);
            nsString message;
            nsString sourceName;
            nsString sourceLine;
            uint32_t lineNumber;
            uint32_t colNumber;
            uint32_t flags;
            nsCString category;
            bool privateWindow;
            ClonedMessageData stack;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(message)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'message'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1366108954)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sourceName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'sourceName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 725837832)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sourceLine)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'sourceLine'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2099440551)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(lineNumber)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'lineNumber'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1005376855)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(colNumber)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'colNumber'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1714268980)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(flags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'flags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2550519284)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(category)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'category'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1962932896)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(privateWindow)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'privateWindow'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3677713676)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(stack)))))) {
                FatalError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            // Sentinel = 'stack'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2105644509)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvScriptErrorWithStack(message, sourceName, sourceLine, lineNumber, colNumber, flags, category, privateWindow, stack)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetClipboard", OTHER);

            PickleIterator iter__(msg__);
            IPCDataTransfer aDataTransfer;
            bool aIsPrivateData;
            Principal aRequestingPrincipal;
            uint32_t aContentPolicyType;
            int32_t aWhichClipboard;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDataTransfer)))))) {
                FatalError("Error deserializing 'IPCDataTransfer'");
                return MsgValueError;
            }
            // Sentinel = 'aDataTransfer'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 234514541)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCDataTransfer'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsPrivateData)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aIsPrivateData'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1857969960)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRequestingPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aRequestingPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2772545910)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContentPolicyType)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aContentPolicyType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2302108504)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aWhichClipboard)))))) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4216338969)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSetClipboard(aDataTransfer, aIsPrivateData, aRequestingPrincipal, aContentPolicyType, aWhichClipboard)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_EmptyClipboard", OTHER);

            PickleIterator iter__(msg__);
            int32_t aWhichClipboard;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aWhichClipboard)))))) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4216338969)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvEmptyClipboard(aWhichClipboard)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PlaySound__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PlaySound", OTHER);

            PickleIterator iter__(msg__);
            URIParams aURL;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aURL)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'aURL'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2075506328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvPlaySound(aURL)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_Beep__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_Beep", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvBeep()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PlayEventSound__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PlayEventSound", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aEventId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aEventId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aEventId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3092164244)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvPlayEventSound(aEventId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_PrivateDocShellsExist__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PrivateDocShellsExist", OTHER);

            PickleIterator iter__(msg__);
            bool aExist;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aExist)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aExist'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1481080944)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvPrivateDocShellsExist(aExist)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FirstIdle", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvFirstIdle()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DeviceReset__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DeviceReset", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDeviceReset()))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CopyFavicon", OTHER);

            PickleIterator iter__(msg__);
            URIParams oldURI;
            URIParams newURI;
            Principal aLoadingPrincipal;
            bool isPrivate;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(oldURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'oldURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 90428473)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(newURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'newURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1179970086)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aLoadingPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aLoadingPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4178989650)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(isPrivate)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'isPrivate'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4033294520)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCopyFavicon(oldURI, newURI, aLoadingPrincipal, isPrivate)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DeallocateLayerTreeId__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DeallocateLayerTreeId", OTHER);

            PickleIterator iter__(msg__);
            ContentParentId cpId;
            LayersId id;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cpId)))))) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            // Sentinel = 'cpId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(id)))))) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            // Sentinel = 'id'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDeallocateLayerTreeId(cpId, id)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_RecordingDeviceEvents__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RecordingDeviceEvents", OTHER);

            PickleIterator iter__(msg__);
            nsString recordingStatus;
            nsString pageURL;
            bool isAudio;
            bool isVideo;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(recordingStatus)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'recordingStatus'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2504558560)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(pageURL)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'pageURL'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3373102899)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(isAudio)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'isAudio'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3505326961)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(isVideo)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'isVideo'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1688400398)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvRecordingDeviceEvents(recordingStatus, pageURL, isAudio, isVideo)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GraphicsError", OTHER);

            PickleIterator iter__(msg__);
            nsCString aError;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aError)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aError'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3299422495)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvGraphicsError(aError)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddIdleObserver", OTHER);

            PickleIterator iter__(msg__);
            uint64_t observerId;
            uint32_t idleTimeInS;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(observerId)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'observerId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2815026823)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(idleTimeInS)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'idleTimeInS'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2527371272)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAddIdleObserver(observerId, idleTimeInS)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemoveIdleObserver", OTHER);

            PickleIterator iter__(msg__);
            uint64_t observerId;
            uint32_t idleTimeInS;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(observerId)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'observerId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2815026823)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(idleTimeInS)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'idleTimeInS'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2527371272)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvRemoveIdleObserver(observerId, idleTimeInS)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BackUpXResources", OTHER);

            PickleIterator iter__(msg__);
            FileDescriptor aXSocketFd;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aXSocketFd)))))) {
                FatalError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            // Sentinel = 'aXSocketFd'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1448798316)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvBackUpXResources(aXSocketFd)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RequestAnonymousTemporaryFile", OTHER);

            PickleIterator iter__(msg__);
            uint64_t aID;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aID)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvRequestAnonymousTemporaryFile(aID)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UnregisterRemoteFrame__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnregisterRemoteFrame", OTHER);

            PickleIterator iter__(msg__);
            TabId tabId;
            ContentParentId cpId;
            bool aMarkedDestroying;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'tabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cpId)))))) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            // Sentinel = 'cpId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMarkedDestroying)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aMarkedDestroying'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4114437722)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvUnregisterRemoteFrame(tabId, cpId, aMarkedDestroying)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyTabDestroying__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyTabDestroying", OTHER);

            PickleIterator iter__(msg__);
            TabId tabId;
            ContentParentId cpId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'tabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cpId)))))) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            // Sentinel = 'cpId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNotifyTabDestroying(tabId, cpId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_POfflineCacheUpdateConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_POfflineCacheUpdateConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            POfflineCacheUpdateParent* actor;
            URIParams manifestURI;
            URIParams documentURI;
            PrincipalInfo loadingPrincipal;
            bool stickDocument;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(manifestURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'manifestURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3261212628)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(documentURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'documentURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3585823520)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(loadingPrincipal)))))) {
                FatalError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            // Sentinel = 'loadingPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2000304082)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PrincipalInfo'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(stickDocument)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'stickDocument'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2826141294)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPOfflineCacheUpdateParent(manifestURI, documentURI, loadingPrincipal, stickDocument);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor POfflineCacheUpdateParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPOfflineCacheUpdateParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPOfflineCacheUpdateConstructor(actor, manifestURI, documentURI, loadingPrincipal, stickDocument)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_SetOfflinePermission__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SetOfflinePermission", OTHER);

            PickleIterator iter__(msg__);
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSetOfflinePermission(principal)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FinishShutdown", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvFinishShutdown()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_UpdateDropEffect__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateDropEffect", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aDragAction;
            uint32_t aDropEffect;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDragAction)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aDragAction'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2407569738)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDropEffect)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aDropEffect'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4065146166)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvUpdateDropEffect(aDragAction, aDropEffect)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PContentPermissionRequestConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PContentPermissionRequestParent* actor;
            nsTArray<PermissionRequest> aRequests;
            Principal aPrincipal;
            bool aIsHandlingUserInput;
            TabId tabId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRequests)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aRequests'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4267960022)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4097511)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsHandlingUserInput)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aIsHandlingUserInput'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3966872117)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'tabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPContentPermissionRequestParent(aRequests, aPrincipal, aIsHandlingUserInput, tabId);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PContentPermissionRequestParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPContentPermissionRequestParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPContentPermissionRequestConstructor(actor, std::move(aRequests), aPrincipal, aIsHandlingUserInput, tabId)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ShutdownProfile", OTHER);

            PickleIterator iter__(msg__);
            nsCString aProfile;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aProfile)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aProfile'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3994647340)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvShutdownProfile(aProfile)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateWindow", OTHER);

            PickleIterator iter__(msg__);
            PBrowserParent* aThisTab;
            PBrowserParent* aNewTab;
            PRenderFrameParent* aRenderFrame;
            uint32_t aChromeFlags;
            bool aCalledFromJS;
            bool aPositionSpecified;
            bool aSizeSpecified;
            OptionalURIParams aURIToLoad;
            nsCString aFeatures;
            nsCString aBaseURI;
            float aFullZoom;
            Principal aTriggeringPrincipal;
            uint32_t aReferrerPolicy;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aThisTab)))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            // Sentinel = 'aThisTab'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 607760926)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aNewTab)))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!((*((&(aNewTab))))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            // Sentinel = 'aNewTab'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2089222425)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRenderFrame)))))) {
                FatalError("Error deserializing 'PRenderFrameParent'");
                return MsgValueError;
            }
            if ((!((*((&(aRenderFrame))))))) {
                FatalError("Error deserializing 'PRenderFrameParent'");
                return MsgValueError;
            }
            // Sentinel = 'aRenderFrame'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1469288264)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PRenderFrameParent'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aChromeFlags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aChromeFlags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3327922672)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCalledFromJS)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aCalledFromJS'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1499256202)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPositionSpecified)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aPositionSpecified'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2933421868)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSizeSpecified)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aSizeSpecified'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3086178338)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aURIToLoad)))))) {
                FatalError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            // Sentinel = 'aURIToLoad'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4091656936)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFeatures)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aFeatures'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1001034525)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBaseURI)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aBaseURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2848511784)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFullZoom)))))) {
                FatalError("Error deserializing 'float'");
                return MsgValueError;
            }
            // Sentinel = 'aFullZoom'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2072210550)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTriggeringPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aTriggeringPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1219575273)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReferrerPolicy)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aReferrerPolicy'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3193013321)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;

            int32_t seqno__ = (msg__).seqno();
            WeakPtr<PContentParent> self__ = this;
            CreateWindowResolver resolver = [this, self__, id__, seqno__](const CreatedWindowInfo& aParam) {
                if ((!(self__))) {
                    NS_WARNING("Not resolving response because actor is dead.");
                    return;
                }
                if ((mLivenessState) == (mozilla::ipc::LivenessState::Dead)) {
                    NS_WARNING("Not resolving response because actor is destroyed.");
                    return;
                }
                bool resolve__ = true;
                CreatedWindowInfo window;
                window = std::move(aParam);
                IPC::Message* reply__ = PContent::Reply_CreateWindow(id__);
                WriteIPDLParam(reply__, self__, resolve__);
                // Sentinel = 'resolve__'
                (reply__)->WriteSentinel(3997392463);
                WriteIPDLParam(reply__, self__, window);
                // Sentinel = 'window'
                (reply__)->WriteSentinel(3032525362);
                (reply__)->set_seqno(seqno__);

                if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                    mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
                }
                bool sendok__ = (GetIPCChannel())->Send(reply__);
                if ((!(sendok__))) {
                    NS_WARNING("Error sending reply");
                }
            };
            if ((!(RecvCreateWindow(aThisTab, aNewTab, aRenderFrame, aChromeFlags, aCalledFromJS, aPositionSpecified, aSizeSpecified, aURIToLoad, aFeatures, aBaseURI, aFullZoom, aTriggeringPrincipal, aReferrerPolicy, std::move(resolver))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_CreateWindowInDifferentProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateWindowInDifferentProcess", OTHER);

            PickleIterator iter__(msg__);
            PBrowserParent* aThisTab;
            uint32_t aChromeFlags;
            bool aCalledFromJS;
            bool aPositionSpecified;
            bool aSizeSpecified;
            OptionalURIParams aURIToLoad;
            nsCString aFeatures;
            nsCString aBaseURI;
            float aFullZoom;
            nsString aName;
            Principal aTriggeringPrincipal;
            uint32_t aReferrerPolicy;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aThisTab)))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!((*((&(aThisTab))))))) {
                FatalError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            // Sentinel = 'aThisTab'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 607760926)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PBrowserParent'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aChromeFlags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aChromeFlags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3327922672)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCalledFromJS)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aCalledFromJS'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1499256202)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPositionSpecified)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aPositionSpecified'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2933421868)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSizeSpecified)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aSizeSpecified'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3086178338)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aURIToLoad)))))) {
                FatalError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            // Sentinel = 'aURIToLoad'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4091656936)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OptionalURIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFeatures)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aFeatures'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1001034525)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBaseURI)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aBaseURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2848511784)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFullZoom)))))) {
                FatalError("Error deserializing 'float'");
                return MsgValueError;
            }
            // Sentinel = 'aFullZoom'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2072210550)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'float'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1450162941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTriggeringPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aTriggeringPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1219575273)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReferrerPolicy)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aReferrerPolicy'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3193013321)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCreateWindowInDifferentProcess(aThisTab, aChromeFlags, aCalledFromJS, aPositionSpecified, aSizeSpecified, aURIToLoad, aFeatures, aBaseURI, aFullZoom, aName, aTriggeringPrincipal, aReferrerPolicy)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyBenchmarkResult__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyBenchmarkResult", OTHER);

            PickleIterator iter__(msg__);
            nsString aCodecName;
            uint32_t aDecodeFPS;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCodecName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aCodecName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1573682074)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDecodeFPS)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aDecodeFPS'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2083295506)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNotifyBenchmarkResult(aCodecName, aDecodeFPS)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyPushObservers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushObservers", OTHER);

            PickleIterator iter__(msg__);
            nsCString scope;
            Principal principal;
            nsString messageId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(scope)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'scope'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2191984953)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(messageId)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'messageId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2887269495)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNotifyPushObservers(scope, principal, messageId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyPushObserversWithData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushObserversWithData", OTHER);

            PickleIterator iter__(msg__);
            nsCString scope;
            Principal principal;
            nsString messageId;
            nsTArray<uint8_t> data;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(scope)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'scope'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2191984953)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(messageId)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'messageId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2887269495)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(data)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'data'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 843352540)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNotifyPushObserversWithData(scope, principal, messageId, std::move(data))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyPushSubscriptionChangeObservers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionChangeObservers", OTHER);

            PickleIterator iter__(msg__);
            nsCString scope;
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(scope)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'scope'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2191984953)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNotifyPushSubscriptionChangeObservers(scope, principal)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetFilesRequest", OTHER);

            PickleIterator iter__(msg__);
            nsID aID;
            nsString aDirectory;
            bool aRecursiveFlag;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aID)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDirectory)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aDirectory'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 106387836)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aRecursiveFlag)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aRecursiveFlag'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3322465491)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvGetFilesRequest(aID, aDirectory, aRecursiveFlag)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DeleteGetFilesRequest", OTHER);

            PickleIterator iter__(msg__);
            nsID aID;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aID)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDeleteGetFilesRequest(aID)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FileCreationRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FileCreationRequest", OTHER);

            PickleIterator iter__(msg__);
            nsID aID;
            nsString aFullPath;
            nsString aType;
            nsString aName;
            bool lastModifiedPassed;
            int64_t lastModified;
            bool aExistenceCheck;
            bool aIsFromNsIFile;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aID)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFullPath)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aFullPath'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4067018590)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aType)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1819585676)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1450162941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(lastModifiedPassed)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'lastModifiedPassed'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3066214163)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(lastModified)))))) {
                FatalError("Error deserializing 'int64_t'");
                return MsgValueError;
            }
            // Sentinel = 'lastModified'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3456113257)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aExistenceCheck)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aExistenceCheck'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1222718518)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsFromNsIFile)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aIsFromNsIFile'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3315483341)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvFileCreationRequest(aID, aFullPath, aType, aName, lastModifiedPassed, lastModified, aExistenceCheck, aIsFromNsIFile)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StoreAndBroadcastBlobURLRegistration", OTHER);

            PickleIterator iter__(msg__);
            nsCString url;
            IPCBlob blob;
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(url)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'url'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210600)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(blob)))))) {
                FatalError("Error deserializing 'IPCBlob'");
                return MsgValueError;
            }
            // Sentinel = 'blob'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1963585077)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCBlob'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvStoreAndBroadcastBlobURLRegistration(url, blob, principal)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UnstoreAndBroadcastBlobURLUnregistration", OTHER);

            PickleIterator iter__(msg__);
            nsCString url;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(url)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'url'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210600)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvUnstoreAndBroadcastBlobURLUnregistration(url)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildHistograms", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<HistogramAccumulation> accumulations;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(accumulations)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'accumulations'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2180708333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAccumulateChildHistograms(std::move(accumulations))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AccumulateChildKeyedHistograms", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<KeyedHistogramAccumulation> accumulations;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(accumulations)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'accumulations'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2180708333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAccumulateChildKeyedHistograms(std::move(accumulations))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildScalars", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<ScalarAction> updates;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(updates)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'updates'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3737108565)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvUpdateChildScalars(std::move(updates))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UpdateChildKeyedScalars", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<KeyedScalarAction> updates;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(updates)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'updates'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3737108565)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvUpdateChildKeyedScalars(std::move(updates))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RecordChildEvents", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<ChildEventData> events;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(events)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'events'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1921707453)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvRecordChildEvents(std::move(events))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RecordDiscardedData", OTHER);

            PickleIterator iter__(msg__);
            DiscardedData data;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(data)))))) {
                FatalError("Error deserializing 'DiscardedData'");
                return MsgValueError;
            }
            // Sentinel = 'data'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 843352540)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DiscardedData'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvRecordDiscardedData(data)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_A11yHandlerControl__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_A11yHandlerControl", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aPid;
            IHandlerControlHolder aHandlerControl;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPid)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aPid'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4120646000)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aHandlerControl)))))) {
                FatalError("Error deserializing 'IHandlerControlHolder'");
                return MsgValueError;
            }
            // Sentinel = 'aHandlerControl'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3719124325)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IHandlerControlHolder'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvA11yHandlerControl(aPid, aHandlerControl)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddMemoryReport", OTHER);

            PickleIterator iter__(msg__);
            MemoryReport aReport;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReport)))))) {
                FatalError("Error deserializing 'MemoryReport'");
                return MsgValueError;
            }
            // Sentinel = 'aReport'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3792799576)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MemoryReport'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAddMemoryReport(aReport)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FinishMemoryReport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FinishMemoryReport", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aGeneration;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aGeneration)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aGeneration'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2329783584)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvFinishMemoryReport(aGeneration)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_MaybeReloadPlugins__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_MaybeReloadPlugins", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvMaybeReloadPlugins()))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BHRThreadHang", OTHER);

            PickleIterator iter__(msg__);
            HangDetails aHangDetails;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aHangDetails)))))) {
                FatalError("Error deserializing 'HangDetails'");
                return MsgValueError;
            }
            // Sentinel = 'aHangDetails'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2710776857)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'HangDetails'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvBHRThreadHang(aHangDetails)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AddPerformanceMetrics__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AddPerformanceMetrics", OTHER);

            PickleIterator iter__(msg__);
            nsID aID;
            nsTArray<PerformanceInfo> aMetrics;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aID)))))) {
                FatalError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsID'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMetrics)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aMetrics'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4116521140)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAddPerformanceMetrics(aID, std::move(aMetrics))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_FirstPartyStorageAccessGrantedForOrigin__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_FirstPartyStorageAccessGrantedForOrigin", OTHER);

            PickleIterator iter__(msg__);
            Principal aParentPrincipal;
            nsCString aTrackingOrigin;
            nsCString aGrantedOrigin;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aParentPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aParentPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3187350213)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTrackingOrigin)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aTrackingOrigin'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3446324311)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aGrantedOrigin)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aGrantedOrigin'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4223735530)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;

            int32_t seqno__ = (msg__).seqno();
            WeakPtr<PContentParent> self__ = this;
            FirstPartyStorageAccessGrantedForOriginResolver resolver = [this, self__, id__, seqno__](const bool& aParam) {
                if ((!(self__))) {
                    NS_WARNING("Not resolving response because actor is dead.");
                    return;
                }
                if ((mLivenessState) == (mozilla::ipc::LivenessState::Dead)) {
                    NS_WARNING("Not resolving response because actor is destroyed.");
                    return;
                }
                bool resolve__ = true;
                bool unused;
                unused = std::move(aParam);
                IPC::Message* reply__ = PContent::Reply_FirstPartyStorageAccessGrantedForOrigin(id__);
                WriteIPDLParam(reply__, self__, resolve__);
                // Sentinel = 'resolve__'
                (reply__)->WriteSentinel(3997392463);
                WriteIPDLParam(reply__, self__, unused);
                // Sentinel = 'unused'
                (reply__)->WriteSentinel(1885311952);
                (reply__)->set_seqno(seqno__);

                if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                    mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
                }
                bool sendok__ = (GetIPCChannel())->Send(reply__);
                if ((!(sendok__))) {
                    NS_WARNING("Error sending reply");
                }
            };
            if ((!(RecvFirstPartyStorageAccessGrantedForOrigin(aParentPrincipal, aTrackingOrigin, aGrantedOrigin, std::move(resolver))))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_StoreUserInteractionAsPermission", OTHER);

            PickleIterator iter__(msg__);
            Principal aPrincipal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4097511)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvStoreUserInteractionAsPermission(aPrincipal)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_AttachBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AttachBrowsingContext", OTHER);

            PickleIterator iter__(msg__);
            BrowsingContextId aParentContextId;
            BrowsingContextId aContextId;
            nsString aName;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aParentContextId)))))) {
                FatalError("Error deserializing 'BrowsingContextId'");
                return MsgValueError;
            }
            // Sentinel = 'aParentContextId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1041596981)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContextId)))))) {
                FatalError("Error deserializing 'BrowsingContextId'");
                return MsgValueError;
            }
            // Sentinel = 'aContextId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1527674007)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1450162941)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAttachBrowsingContext(aParentContextId, aContextId, aName)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_DetachBrowsingContext__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_DetachBrowsingContext", OTHER);

            PickleIterator iter__(msg__);
            BrowsingContextId aContextId;
            bool aMoveToBFCache;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContextId)))))) {
                FatalError("Error deserializing 'BrowsingContextId'");
                return MsgValueError;
            }
            // Sentinel = 'aContextId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1527674007)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BrowsingContextId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMoveToBFCache)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aMoveToBFCache'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3958563075)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDetachBrowsingContext(aContextId, aMoveToBFCache)))) {
                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("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AsyncMessage", OTHER);

            PickleIterator iter__(msg__);
            nsString aMessage;
            nsTArray<CpowEntry> aCpows;
            Principal aPrincipal;
            ClonedMessageData aData;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMessage)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aMessage'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3453110902)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCpows)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aCpows'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2178221451)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4097511)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aData)))))) {
                FatalError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            // Sentinel = 'aData'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3285075324)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvAsyncMessage(aMessage, std::move(aCpows), aPrincipal, aData)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PContent::Msg_NotifyPushSubscriptionModifiedObservers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyPushSubscriptionModifiedObservers", OTHER);

            PickleIterator iter__(msg__);
            nsCString scope;
            Principal principal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(scope)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'scope'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2191984953)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvNotifyPushSubscriptionModifiedObservers(scope, principal)))) {
                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__,
        Message*& reply__) -> PContentParent::Result
{
    int32_t route__ = (msg__).routing_id();
    if ((MSG_ROUTING_CONTROL) != (route__)) {
        IProtocol* routed__ = Lookup(route__);
        if ((!(routed__))) {
            return MsgRouteError;
        }
        return (routed__)->OnMessageReceived(msg__, reply__);
    }

    switch ((msg__).type()) {
    case PContent::Msg_CreateChildProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_CreateChildProcess", OTHER);

            PickleIterator iter__(msg__);
            IPCTabContext context;
            ProcessPriority priority;
            TabId openerTabId;
            TabId tabId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(context)))))) {
                FatalError("Error deserializing 'IPCTabContext'");
                return MsgValueError;
            }
            // Sentinel = 'context'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3514529014)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IPCTabContext'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(priority)))))) {
                FatalError("Error deserializing 'ProcessPriority'");
                return MsgValueError;
            }
            // Sentinel = 'priority'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 558136112)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ProcessPriority'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(openerTabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'openerTabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 817688674)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'tabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            ContentParentId cpId;
            bool isForBrowser;
            if ((!(RecvCreateChildProcess(context, priority, openerTabId, tabId, (&(cpId)), (&(isForBrowser)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_CreateChildProcess(id__);

            WriteIPDLParam(reply__, this, cpId);
            // Sentinel = 'cpId'
            (reply__)->WriteSentinel(2452595622);
            WriteIPDLParam(reply__, this, isForBrowser);
            // Sentinel = 'isForBrowser'
            (reply__)->WriteSentinel(2051565587);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_BridgeToChildProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BridgeToChildProcess", OTHER);

            PickleIterator iter__(msg__);
            ContentParentId cpId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cpId)))))) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            // Sentinel = 'cpId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            Endpoint<mozilla::dom::PContentBridgeParent> endpoint;
            if ((!(RecvBridgeToChildProcess(cpId, (&(endpoint)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_BridgeToChildProcess(id__);

            WriteIPDLParam(reply__, this, endpoint);
            // Sentinel = 'endpoint'
            (reply__)->WriteSentinel(3610972515);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_OpenRecordReplayChannel__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_OpenRecordReplayChannel", OTHER);

            PickleIterator iter__(msg__);
            uint32_t channelId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(channelId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'channelId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 6854027)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            FileDescriptor connection;
            if ((!(RecvOpenRecordReplayChannel(channelId, (&(connection)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_OpenRecordReplayChannel(id__);

            WriteIPDLParam(reply__, this, connection);
            // Sentinel = 'connection'
            (reply__)->WriteSentinel(3784185074);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_LoadPlugin__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_LoadPlugin", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aPluginId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPluginId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aPluginId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4181313310)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsresult aResult;
            uint32_t aRunID;
            Endpoint<mozilla::plugins::PPluginModuleParent> aEndpoint;
            if ((!(RecvLoadPlugin(aPluginId, (&(aResult)), (&(aRunID)), (&(aEndpoint)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_LoadPlugin(id__);

            WriteIPDLParam(reply__, this, aResult);
            // Sentinel = 'aResult'
            (reply__)->WriteSentinel(3888726089);
            WriteIPDLParam(reply__, this, aRunID);
            // Sentinel = 'aRunID'
            (reply__)->WriteSentinel(2758209365);
            WriteIPDLParam(reply__, this, aEndpoint);
            // Sentinel = 'aEndpoint'
            (reply__)->WriteSentinel(2457438235);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_ConnectPluginBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ConnectPluginBridge", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aPluginId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPluginId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aPluginId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4181313310)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsresult rv;
            Endpoint<mozilla::plugins::PPluginModuleParent> aEndpoint;
            if ((!(RecvConnectPluginBridge(aPluginId, (&(rv)), (&(aEndpoint)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_ConnectPluginBridge(id__);

            WriteIPDLParam(reply__, this, rv);
            // Sentinel = 'rv'
            (reply__)->WriteSentinel(702481058);
            WriteIPDLParam(reply__, this, aEndpoint);
            // Sentinel = 'aEndpoint'
            (reply__)->WriteSentinel(2457438235);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_IsSecureURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_IsSecureURI", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aType;
            URIParams aURI;
            uint32_t aFlags;
            OriginAttributes aOriginAttributes;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aType)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1819585676)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aURI)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'aURI'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2075506333)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFlags)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aFlags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3595665704)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aOriginAttributes)))))) {
                FatalError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            // Sentinel = 'aOriginAttributes'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2175998517)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'OriginAttributes'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            bool isSecureURI;
            if ((!(RecvIsSecureURI(aType, aURI, aFlags, aOriginAttributes, (&(isSecureURI)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_IsSecureURI(id__);

            WriteIPDLParam(reply__, this, isSecureURI);
            // Sentinel = 'isSecureURI'
            (reply__)->WriteSentinel(672781896);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_PURLClassifierConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_PURLClassifierConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PURLClassifierParent* actor;
            Principal principal;
            bool useTrackingProtection;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(handle__)))))) {
                FatalError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(useTrackingProtection)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'useTrackingProtection'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3366740154)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            bool success;
            actor = AllocPURLClassifierParent(principal, useTrackingProtection, (&(success)));
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PURLClassifierParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPURLClassifierParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            int32_t id__ = MSG_ROUTING_CONTROL;
            if ((!(RecvPURLClassifierConstructor(actor, principal, useTrackingProtection, (&(success)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }
            reply__ = PContent::Reply_PURLClassifierConstructor(id__);

            WriteIPDLParam(reply__, this, success);
            // Sentinel = 'success'
            (reply__)->WriteSentinel(3877396070);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }

            return MsgProcessed;
        }
    case PContent::Msg_ClassifyLocal__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClassifyLocal", OTHER);

            PickleIterator iter__(msg__);
            URIParams uri;
            nsCString tables;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(uri)))))) {
                FatalError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            // Sentinel = 'uri'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1453210605)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'URIParams'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tables)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'tables'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1212380705)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsresult rv;
            nsTArray<nsCString> results;
            if ((!(RecvClassifyLocal(uri, tables, (&(rv)), (&(results)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_ClassifyLocal(id__);

            WriteIPDLParam(reply__, this, rv);
            // Sentinel = 'rv'
            (reply__)->WriteSentinel(702481058);
            WriteIPDLParam(reply__, this, results);
            // Sentinel = 'results'
            (reply__)->WriteSentinel(1173657613);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetGfxVars__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetGfxVars", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<GfxVarUpdate> vars;
            if ((!(RecvGetGfxVars((&(vars)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetGfxVars(id__);

            WriteIPDLParam(reply__, this, vars);
            // Sentinel = 'vars'
            (reply__)->WriteSentinel(2632090118);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_ReadFontList__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ReadFontList", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<FontListEntry> retValue;
            if ((!(RecvReadFontList((&(retValue)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_ReadFontList(id__);

            WriteIPDLParam(reply__, this, retValue);
            // Sentinel = 'retValue'
            (reply__)->WriteSentinel(3328961628);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_SyncMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_SyncMessage", OTHER);

            PickleIterator iter__(msg__);
            nsString aMessage;
            ClonedMessageData aData;
            nsTArray<CpowEntry> aCpows;
            Principal aPrincipal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMessage)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aMessage'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3453110902)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aData)))))) {
                FatalError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            // Sentinel = 'aData'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3285075324)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCpows)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aCpows'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2178221451)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4097511)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<StructuredCloneData> retval;
            if ((!(RecvSyncMessage(aMessage, aData, std::move(aCpows), aPrincipal, (&(retval)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_SyncMessage(id__);

            WriteIPDLParam(reply__, this, retval);
            // Sentinel = 'retval'
            (reply__)->WriteSentinel(3130628604);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_RpcMessage__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RpcMessage", OTHER);

            PickleIterator iter__(msg__);
            nsString aMessage;
            ClonedMessageData aData;
            nsTArray<CpowEntry> aCpows;
            Principal aPrincipal;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aMessage)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'aMessage'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3453110902)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aData)))))) {
                FatalError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            // Sentinel = 'aData'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3285075324)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ClonedMessageData'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aCpows)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aCpows'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2178221451)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPrincipal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'aPrincipal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4097511)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<StructuredCloneData> retval;
            if ((!(RecvRpcMessage(aMessage, aData, std::move(aCpows), aPrincipal, (&(retval)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_RpcMessage(id__);

            WriteIPDLParam(reply__, this, retval);
            // Sentinel = 'retval'
            (reply__)->WriteSentinel(3130628604);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetClipboard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetClipboard", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<nsCString> aTypes;
            int32_t aWhichClipboard;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTypes)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aTypes'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2467002798)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aWhichClipboard)))))) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4216338969)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            IPCDataTransfer dataTransfer;
            if ((!(RecvGetClipboard(std::move(aTypes), aWhichClipboard, (&(dataTransfer)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetClipboard(id__);

            WriteIPDLParam(reply__, this, dataTransfer);
            // Sentinel = 'dataTransfer'
            (reply__)->WriteSentinel(2250342981);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetExternalClipboardFormats__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetExternalClipboardFormats", OTHER);

            PickleIterator iter__(msg__);
            int32_t aWhichClipboard;
            bool aPlainTextOnly;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aWhichClipboard)))))) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4216338969)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPlainTextOnly)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aPlainTextOnly'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4270627318)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<nsCString> aTypes;
            if ((!(RecvGetExternalClipboardFormats(aWhichClipboard, aPlainTextOnly, (&(aTypes)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetExternalClipboardFormats(id__);

            WriteIPDLParam(reply__, this, aTypes);
            // Sentinel = 'aTypes'
            (reply__)->WriteSentinel(2467002798);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_ClipboardHasType__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_ClipboardHasType", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<nsCString> aTypes;
            int32_t aWhichClipboard;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTypes)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aTypes'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2467002798)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aWhichClipboard)))))) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aWhichClipboard'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4216338969)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            bool hasType;
            if ((!(RecvClipboardHasType(std::move(aTypes), aWhichClipboard, (&(hasType)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_ClipboardHasType(id__);

            WriteIPDLParam(reply__, this, hasType);
            // Sentinel = 'hasType'
            (reply__)->WriteSentinel(2839560423);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetSystemColors__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetSystemColors", OTHER);

            PickleIterator iter__(msg__);
            uint32_t colorsCount;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(colorsCount)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'colorsCount'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 767523530)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<uint32_t> colors;
            if ((!(RecvGetSystemColors(colorsCount, (&(colors)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetSystemColors(id__);

            WriteIPDLParam(reply__, this, colors);
            // Sentinel = 'colors'
            (reply__)->WriteSentinel(2508874770);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetIconForExtension__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetIconForExtension", OTHER);

            PickleIterator iter__(msg__);
            nsCString aFileExt;
            uint32_t aIconSize;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aFileExt)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aFileExt'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 931144044)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIconSize)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aIconSize'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3889311776)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsTArray<uint8_t> bits;
            if ((!(RecvGetIconForExtension(aFileExt, aIconSize, (&(bits)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetIconForExtension(id__);

            WriteIPDLParam(reply__, this, bits);
            // Sentinel = 'bits'
            (reply__)->WriteSentinel(2740652860);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetShowPasswordSetting__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetShowPasswordSetting", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            bool showPassword;
            if ((!(RecvGetShowPasswordSetting((&(showPassword)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetShowPasswordSetting(id__);

            WriteIPDLParam(reply__, this, showPassword);
            // Sentinel = 'showPassword'
            (reply__)->WriteSentinel(2677726048);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_KeywordToURI__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_KeywordToURI", OTHER);

            PickleIterator iter__(msg__);
            nsCString keyword;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(keyword)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'keyword'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1802027878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsString providerName;
            RefPtr<nsIInputStream> postData;
            OptionalURIParams uri;
            if ((!(RecvKeywordToURI(keyword, (&(providerName)), (&(postData)), (&(uri)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_KeywordToURI(id__);

            WriteIPDLParam(reply__, this, providerName);
            // Sentinel = 'providerName'
            (reply__)->WriteSentinel(876606310);
            WriteIPDLParam(reply__, this, postData);
            // Sentinel = 'postData'
            (reply__)->WriteSentinel(1373212390);
            WriteIPDLParam(reply__, this, uri);
            // Sentinel = 'uri'
            (reply__)->WriteSentinel(1453210605);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_NotifyKeywordSearchLoading__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_NotifyKeywordSearchLoading", OTHER);

            PickleIterator iter__(msg__);
            nsString providerName;
            nsString keyword;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(providerName)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'providerName'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 876606310)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(keyword)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'keyword'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1802027878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            if ((!(RecvNotifyKeywordSearchLoading(providerName, keyword)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_NotifyKeywordSearchLoading(id__);


            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_AllocateLayerTreeId__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_AllocateLayerTreeId", OTHER);

            PickleIterator iter__(msg__);
            ContentParentId cpId;
            TabId tabId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(cpId)))))) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            // Sentinel = 'cpId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2452595622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(tabId)))))) {
                FatalError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            // Sentinel = 'tabId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3419081923)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TabId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            LayersId id;
            if ((!(RecvAllocateLayerTreeId(cpId, tabId, (&(id)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_AllocateLayerTreeId(id__);

            WriteIPDLParam(reply__, this, id);
            // Sentinel = 'id'
            (reply__)->WriteSentinel(2794505629);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_BeginDriverCrashGuard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_BeginDriverCrashGuard", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aGuardType;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aGuardType)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aGuardType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2013376914)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            bool crashDetected;
            if ((!(RecvBeginDriverCrashGuard(aGuardType, (&(crashDetected)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_BeginDriverCrashGuard(id__);

            WriteIPDLParam(reply__, this, crashDetected);
            // Sentinel = 'crashDetected'
            (reply__)->WriteSentinel(1759895034);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_EndDriverCrashGuard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_EndDriverCrashGuard", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aGuardType;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aGuardType)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aGuardType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2013376914)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            if ((!(RecvEndDriverCrashGuard(aGuardType)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_EndDriverCrashGuard(id__);


            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_KeygenProcessValue__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_KeygenProcessValue", OTHER);

            PickleIterator iter__(msg__);
            nsString oldValue;
            nsString challenge;
            nsString keytype;
            nsString keyparams;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(oldValue)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'oldValue'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2227149046)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(challenge)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'challenge'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3710327146)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(keytype)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'keytype'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 391822858)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(keyparams)))))) {
                FatalError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            // Sentinel = 'keyparams'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 591068598)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsString newValue;
            if ((!(RecvKeygenProcessValue(oldValue, challenge, keytype, keyparams, (&(newValue)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_KeygenProcessValue(id__);

            WriteIPDLParam(reply__, this, newValue);
            // Sentinel = 'newValue'
            (reply__)->WriteSentinel(1405873629);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_KeygenProvideContent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_KeygenProvideContent", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsString aAttribute;
            nsTArray<nsString> aContent;
            if ((!(RecvKeygenProvideContent((&(aAttribute)), (&(aContent)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_KeygenProvideContent(id__);

            WriteIPDLParam(reply__, this, aAttribute);
            // Sentinel = 'aAttribute'
            (reply__)->WriteSentinel(4137811577);
            WriteIPDLParam(reply__, this, aContent);
            // Sentinel = 'aContent'
            (reply__)->WriteSentinel(2066258676);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetGraphicsDeviceInitData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetGraphicsDeviceInitData", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            ContentDeviceData aData;
            if ((!(RecvGetGraphicsDeviceInitData((&(aData)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetGraphicsDeviceInitData(id__);

            WriteIPDLParam(reply__, this, aData);
            // Sentinel = 'aData'
            (reply__)->WriteSentinel(3285075324);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetAndroidSystemInfo__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetAndroidSystemInfo", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            AndroidSystemInfo info;
            if ((!(RecvGetAndroidSystemInfo((&(info)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetAndroidSystemInfo(id__);

            WriteIPDLParam(reply__, this, info);
            // Sentinel = 'info'
            (reply__)->WriteSentinel(3750868832);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_UngrabPointer__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_UngrabPointer", OTHER);

            PickleIterator iter__(msg__);
            uint32_t time;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(time)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'time'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4231890935)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            if ((!(RecvUngrabPointer(time)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_UngrabPointer(id__);


            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_RemovePermission__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_RemovePermission", OTHER);

            PickleIterator iter__(msg__);
            Principal principal;
            nsCString permissionType;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(principal)))))) {
                FatalError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            // Sentinel = 'principal'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 732240927)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Principal'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(permissionType)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'permissionType'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3770618267)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            nsresult rv;
            if ((!(RecvRemovePermission(principal, permissionType, (&(rv)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_RemovePermission(id__);

            WriteIPDLParam(reply__, this, rv);
            // Sentinel = 'rv'
            (reply__)->WriteSentinel(702481058);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PContent::Msg_GetA11yContentId__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PContent::Msg_GetA11yContentId", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = MSG_ROUTING_CONTROL;
            uint32_t aContentId;
            if ((!(RecvGetA11yContentId((&(aContentId)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PContent::Reply_GetA11yContentId(id__);

            WriteIPDLParam(reply__, this, aContentId);
            // Sentinel = 'aContentId'
            (reply__)->WriteSentinel(2021670937);

            if (mozilla::ipc::LoggingEnabledFor("PContentParent")) {
                mozilla::ipc::LogMessageForProtocol("PContentParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

auto PContentParent::OnCallReceived(
        const Message& msg__,
        Message*& reply__) -> PContentParent::Result
{
    MOZ_ASSERT_UNREACHABLE("message protocol not supported");
    return MsgNotKnown;
}

auto PContentParent::GetProtocolTypeId() -> int32_t
{
    return PContentMsgStart;
}

auto PContentParent::OnChannelClose() -> void
{
    DestroySubtree(NormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPContentParent();
}

auto PContentParent::OnChannelError() -> void
{
    DestroySubtree(AbnormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPContentParent();
}

auto PContentParent::DestroySubtree(ActorDestroyReason why) -> void
{
    ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);

    {
        // Recursively shutting down PBrowser kids
        nsTArray<PBrowserParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPBrowserParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPBrowserParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PClientOpenWindowOp kids
        nsTArray<PClientOpenWindowOpParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPClientOpenWindowOpParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPClientOpenWindowOpParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PContentPermissionRequest kids
        nsTArray<PContentPermissionRequestParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPContentPermissionRequestParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPContentPermissionRequestParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCycleCollectWithLogs kids
        nsTArray<PCycleCollectWithLogsParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCycleCollectWithLogsParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCycleCollectWithLogsParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PPSMContentDownloader kids
        nsTArray<PPSMContentDownloaderParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPPSMContentDownloaderParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPPSMContentDownloaderParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PExternalHelperApp kids
        nsTArray<PExternalHelperAppParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPExternalHelperAppParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPExternalHelperAppParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PFileDescriptorSet kids
        nsTArray<PFileDescriptorSetParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPFileDescriptorSetParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPFileDescriptorSetParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PHal kids
        nsTArray<PHalParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPHalParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPHalParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PHandlerService kids
        nsTArray<PHandlerServiceParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPHandlerServiceParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPHandlerServiceParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PHeapSnapshotTempFileHelper kids
        nsTArray<PHeapSnapshotTempFileHelperParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPHeapSnapshotTempFileHelperParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPHeapSnapshotTempFileHelperParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PIPCBlobInputStream kids
        nsTArray<PIPCBlobInputStreamParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPIPCBlobInputStreamParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPIPCBlobInputStreamParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PMedia kids
        nsTArray<PMediaParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPMediaParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPMediaParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PNecko kids
        nsTArray<PNeckoParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPNeckoParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPNeckoParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down POfflineCacheUpdate kids
        nsTArray<POfflineCacheUpdateParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPOfflineCacheUpdateParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPOfflineCacheUpdateParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PPrinting kids
        nsTArray<PPrintingParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPPrintingParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPPrintingParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PChildToParentStream kids
        nsTArray<PChildToParentStreamParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPChildToParentStreamParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPChildToParentStreamParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PParentToChildStream kids
        nsTArray<PParentToChildStreamParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPParentToChildStreamParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPParentToChildStreamParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PSpeechSynthesis kids
        nsTArray<PSpeechSynthesisParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPSpeechSynthesisParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPSpeechSynthesisParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTestShell kids
        nsTArray<PTestShellParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTestShellParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTestShellParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PJavaScript kids
        nsTArray<PJavaScriptParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPJavaScriptParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPJavaScriptParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PRemoteSpellcheckEngine kids
        nsTArray<PRemoteSpellcheckEngineParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPRemoteSpellcheckEngineParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPRemoteSpellcheckEngineParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebBrowserPersistDocument kids
        nsTArray<PWebBrowserPersistDocumentParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebBrowserPersistDocumentParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebBrowserPersistDocumentParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebrtcGlobal kids
        nsTArray<PWebrtcGlobalParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebrtcGlobalParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebrtcGlobalParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PPresentation kids
        nsTArray<PPresentationParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPPresentationParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPPresentationParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PURLClassifier kids
        nsTArray<PURLClassifierParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPURLClassifierParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPURLClassifierParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PURLClassifierLocal kids
        nsTArray<PURLClassifierLocalParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPURLClassifierLocalParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPURLClassifierLocalParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PScriptCache kids
        nsTArray<PScriptCacheParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPScriptCacheParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPScriptCacheParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PLoginReputation kids
        nsTArray<PLoginReputationParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPLoginReputationParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPLoginReputationParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

    // Reject owning pending responses.
    (GetIPCChannel())->RejectPendingResponsesForActor(this);

    // Finally, destroy "us".
    ActorDestroy(why);
}

auto PContentParent::DeallocSubtree() -> void
{
    {
        // Recursively deleting PBrowser kids
        for (auto iter = (mManagedPBrowserParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPBrowserParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPBrowserParent(((iter).Get())->GetKey());
        }
        (mManagedPBrowserParent).Clear();
    }
    {
        // Recursively deleting PClientOpenWindowOp kids
        for (auto iter = (mManagedPClientOpenWindowOpParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPClientOpenWindowOpParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPClientOpenWindowOpParent(((iter).Get())->GetKey());
        }
        (mManagedPClientOpenWindowOpParent).Clear();
    }
    {
        // Recursively deleting PContentPermissionRequest kids
        for (auto iter = (mManagedPContentPermissionRequestParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPContentPermissionRequestParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPContentPermissionRequestParent(((iter).Get())->GetKey());
        }
        (mManagedPContentPermissionRequestParent).Clear();
    }
    {
        // Recursively deleting PCycleCollectWithLogs kids
        for (auto iter = (mManagedPCycleCollectWithLogsParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCycleCollectWithLogsParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCycleCollectWithLogsParent(((iter).Get())->GetKey());
        }
        (mManagedPCycleCollectWithLogsParent).Clear();
    }
    {
        // Recursively deleting PPSMContentDownloader kids
        for (auto iter = (mManagedPPSMContentDownloaderParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPPSMContentDownloaderParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPPSMContentDownloaderParent(((iter).Get())->GetKey());
        }
        (mManagedPPSMContentDownloaderParent).Clear();
    }
    {
        // Recursively deleting PExternalHelperApp kids
        for (auto iter = (mManagedPExternalHelperAppParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPExternalHelperAppParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPExternalHelperAppParent(((iter).Get())->GetKey());
        }
        (mManagedPExternalHelperAppParent).Clear();
    }
    {
        // Recursively deleting PFileDescriptorSet kids
        for (auto iter = (mManagedPFileDescriptorSetParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPFileDescriptorSetParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPFileDescriptorSetParent(((iter).Get())->GetKey());
        }
        (mManagedPFileDescriptorSetParent).Clear();
    }
    {
        // Recursively deleting PHal kids
        for (auto iter = (mManagedPHalParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPHalParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPHalParent(((iter).Get())->GetKey());
        }
        (mManagedPHalParent).Clear();
    }
    {
        // Recursively deleting PHandlerService kids
        for (auto iter = (mManagedPHandlerServiceParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPHandlerServiceParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPHandlerServiceParent(((iter).Get())->GetKey());
        }
        (mManagedPHandlerServiceParent).Clear();
    }
    {
        // Recursively deleting PHeapSnapshotTempFileHelper kids
        for (auto iter = (mManagedPHeapSnapshotTempFileHelperParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPHeapSnapshotTempFileHelperParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPHeapSnapshotTempFileHelperParent(((iter).Get())->GetKey());
        }
        (mManagedPHeapSnapshotTempFileHelperParent).Clear();
    }
    {
        // Recursively deleting PIPCBlobInputStream kids
        for (auto iter = (mManagedPIPCBlobInputStreamParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPIPCBlobInputStreamParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPIPCBlobInputStreamParent(((iter).Get())->GetKey());
        }
        (mManagedPIPCBlobInputStreamParent).Clear();
    }
    {
        // Recursively deleting PMedia kids
        for (auto iter = (mManagedPMediaParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPMediaParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPMediaParent(((iter).Get())->GetKey());
        }
        (mManagedPMediaParent).Clear();
    }
    {
        // Recursively deleting PNecko kids
        for (auto iter = (mManagedPNeckoParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPNeckoParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPNeckoParent(((iter).Get())->GetKey());
        }
        (mManagedPNeckoParent).Clear();
    }
    {
        // Recursively deleting POfflineCacheUpdate kids
        for (auto iter = (mManagedPOfflineCacheUpdateParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPOfflineCacheUpdateParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPOfflineCacheUpdateParent(((iter).Get())->GetKey());
        }
        (mManagedPOfflineCacheUpdateParent).Clear();
    }
    {
        // Recursively deleting PPrinting kids
        for (auto iter = (mManagedPPrintingParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPPrintingParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPPrintingParent(((iter).Get())->GetKey());
        }
        (mManagedPPrintingParent).Clear();
    }
    {
        // Recursively deleting PChildToParentStream kids
        for (auto iter = (mManagedPChildToParentStreamParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPChildToParentStreamParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPChildToParentStreamParent(((iter).Get())->GetKey());
        }
        (mManagedPChildToParentStreamParent).Clear();
    }
    {
        // Recursively deleting PParentToChildStream kids
        for (auto iter = (mManagedPParentToChildStreamParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPParentToChildStreamParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPParentToChildStreamParent(((iter).Get())->GetKey());
        }
        (mManagedPParentToChildStreamParent).Clear();
    }
    {
        // Recursively deleting PSpeechSynthesis kids
        for (auto iter = (mManagedPSpeechSynthesisParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPSpeechSynthesisParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPSpeechSynthesisParent(((iter).Get())->GetKey());
        }
        (mManagedPSpeechSynthesisParent).Clear();
    }
    {
        // Recursively deleting PTestShell kids
        for (auto iter = (mManagedPTestShellParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPTestShellParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPTestShellParent(((iter).Get())->GetKey());
        }
        (mManagedPTestShellParent).Clear();
    }
    {
        // Recursively deleting PJavaScript kids
        for (auto iter = (mManagedPJavaScriptParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPJavaScriptParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPJavaScriptParent(((iter).Get())->GetKey());
        }
        (mManagedPJavaScriptParent).Clear();
    }
    {
        // Recursively deleting PRemoteSpellcheckEngine kids
        for (auto iter = (mManagedPRemoteSpellcheckEngineParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPRemoteSpellcheckEngineParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPRemoteSpellcheckEngineParent(((iter).Get())->GetKey());
        }
        (mManagedPRemoteSpellcheckEngineParent).Clear();
    }
    {
        // Recursively deleting PWebBrowserPersistDocument kids
        for (auto iter = (mManagedPWebBrowserPersistDocumentParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWebBrowserPersistDocumentParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWebBrowserPersistDocumentParent(((iter).Get())->GetKey());
        }
        (mManagedPWebBrowserPersistDocumentParent).Clear();
    }
    {
        // Recursively deleting PWebrtcGlobal kids
        for (auto iter = (mManagedPWebrtcGlobalParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWebrtcGlobalParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWebrtcGlobalParent(((iter).Get())->GetKey());
        }
        (mManagedPWebrtcGlobalParent).Clear();
    }
    {
        // Recursively deleting PPresentation kids
        for (auto iter = (mManagedPPresentationParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPPresentationParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPPresentationParent(((iter).Get())->GetKey());
        }
        (mManagedPPresentationParent).Clear();
    }
    {
        // Recursively deleting PURLClassifier kids
        for (auto iter = (mManagedPURLClassifierParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPURLClassifierParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPURLClassifierParent(((iter).Get())->GetKey());
        }
        (mManagedPURLClassifierParent).Clear();
    }
    {
        // Recursively deleting PURLClassifierLocal kids
        for (auto iter = (mManagedPURLClassifierLocalParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPURLClassifierLocalParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPURLClassifierLocalParent(((iter).Get())->GetKey());
        }
        (mManagedPURLClassifierLocalParent).Clear();
    }
    {
        // Recursively deleting PScriptCache kids
        for (auto iter = (mManagedPScriptCacheParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPScriptCacheParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPScriptCacheParent(((iter).Get())->GetKey());
        }
        (mManagedPScriptCacheParent).Clear();
    }
    {
        // Recursively deleting PLoginReputation kids
        for (auto iter = (mManagedPLoginReputationParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPLoginReputationParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPLoginReputationParent(((iter).Get())->GetKey());
        }
        (mManagedPLoginReputationParent).Clear();
    }
}

auto PContentParent::DeallocPContentParent() -> void
{
}



} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::PContentParent>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    int32_t id;
    if ((!(aVar))) {
        id = 0;
    }
    else {
        id = (aVar)->Id();
        if ((1) == (id)) {
            (aActor)->FatalError("actor has been |delete|d");
        }
    }
    WriteIPDLParam(aMsg, aActor, id);
}

auto IPDLParamTraits<mozilla::dom::PContentParent>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PContent", PContentMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(aVar)) = static_cast<mozilla::dom::PContentParent*>((actor).value());
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53