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

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


#include "mozilla/layers/PCompositorBridgeParent.h"
#include "FrameMetrics.h"
#include "ipc/IPCMessageUtils.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/FrameUniformityData.h"
#include "mozilla/layers/LayersTypes.h"

#include "mozilla/layers/PAPZParent.h"
#include "mozilla/layers/PAPZCTreeManagerParent.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/layers/PCompositorManagerParent.h"
#include "mozilla/widget/PCompositorWidgetParent.h"
#include "mozilla/layers/PLayerTransactionParent.h"
#include "mozilla/layers/PTextureParent.h"
#include "mozilla/layers/PWebRenderBridgeParent.h"

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

namespace mozilla {
namespace layers {


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

auto PCompositorBridgeParent::RecvPCompositorWidgetConstructor(
        PCompositorWidgetParent* actor,
        const CompositorWidgetInitData& aInitData) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PCompositorBridgeParent::RecvPAPZConstructor(
        PAPZParent* actor,
        const LayersId& layersId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PCompositorBridgeParent::RecvPAPZCTreeManagerConstructor(
        PAPZCTreeManagerParent* actor,
        const LayersId& layersId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PCompositorBridgeParent::RecvPLayerTransactionConstructor(
        PLayerTransactionParent* actor,
        nsTArray<LayersBackend>&& layersBackendHints,
        const LayersId& id) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PCompositorBridgeParent::RecvPTextureConstructor(
        PTextureParent* actor,
        const SurfaceDescriptor& aSharedData,
        const ReadLockDescriptor& aReadLock,
        const LayersBackend& aBackend,
        const TextureFlags& aTextureFlags,
        const LayersId& id,
        const uint64_t& aSerial,
        const MaybeExternalImageId& aExternalImageId) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PCompositorBridgeParent::RecvPWebRenderBridgeConstructor(
        PWebRenderBridgeParent* actor,
        const PipelineId& pipelineId,
        const LayoutDeviceIntSize& aSize,
        TextureFactoryIdentifier* textureFactoryIdentifier,
        IdNamespace* idNamespace) -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

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

MOZ_IMPLICIT PCompositorBridgeParent::PCompositorBridgeParent() :
    mozilla::ipc::IProtocol(mozilla::ipc::ParentSide),
    mLivenessState(mozilla::ipc::LivenessState::Dead)
{
    MOZ_COUNT_CTOR(PCompositorBridgeParent);
}

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

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

auto PCompositorBridgeParent::ManagedPAPZParent(nsTArray<PAPZParent*>& aArr) const -> void
{
    (mManagedPAPZParent).ToArray(aArr);
}

auto PCompositorBridgeParent::ManagedPAPZParent() const -> const ManagedContainer<PAPZParent>&
{
    return mManagedPAPZParent;
}

auto PCompositorBridgeParent::ManagedPAPZCTreeManagerParent(nsTArray<PAPZCTreeManagerParent*>& aArr) const -> void
{
    (mManagedPAPZCTreeManagerParent).ToArray(aArr);
}

auto PCompositorBridgeParent::ManagedPAPZCTreeManagerParent() const -> const ManagedContainer<PAPZCTreeManagerParent>&
{
    return mManagedPAPZCTreeManagerParent;
}

auto PCompositorBridgeParent::ManagedPLayerTransactionParent(nsTArray<PLayerTransactionParent*>& aArr) const -> void
{
    (mManagedPLayerTransactionParent).ToArray(aArr);
}

auto PCompositorBridgeParent::ManagedPLayerTransactionParent() const -> const ManagedContainer<PLayerTransactionParent>&
{
    return mManagedPLayerTransactionParent;
}

auto PCompositorBridgeParent::ManagedPTextureParent(nsTArray<PTextureParent*>& aArr) const -> void
{
    (mManagedPTextureParent).ToArray(aArr);
}

auto PCompositorBridgeParent::ManagedPTextureParent() const -> const ManagedContainer<PTextureParent>&
{
    return mManagedPTextureParent;
}

auto PCompositorBridgeParent::ManagedPCompositorWidgetParent(nsTArray<PCompositorWidgetParent*>& aArr) const -> void
{
    (mManagedPCompositorWidgetParent).ToArray(aArr);
}

auto PCompositorBridgeParent::ManagedPCompositorWidgetParent() const -> const ManagedContainer<PCompositorWidgetParent>&
{
    return mManagedPCompositorWidgetParent;
}

auto PCompositorBridgeParent::ManagedPWebRenderBridgeParent(nsTArray<PWebRenderBridgeParent*>& aArr) const -> void
{
    (mManagedPWebRenderBridgeParent).ToArray(aArr);
}

auto PCompositorBridgeParent::ManagedPWebRenderBridgeParent() const -> const ManagedContainer<PWebRenderBridgeParent>&
{
    return mManagedPWebRenderBridgeParent;
}

auto PCompositorBridgeParent::SendInvalidateLayers(const LayersId& layersId) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_InvalidateLayers(Id());

    WriteIPDLParam(msg__, this, layersId);
    // Sentinel = 'layersId'
    (msg__)->WriteSentinel(2382073245);




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

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

auto PCompositorBridgeParent::SendDidComposite(
        const LayersId& id,
        const TransactionId& transactionId,
        const TimeStamp& compositeStart,
        const TimeStamp& compositeEnd) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_DidComposite(Id());

    WriteIPDLParam(msg__, this, id);
    // Sentinel = 'id'
    (msg__)->WriteSentinel(2794505629);
    WriteIPDLParam(msg__, this, transactionId);
    // Sentinel = 'transactionId'
    (msg__)->WriteSentinel(3330976378);
    WriteIPDLParam(msg__, this, compositeStart);
    // Sentinel = 'compositeStart'
    (msg__)->WriteSentinel(2314271973);
    WriteIPDLParam(msg__, this, compositeEnd);
    // Sentinel = 'compositeEnd'
    (msg__)->WriteSentinel(3871762396);




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

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

auto PCompositorBridgeParent::SendRemotePaintIsReady() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_RemotePaintIsReady(Id());





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

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

auto PCompositorBridgeParent::SendUpdatePluginConfigurations(
        const LayoutDeviceIntPoint& aContentOffset,
        const LayoutDeviceIntRegion& aVisibleRegion,
        const nsTArray<PluginWindowData>& aPlugins) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_UpdatePluginConfigurations(Id());

    WriteIPDLParam(msg__, this, aContentOffset);
    // Sentinel = 'aContentOffset'
    (msg__)->WriteSentinel(2149079995);
    WriteIPDLParam(msg__, this, aVisibleRegion);
    // Sentinel = 'aVisibleRegion'
    (msg__)->WriteSentinel(24324155);
    WriteIPDLParam(msg__, this, aPlugins);
    // Sentinel = 'aPlugins'
    (msg__)->WriteSentinel(1444186915);




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

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

auto PCompositorBridgeParent::SendCaptureAllPlugins(const uintptr_t& aParentWidget) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_CaptureAllPlugins(Id());

    WriteIPDLParam(msg__, this, aParentWidget);
    // Sentinel = 'aParentWidget'
    (msg__)->WriteSentinel(2198235748);




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

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

auto PCompositorBridgeParent::SendHideAllPlugins(const uintptr_t& aParentWidget) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_HideAllPlugins(Id());

    WriteIPDLParam(msg__, this, aParentWidget);
    // Sentinel = 'aParentWidget'
    (msg__)->WriteSentinel(2198235748);




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

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

auto PCompositorBridgeParent::SendParentAsyncMessages(const nsTArray<AsyncParentMessageData>& aMessages) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_ParentAsyncMessages(Id());

    WriteIPDLParam(msg__, this, aMessages);
    // Sentinel = 'aMessages'
    (msg__)->WriteSentinel(1923086976);




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

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

auto PCompositorBridgeParent::SendObserveLayersUpdate(
        const LayersId& aLayersId,
        const LayersObserverEpoch& aEpoch,
        const bool& aActive) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_ObserveLayersUpdate(Id());

    WriteIPDLParam(msg__, this, aLayersId);
    // Sentinel = 'aLayersId'
    (msg__)->WriteSentinel(1401196721);
    WriteIPDLParam(msg__, this, aEpoch);
    // Sentinel = 'aEpoch'
    (msg__)->WriteSentinel(2333012390);
    WriteIPDLParam(msg__, this, aActive);
    // Sentinel = 'aActive'
    (msg__)->WriteSentinel(1215369048);




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

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

auto PCompositorBridgeParent::SendSharedCompositorFrameMetrics(
        const Handle& metrics,
        const CrossProcessMutexHandle& mutex,
        const LayersId& aLayersId,
        const uint32_t& aAPZCId) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_SharedCompositorFrameMetrics(Id());

    WriteIPDLParam(msg__, this, metrics);
    // Sentinel = 'metrics'
    (msg__)->WriteSentinel(293471184);
    WriteIPDLParam(msg__, this, mutex);
    // Sentinel = 'mutex'
    (msg__)->WriteSentinel(4247164084);
    WriteIPDLParam(msg__, this, aLayersId);
    // Sentinel = 'aLayersId'
    (msg__)->WriteSentinel(1401196721);
    WriteIPDLParam(msg__, this, aAPZCId);
    // Sentinel = 'aAPZCId'
    (msg__)->WriteSentinel(1661101435);




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

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

auto PCompositorBridgeParent::SendReleaseSharedCompositorFrameMetrics(
        const ViewID& aId,
        const uint32_t& aAPZCId) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_ReleaseSharedCompositorFrameMetrics(Id());

    WriteIPDLParam(msg__, this, aId);
    // Sentinel = 'aId'
    (msg__)->WriteSentinel(2735041817);
    WriteIPDLParam(msg__, this, aAPZCId);
    // Sentinel = 'aAPZCId'
    (msg__)->WriteSentinel(1661101435);




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

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

auto PCompositorBridgeParent::SendNotifyWebRenderError(const WebRenderError& error) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_NotifyWebRenderError(Id());

    WriteIPDLParam(msg__, this, error);
    // Sentinel = 'error'
    (msg__)->WriteSentinel(313726327);




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

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

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

            (container).RemoveEntry(actor);
            DeallocPAPZParent(actor);
            return;
        }
    case PAPZCTreeManagerMsgStart:
        {
            PAPZCTreeManagerParent* actor = static_cast<PAPZCTreeManagerParent*>(aListener);
            auto& container = mManagedPAPZCTreeManagerParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPAPZCTreeManagerParent(actor);
            return;
        }
    case PLayerTransactionMsgStart:
        {
            PLayerTransactionParent* actor = static_cast<PLayerTransactionParent*>(aListener);
            auto& container = mManagedPLayerTransactionParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPLayerTransactionParent(actor);
            return;
        }
    case PTextureMsgStart:
        {
            PTextureParent* actor = static_cast<PTextureParent*>(aListener);
            auto& container = mManagedPTextureParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPTextureParent(actor);
            return;
        }
    case PCompositorWidgetMsgStart:
        {
            PCompositorWidgetParent* actor = static_cast<PCompositorWidgetParent*>(aListener);
            auto& container = mManagedPCompositorWidgetParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPCompositorWidgetParent(actor);
            return;
        }
    case PWebRenderBridgeMsgStart:
        {
            PWebRenderBridgeParent* actor = static_cast<PWebRenderBridgeParent*>(aListener);
            auto& container = mManagedPWebRenderBridgeParent;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

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

auto PCompositorBridgeParent::OnMessageReceived(const Message& msg__) -> PCompositorBridgeParent::Result
{
    switch ((msg__).type()) {
    case PCompositorBridge::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg___delete__", OTHER);

            PickleIterator iter__(msg__);
            PCompositorBridgeParent* actor;

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


            IProtocol* mgr = (actor)->Manager();
            (actor)->DestroySubtree(Deletion);
            (actor)->DeallocSubtree();
            (mgr)->RemoveManagee(PCompositorBridgeMsgStart, actor);

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_PCompositorWidgetConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PCompositorWidgetConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PCompositorWidgetParent* actor;
            CompositorWidgetInitData aInitData;

            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, (&(aInitData)))))) {
                FatalError("Error deserializing 'CompositorWidgetInitData'");
                return MsgValueError;
            }
            // Sentinel = 'aInitData'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 897514454)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CompositorWidgetInitData'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPCompositorWidgetParent(aInitData);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PCompositorWidgetParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPCompositorWidgetParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_PAPZConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PAPZParent* actor;
            LayersId layersId;

            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, (&(layersId)))))) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            // Sentinel = 'layersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2382073245)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPAPZParent(layersId);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PAPZParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPAPZParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_PAPZCTreeManagerConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZCTreeManagerConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PAPZCTreeManagerParent* actor;
            LayersId layersId;

            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, (&(layersId)))))) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            // Sentinel = 'layersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2382073245)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPAPZCTreeManagerParent(layersId);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PAPZCTreeManagerParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPAPZCTreeManagerParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_RemotePluginsReady__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RemotePluginsReady", OTHER);

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_AdoptChild__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_AdoptChild", OTHER);

            PickleIterator iter__(msg__);
            LayersId id;

            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 ((!(RecvAdoptChild(id)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_FlushRenderingAsync__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRenderingAsync", OTHER);

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_ForcePresent__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ForcePresent", OTHER);

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_PLayerTransactionConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PLayerTransactionConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PLayerTransactionParent* actor;
            nsTArray<LayersBackend> layersBackendHints;
            LayersId id;

            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, (&(layersBackendHints)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'layersBackendHints'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3491646450)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                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;
            }
            actor = AllocPLayerTransactionParent(layersBackendHints, id);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PLayerTransactionParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPLayerTransactionParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPLayerTransactionConstructor(actor, std::move(layersBackendHints), id)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_NotifyRegionInvalidated__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyRegionInvalidated", OTHER);

            PickleIterator iter__(msg__);
            nsIntRegion region;

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_RequestNotifyAfterRemotePaint__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_RequestNotifyAfterRemotePaint", OTHER);

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_AllPluginsCaptured__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_AllPluginsCaptured", OTHER);

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_PTextureConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PTextureConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PTextureParent* actor;
            SurfaceDescriptor aSharedData;
            ReadLockDescriptor aReadLock;
            LayersBackend aBackend;
            TextureFlags aTextureFlags;
            LayersId id;
            uint64_t aSerial;
            MaybeExternalImageId aExternalImageId;

            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, (&(aSharedData)))))) {
                FatalError("Error deserializing 'SurfaceDescriptor'");
                return MsgValueError;
            }
            // Sentinel = 'aSharedData'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3013593029)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceDescriptor'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aReadLock)))))) {
                FatalError("Error deserializing 'ReadLockDescriptor'");
                return MsgValueError;
            }
            // Sentinel = 'aReadLock'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1208527801)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ReadLockDescriptor'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aBackend)))))) {
                FatalError("Error deserializing 'LayersBackend'");
                return MsgValueError;
            }
            // Sentinel = 'aBackend'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2878499283)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersBackend'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aTextureFlags)))))) {
                FatalError("Error deserializing 'TextureFlags'");
                return MsgValueError;
            }
            // Sentinel = 'aTextureFlags'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3005687826)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TextureFlags'");
                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;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSerial)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aSerial'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1247987114)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aExternalImageId)))))) {
                FatalError("Error deserializing 'MaybeExternalImageId'");
                return MsgValueError;
            }
            // Sentinel = 'aExternalImageId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2889998824)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'MaybeExternalImageId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            actor = AllocPTextureParent(aSharedData, aReadLock, aBackend, aTextureFlags, id, aSerial, aExternalImageId);
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PTextureParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPTextureParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            if ((!(RecvPTextureConstructor(actor, aSharedData, aReadLock, aBackend, aTextureFlags, id, aSerial, aExternalImageId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

auto PCompositorBridgeParent::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PCompositorBridgeParent::Result
{
    switch ((msg__).type()) {
    case PCompositorBridge::Msg_Initialize__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Initialize", OTHER);

            PickleIterator iter__(msg__);
            LayersId rootLayerTreeId;

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

            reply__ = PCompositorBridge::Reply_Initialize(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_GetFrameUniformity__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_GetFrameUniformity", OTHER);

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

            reply__ = PCompositorBridge::Reply_GetFrameUniformity(id__);

            WriteIPDLParam(reply__, this, data);
            // Sentinel = 'data'
            (reply__)->WriteSentinel(843352540);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_WillClose__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_WillClose", OTHER);

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

            reply__ = PCompositorBridge::Reply_WillClose(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_Pause__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Pause", OTHER);

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

            reply__ = PCompositorBridge::Reply_Pause(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_Resume__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_Resume", OTHER);

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

            reply__ = PCompositorBridge::Reply_Resume(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_NotifyChildCreated__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyChildCreated", OTHER);

            PickleIterator iter__(msg__);
            LayersId id;

            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;
            }
            int32_t id__ = Id();
            CompositorOptions compositorOptions;
            if ((!(RecvNotifyChildCreated(id, (&(compositorOptions)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_NotifyChildCreated(id__);

            WriteIPDLParam(reply__, this, compositorOptions);
            // Sentinel = 'compositorOptions'
            (reply__)->WriteSentinel(1905928698);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_MapAndNotifyChildCreated__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_MapAndNotifyChildCreated", OTHER);

            PickleIterator iter__(msg__);
            LayersId id;
            ProcessId owner;

            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;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(owner)))))) {
                FatalError("Error deserializing 'ProcessId'");
                return MsgValueError;
            }
            // Sentinel = 'owner'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 622631704)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ProcessId'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = Id();
            CompositorOptions compositorOptions;
            if ((!(RecvMapAndNotifyChildCreated(id, owner, (&(compositorOptions)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_MapAndNotifyChildCreated(id__);

            WriteIPDLParam(reply__, this, compositorOptions);
            // Sentinel = 'compositorOptions'
            (reply__)->WriteSentinel(1905928698);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_NotifyChildRecreated__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_NotifyChildRecreated", OTHER);

            PickleIterator iter__(msg__);
            LayersId id;

            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;
            }
            int32_t id__ = Id();
            CompositorOptions compositorOptions;
            if ((!(RecvNotifyChildRecreated(id, (&(compositorOptions)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_NotifyChildRecreated(id__);

            WriteIPDLParam(reply__, this, compositorOptions);
            // Sentinel = 'compositorOptions'
            (reply__)->WriteSentinel(1905928698);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_MakeSnapshot__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_MakeSnapshot", OTHER);

            PickleIterator iter__(msg__);
            SurfaceDescriptor inSnapshot;
            IntRect dirtyRect;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(inSnapshot)))))) {
                FatalError("Error deserializing 'SurfaceDescriptor'");
                return MsgValueError;
            }
            // Sentinel = 'inSnapshot'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1570595367)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'SurfaceDescriptor'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(dirtyRect)))))) {
                FatalError("Error deserializing 'IntRect'");
                return MsgValueError;
            }
            // Sentinel = 'dirtyRect'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1726016483)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IntRect'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            int32_t id__ = Id();
            if ((!(RecvMakeSnapshot(inSnapshot, dirtyRect)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_MakeSnapshot(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_FlushRendering__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_FlushRendering", OTHER);

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

            reply__ = PCompositorBridge::Reply_FlushRendering(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_WaitOnTransactionProcessed__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_WaitOnTransactionProcessed", OTHER);

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

            reply__ = PCompositorBridge::Reply_WaitOnTransactionProcessed(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_StartFrameTimeRecording__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_StartFrameTimeRecording", OTHER);

            PickleIterator iter__(msg__);
            int32_t bufferSize;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(bufferSize)))))) {
                FatalError("Error deserializing 'int32_t'");
                return MsgValueError;
            }
            // Sentinel = 'bufferSize'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3444538779)))) {
                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__ = Id();
            uint32_t startIndex;
            if ((!(RecvStartFrameTimeRecording(bufferSize, (&(startIndex)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_StartFrameTimeRecording(id__);

            WriteIPDLParam(reply__, this, startIndex);
            // Sentinel = 'startIndex'
            (reply__)->WriteSentinel(4220530450);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_StopFrameTimeRecording__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_StopFrameTimeRecording", OTHER);

            PickleIterator iter__(msg__);
            uint32_t startIndex;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(startIndex)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'startIndex'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4220530450)))) {
                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__ = Id();
            nsTArray<float> intervals;
            if ((!(RecvStopFrameTimeRecording(startIndex, (&(intervals)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_StopFrameTimeRecording(id__);

            WriteIPDLParam(reply__, this, intervals);
            // Sentinel = 'intervals'
            (reply__)->WriteSentinel(470677011);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_SyncWithCompositor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_SyncWithCompositor", OTHER);

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

            reply__ = PCompositorBridge::Reply_SyncWithCompositor(id__);


            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_PWebRenderBridgeConstructor__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PWebRenderBridgeConstructor", OTHER);

            PickleIterator iter__(msg__);
            ActorHandle handle__;
            PWebRenderBridgeParent* actor;
            PipelineId pipelineId;
            LayoutDeviceIntSize aSize;

            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, (&(pipelineId)))))) {
                FatalError("Error deserializing 'PipelineId'");
                return MsgValueError;
            }
            // Sentinel = 'pipelineId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4067092043)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PipelineId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aSize)))))) {
                FatalError("Error deserializing 'LayoutDeviceIntSize'");
                return MsgValueError;
            }
            // Sentinel = 'aSize'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2556665555)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntSize'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            TextureFactoryIdentifier textureFactoryIdentifier;
            IdNamespace idNamespace;
            actor = AllocPWebRenderBridgeParent(pipelineId, aSize, (&(textureFactoryIdentifier)), (&(idNamespace)));
            if ((!(actor))) {
                NS_WARNING("Error constructing actor PWebRenderBridgeParent");
                return MsgValueError;
            }
            (actor)->SetManagerAndRegister(this, (handle__).mId);
            (mManagedPWebRenderBridgeParent).PutEntry(actor);
            (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

            int32_t id__ = Id();
            if ((!(RecvPWebRenderBridgeConstructor(actor, pipelineId, aSize, (&(textureFactoryIdentifier)), (&(idNamespace)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }
            reply__ = PCompositorBridge::Reply_PWebRenderBridgeConstructor(id__);

            WriteIPDLParam(reply__, this, textureFactoryIdentifier);
            // Sentinel = 'textureFactoryIdentifier'
            (reply__)->WriteSentinel(1630882508);
            WriteIPDLParam(reply__, this, idNamespace);
            // Sentinel = 'idNamespace'
            (reply__)->WriteSentinel(1477745059);

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

            return MsgProcessed;
        }
    case PCompositorBridge::Msg_CheckContentOnlyTDR__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_CheckContentOnlyTDR", OTHER);

            PickleIterator iter__(msg__);
            uint32_t sequenceNum;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(sequenceNum)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'sequenceNum'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1222681202)))) {
                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__ = Id();
            bool isContentOnlyTDR;
            if ((!(RecvCheckContentOnlyTDR(sequenceNum, (&(isContentOnlyTDR)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PCompositorBridge::Reply_CheckContentOnlyTDR(id__);

            WriteIPDLParam(reply__, this, isContentOnlyTDR);
            // Sentinel = 'isContentOnlyTDR'
            (reply__)->WriteSentinel(1577543213);

            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeParent")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

auto PCompositorBridgeParent::OnCallReceived(
        const Message& msg__,
        Message*& reply__) -> PCompositorBridgeParent::Result
{
    MOZ_ASSERT_UNREACHABLE("message protocol not supported");
    return MsgNotKnown;
}

auto PCompositorBridgeParent::GetProtocolTypeId() -> int32_t
{
    return PCompositorBridgeMsgStart;
}

auto PCompositorBridgeParent::DestroySubtree(ActorDestroyReason why) -> void
{
    // Unregister from our manager.
    Unregister(Id());

    ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);

    {
        // Recursively shutting down PAPZ kids
        nsTArray<PAPZParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAPZParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAPZParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PAPZCTreeManager kids
        nsTArray<PAPZCTreeManagerParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAPZCTreeManagerParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAPZCTreeManagerParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PLayerTransaction kids
        nsTArray<PLayerTransactionParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPLayerTransactionParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPLayerTransactionParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTexture kids
        nsTArray<PTextureParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTextureParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTextureParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCompositorWidget kids
        nsTArray<PCompositorWidgetParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCompositorWidgetParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCompositorWidgetParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebRenderBridge kids
        nsTArray<PWebRenderBridgeParent*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebRenderBridgeParent(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebRenderBridgeParent).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

    // Reject owning pending responses.
    (GetIPCChannel())->RejectPendingResponsesForActor(this);

    // Finally, destroy "us".
    ActorDestroy(why);
}

auto PCompositorBridgeParent::DeallocSubtree() -> void
{
    {
        // Recursively deleting PAPZ kids
        for (auto iter = (mManagedPAPZParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPAPZParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPAPZParent(((iter).Get())->GetKey());
        }
        (mManagedPAPZParent).Clear();
    }
    {
        // Recursively deleting PAPZCTreeManager kids
        for (auto iter = (mManagedPAPZCTreeManagerParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPAPZCTreeManagerParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPAPZCTreeManagerParent(((iter).Get())->GetKey());
        }
        (mManagedPAPZCTreeManagerParent).Clear();
    }
    {
        // Recursively deleting PLayerTransaction kids
        for (auto iter = (mManagedPLayerTransactionParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPLayerTransactionParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPLayerTransactionParent(((iter).Get())->GetKey());
        }
        (mManagedPLayerTransactionParent).Clear();
    }
    {
        // Recursively deleting PTexture kids
        for (auto iter = (mManagedPTextureParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPTextureParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPTextureParent(((iter).Get())->GetKey());
        }
        (mManagedPTextureParent).Clear();
    }
    {
        // Recursively deleting PCompositorWidget kids
        for (auto iter = (mManagedPCompositorWidgetParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPCompositorWidgetParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPCompositorWidgetParent(((iter).Get())->GetKey());
        }
        (mManagedPCompositorWidgetParent).Clear();
    }
    {
        // Recursively deleting PWebRenderBridge kids
        for (auto iter = (mManagedPWebRenderBridgeParent).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPWebRenderBridgeParent).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPWebRenderBridgeParent(((iter).Get())->GetKey());
        }
        (mManagedPWebRenderBridgeParent).Clear();
    }
}



} // namespace layers
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::PCompositorBridgeParent>::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::layers::PCompositorBridgeParent>::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, "PCompositorBridge", PCompositorBridgeMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(aVar)) = static_cast<mozilla::layers::PCompositorBridgeParent*>((actor).value());
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53