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


#include "mozilla/layers/PWebRenderBridgeChild.h"
#include "gfxipc/ShadowLayerUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/layers/CompositorTypes.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/layers/WebRenderBridgeChild.h"
#include "mozilla/layers/WebRenderMessageUtils.h"
#include "nsPoint.h"
#include "nsRect.h"

#include "mozilla/layers/PCompositorBridgeChild.h"
#include "mozilla/layers/PTextureChild.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"

namespace mozilla {
namespace layers {


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

MOZ_IMPLICIT PWebRenderBridgeChild::PWebRenderBridgeChild() :
    mozilla::ipc::IProtocol(kProtocolId, mozilla::ipc::ChildSide)
{
    MOZ_COUNT_CTOR(PWebRenderBridgeChild);
}

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

auto PWebRenderBridgeChild::ActorAlloc() -> void
{
}

auto PWebRenderBridgeChild::ActorDealloc() -> void
{
    if (Manager()) {
        Manager()->DeallocManagee(kProtocolId, this);
    }
}

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

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

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

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

auto PWebRenderBridgeChild::ManagedProtocolIds() const -> mozilla::Span<mozilla::ipc::ProtocolId const>
{
    return {};
}

auto PWebRenderBridgeChild::GetManagedActors(mozilla::ipc::ProtocolId aProtocol) -> UntypedManagedContainer*
{
    switch (aProtocol) {
    default:
        return nullptr;
    }
}

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

auto PWebRenderBridgeChild::SendEnsureConnected(
        TextureFactoryIdentifier* textureFactoryIdentifier,
        MaybeIdNamespace* maybeIdNamespace,
        nsCString* error) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_EnsureConnected(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_EnsureConnected", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_EnsureConnected", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__textureFactoryIdentifier__reply = IPC::ReadParam<TextureFactoryIdentifier>((&(reader__)));
    if (!maybe__textureFactoryIdentifier__reply) {
        FatalError("Error deserializing 'TextureFactoryIdentifier'");
        return false;

    }
    auto& textureFactoryIdentifier__reply = *maybe__textureFactoryIdentifier__reply;
    // Sentinel = 'textureFactoryIdentifier'
    if ((!(((&(reader__)))->ReadSentinel(2096630253)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TextureFactoryIdentifier'");
        return false;
    }
    auto maybe__maybeIdNamespace__reply = IPC::ReadParam<MaybeIdNamespace>((&(reader__)));
    if (!maybe__maybeIdNamespace__reply) {
        FatalError("Error deserializing 'MaybeIdNamespace'");
        return false;

    }
    auto& maybeIdNamespace__reply = *maybe__maybeIdNamespace__reply;
    // Sentinel = 'maybeIdNamespace'
    if ((!(((&(reader__)))->ReadSentinel(895092297)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'MaybeIdNamespace'");
        return false;
    }
    auto maybe__error__reply = IPC::ReadParam<nsCString>((&(reader__)));
    if (!maybe__error__reply) {
        FatalError("Error deserializing 'nsCString'");
        return false;

    }
    auto& error__reply = *maybe__error__reply;
    // Sentinel = 'error'
    if ((!(((&(reader__)))->ReadSentinel(107741739)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
        return false;
    }
    (*(textureFactoryIdentifier)) = std::move(textureFactoryIdentifier__reply);
    (*(maybeIdNamespace)) = std::move(maybeIdNamespace__reply);
    (*(error)) = std::move(error__reply);
    reader__.EndRead();

    return true;
}

auto PWebRenderBridgeChild::SendNewCompositable(
        const CompositableHandle& handle,
        const TextureInfo& info) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_NewCompositable(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_NewCompositable", OTHER);

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

auto PWebRenderBridgeChild::SendReleaseCompositable(const CompositableHandle& compositable) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_ReleaseCompositable(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_ReleaseCompositable", OTHER);

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

auto PWebRenderBridgeChild::SendDeleteCompositorAnimations(mozilla::Span<uint64_t const> aIds) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_DeleteCompositorAnimations(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_DeleteCompositorAnimations", OTHER);

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

auto PWebRenderBridgeChild::SendSetDisplayList(
        DisplayListData&& displayList,
        mozilla::Span<OpDestroy const> toDestroy,
        const uint64_t& fwdTransactionId,
        const TransactionId& transactionId,
        const bool& containsSVGGroup,
        const VsyncId& vsyncId,
        const TimeStamp& vsyncStartTime,
        const TimeStamp& refreshStartTime,
        const TimeStamp& txnStartTime,
        const nsACString& txnURL,
        const TimeStamp& fwdTime,
        mozilla::Span<CompositionPayload const> payloads,
        const bool& renderOffscreen) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetDisplayList(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(displayList));
    // Sentinel = 'displayList'
    ((&(writer__)))->WriteSentinel(458753171);
    IPC::WriteParam((&(writer__)), toDestroy);
    // Sentinel = 'toDestroy'
    ((&(writer__)))->WriteSentinel(311100366);
    IPC::WriteParam((&(writer__)), fwdTransactionId);
    // Sentinel = 'fwdTransactionId'
    ((&(writer__)))->WriteSentinel(930940533);
    IPC::WriteParam((&(writer__)), transactionId);
    // Sentinel = 'transactionId'
    ((&(writer__)))->WriteSentinel(642319700);
    IPC::WriteParam((&(writer__)), containsSVGGroup);
    // Sentinel = 'containsSVGGroup'
    ((&(writer__)))->WriteSentinel(914163293);
    IPC::WriteParam((&(writer__)), vsyncId);
    // Sentinel = 'vsyncId'
    ((&(writer__)))->WriteSentinel(203883233);
    IPC::WriteParam((&(writer__)), vsyncStartTime);
    // Sentinel = 'vsyncStartTime'
    ((&(writer__)))->WriteSentinel(747177425);
    IPC::WriteParam((&(writer__)), refreshStartTime);
    // Sentinel = 'refreshStartTime'
    ((&(writer__)))->WriteSentinel(941753997);
    IPC::WriteParam((&(writer__)), txnStartTime);
    // Sentinel = 'txnStartTime'
    ((&(writer__)))->WriteSentinel(551290104);
    IPC::WriteParam((&(writer__)), txnURL);
    // Sentinel = 'txnURL'
    ((&(writer__)))->WriteSentinel(146604622);
    IPC::WriteParam((&(writer__)), fwdTime);
    // Sentinel = 'fwdTime'
    ((&(writer__)))->WriteSentinel(190382801);
    IPC::WriteParam((&(writer__)), payloads);
    // Sentinel = 'payloads'
    ((&(writer__)))->WriteSentinel(255525726);
    IPC::WriteParam((&(writer__)), renderOffscreen);
    // Sentinel = 'renderOffscreen'
    ((&(writer__)))->WriteSentinel(820315676);


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetDisplayList", OTHER);

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

auto PWebRenderBridgeChild::SendEmptyTransaction(
        const FocusTarget& focusTarget,
        MaybeTransactionData&& transationData,
        mozilla::Span<OpDestroy const> toDestroy,
        const uint64_t& fwdTransactionId,
        const TransactionId& transactionId,
        const VsyncId& vsyncId,
        const TimeStamp& vsyncStartTime,
        const TimeStamp& refreshStartTime,
        const TimeStamp& txnStartTime,
        const nsACString& txnURL,
        const TimeStamp& fwdTime,
        mozilla::Span<CompositionPayload const> payloads) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_EmptyTransaction(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), focusTarget);
    // Sentinel = 'focusTarget'
    ((&(writer__)))->WriteSentinel(455279752);
    IPC::WriteParam((&(writer__)), std::move(transationData));
    // Sentinel = 'transationData'
    ((&(writer__)))->WriteSentinel(739771838);
    IPC::WriteParam((&(writer__)), toDestroy);
    // Sentinel = 'toDestroy'
    ((&(writer__)))->WriteSentinel(311100366);
    IPC::WriteParam((&(writer__)), fwdTransactionId);
    // Sentinel = 'fwdTransactionId'
    ((&(writer__)))->WriteSentinel(930940533);
    IPC::WriteParam((&(writer__)), transactionId);
    // Sentinel = 'transactionId'
    ((&(writer__)))->WriteSentinel(642319700);
    IPC::WriteParam((&(writer__)), vsyncId);
    // Sentinel = 'vsyncId'
    ((&(writer__)))->WriteSentinel(203883233);
    IPC::WriteParam((&(writer__)), vsyncStartTime);
    // Sentinel = 'vsyncStartTime'
    ((&(writer__)))->WriteSentinel(747177425);
    IPC::WriteParam((&(writer__)), refreshStartTime);
    // Sentinel = 'refreshStartTime'
    ((&(writer__)))->WriteSentinel(941753997);
    IPC::WriteParam((&(writer__)), txnStartTime);
    // Sentinel = 'txnStartTime'
    ((&(writer__)))->WriteSentinel(551290104);
    IPC::WriteParam((&(writer__)), txnURL);
    // Sentinel = 'txnURL'
    ((&(writer__)))->WriteSentinel(146604622);
    IPC::WriteParam((&(writer__)), fwdTime);
    // Sentinel = 'fwdTime'
    ((&(writer__)))->WriteSentinel(190382801);
    IPC::WriteParam((&(writer__)), payloads);
    // Sentinel = 'payloads'
    ((&(writer__)))->WriteSentinel(255525726);


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_EmptyTransaction", OTHER);

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

auto PWebRenderBridgeChild::SendSetFocusTarget(const FocusTarget& focusTarget) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetFocusTarget(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetFocusTarget", OTHER);

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

auto PWebRenderBridgeChild::SendUpdateResources(
        const IdNamespace& aIdNamespace,
        mozilla::Span<OpUpdateResource const> aResourceUpdates,
        mozilla::Span<RefCountedShmem const> aSmallShmems,
        nsTArray<Shmem>&& aLargeShmems) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_UpdateResources(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aIdNamespace);
    // Sentinel = 'aIdNamespace'
    ((&(writer__)))->WriteSentinel(487523484);
    IPC::WriteParam((&(writer__)), aResourceUpdates);
    // Sentinel = 'aResourceUpdates'
    ((&(writer__)))->WriteSentinel(916522624);
    IPC::WriteParam((&(writer__)), aSmallShmems);
    // Sentinel = 'aSmallShmems'
    ((&(writer__)))->WriteSentinel(508691656);
    IPC::WriteParam((&(writer__)), std::move(aLargeShmems));
    // Sentinel = 'aLargeShmems'
    ((&(writer__)))->WriteSentinel(499975354);


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_UpdateResources", OTHER);

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

auto PWebRenderBridgeChild::SendParentCommands(
        const IdNamespace& aIdNamespace,
        mozilla::Span<WebRenderParentCommand const> commands) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_ParentCommands(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aIdNamespace);
    // Sentinel = 'aIdNamespace'
    ((&(writer__)))->WriteSentinel(487523484);
    IPC::WriteParam((&(writer__)), commands);
    // Sentinel = 'commands'
    ((&(writer__)))->WriteSentinel(249627475);


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_ParentCommands", OTHER);

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

auto PWebRenderBridgeChild::SendGetSnapshot(
        mozilla::NotNull<PTextureChild*> texture,
        bool* aNeedsYFlip) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_GetSnapshot(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_GetSnapshot", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_GetSnapshot", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__aNeedsYFlip__reply = IPC::ReadParam<bool>((&(reader__)));
    if (!maybe__aNeedsYFlip__reply) {
        FatalError("Error deserializing 'bool'");
        return false;

    }
    auto& aNeedsYFlip__reply = *maybe__aNeedsYFlip__reply;
    // Sentinel = 'aNeedsYFlip'
    if ((!(((&(reader__)))->ReadSentinel(415237173)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
        return false;
    }
    (*(aNeedsYFlip)) = std::move(aNeedsYFlip__reply);
    reader__.EndRead();

    return true;
}

auto PWebRenderBridgeChild::SendClearCachedResources() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_ClearCachedResources(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_ClearCachedResources", OTHER);

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

auto PWebRenderBridgeChild::SendSetDefaultClearColor(const uint32_t& aColor) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetDefaultClearColor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetDefaultClearColor", OTHER);

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

auto PWebRenderBridgeChild::SendInvalidateRenderedFrame() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_InvalidateRenderedFrame(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_InvalidateRenderedFrame", OTHER);

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

auto PWebRenderBridgeChild::SendScheduleComposite(const RenderReasons& aReasons) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_ScheduleComposite(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_ScheduleComposite", OTHER);

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

auto PWebRenderBridgeChild::SendCapture() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_Capture(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_Capture", OTHER);

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

auto PWebRenderBridgeChild::SendStartCaptureSequence(
        const nsACString& aPath,
        const uint32_t& aFlags) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_StartCaptureSequence(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_StartCaptureSequence", OTHER);

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

auto PWebRenderBridgeChild::SendStopCaptureSequence() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_StopCaptureSequence(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_StopCaptureSequence", OTHER);

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

auto PWebRenderBridgeChild::SendSyncWithCompositor() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SyncWithCompositor(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SyncWithCompositor", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_SyncWithCompositor", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PWebRenderBridgeChild::SendSetConfirmedTargetAPZC(
        const uint64_t& aInputBlockId,
        mozilla::Span<ScrollableLayerGuid const> aTargets) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetConfirmedTargetAPZC(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aInputBlockId);
    // Sentinel = 'aInputBlockId'
    ((&(writer__)))->WriteSentinel(595657994);
    IPC::WriteParam((&(writer__)), aTargets);
    // Sentinel = 'aTargets'
    ((&(writer__)))->WriteSentinel(235012924);


    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetConfirmedTargetAPZC", OTHER);

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

auto PWebRenderBridgeChild::SendSetTestSampleTime(const TimeStamp& sampleTime) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetTestSampleTime(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetTestSampleTime", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_SetTestSampleTime", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PWebRenderBridgeChild::SendLeaveTestMode() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_LeaveTestMode(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_LeaveTestMode", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_LeaveTestMode", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PWebRenderBridgeChild::SendGetAnimationValue(
        const uint64_t& aCompositorAnimationsId,
        OMTAValue* value) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_GetAnimationValue(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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

    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_GetAnimationValue", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_GetAnimationValue", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__value__reply = IPC::ReadParam<OMTAValue>((&(reader__)));
    if (!maybe__value__reply) {
        FatalError("Error deserializing 'OMTAValue'");
        return false;

    }
    auto& value__reply = *maybe__value__reply;
    // Sentinel = 'value'
    if ((!(((&(reader__)))->ReadSentinel(107610654)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'OMTAValue'");
        return false;
    }
    (*(value)) = std::move(value__reply);
    reader__.EndRead();

    return true;
}

auto PWebRenderBridgeChild::SendSetAsyncScrollOffset(
        const ViewID& scrollId,
        const float& x,
        const float& y) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetAsyncScrollOffset(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), scrollId);
    // Sentinel = 'scrollId'
    ((&(writer__)))->WriteSentinel(253100861);
    IPC::WriteParam((&(writer__)), x);
    // Sentinel = 'x'
    ((&(writer__)))->WriteSentinel(7929977);
    IPC::WriteParam((&(writer__)), y);
    // Sentinel = 'y'
    ((&(writer__)))->WriteSentinel(7995514);

    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetAsyncScrollOffset", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_SetAsyncScrollOffset", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PWebRenderBridgeChild::SendSetAsyncZoom(
        const ViewID& scrollId,
        const float& zoom) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_SetAsyncZoom(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), scrollId);
    // Sentinel = 'scrollId'
    ((&(writer__)))->WriteSentinel(253100861);
    IPC::WriteParam((&(writer__)), zoom);
    // Sentinel = 'zoom'
    ((&(writer__)))->WriteSentinel(75760070);

    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_SetAsyncZoom", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_SetAsyncZoom", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PWebRenderBridgeChild::SendFlushApzRepaints() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_FlushApzRepaints(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_FlushApzRepaints", OTHER);

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

auto PWebRenderBridgeChild::SendGetAPZTestData(APZTestData* data) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_GetAPZTestData(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_GetAPZTestData", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_GetAPZTestData", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__data__reply = IPC::ReadParam<APZTestData>((&(reader__)));
    if (!maybe__data__reply) {
        FatalError("Error deserializing 'APZTestData'");
        return false;

    }
    auto& data__reply = *maybe__data__reply;
    // Sentinel = 'data'
    if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'APZTestData'");
        return false;
    }
    (*(data)) = std::move(data__reply);
    reader__.EndRead();

    return true;
}

auto PWebRenderBridgeChild::SendGetFrameUniformity(FrameUniformityData* data) -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_GetFrameUniformity(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_GetFrameUniformity", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_GetFrameUniformity", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    IPC::MessageReader reader__{
            (*(reply__)),
            this};

    auto maybe__data__reply = IPC::ReadParam<FrameUniformityData>((&(reader__)));
    if (!maybe__data__reply) {
        FatalError("Error deserializing 'FrameUniformityData'");
        return false;

    }
    auto& data__reply = *maybe__data__reply;
    // Sentinel = 'data'
    if ((!(((&(reader__)))->ReadSentinel(67109275)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'FrameUniformityData'");
        return false;
    }
    (*(data)) = std::move(data__reply);
    reader__.EndRead();

    return true;
}

auto PWebRenderBridgeChild::SendEndWheelTransaction(
        mozilla::ipc::ResolveCallback<bool>&& aResolve,
        mozilla::ipc::RejectCallback&& aReject) -> void
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_EndWheelTransaction(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_EndWheelTransaction", OTHER);

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

            }
            auto& unused = *maybe__unused;
            // Sentinel = 'unused'
            if ((!((aReader)->ReadSentinel(155517589)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }


            aReader->EndRead();

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

auto PWebRenderBridgeChild::SendEndWheelTransaction() -> RefPtr<EndWheelTransactionPromise>
{
    RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
    promise__->UseDirectTaskDispatch(__func__);
    SendEndWheelTransaction([promise__](bool&& aValue) {
        promise__->Resolve(std::move(aValue), __func__);
    }, [promise__](ResponseRejectReason&& aReason) {
        promise__->Reject(std::move(aReason), __func__);
    });
    return promise__;
}

auto PWebRenderBridgeChild::SendShutdown() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_Shutdown(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



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

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

auto PWebRenderBridgeChild::SendShutdownSync() -> bool
{
    UniquePtr<IPC::Message> msg__ = PWebRenderBridge::Msg_ShutdownSync(Id());
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};


    UniquePtr<Message> reply__;

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_ShutdownSync", OTHER);

    bool sendok__ = false;
    {
        AUTO_PROFILER_MARKER("PWebRenderBridge::Msg_ShutdownSync", IPC);
        sendok__ = ChannelSend(std::move(msg__), (&(reply__)));
    }
    if ((!(sendok__))) {
        return false;
    }

    if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PWebRenderBridgeChild",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Received reply ",
            reply__->type(),
            mozilla::ipc::MessageDirection::eReceiving);
    }

    return true;
}

auto PWebRenderBridgeChild::DeallocManagee(
        mozilla::ipc::ProtocolId aProtocolId,
        IProtocol* aListener) -> void
{
    FatalError("unreached");
    return;
}

auto PWebRenderBridgeChild::OnMessageReceived(const Message& msg__) -> PWebRenderBridgeChild::Result
{
    switch (msg__.type()) {
    case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
        {
            if (!mAwaitingManagedEndpointBind) {
                NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
                return MsgNotAllowed;
            }
            mAwaitingManagedEndpointBind = false;
            return MsgProcessed;
        }
    case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
        {
            if (!mAwaitingManagedEndpointBind) {
                NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
                return MsgNotAllowed;
            }
            mAwaitingManagedEndpointBind = false;
            this->ActorDisconnected(ManagedEndpointDropped);
            return MsgProcessed;
        }
    case PWebRenderBridge::Reply_EndWheelTransaction__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWebRenderBridgeChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }

            AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_EndWheelTransaction", OTHER);


            return mAsyncCallbacks.GotReply(this, msg__);
        }
    case PWebRenderBridge::Msg_WrUpdated__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWebRenderBridgeChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_WrUpdated", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aNewIdNamespace = *maybe__aNewIdNamespace;
            // Sentinel = 'aNewIdNamespace'
            if ((!(((&(reader__)))->ReadSentinel(757990854)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'IdNamespace'");
                return MsgValueError;
            }
            auto maybe__textureFactoryIdentifier = IPC::ReadParam<TextureFactoryIdentifier>((&(reader__)));
            if (!maybe__textureFactoryIdentifier) {
                FatalError("Error deserializing 'TextureFactoryIdentifier'");
                return MsgValueError;

            }
            auto& textureFactoryIdentifier = *maybe__textureFactoryIdentifier;
            // Sentinel = 'textureFactoryIdentifier'
            if ((!(((&(reader__)))->ReadSentinel(2096630253)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'TextureFactoryIdentifier'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<WebRenderBridgeChild*>(this))->RecvWrUpdated(std::move(aNewIdNamespace), std::move(textureFactoryIdentifier));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWebRenderBridge::Msg_WrReleasedImages__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWebRenderBridgeChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWebRenderBridge::Msg_WrReleasedImages", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__pairs = IPC::ReadParam<nsTArray<ExternalImageKeyPair>>((&(reader__)));
            if (!maybe__pairs) {
                FatalError("Error deserializing 'ExternalImageKeyPair[]'");
                return MsgValueError;

            }
            auto& pairs = *maybe__pairs;
            // Sentinel = 'pairs'
            if ((!(((&(reader__)))->ReadSentinel(105579040)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ExternalImageKeyPair[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<WebRenderBridgeChild*>(this))->RecvWrReleasedImages(std::move(pairs));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PWebRenderBridge::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PWebRenderBridge", mozilla::ipc::ChildSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PWebRenderBridgeChild",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PWebRenderBridge::Msg___delete__", OTHER);

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


            this->ActorDisconnected(Deletion);

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}

auto PWebRenderBridgeChild::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PWebRenderBridgeChild::Result
{
    return MsgNotKnown;
}



} // namespace layers
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::layers::PWebRenderBridgeChild*>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, static_cast<mozilla::ipc::IProtocol*>(aVar));
    // Sentinel = 'PWebRenderBridge'
    (aWriter)->WriteSentinel(850855452);
}

auto ParamTraits<::mozilla::layers::PWebRenderBridgeChild*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe__actor = IPC::ReadParam<mozilla::ipc::IProtocol*>(aReader);
    if (!maybe__actor) {
        aReader->FatalError("Error deserializing managed PWebRenderBridge actor");
        return {};

    }
    auto& actor = *maybe__actor;
    // Sentinel = 'PWebRenderBridge'
    if ((!((aReader)->ReadSentinel(850855452)))) {
        mozilla::ipc::SentinelReadError("Error deserializing managed PWebRenderBridge actor");
        return {};
    }

    if (actor && actor->GetProtocolId() != PWebRenderBridgeMsgStart) {
        aReader->FatalError("Unexpected actor type (expected PWebRenderBridge)");

        return {};
    }
    return static_cast<::mozilla::layers::PWebRenderBridgeChild*>(actor);
}

} // namespace IPC
