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

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


#include "mozilla/layers/PCompositorBridgeChild.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/PAPZChild.h"
#include "mozilla/layers/PAPZCTreeManagerChild.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/layers/PCompositorManagerChild.h"
#include "mozilla/widget/PCompositorWidgetChild.h"
#include "mozilla/layers/PLayerTransactionChild.h"
#include "mozilla/layers/PTextureChild.h"
#include "mozilla/layers/PWebRenderBridgeChild.h"

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

namespace mozilla {
namespace layers {


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

MOZ_IMPLICIT PCompositorBridgeChild::PCompositorBridgeChild() :
    mozilla::ipc::IProtocol(mozilla::ipc::ChildSide),
    mLivenessState(mozilla::ipc::LivenessState::Dead)
{
    MOZ_COUNT_CTOR(PCompositorBridgeChild);
}

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

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

auto PCompositorBridgeChild::ManagedPAPZChild(nsTArray<PAPZChild*>& aArr) const -> void
{
    (mManagedPAPZChild).ToArray(aArr);
}

auto PCompositorBridgeChild::ManagedPAPZChild() const -> const ManagedContainer<PAPZChild>&
{
    return mManagedPAPZChild;
}

auto PCompositorBridgeChild::ManagedPAPZCTreeManagerChild(nsTArray<PAPZCTreeManagerChild*>& aArr) const -> void
{
    (mManagedPAPZCTreeManagerChild).ToArray(aArr);
}

auto PCompositorBridgeChild::ManagedPAPZCTreeManagerChild() const -> const ManagedContainer<PAPZCTreeManagerChild>&
{
    return mManagedPAPZCTreeManagerChild;
}

auto PCompositorBridgeChild::ManagedPLayerTransactionChild(nsTArray<PLayerTransactionChild*>& aArr) const -> void
{
    (mManagedPLayerTransactionChild).ToArray(aArr);
}

auto PCompositorBridgeChild::ManagedPLayerTransactionChild() const -> const ManagedContainer<PLayerTransactionChild>&
{
    return mManagedPLayerTransactionChild;
}

auto PCompositorBridgeChild::ManagedPTextureChild(nsTArray<PTextureChild*>& aArr) const -> void
{
    (mManagedPTextureChild).ToArray(aArr);
}

auto PCompositorBridgeChild::ManagedPTextureChild() const -> const ManagedContainer<PTextureChild>&
{
    return mManagedPTextureChild;
}

auto PCompositorBridgeChild::ManagedPCompositorWidgetChild(nsTArray<PCompositorWidgetChild*>& aArr) const -> void
{
    (mManagedPCompositorWidgetChild).ToArray(aArr);
}

auto PCompositorBridgeChild::ManagedPCompositorWidgetChild() const -> const ManagedContainer<PCompositorWidgetChild>&
{
    return mManagedPCompositorWidgetChild;
}

auto PCompositorBridgeChild::ManagedPWebRenderBridgeChild(nsTArray<PWebRenderBridgeChild*>& aArr) const -> void
{
    (mManagedPWebRenderBridgeChild).ToArray(aArr);
}

auto PCompositorBridgeChild::ManagedPWebRenderBridgeChild() const -> const ManagedContainer<PWebRenderBridgeChild>&
{
    return mManagedPWebRenderBridgeChild;
}

auto PCompositorBridgeChild::Send__delete__(PCompositorBridgeChild* actor) -> bool
{
    if ((!(actor))) {
        return false;
    }

    IPC::Message* msg__ = PCompositorBridge::Msg___delete__((actor)->Id());

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



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

    bool sendok__ = ((actor)->GetIPCChannel())->Send(msg__);

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

auto PCompositorBridgeChild::SendPCompositorWidgetConstructor(const CompositorWidgetInitData& aInitData) -> PCompositorWidgetChild*
{
    return SendPCompositorWidgetConstructor(AllocPCompositorWidgetChild(aInitData), aInitData);
}

auto PCompositorBridgeChild::SendPCompositorWidgetConstructor(
        PCompositorWidgetChild* actor,
        const CompositorWidgetInitData& aInitData) -> PCompositorWidgetChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PCompositorWidgetChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPCompositorWidgetChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PCompositorBridge::Msg_PCompositorWidgetConstructor(Id());

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



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PCompositorBridgeChild::SendInitialize(const LayersId& rootLayerTreeId) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_Initialize(Id());

    WriteIPDLParam(msg__, this, rootLayerTreeId);
    // Sentinel = 'rootLayerTreeId'
    (msg__)->WriteSentinel(191972583);



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_Initialize");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendPAPZConstructor(const LayersId& layersId) -> PAPZChild*
{
    return SendPAPZConstructor(AllocPAPZChild(layersId), layersId);
}

auto PCompositorBridgeChild::SendPAPZConstructor(
        PAPZChild* actor,
        const LayersId& layersId) -> PAPZChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAPZChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPAPZChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PCompositorBridge::Msg_PAPZConstructor(Id());

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



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PCompositorBridgeChild::SendPAPZCTreeManagerConstructor(const LayersId& layersId) -> PAPZCTreeManagerChild*
{
    return SendPAPZCTreeManagerConstructor(AllocPAPZCTreeManagerChild(layersId), layersId);
}

auto PCompositorBridgeChild::SendPAPZCTreeManagerConstructor(
        PAPZCTreeManagerChild* actor,
        const LayersId& layersId) -> PAPZCTreeManagerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAPZCTreeManagerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPAPZCTreeManagerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PCompositorBridge::Msg_PAPZCTreeManagerConstructor(Id());

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



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PCompositorBridgeChild::SendRemotePluginsReady() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_RemotePluginsReady(Id());





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

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

auto PCompositorBridgeChild::SendGetFrameUniformity(FrameUniformityData* data) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_GetFrameUniformity(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_GetFrameUniformity");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, data)))) {
        FatalError("Error deserializing 'FrameUniformityData'");
        return false;
    }
    // Sentinel = 'data'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 843352540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'FrameUniformityData'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

auto PCompositorBridgeChild::SendWillClose() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_WillClose(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_WillClose");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendPause() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_Pause(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_Pause");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendResume() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_Resume(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_Resume");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendNotifyChildCreated(
        const LayersId& id,
        CompositorOptions* compositorOptions) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_NotifyChildCreated(Id());

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



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_NotifyChildCreated");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, compositorOptions)))) {
        FatalError("Error deserializing 'CompositorOptions'");
        return false;
    }
    // Sentinel = 'compositorOptions'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 1905928698)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

auto PCompositorBridgeChild::SendMapAndNotifyChildCreated(
        const LayersId& id,
        const ProcessId& owner,
        CompositorOptions* compositorOptions) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_MapAndNotifyChildCreated(Id());

