//
// 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/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),
    mState(PCompositorBridge::__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());

    (actor)->Write(actor, msg__, false);
    // 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);
    PCompositorBridge::Transition(PCompositorBridge::Msg___delete____ID, (&((actor)->mState)));

    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)->SetManager(this);
    Register(actor);
    (actor)->SetIPCChannel(GetIPCChannel());
    (mManagedPCompositorWidgetChild).PutEntry(actor);
    (actor)->mState = mozilla::widget::PCompositorWidget::__Start;

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

    Write(actor, msg__, false);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    Write(aInitData, msg__);
    // Sentinel = 'aInitData'
    (msg__)->WriteSentinel(897514454);

    (msg__)->set_constructor();


    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PCompositorWidgetConstructor", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_PCompositorWidgetConstructor__ID, (&(mState)));

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

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

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_Initialize__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 uint64_t& layersId) -> PAPZChild*
{
    return SendPAPZConstructor(AllocPAPZChild(layersId), layersId);
}

auto PCompositorBridgeChild::SendPAPZConstructor(
        PAPZChild* actor,
        const uint64_t& layersId) -> PAPZChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAPZChild");
        return nullptr;
    }
    (actor)->SetManager(this);
    Register(actor);
    (actor)->SetIPCChannel(GetIPCChannel());
    (mManagedPAPZChild).PutEntry(actor);
    (actor)->mState = mozilla::layers::PAPZ::__Start;

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

    Write(actor, msg__, false);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    Write(layersId, msg__);
    // Sentinel = 'layersId'
    (msg__)->WriteSentinel(2382073245);

    (msg__)->set_constructor();


    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZConstructor", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_PAPZConstructor__ID, (&(mState)));

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

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

auto PCompositorBridgeChild::SendPAPZCTreeManagerConstructor(
        PAPZCTreeManagerChild* actor,
        const uint64_t& layersId) -> PAPZCTreeManagerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAPZCTreeManagerChild");
        return nullptr;
    }
    (actor)->SetManager(this);
    Register(actor);
    (actor)->SetIPCChannel(GetIPCChannel());
    (mManagedPAPZCTreeManagerChild).PutEntry(actor);
    (actor)->mState = mozilla::layers::PAPZCTreeManager::__Start;

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

    Write(actor, msg__, false);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    Write(layersId, msg__);
    // Sentinel = 'layersId'
    (msg__)->WriteSentinel(2382073245);

    (msg__)->set_constructor();


    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PAPZCTreeManagerConstructor", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_PAPZCTreeManagerConstructor__ID, (&(mState)));

    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_RemotePluginsReady__ID, (&(mState)));

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

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


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_GetFrameUniformity__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(data, (&(reply__)), (&(iter__)))))) {
        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());


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_WillClose__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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());


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_Pause__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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());


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_Resume__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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::SendForceIsFirstPaint() -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_ForceIsFirstPaint(Id());





    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ForceIsFirstPaint", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_ForceIsFirstPaint__ID, (&(mState)));

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

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

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_NotifyChildCreated__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(compositorOptions, (&(reply__)), (&(iter__)))))) {
        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 uint64_t& id,
        const ProcessId& owner,
        CompositorOptions* compositorOptions) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_MapAndNotifyChildCreated(Id());

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_MapAndNotifyChildCreated__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(compositorOptions, (&(reply__)), (&(iter__)))))) {
        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 uint64_t& id) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_AdoptChild(Id());

    Write(id, msg__);
    // 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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_AdoptChild__ID, (&(mState)));

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

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

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_NotifyChildRecreated__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(compositorOptions, (&(reply__)), (&(iter__)))))) {
        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());

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_MakeSnapshot__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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());


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_FlushRendering__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_FlushRenderingAsync__ID, (&(mState)));

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

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


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_WaitOnTransactionProcessed__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_ForcePresent__ID, (&(mState)));

    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());

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_StartFrameTimeRecording__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(startIndex, (&(reply__)), (&(iter__)))))) {
        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());

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_StopFrameTimeRecording__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(intervals, (&(reply__)), (&(iter__)))))) {
        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 uint64_t& id) -> PLayerTransactionChild*
{
    return SendPLayerTransactionConstructor(AllocPLayerTransactionChild(layersBackendHints, id), layersBackendHints, id);
}

auto PCompositorBridgeChild::SendPLayerTransactionConstructor(
        PLayerTransactionChild* actor,
        const nsTArray<LayersBackend>& layersBackendHints,
        const uint64_t& id) -> PLayerTransactionChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PLayerTransactionChild");
        return nullptr;
    }
    (actor)->SetManager(this);
    Register(actor);
    (actor)->SetIPCChannel(GetIPCChannel());
    (mManagedPLayerTransactionChild).PutEntry(actor);
    (actor)->mState = mozilla::layers::PLayerTransaction::__Start;

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

    Write(actor, msg__, false);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    Write(layersBackendHints, msg__);
    // Sentinel = 'layersBackendHints'
    (msg__)->WriteSentinel(3491646450);
    Write(id, msg__);
    // Sentinel = 'id'
    (msg__)->WriteSentinel(2794505629);

    (msg__)->set_constructor();


    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PLayerTransactionConstructor", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_PLayerTransactionConstructor__ID, (&(mState)));

    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());

    Write(region, msg__);
    // 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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_NotifyRegionInvalidated__ID, (&(mState)));

    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_RequestNotifyAfterRemotePaint__ID, (&(mState)));

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

auto PCompositorBridgeChild::SendClearApproximatelyVisibleRegions(
        const uint64_t& layersId,
        const uint32_t& presShellId) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_ClearApproximatelyVisibleRegions(Id());

    Write(layersId, msg__);
    // Sentinel = 'layersId'
    (msg__)->WriteSentinel(2382073245);
    Write(presShellId, msg__);
    // Sentinel = 'presShellId'
    (msg__)->WriteSentinel(3004057044);




    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_ClearApproximatelyVisibleRegions", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_ClearApproximatelyVisibleRegions__ID, (&(mState)));

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

auto PCompositorBridgeChild::SendNotifyApproximatelyVisibleRegion(
        const ScrollableLayerGuid& guid,
        const CSSIntRegion& region) -> bool
{
    IPC::Message* msg__ = PCompositorBridge::Msg_NotifyApproximatelyVisibleRegion(Id());

    Write(guid, msg__);
    // Sentinel = 'guid'
    (msg__)->WriteSentinel(972072219);
    Write(region, msg__);
    // 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_NotifyApproximatelyVisibleRegion", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_NotifyApproximatelyVisibleRegion__ID, (&(mState)));

    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_AllPluginsCaptured__ID, (&(mState)));

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

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