    WriteIPDLParam(msg__, this, id);
    // Sentinel = 'id'
    (msg__)->WriteSentinel(2794505629);
    WriteIPDLParam(msg__, this, owner);
    // Sentinel = 'owner'
    (msg__)->WriteSentinel(622631704);



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_MapAndNotifyChildCreated");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, compositorOptions)))) {
        FatalError("Error deserializing 'CompositorOptions'");
        return false;
    }
    // Sentinel = 'compositorOptions'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 1905928698)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

auto PCompositorBridgeChild::SendAdoptChild(const LayersId& id) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_AdoptChild(Id());

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




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

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

auto PCompositorBridgeChild::SendNotifyChildRecreated(
        const LayersId& id,
        CompositorOptions* compositorOptions) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_NotifyChildRecreated(Id());

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



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_NotifyChildRecreated");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, compositorOptions)))) {
        FatalError("Error deserializing 'CompositorOptions'");
        return false;
    }
    // Sentinel = 'compositorOptions'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 1905928698)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'CompositorOptions'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

auto PCompositorBridgeChild::SendMakeSnapshot(
        const SurfaceDescriptor& inSnapshot,
        const IntRect& dirtyRect) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_MakeSnapshot(Id());

    WriteIPDLParam(msg__, this, inSnapshot);
    // Sentinel = 'inSnapshot'
    (msg__)->WriteSentinel(1570595367);
    WriteIPDLParam(msg__, this, dirtyRect);
    // Sentinel = 'dirtyRect'
    (msg__)->WriteSentinel(1726016483);



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_MakeSnapshot");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendFlushRendering() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_FlushRendering(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_FlushRendering");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendFlushRenderingAsync() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_FlushRenderingAsync(Id());





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

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

auto PCompositorBridgeChild::SendWaitOnTransactionProcessed() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_WaitOnTransactionProcessed(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_WaitOnTransactionProcessed");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendForcePresent() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_ForcePresent(Id());





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

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

auto PCompositorBridgeChild::SendStartFrameTimeRecording(
        const int32_t& bufferSize,
        uint32_t* startIndex) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_StartFrameTimeRecording(Id());

    WriteIPDLParam(msg__, this, bufferSize);
    // Sentinel = 'bufferSize'
    (msg__)->WriteSentinel(3444538779);



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_StartFrameTimeRecording");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, startIndex)))) {
        FatalError("Error deserializing 'uint32_t'");
        return false;
    }
    // Sentinel = 'startIndex'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 4220530450)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

auto PCompositorBridgeChild::SendStopFrameTimeRecording(
        const uint32_t& startIndex,
        nsTArray<float>* intervals) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_StopFrameTimeRecording(Id());

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



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_StopFrameTimeRecording");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, intervals)))) {
        FatalError("Error deserializing 'nsTArray'");
        return false;
    }
    // Sentinel = 'intervals'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 470677011)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

auto PCompositorBridgeChild::SendPLayerTransactionConstructor(
        const nsTArray<LayersBackend>& layersBackendHints,
        const LayersId& id) -> PLayerTransactionChild*
{
    return SendPLayerTransactionConstructor(AllocPLayerTransactionChild(layersBackendHints, id), layersBackendHints, id);
}

auto PCompositorBridgeChild::SendPLayerTransactionConstructor(
        PLayerTransactionChild* actor,
        const nsTArray<LayersBackend>& layersBackendHints,
        const LayersId& id) -> PLayerTransactionChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PLayerTransactionChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPLayerTransactionChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PCompositorBridge::Msg_PLayerTransactionConstructor(Id());

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



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PCompositorBridgeChild::SendNotifyRegionInvalidated(const nsIntRegion& region) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_NotifyRegionInvalidated(Id());

    WriteIPDLParam(msg__, this, region);
    // Sentinel = 'region'
    (msg__)->WriteSentinel(688844010);




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

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

auto PCompositorBridgeChild::SendRequestNotifyAfterRemotePaint() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_RequestNotifyAfterRemotePaint(Id());





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

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

auto PCompositorBridgeChild::SendAllPluginsCaptured() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_AllPluginsCaptured(Id());





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

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

auto PCompositorBridgeChild::SendPTextureConstructor(
        const SurfaceDescriptor& aSharedData,
        const ReadLockDescriptor& aReadLock,
        const LayersBackend& aBackend,
        const TextureFlags& aTextureFlags,
        const LayersId& id,
        const uint64_t& aSerial,
        const MaybeExternalImageId& aExternalImageId) -> PTextureChild*
{
    return SendPTextureConstructor(AllocPTextureChild(aSharedData, aReadLock, aBackend, aTextureFlags, id, aSerial, aExternalImageId), aSharedData, aReadLock, aBackend, aTextureFlags, id, aSerial, aExternalImageId);
}

auto PCompositorBridgeChild::SendPTextureConstructor(
        PTextureChild* actor,
        const SurfaceDescriptor& aSharedData,
        const ReadLockDescriptor& aReadLock,
        const LayersBackend& aBackend,
        const TextureFlags& aTextureFlags,
        const LayersId& id,
        const uint64_t& aSerial,
        const MaybeExternalImageId& aExternalImageId) -> PTextureChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PTextureChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPTextureChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PCompositorBridge::Msg_PTextureConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, aSharedData);
    // Sentinel = 'aSharedData'
    (msg__)->WriteSentinel(3013593029);
    WriteIPDLParam(msg__, this, aReadLock);
    // Sentinel = 'aReadLock'
    (msg__)->WriteSentinel(1208527801);
    WriteIPDLParam(msg__, this, aBackend);
    // Sentinel = 'aBackend'
    (msg__)->WriteSentinel(2878499283);
    WriteIPDLParam(msg__, this, aTextureFlags);
    // Sentinel = 'aTextureFlags'
    (msg__)->WriteSentinel(3005687826);
    WriteIPDLParam(msg__, this, id);
    // Sentinel = 'id'
    (msg__)->WriteSentinel(2794505629);
    WriteIPDLParam(msg__, this, aSerial);
    // Sentinel = 'aSerial'
    (msg__)->WriteSentinel(1247987114);
    WriteIPDLParam(msg__, this, aExternalImageId);
    // Sentinel = 'aExternalImageId'
    (msg__)->WriteSentinel(2889998824);



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PCompositorBridgeChild::SendSyncWithCompositor() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_SyncWithCompositor(Id());




    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_SyncWithCompositor");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PCompositorBridgeChild::SendPWebRenderBridgeConstructor(
        const PipelineId& pipelineId,
        const LayoutDeviceIntSize& aSize,
        TextureFactoryIdentifier* textureFactoryIdentifier,
        IdNamespace* idNamespace) -> PWebRenderBridgeChild*
{
    return SendPWebRenderBridgeConstructor(AllocPWebRenderBridgeChild(pipelineId, aSize, textureFactoryIdentifier, idNamespace), pipelineId, aSize, textureFactoryIdentifier, idNamespace);
}