auto PCompositorBridgeChild::SendPTextureConstructor(
        PTextureChild* actor,
        const SurfaceDescriptor& aSharedData,
        const LayersBackend& aBackend,
        const TextureFlags& aTextureFlags,
        const uint64_t& id,
        const uint64_t& aSerial,
        const MaybeExternalImageId& aExternalImageId) -> PTextureChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PTextureChild");
        return nullptr;
    }
    (actor)->SetManager(this);
    Register(actor);
    (actor)->SetIPCChannel(GetIPCChannel());
    (mManagedPTextureChild).PutEntry(actor);
    (actor)->mState = mozilla::layers::PTexture::__Start;

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

    Write(actor, msg__, false);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    Write(aSharedData, msg__);
    // Sentinel = 'aSharedData'
    (msg__)->WriteSentinel(3013593029);
    Write(aBackend, msg__);
    // Sentinel = 'aBackend'
    (msg__)->WriteSentinel(2878499283);
    Write(aTextureFlags, msg__);
    // Sentinel = 'aTextureFlags'
    (msg__)->WriteSentinel(3005687826);
    Write(id, msg__);
    // Sentinel = 'id'
    (msg__)->WriteSentinel(2794505629);
    Write(aSerial, msg__);
    // Sentinel = 'aSerial'
    (msg__)->WriteSentinel(1247987114);
    Write(aExternalImageId, msg__);
    // Sentinel = 'aExternalImageId'
    (msg__)->WriteSentinel(2889998824);

    (msg__)->set_constructor();


    if (mozilla::ipc::LoggingEnabledFor("PCompositorBridgeChild")) {
        mozilla::ipc::LogMessageForProtocol("PCompositorBridgeChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PCompositorBridge::Msg_PTextureConstructor", OTHER);
    PCompositorBridge::Transition(PCompositorBridge::Msg_PTextureConstructor__ID, (&(mState)));

    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());


    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_SyncWithCompositor__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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)->SetManager(this);
    Register(actor);
    (actor)->SetIPCChannel(GetIPCChannel());
    (mManagedPWebRenderBridgeChild).PutEntry(actor);
    (actor)->mState = mozilla::layers::PWebRenderBridge::__Start;

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

    Write(actor, msg__, false);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    Write(pipelineId, msg__);
    // Sentinel = 'pipelineId'
    (msg__)->WriteSentinel(4067092043);
    Write(aSize, msg__);
    // Sentinel = 'aSize'
    (msg__)->WriteSentinel(2556665555);

    (msg__)->set_sync();
    (msg__)->set_constructor();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_PWebRenderBridgeConstructor__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(textureFactoryIdentifier, (&(reply__)), (&(iter__)))))) {
        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 ((!(Read(idNamespace, (&(reply__)), (&(iter__)))))) {
        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());

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

    (msg__)->set_sync();


    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);
    PCompositorBridge::Transition(PCompositorBridge::Msg_CheckContentOnlyTDR__ID, (&(mState)));

    bool sendok__;
    {
        AutoProfilerTracing syncIPCTracer(
                "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 ((!(Read(isContentOnlyTDR, (&(reply__)), (&(iter__)))))) {
        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,
        ProtocolBase* 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__);
            uint64_t layersId;

            if ((!(Read((&(layersId)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'layersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2382073245)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            PCompositorBridge::Transition(PCompositorBridge::Msg_InvalidateLayers__ID, (&(mState)));
            if ((!(RecvInvalidateLayers(mozilla::Move(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__);
            uint64_t id;
            uint64_t transactionId;
            TimeStamp compositeStart;
            TimeStamp compositeEnd;

            if ((!(Read((&(id)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'id'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2794505629)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(Read((&(transactionId)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'transactionId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3330976378)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(Read((&(compositeStart)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            // Sentinel = 'compositeStart'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2314271973)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TimeStamp'");
                return MsgValueError;
            }
            if ((!(Read((&(compositeEnd)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_DidComposite__ID, (&(mState)));
            if ((!(RecvDidComposite(mozilla::Move(id), mozilla::Move(transactionId), mozilla::Move(compositeStart), mozilla::Move(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);

            PCompositorBridge::Transition(PCompositorBridge::Msg_RemotePaintIsReady__ID, (&(mState)));
            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 ((!(Read((&(aContentOffset)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            // Sentinel = 'aContentOffset'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2149079995)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntPoint'");
                return MsgValueError;
            }
            if ((!(Read((&(aVisibleRegion)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'LayoutDeviceIntRegion'");
                return MsgValueError;
            }
            // Sentinel = 'aVisibleRegion'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 24324155)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayoutDeviceIntRegion'");
                return MsgValueError;
            }
            if ((!(Read((&(aPlugins)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_UpdatePluginConfigurations__ID, (&(mState)));
            if ((!(RecvUpdatePluginConfigurations(mozilla::Move(aContentOffset), mozilla::Move(aVisibleRegion), mozilla::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 ((!(Read((&(aParentWidget)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_CaptureAllPlugins__ID, (&(mState)));
            if ((!(RecvCaptureAllPlugins(mozilla::Move(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 ((!(Read((&(aParentWidget)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_HideAllPlugins__ID, (&(mState)));
            if ((!(RecvHideAllPlugins(mozilla::Move(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 ((!(Read((&(aMessages)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_ParentAsyncMessages__ID, (&(mState)));
            if ((!(RecvParentAsyncMessages(mozilla::Move(aMessages))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

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

            PickleIterator iter__(msg__);
            uint64_t aLayersId;
            uint64_t aEpoch;
            bool aActive;

            if ((!(Read((&(aLayersId)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aLayersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1401196721)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(Read((&(aEpoch)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aEpoch'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2333012390)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(Read((&(aActive)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_ObserveLayerUpdate__ID, (&(mState)));
            if ((!(RecvObserveLayerUpdate(mozilla::Move(aLayersId), mozilla::Move(aEpoch), mozilla::Move(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;
            uint64_t aLayersId;
            uint32_t aAPZCId;

            if ((!(Read((&(metrics)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'Handle'");
                return MsgValueError;
            }
            // Sentinel = 'metrics'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 293471184)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Handle'");
                return MsgValueError;
            }
            if ((!(Read((&(mutex)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'CrossProcessMutexHandle'");
                return MsgValueError;
            }
            // Sentinel = 'mutex'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4247164084)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'CrossProcessMutexHandle'");
                return MsgValueError;
            }
            if ((!(Read((&(aLayersId)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'aLayersId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1401196721)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(Read((&(aAPZCId)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_SharedCompositorFrameMetrics__ID, (&(mState)));
            if ((!(RecvSharedCompositorFrameMetrics(mozilla::Move(metrics), mozilla::Move(mutex), mozilla::Move(aLayersId), mozilla::Move(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 ((!(Read((&(aId)), (&(msg__)), (&(iter__)))))) {
                FatalError("Error deserializing 'ViewID'");
                return MsgValueError;
            }
            // Sentinel = 'aId'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041817)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ViewID'");
                return MsgValueError;
            }
            if ((!(Read((&(aAPZCId)), (&(msg__)), (&(iter__)))))) {
                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());
            PCompositorBridge::Transition(PCompositorBridge::Msg_ReleaseSharedCompositorFrameMetrics__ID, (&(mState)));
            if ((!(RecvReleaseSharedCompositorFrameMetrics(mozilla::Move(aId), mozilla::Move(aAPZCId))))) {
                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::ProtocolName() const -> const char*
{
    return "PCompositorBridgeChild";
}

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 promises.
    (GetIPCChannel())->RejectPendingPromisesForActor(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();
    }
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptor& v__,
        Message* msg__) -> void
{
    typedef SurfaceDescriptor type__;
    Write(int((v__).type()), msg__);
    // Sentinel = 'SurfaceDescriptor'
    (msg__)->WriteSentinel(1058499359);

    switch ((v__).type()) {
    case type__::TSurfaceDescriptorBuffer:
        {
            Write((v__).get_SurfaceDescriptorBuffer(), msg__);
            // Sentinel = 'TSurfaceDescriptorBuffer'
            (msg__)->WriteSentinel(2202696360);
            return;
        }
    case type__::TSurfaceDescriptorDIB:
        {
            Write((v__).get_SurfaceDescriptorDIB(), msg__);
            // Sentinel = 'TSurfaceDescriptorDIB'
            (msg__)->WriteSentinel(998410538);
            return;
        }
    case type__::TSurfaceDescriptorD3D10:
        {
            Write((v__).get_SurfaceDescriptorD3D10(), msg__);
            // Sentinel = 'TSurfaceDescriptorD3D10'
            (msg__)->WriteSentinel(2753564567);
            return;
        }
    case type__::TSurfaceDescriptorFileMapping:
        {
            Write((v__).get_SurfaceDescriptorFileMapping(), msg__);
            // Sentinel = 'TSurfaceDescriptorFileMapping'
            (msg__)->WriteSentinel(722196935);
            return;
        }
    case type__::TSurfaceDescriptorDXGIYCbCr:
        {
            Write((v__).get_SurfaceDescriptorDXGIYCbCr(), msg__);
            // Sentinel = 'TSurfaceDescriptorDXGIYCbCr'
            (msg__)->WriteSentinel(3061212892);
            return;
        }
    case type__::TSurfaceDescriptorX11:
        {
            Write((v__).get_SurfaceDescriptorX11(), msg__);
            // Sentinel = 'TSurfaceDescriptorX11'
            (msg__)->WriteSentinel(3923930613);
            return;
        }
    case type__::TSurfaceTextureDescriptor:
        {
            Write((v__).get_SurfaceTextureDescriptor(), msg__);
            // Sentinel = 'TSurfaceTextureDescriptor'
            (msg__)->WriteSentinel(2253946800);
            return;
        }
    case type__::TEGLImageDescriptor:
        {
            Write((v__).get_EGLImageDescriptor(), msg__);
            // Sentinel = 'TEGLImageDescriptor'
            (msg__)->WriteSentinel(2680446099);
            return;
        }
    case type__::TSurfaceDescriptorMacIOSurface:
        {
            Write((v__).get_SurfaceDescriptorMacIOSurface(), msg__);
            // Sentinel = 'TSurfaceDescriptorMacIOSurface'
            (msg__)->WriteSentinel(4267688786);
            return;
        }
    case type__::TSurfaceDescriptorSharedGLTexture:
        {
            Write((v__).get_SurfaceDescriptorSharedGLTexture(), msg__);
            // Sentinel = 'TSurfaceDescriptorSharedGLTexture'
            (msg__)->WriteSentinel(4169514976);
            return;
        }
    case type__::TSurfaceDescriptorGPUVideo:
        {
            Write((v__).get_SurfaceDescriptorGPUVideo(), msg__);
            // Sentinel = 'TSurfaceDescriptorGPUVideo'
            (msg__)->WriteSentinel(2406892431);
            return;
        }
    case type__::Tnull_t:
        {
            Write((v__).get_null_t(), msg__);
            // Sentinel = 'Tnull_t'
            (msg__)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            FatalError("unknown union type");
            return;
        }
    }
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    typedef SurfaceDescriptor type__;
    int type;
    if ((!(Read((&(type)), msg__, iter__)))) {
        mozilla::ipc::UnionTypeReadError("SurfaceDescriptor");
        return false;
    }
    // Sentinel = 'SurfaceDescriptor'
    if ((!((msg__)->ReadSentinel(iter__, 1058499359)))) {
        mozilla::ipc::SentinelReadError("SurfaceDescriptor");
        return false;
    }

    switch (type) {
    case type__::TSurfaceDescriptorBuffer:
        {
            SurfaceDescriptorBuffer tmp = SurfaceDescriptorBuffer();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorBuffer())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorBuffer'
            if ((!((msg__)->ReadSentinel(iter__, 2202696360)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorDIB:
        {
            SurfaceDescriptorDIB tmp = SurfaceDescriptorDIB();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorDIB())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorDIB'
            if ((!((msg__)->ReadSentinel(iter__, 998410538)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorD3D10:
        {
            SurfaceDescriptorD3D10 tmp = SurfaceDescriptorD3D10();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorD3D10())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorD3D10'
            if ((!((msg__)->ReadSentinel(iter__, 2753564567)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorFileMapping:
        {
            SurfaceDescriptorFileMapping tmp = SurfaceDescriptorFileMapping();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorFileMapping())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorFileMapping'
            if ((!((msg__)->ReadSentinel(iter__, 722196935)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorDXGIYCbCr:
        {
            SurfaceDescriptorDXGIYCbCr tmp = SurfaceDescriptorDXGIYCbCr();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorDXGIYCbCr())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorDXGIYCbCr'
            if ((!((msg__)->ReadSentinel(iter__, 3061212892)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorX11:
        {
            SurfaceDescriptorX11 tmp = SurfaceDescriptorX11();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorX11())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorX11'
            if ((!((msg__)->ReadSentinel(iter__, 3923930613)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceTextureDescriptor:
        {
            SurfaceTextureDescriptor tmp = SurfaceTextureDescriptor();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceTextureDescriptor())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceTextureDescriptor'
            if ((!((msg__)->ReadSentinel(iter__, 2253946800)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TEGLImageDescriptor:
        {
            EGLImageDescriptor tmp = EGLImageDescriptor();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_EGLImageDescriptor())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TEGLImageDescriptor'
            if ((!((msg__)->ReadSentinel(iter__, 2680446099)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorMacIOSurface:
        {
            SurfaceDescriptorMacIOSurface tmp = SurfaceDescriptorMacIOSurface();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorMacIOSurface())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorMacIOSurface'
            if ((!((msg__)->ReadSentinel(iter__, 4267688786)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorSharedGLTexture:
        {
            SurfaceDescriptorSharedGLTexture tmp = SurfaceDescriptorSharedGLTexture();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorSharedGLTexture())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorSharedGLTexture'
            if ((!((msg__)->ReadSentinel(iter__, 4169514976)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TSurfaceDescriptorGPUVideo:
        {
            SurfaceDescriptorGPUVideo tmp = SurfaceDescriptorGPUVideo();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_SurfaceDescriptorGPUVideo())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TSurfaceDescriptorGPUVideo'
            if ((!((msg__)->ReadSentinel(iter__, 2406892431)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::Tnull_t:
        {
            null_t tmp = null_t();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_null_t())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((msg__)->ReadSentinel(iter__, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    default:
        {
            FatalError("unknown union type");
            return false;
        }
    }
}

auto PCompositorBridgeChild::Write(
        const PAPZChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PAPZChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PAPZ", PAPZMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PAPZChild*>((actor).value());
    return true;
}

auto PCompositorBridgeChild::Write(
        const nsTArray<PluginWindowData>& v__,
        Message* msg__) -> void
{
    uint32_t length = (v__).Length();
    Write(length, msg__);
    // Sentinel = ('length', 'PluginWindowData[]')
    (msg__)->WriteSentinel(3757363184);

    for (auto& elem : v__) {
        Write(elem, msg__);
        // Sentinel = 'PluginWindowData[]'
        (msg__)->WriteSentinel(3814367271);
    }
}

auto PCompositorBridgeChild::Read(
        nsTArray<PluginWindowData>* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    nsTArray<PluginWindowData> fa;
    uint32_t length;
    if ((!(Read((&(length)), msg__, iter__)))) {
        mozilla::ipc::ArrayLengthReadError("PluginWindowData[]");
        return false;
    }
    // Sentinel = ('length', 'PluginWindowData[]')
    if ((!((msg__)->ReadSentinel(iter__, 3757363184)))) {
        mozilla::ipc::SentinelReadError("PluginWindowData[]");
        return false;
    }

    PluginWindowData* elems = (fa).AppendElements(length);
    for (uint32_t i = 0; (i) < (length); (++(i))) {
        if ((!(Read((&(elems[i])), msg__, iter__)))) {
            FatalError("Error deserializing 'PluginWindowData[i]'");
            return false;
        }
        // Sentinel = 'PluginWindowData[]'
        if ((!((msg__)->ReadSentinel(iter__, 3814367271)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'PluginWindowData[i]'");
            return false;
        }
    }
    (v__)->SwapElements(fa);
    return true;
}

auto PCompositorBridgeChild::Write(
        const PCompositorWidgetChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PCompositorWidgetChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCompositorWidget", PCompositorWidgetMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PCompositorWidgetChild*>((actor).value());
    return true;
}

auto PCompositorBridgeChild::Write(
        const PCompositorBridgeChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PCompositorBridgeChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PCompositorBridge", PCompositorBridgeMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PCompositorBridgeChild*>((actor).value());
    return true;
}

auto PCompositorBridgeChild::Write(
        const PAPZCTreeManagerChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PAPZCTreeManagerChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PAPZCTreeManager", PAPZCTreeManagerMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PAPZCTreeManagerChild*>((actor).value());
    return true;
}

auto PCompositorBridgeChild::Write(
        Shmem& v__,
        Message* msg__) -> void
{
    IPC::WriteParam(msg__, v__);
    (v__).RevokeRights(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    (v__).forget(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
}

auto PCompositorBridgeChild::Read(
        Shmem* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    Shmem tmp;
    if ((!(IPC::ReadParam(msg__, iter__, (&(tmp)))))) {
        return false;
    }

    Shmem::id_t shmemid = (tmp).Id(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead());
    Shmem::SharedMemory* rawmem = LookupSharedMemory(shmemid);
    if (rawmem) {
        (*(v__)) = Shmem(Shmem::IHadBetterBeIPDLCodeCallingThis_OtherwiseIAmADoodyhead(), rawmem, shmemid);
        return true;
    }
    (*(v__)) = Shmem();
    return true;
}

auto PCompositorBridgeChild::Write(
        const HeadlessCompositorWidgetInitData& v__,
        Message* msg__) -> void
{
    Write((v__).InitialClientSize(), msg__);
    // Sentinel = 'InitialClientSize'
    (msg__)->WriteSentinel(3343771687);
}

auto PCompositorBridgeChild::Read(
        HeadlessCompositorWidgetInitData* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->InitialClientSize())), msg__, iter__)))) {
        FatalError("Error deserializing 'InitialClientSize' (LayoutDeviceIntSize) member of 'HeadlessCompositorWidgetInitData'");
        return false;
    }
    // Sentinel = 'InitialClientSize'
    if ((!((msg__)->ReadSentinel(iter__, 3343771687)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'InitialClientSize' (LayoutDeviceIntSize) member of 'HeadlessCompositorWidgetInitData'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const AsyncParentMessageData& v__,
        Message* msg__) -> void
{
    typedef AsyncParentMessageData type__;
    Write(int((v__).type()), msg__);
    // Sentinel = 'AsyncParentMessageData'
    (msg__)->WriteSentinel(3809282103);

    switch ((v__).type()) {
    case type__::TOpNotifyNotUsed:
        {
            Write((v__).get_OpNotifyNotUsed(), msg__);
            // Sentinel = 'TOpNotifyNotUsed'
            (msg__)->WriteSentinel(2920493638);
            return;
        }
    default:
        {
            FatalError("unknown union type");
            return;
        }
    }
}

auto PCompositorBridgeChild::Read(
        AsyncParentMessageData* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    typedef AsyncParentMessageData type__;
    int type;
    if ((!(Read((&(type)), msg__, iter__)))) {
        mozilla::ipc::UnionTypeReadError("AsyncParentMessageData");
        return false;
    }
    // Sentinel = 'AsyncParentMessageData'
    if ((!((msg__)->ReadSentinel(iter__, 3809282103)))) {
        mozilla::ipc::SentinelReadError("AsyncParentMessageData");
        return false;
    }

    switch (type) {
    case type__::TOpNotifyNotUsed:
        {
            OpNotifyNotUsed tmp = OpNotifyNotUsed();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_OpNotifyNotUsed())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TOpNotifyNotUsed'
            if ((!((msg__)->ReadSentinel(iter__, 2920493638)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    default:
        {
            FatalError("unknown union type");
            return false;
        }
    }
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorBuffer& v__,
        Message* msg__) -> void
{
    Write((v__).desc(), msg__);
    // Sentinel = 'desc'
    (msg__)->WriteSentinel(3761872479);
    Write((v__).data(), msg__);
    // Sentinel = 'data'
    (msg__)->WriteSentinel(843352540);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorBuffer* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->desc())), msg__, iter__)))) {
        FatalError("Error deserializing 'desc' (BufferDescriptor) member of 'SurfaceDescriptorBuffer'");
        return false;
    }
    // Sentinel = 'desc'
    if ((!((msg__)->ReadSentinel(iter__, 3761872479)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'desc' (BufferDescriptor) member of 'SurfaceDescriptorBuffer'");
        return false;
    }
    if ((!(Read((&((v__)->data())), msg__, iter__)))) {
        FatalError("Error deserializing 'data' (MemoryOrShmem) member of 'SurfaceDescriptorBuffer'");
        return false;
    }
    // Sentinel = 'data'
    if ((!((msg__)->ReadSentinel(iter__, 843352540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (MemoryOrShmem) member of 'SurfaceDescriptorBuffer'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const YCbCrDescriptor& v__,
        Message* msg__) -> void
{
    Write((v__).ySize(), msg__);
    // Sentinel = 'ySize'
    (msg__)->WriteSentinel(313512843);
    Write((v__).cbCrSize(), msg__);
    // Sentinel = 'cbCrSize'
    (msg__)->WriteSentinel(2601117167);
    Write((v__).yOffset(), msg__);
    // Sentinel = 'yOffset'
    (msg__)->WriteSentinel(983795183);
    Write((v__).cbOffset(), msg__);
    // Sentinel = 'cbOffset'
    (msg__)->WriteSentinel(4197159602);
    Write((v__).crOffset(), msg__);
    // Sentinel = 'crOffset'
    (msg__)->WriteSentinel(1739681986);
    Write((v__).stereoMode(), msg__);
    // Sentinel = 'stereoMode'
    (msg__)->WriteSentinel(2234072623);
    Write((v__).yUVColorSpace(), msg__);
    // Sentinel = 'yUVColorSpace'
    (msg__)->WriteSentinel(1051398544);
    Write((v__).hasIntermediateBuffer(), msg__);
    // Sentinel = 'hasIntermediateBuffer'
    (msg__)->WriteSentinel(985857996);
}

auto PCompositorBridgeChild::Read(
        YCbCrDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->ySize())), msg__, iter__)))) {
        FatalError("Error deserializing 'ySize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'ySize'
    if ((!((msg__)->ReadSentinel(iter__, 313512843)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ySize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->cbCrSize())), msg__, iter__)))) {
        FatalError("Error deserializing 'cbCrSize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'cbCrSize'
    if ((!((msg__)->ReadSentinel(iter__, 2601117167)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cbCrSize' (IntSize) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->yOffset())), msg__, iter__)))) {
        FatalError("Error deserializing 'yOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'yOffset'
    if ((!((msg__)->ReadSentinel(iter__, 983795183)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'yOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->cbOffset())), msg__, iter__)))) {
        FatalError("Error deserializing 'cbOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'cbOffset'
    if ((!((msg__)->ReadSentinel(iter__, 4197159602)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cbOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->crOffset())), msg__, iter__)))) {
        FatalError("Error deserializing 'crOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'crOffset'
    if ((!((msg__)->ReadSentinel(iter__, 1739681986)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'crOffset' (uint32_t) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->stereoMode())), msg__, iter__)))) {
        FatalError("Error deserializing 'stereoMode' (StereoMode) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'stereoMode'
    if ((!((msg__)->ReadSentinel(iter__, 2234072623)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stereoMode' (StereoMode) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->yUVColorSpace())), msg__, iter__)))) {
        FatalError("Error deserializing 'yUVColorSpace' (YUVColorSpace) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'yUVColorSpace'
    if ((!((msg__)->ReadSentinel(iter__, 1051398544)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'yUVColorSpace' (YUVColorSpace) member of 'YCbCrDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->hasIntermediateBuffer())), msg__, iter__)))) {
        FatalError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'YCbCrDescriptor'");
        return false;
    }
    // Sentinel = 'hasIntermediateBuffer'
    if ((!((msg__)->ReadSentinel(iter__, 985857996)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'YCbCrDescriptor'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorSharedGLTexture& v__,
        Message* msg__) -> void
{
    Write((v__).texture(), msg__);
    // Sentinel = 'texture'
    (msg__)->WriteSentinel(3654462510);
    Write((v__).target(), msg__);
    // Sentinel = 'target'
    (msg__)->WriteSentinel(2226365285);
    Write((v__).fence(), msg__);
    // Sentinel = 'fence'
    (msg__)->WriteSentinel(1225633926);
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
    Write((v__).hasAlpha(), msg__);
    // Sentinel = 'hasAlpha'
    (msg__)->WriteSentinel(309498444);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorSharedGLTexture* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->texture())), msg__, iter__)))) {
        FatalError("Error deserializing 'texture' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'texture'
    if ((!((msg__)->ReadSentinel(iter__, 3654462510)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'texture' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(Read((&((v__)->target())), msg__, iter__)))) {
        FatalError("Error deserializing 'target' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'target'
    if ((!((msg__)->ReadSentinel(iter__, 2226365285)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'target' (uint32_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(Read((&((v__)->fence())), msg__, iter__)))) {
        FatalError("Error deserializing 'fence' (uintptr_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'fence'
    if ((!((msg__)->ReadSentinel(iter__, 1225633926)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fence' (uintptr_t) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    if ((!(Read((&((v__)->hasAlpha())), msg__, iter__)))) {
        FatalError("Error deserializing 'hasAlpha' (bool) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    // Sentinel = 'hasAlpha'
    if ((!((msg__)->ReadSentinel(iter__, 309498444)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasAlpha' (bool) member of 'SurfaceDescriptorSharedGLTexture'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorGPUVideo& v__,
        Message* msg__) -> void
{
    Write((v__).handle(), msg__);
    // Sentinel = 'handle'
    (msg__)->WriteSentinel(453975108);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorGPUVideo* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->handle())), msg__, iter__)))) {
        FatalError("Error deserializing 'handle' (uint64_t) member of 'SurfaceDescriptorGPUVideo'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((msg__)->ReadSentinel(iter__, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (uint64_t) member of 'SurfaceDescriptorGPUVideo'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorD3D10& v__,
        Message* msg__) -> void
{
    Write((v__).handle(), msg__);
    // Sentinel = 'handle'
    (msg__)->WriteSentinel(453975108);
    Write((v__).format(), msg__);
    // Sentinel = 'format'
    (msg__)->WriteSentinel(2052265543);
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorD3D10* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->handle())), msg__, iter__)))) {
        FatalError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((msg__)->ReadSentinel(iter__, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    if ((!(Read((&((v__)->format())), msg__, iter__)))) {
        FatalError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((msg__)->ReadSentinel(iter__, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorD3D10'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const nsTArray<AsyncParentMessageData>& v__,
        Message* msg__) -> void
{
    uint32_t length = (v__).Length();
    Write(length, msg__);
    // Sentinel = ('length', 'AsyncParentMessageData[]')
    (msg__)->WriteSentinel(3866187970);

    for (auto& elem : v__) {
        Write(elem, msg__);
        // Sentinel = 'AsyncParentMessageData[]'
        (msg__)->WriteSentinel(4194735789);
    }
}

auto PCompositorBridgeChild::Read(
        nsTArray<AsyncParentMessageData>* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    nsTArray<AsyncParentMessageData> fa;
    uint32_t length;
    if ((!(Read((&(length)), msg__, iter__)))) {
        mozilla::ipc::ArrayLengthReadError("AsyncParentMessageData[]");
        return false;
    }
    // Sentinel = ('length', 'AsyncParentMessageData[]')
    if ((!((msg__)->ReadSentinel(iter__, 3866187970)))) {
        mozilla::ipc::SentinelReadError("AsyncParentMessageData[]");
        return false;
    }

    AsyncParentMessageData* elems = (fa).AppendElements(length);
    for (uint32_t i = 0; (i) < (length); (++(i))) {
        if ((!(Read((&(elems[i])), msg__, iter__)))) {
            FatalError("Error deserializing 'AsyncParentMessageData[i]'");
            return false;
        }
        // Sentinel = 'AsyncParentMessageData[]'
        if ((!((msg__)->ReadSentinel(iter__, 4194735789)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'AsyncParentMessageData[i]'");
            return false;
        }
    }
    (v__)->SwapElements(fa);
    return true;
}

auto PCompositorBridgeChild::Write(
        const OpNotifyNotUsed& v__,
        Message* msg__) -> void
{
    Write((v__).TextureId(), msg__);
    // Sentinel = 'TextureId'
    (msg__)->WriteSentinel(2545498075);
    Write((v__).fwdTransactionId(), msg__);
    // Sentinel = 'fwdTransactionId'
    (msg__)->WriteSentinel(2023976742);
}

auto PCompositorBridgeChild::Read(
        OpNotifyNotUsed* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->TextureId())), msg__, iter__)))) {
        FatalError("Error deserializing 'TextureId' (uint64_t) member of 'OpNotifyNotUsed'");
        return false;
    }
    // Sentinel = 'TextureId'
    if ((!((msg__)->ReadSentinel(iter__, 2545498075)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TextureId' (uint64_t) member of 'OpNotifyNotUsed'");
        return false;
    }
    if ((!(Read((&((v__)->fwdTransactionId())), msg__, iter__)))) {
        FatalError("Error deserializing 'fwdTransactionId' (uint64_t) member of 'OpNotifyNotUsed'");
        return false;
    }
    // Sentinel = 'fwdTransactionId'
    if ((!((msg__)->ReadSentinel(iter__, 2023976742)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fwdTransactionId' (uint64_t) member of 'OpNotifyNotUsed'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorFileMapping& v__,
        Message* msg__) -> void
{
    Write((v__).handle(), msg__);
    // Sentinel = 'handle'
    (msg__)->WriteSentinel(453975108);
    Write((v__).format(), msg__);
    // Sentinel = 'format'
    (msg__)->WriteSentinel(2052265543);
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorFileMapping* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->handle())), msg__, iter__)))) {
        FatalError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((msg__)->ReadSentinel(iter__, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (WindowsHandle) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    if ((!(Read((&((v__)->format())), msg__, iter__)))) {
        FatalError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((msg__)->ReadSentinel(iter__, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorFileMapping'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorDIB& v__,
        Message* msg__) -> void
{
    Write((v__).surface(), msg__);
    // Sentinel = 'surface'
    (msg__)->WriteSentinel(2386836878);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorDIB* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->surface())), msg__, iter__)))) {
        FatalError("Error deserializing 'surface' (uintptr_t) member of 'SurfaceDescriptorDIB'");
        return false;
    }
    // Sentinel = 'surface'
    if ((!((msg__)->ReadSentinel(iter__, 2386836878)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'surface' (uintptr_t) member of 'SurfaceDescriptorDIB'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const PLayerTransactionChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PLayerTransactionChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PLayerTransaction", PLayerTransactionMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PLayerTransactionChild*>((actor).value());
    return true;
}

auto PCompositorBridgeChild::Write(
        const PWebRenderBridgeChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PWebRenderBridgeChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PWebRenderBridge", PWebRenderBridgeMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PWebRenderBridgeChild*>((actor).value());
    return true;
}

auto PCompositorBridgeChild::Write(
        const EGLImageDescriptor& v__,
        Message* msg__) -> void
{
    Write((v__).image(), msg__);
    // Sentinel = 'image'
    (msg__)->WriteSentinel(103190282);
    Write((v__).fence(), msg__);
    // Sentinel = 'fence'
    (msg__)->WriteSentinel(1225633926);
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
    Write((v__).hasAlpha(), msg__);
    // Sentinel = 'hasAlpha'
    (msg__)->WriteSentinel(309498444);
}

auto PCompositorBridgeChild::Read(
        EGLImageDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->image())), msg__, iter__)))) {
        FatalError("Error deserializing 'image' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'image'
    if ((!((msg__)->ReadSentinel(iter__, 103190282)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'image' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->fence())), msg__, iter__)))) {
        FatalError("Error deserializing 'fence' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'fence'
    if ((!((msg__)->ReadSentinel(iter__, 1225633926)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fence' (uintptr_t) member of 'EGLImageDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'EGLImageDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->hasAlpha())), msg__, iter__)))) {
        FatalError("Error deserializing 'hasAlpha' (bool) member of 'EGLImageDescriptor'");
        return false;
    }
    // Sentinel = 'hasAlpha'
    if ((!((msg__)->ReadSentinel(iter__, 309498444)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasAlpha' (bool) member of 'EGLImageDescriptor'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const RGBDescriptor& v__,
        Message* msg__) -> void
{
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
    Write((v__).format(), msg__);
    // Sentinel = 'format'
    (msg__)->WriteSentinel(2052265543);
    Write((v__).hasIntermediateBuffer(), msg__);
    // Sentinel = 'hasIntermediateBuffer'
    (msg__)->WriteSentinel(985857996);
}

auto PCompositorBridgeChild::Read(
        RGBDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'RGBDescriptor'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'RGBDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->format())), msg__, iter__)))) {
        FatalError("Error deserializing 'format' (SurfaceFormat) member of 'RGBDescriptor'");
        return false;
    }
    // Sentinel = 'format'
    if ((!((msg__)->ReadSentinel(iter__, 2052265543)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'format' (SurfaceFormat) member of 'RGBDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->hasIntermediateBuffer())), msg__, iter__)))) {
        FatalError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'RGBDescriptor'");
        return false;
    }
    // Sentinel = 'hasIntermediateBuffer'
    if ((!((msg__)->ReadSentinel(iter__, 985857996)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'hasIntermediateBuffer' (bool) member of 'RGBDescriptor'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorDXGIYCbCr& v__,
        Message* msg__) -> void
{
    Write((v__).handleY(), msg__);
    // Sentinel = 'handleY'
    (msg__)->WriteSentinel(2719705368);
    Write((v__).handleCb(), msg__);
    // Sentinel = 'handleCb'
    (msg__)->WriteSentinel(2777335333);
    Write((v__).handleCr(), msg__);
    // Sentinel = 'handleCr'
    (msg__)->WriteSentinel(2777335349);
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
    Write((v__).sizeY(), msg__);
    // Sentinel = 'sizeY'
    (msg__)->WriteSentinel(886619725);
    Write((v__).sizeCbCr(), msg__);
    // Sentinel = 'sizeCbCr'
    (msg__)->WriteSentinel(2196484423);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorDXGIYCbCr* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->handleY())), msg__, iter__)))) {
        FatalError("Error deserializing 'handleY' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'handleY'
    if ((!((msg__)->ReadSentinel(iter__, 2719705368)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleY' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(Read((&((v__)->handleCb())), msg__, iter__)))) {
        FatalError("Error deserializing 'handleCb' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'handleCb'
    if ((!((msg__)->ReadSentinel(iter__, 2777335333)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleCb' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(Read((&((v__)->handleCr())), msg__, iter__)))) {
        FatalError("Error deserializing 'handleCr' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'handleCr'
    if ((!((msg__)->ReadSentinel(iter__, 2777335349)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handleCr' (WindowsHandle) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(Read((&((v__)->sizeY())), msg__, iter__)))) {
        FatalError("Error deserializing 'sizeY' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'sizeY'
    if ((!((msg__)->ReadSentinel(iter__, 886619725)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sizeY' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    if ((!(Read((&((v__)->sizeCbCr())), msg__, iter__)))) {
        FatalError("Error deserializing 'sizeCbCr' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    // Sentinel = 'sizeCbCr'
    if ((!((msg__)->ReadSentinel(iter__, 2196484423)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sizeCbCr' (IntSize) member of 'SurfaceDescriptorDXGIYCbCr'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const MemoryOrShmem& v__,
        Message* msg__) -> void
{
    typedef MemoryOrShmem type__;
    Write(int((v__).type()), msg__);
    // Sentinel = 'MemoryOrShmem'
    (msg__)->WriteSentinel(3227621763);

    switch ((v__).type()) {
    case type__::Tuintptr_t:
        {
            Write((v__).get_uintptr_t(), msg__);
            // Sentinel = 'Tuintptr_t'
            (msg__)->WriteSentinel(3218141805);
            return;
        }
    case type__::TShmem:
        {
            Write((v__).get_Shmem(), msg__);
            // Sentinel = 'TShmem'
            (msg__)->WriteSentinel(3517971266);
            return;
        }
    default:
        {
            FatalError("unknown union type");
            return;
        }
    }
}

auto PCompositorBridgeChild::Read(
        MemoryOrShmem* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    typedef MemoryOrShmem type__;
    int type;
    if ((!(Read((&(type)), msg__, iter__)))) {
        mozilla::ipc::UnionTypeReadError("MemoryOrShmem");
        return false;
    }
    // Sentinel = 'MemoryOrShmem'
    if ((!((msg__)->ReadSentinel(iter__, 3227621763)))) {
        mozilla::ipc::SentinelReadError("MemoryOrShmem");
        return false;
    }

    switch (type) {
    case type__::Tuintptr_t:
        {
            uintptr_t tmp = uintptr_t();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_uintptr_t())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'Tuintptr_t'
            if ((!((msg__)->ReadSentinel(iter__, 3218141805)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TShmem:
        {
            Shmem tmp = Shmem();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_Shmem())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TShmem'
            if ((!((msg__)->ReadSentinel(iter__, 3517971266)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    default:
        {
            FatalError("unknown union type");
            return false;
        }
    }
}

auto PCompositorBridgeChild::Write(
        const PluginWindowData& v__,
        Message* msg__) -> void
{
    Write((v__).windowId(), msg__);
    // Sentinel = 'windowId'
    (msg__)->WriteSentinel(719502035);
    Write((v__).clip(), msg__);
    // Sentinel = 'clip'
    (msg__)->WriteSentinel(3899292550);
    Write((v__).bounds(), msg__);
    // Sentinel = 'bounds'
    (msg__)->WriteSentinel(809584493);
    Write((v__).visible(), msg__);
    // Sentinel = 'visible'
    (msg__)->WriteSentinel(1037099281);
}

auto PCompositorBridgeChild::Read(
        PluginWindowData* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->windowId())), msg__, iter__)))) {
        FatalError("Error deserializing 'windowId' (uintptr_t) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'windowId'
    if ((!((msg__)->ReadSentinel(iter__, 719502035)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'windowId' (uintptr_t) member of 'PluginWindowData'");
        return false;
    }
    if ((!(Read((&((v__)->clip())), msg__, iter__)))) {
        FatalError("Error deserializing 'clip' (LayoutDeviceIntRect[]) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'clip'
    if ((!((msg__)->ReadSentinel(iter__, 3899292550)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clip' (LayoutDeviceIntRect[]) member of 'PluginWindowData'");
        return false;
    }
    if ((!(Read((&((v__)->bounds())), msg__, iter__)))) {
        FatalError("Error deserializing 'bounds' (LayoutDeviceIntRect) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'bounds'
    if ((!((msg__)->ReadSentinel(iter__, 809584493)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bounds' (LayoutDeviceIntRect) member of 'PluginWindowData'");
        return false;
    }
    if ((!(Read((&((v__)->visible())), msg__, iter__)))) {
        FatalError("Error deserializing 'visible' (bool) member of 'PluginWindowData'");
        return false;
    }
    // Sentinel = 'visible'
    if ((!((msg__)->ReadSentinel(iter__, 1037099281)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'visible' (bool) member of 'PluginWindowData'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const CompositorWidgetInitData& v__,
        Message* msg__) -> void
{
    typedef CompositorWidgetInitData type__;
    Write(int((v__).type()), msg__);
    // Sentinel = 'CompositorWidgetInitData'
    (msg__)->WriteSentinel(1324856037);

    switch ((v__).type()) {
    case type__::THeadlessCompositorWidgetInitData:
        {
            Write((v__).get_HeadlessCompositorWidgetInitData(), msg__);
            // Sentinel = 'THeadlessCompositorWidgetInitData'
            (msg__)->WriteSentinel(210151885);
            return;
        }
    default:
        {
            FatalError("unknown union type");
            return;
        }
    }
}

auto PCompositorBridgeChild::Read(
        CompositorWidgetInitData* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    typedef CompositorWidgetInitData type__;
    int type;
    if ((!(Read((&(type)), msg__, iter__)))) {
        mozilla::ipc::UnionTypeReadError("CompositorWidgetInitData");
        return false;
    }
    // Sentinel = 'CompositorWidgetInitData'
    if ((!((msg__)->ReadSentinel(iter__, 1324856037)))) {
        mozilla::ipc::SentinelReadError("CompositorWidgetInitData");
        return false;
    }

    switch (type) {
    case type__::THeadlessCompositorWidgetInitData:
        {
            HeadlessCompositorWidgetInitData tmp = HeadlessCompositorWidgetInitData();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_HeadlessCompositorWidgetInitData())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'THeadlessCompositorWidgetInitData'
            if ((!((msg__)->ReadSentinel(iter__, 210151885)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    default:
        {
            FatalError("unknown union type");
            return false;
        }
    }
}

auto PCompositorBridgeChild::Write(
        const SurfaceTextureDescriptor& v__,
        Message* msg__) -> void
{
    Write((v__).handle(), msg__);
    // Sentinel = 'handle'
    (msg__)->WriteSentinel(453975108);
    Write((v__).size(), msg__);
    // Sentinel = 'size'
    (msg__)->WriteSentinel(931048223);
    Write((v__).continuous(), msg__);
    // Sentinel = 'continuous'
    (msg__)->WriteSentinel(2103626571);
}

auto PCompositorBridgeChild::Read(
        SurfaceTextureDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->handle())), msg__, iter__)))) {
        FatalError("Error deserializing 'handle' (uint64_t) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'handle'
    if ((!((msg__)->ReadSentinel(iter__, 453975108)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'handle' (uint64_t) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->size())), msg__, iter__)))) {
        FatalError("Error deserializing 'size' (IntSize) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((msg__)->ReadSentinel(iter__, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (IntSize) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    if ((!(Read((&((v__)->continuous())), msg__, iter__)))) {
        FatalError("Error deserializing 'continuous' (bool) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    // Sentinel = 'continuous'
    if ((!((msg__)->ReadSentinel(iter__, 2103626571)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'continuous' (bool) member of 'SurfaceTextureDescriptor'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const SurfaceDescriptorMacIOSurface& v__,
        Message* msg__) -> void
{
    Write((v__).surfaceId(), msg__);
    // Sentinel = 'surfaceId'
    (msg__)->WriteSentinel(4108848731);
    Write((v__).scaleFactor(), msg__);
    // Sentinel = 'scaleFactor'
    (msg__)->WriteSentinel(1184637148);
    Write((v__).isOpaque(), msg__);
    // Sentinel = 'isOpaque'
    (msg__)->WriteSentinel(3519081617);
}

auto PCompositorBridgeChild::Read(
        SurfaceDescriptorMacIOSurface* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->surfaceId())), msg__, iter__)))) {
        FatalError("Error deserializing 'surfaceId' (uint32_t) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    // Sentinel = 'surfaceId'
    if ((!((msg__)->ReadSentinel(iter__, 4108848731)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'surfaceId' (uint32_t) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    if ((!(Read((&((v__)->scaleFactor())), msg__, iter__)))) {
        FatalError("Error deserializing 'scaleFactor' (double) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    // Sentinel = 'scaleFactor'
    if ((!((msg__)->ReadSentinel(iter__, 1184637148)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scaleFactor' (double) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    if ((!(Read((&((v__)->isOpaque())), msg__, iter__)))) {
        FatalError("Error deserializing 'isOpaque' (bool) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    // Sentinel = 'isOpaque'
    if ((!((msg__)->ReadSentinel(iter__, 3519081617)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isOpaque' (bool) member of 'SurfaceDescriptorMacIOSurface'");
        return false;
    }
    return true;
}

auto PCompositorBridgeChild::Write(
        const BufferDescriptor& v__,
        Message* msg__) -> void
{
    typedef BufferDescriptor type__;
    Write(int((v__).type()), msg__);
    // Sentinel = 'BufferDescriptor'
    (msg__)->WriteSentinel(764535685);

    switch ((v__).type()) {
    case type__::TRGBDescriptor:
        {
            Write((v__).get_RGBDescriptor(), msg__);
            // Sentinel = 'TRGBDescriptor'
            (msg__)->WriteSentinel(2888062100);
            return;
        }
    case type__::TYCbCrDescriptor:
        {
            Write((v__).get_YCbCrDescriptor(), msg__);
            // Sentinel = 'TYCbCrDescriptor'
            (msg__)->WriteSentinel(3533945878);
            return;
        }
    default:
        {
            FatalError("unknown union type");
            return;
        }
    }
}

auto PCompositorBridgeChild::Read(
        BufferDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    typedef BufferDescriptor type__;
    int type;
    if ((!(Read((&(type)), msg__, iter__)))) {
        mozilla::ipc::UnionTypeReadError("BufferDescriptor");
        return false;
    }
    // Sentinel = 'BufferDescriptor'
    if ((!((msg__)->ReadSentinel(iter__, 764535685)))) {
        mozilla::ipc::SentinelReadError("BufferDescriptor");
        return false;
    }

    switch (type) {
    case type__::TRGBDescriptor:
        {
            RGBDescriptor tmp = RGBDescriptor();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_RGBDescriptor())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TRGBDescriptor'
            if ((!((msg__)->ReadSentinel(iter__, 2888062100)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TYCbCrDescriptor:
        {
            YCbCrDescriptor tmp = YCbCrDescriptor();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_YCbCrDescriptor())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TYCbCrDescriptor'
            if ((!((msg__)->ReadSentinel(iter__, 3533945878)))) {
                mozilla::ipc::SentinelReadError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    default:
        {
            FatalError("unknown union type");
            return false;
        }
    }
}

auto PCompositorBridgeChild::Write(
        const PTextureChild* v__,
        Message* msg__,
        bool nullable__) -> void
{
    int32_t id;
    if ((!(v__))) {
        if ((!(nullable__))) {
            FatalError("NULL actor value passed to non-nullable param");
        }
        id = 0;
    }
    else {
        id = (v__)->Id();
        if ((1) == (id)) {
            FatalError("actor has been |delete|d");
        }
    }

    Write(id, msg__);
}

auto PCompositorBridgeChild::Read(
        PTextureChild** v__,
        const Message* msg__,
        PickleIterator* iter__,
        bool nullable__) -> bool
{
    Maybe<mozilla::ipc::IProtocol*> actor = ReadActor(msg__, iter__, nullable__, "PTexture", PTextureMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(v__)) = static_cast<PTextureChild*>((actor).value());
    return true;
}



} // namespace layers
} // namespace mozilla