auto PCompositorBridgeChild::SendPWebRenderBridgeConstructor(
        PWebRenderBridgeChild* actor,
        const PipelineId& pipelineId,
        const LayoutDeviceIntSize& aSize,
        TextureFactoryIdentifier* textureFactoryIdentifier,
        IdNamespace* idNamespace) -> PWebRenderBridgeChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PWebRenderBridgeChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPWebRenderBridgeChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PCompositorBridge::Msg_PWebRenderBridgeConstructor(Id());

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



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_PWebRenderBridgeConstructor");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, textureFactoryIdentifier)))) {
        if (true) {
            FatalError("constructor for actor failed");
            return nullptr;
        }
    }
    // Sentinel = 'textureFactoryIdentifier'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 1630882508)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TextureFactoryIdentifier'");
        return nullptr;
    }
    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, idNamespace)))) {
        if (true) {
            FatalError("constructor for actor failed");
            return nullptr;
        }
    }
    // Sentinel = 'idNamespace'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 1477745059)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'IdNamespace'");
        return nullptr;
    }
    (reply__).EndRead(iter__, (reply__).type());
    return actor;
}

auto PCompositorBridgeChild::SendCheckContentOnlyTDR(
        const uint32_t& sequenceNum,
        bool* isContentOnlyTDR) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_CheckContentOnlyTDR(Id());

    WriteIPDLParam(msg__, this, sequenceNum);
    // Sentinel = 'sequenceNum'
    (msg__)->WriteSentinel(1222681202);



    Message reply__;

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

    bool sendok__;
    {
        AUTO_PROFILER_TRACING("IPC", "PCompositorBridge::Msg_CheckContentOnlyTDR");
        sendok__ = (GetIPCChannel())->Send(msg__, (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received reply ", ((&(reply__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
    }

    PickleIterator iter__(reply__);

    if ((!(ReadIPDLParam((&(reply__)), (&(iter__)), this, isContentOnlyTDR)))) {
        FatalError("Error deserializing 'bool'");
        return false;
    }
    // Sentinel = 'isContentOnlyTDR'
    if ((!(((&(reply__)))->ReadSentinel((&(iter__)), 1577543213)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
        return false;
    }
    (reply__).EndRead(iter__, (reply__).type());

    return true;
}

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

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

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

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

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

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

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

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

            PickleIterator iter__(msg__);
            LayersId layersId;

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

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

            PickleIterator iter__(msg__);
            LayersId id;
            TransactionId transactionId;
            TimeStamp compositeStart;
            TimeStamp compositeEnd;

            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, (&(transactionId)))))) {
                FatalError("Error deserializing 'TransactionId'");
                return MsgValueError;
            }
            // Sentinel = 'transactionId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3330976378)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TransactionId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(compositeStart)))))) {
                FatalError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            // Sentinel = 'compositeStart'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2314271973)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(compositeEnd)))))) {
                FatalError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            // Sentinel = 'compositeEnd'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3871762396)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDidComposite(id, transactionId, compositeStart, compositeEnd)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

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

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

            PickleIterator iter__(msg__);
            LayoutDeviceIntPoint aContentOffset;
            LayoutDeviceIntRegion aVisibleRegion;
            nsTArray<PluginWindowData> aPlugins;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aContentOffset)))))) {
                FatalError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            // Sentinel = 'aContentOffset'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2149079995)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aVisibleRegion)))))) {
                FatalError("Error deserializing 'LayoutDeviceIntRegion'");
                return MsgValueError;
            }
            // Sentinel = 'aVisibleRegion'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 24324155)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntRegion'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPlugins)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aPlugins'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1444186915)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvUpdatePluginConfigurations(aContentOffset, aVisibleRegion, std::move(aPlugins))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            PickleIterator iter__(msg__);
            uintptr_t aParentWidget;

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

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

            PickleIterator iter__(msg__);
            uintptr_t aParentWidget;

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

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

            PickleIterator iter__(msg__);
            nsTArray<AsyncParentMessageData> aMessages;

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

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

            PickleIterator iter__(msg__);
            LayersId aLayersId;
            LayersObserverEpoch aEpoch;
            bool aActive;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aLayersId)))))) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            // Sentinel = 'aLayersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1401196721)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aEpoch)))))) {
                FatalError("Error deserializing 'LayersObserverEpoch'");
                return MsgValueError;
            }
            // Sentinel = 'aEpoch'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2333012390)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersObserverEpoch'");
                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;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvObserveLayersUpdate(aLayersId, aEpoch, aActive)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PCompositorBridge::Reply___delete____ID:
        {
            return MsgProcessed;
        }
    case PCompositorBridge::Reply_PCompositorWidgetConstructor__ID:
        {
            return MsgProcessed;
        }
    case PCompositorBridge::Reply_PAPZConstructor__ID:
        {
            return MsgProcessed;
        }
    case PCompositorBridge::Reply_PAPZCTreeManagerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PCompositorBridge::Reply_PLayerTransactionConstructor__ID:
        {
            return MsgProcessed;
        }
    case PCompositorBridge::Reply_PTextureConstructor__ID:
        {
            return MsgProcessed;
        }
    case PCompositorBridge::Msg_SharedCompositorFrameMetrics__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
                mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PCompositorBridge::Msg_SharedCompositorFrameMetrics", OTHER);

            PickleIterator iter__(msg__);
            Handle metrics;
            CrossProcessMutexHandle mutex;
            LayersId aLayersId;
            uint32_t aAPZCId;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(metrics)))))) {
                FatalError("Error deserializing 'Handle'");
                return MsgValueError;
            }
            // Sentinel = 'metrics'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 293471184)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Handle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(mutex)))))) {
                FatalError("Error deserializing 'CrossProcessMutexHandle'");
                return MsgValueError;
            }
            // Sentinel = 'mutex'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4247164084)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CrossProcessMutexHandle'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aLayersId)))))) {
                FatalError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            // Sentinel = 'aLayersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1401196721)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aAPZCId)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aAPZCId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1661101435)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSharedCompositorFrameMetrics(metrics, mutex, aLayersId, aAPZCId)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            PickleIterator iter__(msg__);
            ViewID aId;
            uint32_t aAPZCId;

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

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

            PickleIterator iter__(msg__);
            WebRenderError error;

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

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

auto PCompositorBridgeChild::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PCompositorBridgeChild::Result
{
    return MsgNotKnown;
}

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

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

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

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

    {
        // Recursively shutting down PAPZ kids
        nsTArray<PAPZChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAPZChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAPZChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PAPZCTreeManager kids
        nsTArray<PAPZCTreeManagerChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAPZCTreeManagerChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAPZCTreeManagerChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PLayerTransaction kids
        nsTArray<PLayerTransactionChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPLayerTransactionChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPLayerTransactionChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PTexture kids
        nsTArray<PTextureChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPTextureChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPTextureChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PCompositorWidget kids
        nsTArray<PCompositorWidgetChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPCompositorWidgetChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPCompositorWidgetChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }
    {
        // Recursively shutting down PWebRenderBridge kids
        nsTArray<PWebRenderBridgeChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPWebRenderBridgeChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPWebRenderBridgeChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

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

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

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

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

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

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

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

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

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



} // namespace layers
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::layers::PCompositorBridgeChild>::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::PCompositorBridgeChild>::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::PCompositorBridgeChild*>((actor).value());
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53