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


#include "mozilla/gfx/PGPUParent.h"
#include "mozilla/D3DMessageUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/gfx/GPUParent.h"
#include "mozilla/ipc/ByteBufUtils.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/layers/LayersMessageUtils.h"

#include "mozilla/layers/PAPZInputBridgeParent.h"
#include "mozilla/layers/PCompositorManagerParent.h"
#include "mozilla/layers/PImageBridgeParent.h"
#include "mozilla/PProfilerParent.h"
#include "mozilla/gfx/PVRGPUParent.h"
#include "mozilla/gfx/PVRManagerParent.h"
#include "mozilla/layers/PVideoBridgeParent.h"
#include "mozilla/gfx/PVsyncBridgeParent.h"
#include "mozilla/layers/PUiCompositorControllerParent.h"
#include "mozilla/PRemoteMediaManagerParent.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 gfx {


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

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

MOZ_IMPLICIT PGPUParent::PGPUParent() :
    mozilla::ipc::IToplevelProtocol("PGPUParent", kProtocolId, mozilla::ipc::ParentSide)
{
    MOZ_COUNT_CTOR(PGPUParent);
}

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

auto PGPUParent::ActorAlloc() -> void
{
    MOZ_RELEASE_ASSERT(XRE_IsGPUProcess(), "Invalid process for `PGPUParent'");
    AddRef();
}

auto PGPUParent::ActorDealloc() -> void
{
    Release();
}

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

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

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

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

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

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

auto PGPUParent::SendReportCheckerboard(
        const uint32_t& severity,
        const nsACString& log) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_ReportCheckerboard(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), severity);
    // Sentinel = 'severity'
    ((&(writer__)))->WriteSentinel(260309884);
    IPC::WriteParam((&(writer__)), log);
    // Sentinel = 'log'
    ((&(writer__)))->WriteSentinel(42729795);


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_ReportCheckerboard", OTHER);

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

auto PGPUParent::SendGraphicsError(const nsACString& aError) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_GraphicsError(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_GraphicsError", OTHER);

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

auto PGPUParent::SendInitCrashReporter(const CrashReporterInitArgs& aInitArgs) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_InitCrashReporter(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_InitCrashReporter", OTHER);

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

auto PGPUParent::SendCreateVRProcess() -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_CreateVRProcess(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_CreateVRProcess", OTHER);

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

auto PGPUParent::SendShutdownVRProcess() -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_ShutdownVRProcess(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_ShutdownVRProcess", OTHER);

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

auto PGPUParent::SendNotifyUiObservers(const nsACString& aTopic) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_NotifyUiObservers(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_NotifyUiObservers", OTHER);

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

auto PGPUParent::SendAccumulateChildHistograms(mozilla::Span<HistogramAccumulation const> accumulations) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_AccumulateChildHistograms(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_AccumulateChildHistograms", OTHER);

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

auto PGPUParent::SendAccumulateChildKeyedHistograms(mozilla::Span<KeyedHistogramAccumulation const> accumulations) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_AccumulateChildKeyedHistograms(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_AccumulateChildKeyedHistograms", OTHER);

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

auto PGPUParent::SendUpdateChildScalars(mozilla::Span<ScalarAction const> actions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_UpdateChildScalars(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_UpdateChildScalars", OTHER);

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

auto PGPUParent::SendUpdateChildKeyedScalars(mozilla::Span<KeyedScalarAction const> actions) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_UpdateChildKeyedScalars(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_UpdateChildKeyedScalars", OTHER);

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

auto PGPUParent::SendRecordChildEvents(mozilla::Span<ChildEventData const> events) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_RecordChildEvents(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_RecordChildEvents", OTHER);

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

auto PGPUParent::SendRecordDiscardedData(const DiscardedData& data) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_RecordDiscardedData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_RecordDiscardedData", OTHER);

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

auto PGPUParent::SendDeclareStable() -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_DeclareStable(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_DeclareStable", OTHER);

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

auto PGPUParent::SendNotifyDeviceReset(
        const GPUDeviceData& status,
        const DeviceResetReason& reason,
        const DeviceResetDetectPlace& place) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_NotifyDeviceReset(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), status);
    // Sentinel = 'status'
    ((&(writer__)))->WriteSentinel(154731173);
    IPC::WriteParam((&(writer__)), reason);
    // Sentinel = 'reason'
    ((&(writer__)))->WriteSentinel(148112009);
    IPC::WriteParam((&(writer__)), place);
    // Sentinel = 'place'
    ((&(writer__)))->WriteSentinel(104006150);


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_NotifyDeviceReset", OTHER);

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

auto PGPUParent::SendNotifyOverlayInfo(const OverlayInfo& info) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_NotifyOverlayInfo(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_NotifyOverlayInfo", OTHER);

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

auto PGPUParent::SendNotifySwapChainInfo(const SwapChainInfo& info) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_NotifySwapChainInfo(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_NotifySwapChainInfo", OTHER);

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

auto PGPUParent::SendNotifyDisableRemoteCanvas() -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_NotifyDisableRemoteCanvas(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};



    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_NotifyDisableRemoteCanvas", OTHER);

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

auto PGPUParent::SendFlushMemory(const nsAString& reason) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_FlushMemory(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_FlushMemory", OTHER);

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

auto PGPUParent::SendAddMemoryReport(const MemoryReport& aReport) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_AddMemoryReport(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_AddMemoryReport", OTHER);

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

auto PGPUParent::SendUpdateFeature(
        const Feature& aFeature,
        const FeatureFailure& aChange) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_UpdateFeature(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFeature);
    // Sentinel = 'aFeature'
    ((&(writer__)))->WriteSentinel(229966638);
    IPC::WriteParam((&(writer__)), aChange);
    // Sentinel = 'aChange'
    ((&(writer__)))->WriteSentinel(172556968);


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_UpdateFeature", OTHER);

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

auto PGPUParent::SendUsedFallback(
        const Fallback& aFallback,
        const nsACString& message) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_UsedFallback(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), aFallback);
    // Sentinel = 'aFallback'
    ((&(writer__)))->WriteSentinel(281609074);
    IPC::WriteParam((&(writer__)), message);
    // Sentinel = 'message'
    ((&(writer__)))->WriteSentinel(197198566);


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_UsedFallback", OTHER);

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

auto PGPUParent::SendBHRThreadHang(const HangDetails& aDetails) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_BHRThreadHang(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_BHRThreadHang", OTHER);

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

auto PGPUParent::SendUpdateMediaCodecsSupported(const MediaCodecsSupported& aSupported) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_UpdateMediaCodecsSupported(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

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


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_UpdateMediaCodecsSupported", OTHER);

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

auto PGPUParent::SendFOGData(ByteBuf&& buf) -> bool
{
    UniquePtr<IPC::Message> msg__ = PGPU::Msg_FOGData(MSG_ROUTING_CONTROL);
    IPC::MessageWriter writer__{
            (*(msg__)),
            this};

    IPC::WriteParam((&(writer__)), std::move(buf));
    // Sentinel = 'buf'
    ((&(writer__)))->WriteSentinel(41484606);


    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
        mozilla::ipc::LogMessageForProtocol(
            "PGPUParent",
            this->ToplevelProtocol()->OtherPidMaybeInvalid(),
            "Sending ",
            msg__->type(),
            mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PGPU::Msg_FOGData", OTHER);

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

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

auto PGPUParent::OnMessageReceived(const Message& msg__) -> PGPUParent::Result
{
    switch (msg__.type()) {
    case PGPU::Msg_Init__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_Init", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& vars = *maybe__vars;
            // Sentinel = 'vars'
            if ((!(((&(reader__)))->ReadSentinel(72745405)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GfxVarUpdate[]'");
                return MsgValueError;
            }
            auto maybe__devicePrefs = IPC::ReadParam<DevicePrefs>((&(reader__)));
            if (!maybe__devicePrefs) {
                FatalError("Error deserializing 'DevicePrefs'");
                return MsgValueError;

            }
            auto& devicePrefs = *maybe__devicePrefs;
            // Sentinel = 'devicePrefs'
            if ((!(((&(reader__)))->ReadSentinel(445645937)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'DevicePrefs'");
                return MsgValueError;
            }
            auto maybe__mapping = IPC::ReadParam<nsTArray<LayerTreeIdMapping>>((&(reader__)));
            if (!maybe__mapping) {
                FatalError("Error deserializing 'LayerTreeIdMapping[]'");
                return MsgValueError;

            }
            auto& mapping = *maybe__mapping;
            // Sentinel = 'mapping'
            if ((!(((&(reader__)))->ReadSentinel(196477677)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayerTreeIdMapping[]'");
                return MsgValueError;
            }
            auto maybe__features = IPC::ReadParam<nsTArray<GfxInfoFeatureStatus>>((&(reader__)));
            if (!maybe__features) {
                FatalError("Error deserializing 'GfxInfoFeatureStatus[]'");
                return MsgValueError;

            }
            auto& features = *maybe__features;
            // Sentinel = 'features'
            if ((!(((&(reader__)))->ReadSentinel(250348384)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GfxInfoFeatureStatus[]'");
                return MsgValueError;
            }
            auto maybe__wrNamespace = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__wrNamespace) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& wrNamespace = *maybe__wrNamespace;
            // Sentinel = 'wrNamespace'
            if ((!(((&(reader__)))->ReadSentinel(453510263)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PGPU::Reply_Init(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            InitResolver resolver = [resolver__ = std::move(resolver__)](const GPUDeviceData& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'data'
                    ((&(writer__)))->WriteSentinel(67109275);

                    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PGPUParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInit(std::move(vars), std::move(devicePrefs), std::move(mapping), std::move(features), std::move(wrNamespace), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitCompositorManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitCompositorManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PCompositorManagerParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerParent>'");
                return MsgValueError;
            }
            auto maybe__aNamespace = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aNamespace) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aNamespace = *maybe__aNamespace;
            // Sentinel = 'aNamespace'
            if ((!(((&(reader__)))->ReadSentinel(356516847)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitCompositorManager(std::move(endpoint), std::move(aNamespace));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitVsyncBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitVsyncBridge", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::gfx::PVsyncBridgeParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVsyncBridgeParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVsyncBridgeParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitVsyncBridge(std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitImageBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitImageBridge", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PImageBridgeParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitImageBridge(std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitVideoBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitVideoBridge", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PVideoBridgeParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PVideoBridgeParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PVideoBridgeParent>'");
                return MsgValueError;
            }
            auto maybe__aSource = IPC::ReadParam<VideoBridgeSource>((&(reader__)));
            if (!maybe__aSource) {
                FatalError("Error deserializing 'VideoBridgeSource'");
                return MsgValueError;

            }
            auto& aSource = *maybe__aSource;
            // Sentinel = 'aSource'
            if ((!(((&(reader__)))->ReadSentinel(186647251)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'VideoBridgeSource'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitVideoBridge(std::move(endpoint), std::move(aSource));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitVRManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitVRManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRManagerParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitVRManager(std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitUiCompositorController__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitUiCompositorController", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& rootLayerTreeId = *maybe__rootLayerTreeId;
            // Sentinel = 'rootLayerTreeId'
            if ((!(((&(reader__)))->ReadSentinel(828507647)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PUiCompositorControllerParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PUiCompositorControllerParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PUiCompositorControllerParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitUiCompositorController(std::move(rootLayerTreeId), std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitAPZInputBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitAPZInputBridge", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& layersId = *maybe__layersId;
            // Sentinel = 'layersId'
            if ((!(((&(reader__)))->ReadSentinel(250938174)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayersId'");
                return MsgValueError;
            }
            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PAPZInputBridgeParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PAPZInputBridgeParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PAPZInputBridgeParent>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitAPZInputBridge(std::move(layersId), std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitProfiler__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitProfiler", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::PProfilerChild>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::PProfilerChild>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PProfilerChild>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitProfiler(std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_InitVR__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitVR", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRGPUChild>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRGPUChild>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRGPUChild>'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvInitVR(std::move(endpoint));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_UpdateVar__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_UpdateVar", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& var = *maybe__var;
            // Sentinel = 'var'
            if ((!(((&(reader__)))->ReadSentinel(43581770)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'GfxVarUpdate[]'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvUpdateVar(std::move(var));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_PreferenceUpdate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_PreferenceUpdate", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& pref = *maybe__pref;
            // Sentinel = 'pref'
            if ((!(((&(reader__)))->ReadSentinel(71958958)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Pref'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvPreferenceUpdate(std::move(pref));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_ScreenInformationChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_ScreenInformationChanged", OTHER);

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

            return MsgProcessed;
        }
    case PGPU::Msg_NotifyBatteryInfo__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NotifyBatteryInfo", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aBatteryInfo = *maybe__aBatteryInfo;
            // Sentinel = 'aBatteryInfo'
            if ((!(((&(reader__)))->ReadSentinel(509674697)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'BatteryInformation'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvNotifyBatteryInfo(std::move(aBatteryInfo));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_NewContentCompositorManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NewContentCompositorManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PCompositorManagerParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PCompositorManagerParent>'");
                return MsgValueError;
            }
            auto maybe__childId = IPC::ReadParam<ContentParentId>((&(reader__)));
            if (!maybe__childId) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;

            }
            auto& childId = *maybe__childId;
            // Sentinel = 'childId'
            if ((!(((&(reader__)))->ReadSentinel(185270962)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            auto maybe__aNamespace = IPC::ReadParam<uint32_t>((&(reader__)));
            if (!maybe__aNamespace) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;

            }
            auto& aNamespace = *maybe__aNamespace;
            // Sentinel = 'aNamespace'
            if ((!(((&(reader__)))->ReadSentinel(356516847)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvNewContentCompositorManager(std::move(endpoint), std::move(childId), std::move(aNamespace));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_NewContentImageBridge__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NewContentImageBridge", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::layers::PImageBridgeParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::layers::PImageBridgeParent>'");
                return MsgValueError;
            }
            auto maybe__childId = IPC::ReadParam<ContentParentId>((&(reader__)));
            if (!maybe__childId) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;

            }
            auto& childId = *maybe__childId;
            // Sentinel = 'childId'
            if ((!(((&(reader__)))->ReadSentinel(185270962)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvNewContentImageBridge(std::move(endpoint), std::move(childId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_NewContentVRManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NewContentVRManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::gfx::PVRManagerParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::gfx::PVRManagerParent>'");
                return MsgValueError;
            }
            auto maybe__childId = IPC::ReadParam<ContentParentId>((&(reader__)));
            if (!maybe__childId) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;

            }
            auto& childId = *maybe__childId;
            // Sentinel = 'childId'
            if ((!(((&(reader__)))->ReadSentinel(185270962)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvNewContentVRManager(std::move(endpoint), std::move(childId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_NewContentRemoteMediaManager__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NewContentRemoteMediaManager", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

            auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::PRemoteMediaManagerParent>>((&(reader__)));
            if (!maybe__endpoint) {
                FatalError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerParent>'");
                return MsgValueError;

            }
            auto& endpoint = *maybe__endpoint;
            // Sentinel = 'endpoint'
            if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::PRemoteMediaManagerParent>'");
                return MsgValueError;
            }
            auto maybe__childId = IPC::ReadParam<ContentParentId>((&(reader__)));
            if (!maybe__childId) {
                FatalError("Error deserializing 'ContentParentId'");
                return MsgValueError;

            }
            auto& childId = *maybe__childId;
            // Sentinel = 'childId'
            if ((!(((&(reader__)))->ReadSentinel(185270962)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'ContentParentId'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvNewContentRemoteMediaManager(std::move(endpoint), std::move(childId));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_RemoveLayerTreeIdMapping__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_RemoveLayerTreeIdMapping", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& mapping = *maybe__mapping;
            // Sentinel = 'mapping'
            if ((!(((&(reader__)))->ReadSentinel(196477677)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayerTreeIdMapping'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvRemoveLayerTreeIdMapping(std::move(mapping));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_SimulateDeviceReset__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_SimulateDeviceReset", OTHER);

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

            return MsgProcessed;
        }
    case PGPU::Msg_NotifyGpuObservers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NotifyGpuObservers", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aTopic = *maybe__aTopic;
            // Sentinel = 'aTopic'
            if ((!(((&(reader__)))->ReadSentinel(137429601)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvNotifyGpuObservers(std::move(aTopic));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_RequestMemoryReport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_RequestMemoryReport", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& generation = *maybe__generation;
            // Sentinel = 'generation'
            if ((!(((&(reader__)))->ReadSentinel(381158445)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            auto maybe__anonymize = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__anonymize) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& anonymize = *maybe__anonymize;
            // Sentinel = 'anonymize'
            if ((!(((&(reader__)))->ReadSentinel(321127387)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__minimizeMemoryUsage = IPC::ReadParam<bool>((&(reader__)));
            if (!maybe__minimizeMemoryUsage) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;

            }
            auto& minimizeMemoryUsage = *maybe__minimizeMemoryUsage;
            // Sentinel = 'minimizeMemoryUsage'
            if ((!(((&(reader__)))->ReadSentinel(1321600977)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            auto maybe__DMDFile = IPC::ReadParam<mozilla::Maybe<FileDescriptor>>((&(reader__)));
            if (!maybe__DMDFile) {
                FatalError("Error deserializing 'FileDescriptor?'");
                return MsgValueError;

            }
            auto& DMDFile = *maybe__DMDFile;
            // Sentinel = 'DMDFile'
            if ((!(((&(reader__)))->ReadSentinel(143983190)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor?'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PGPU::Reply_RequestMemoryReport(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            RequestMemoryReportResolver resolver = [resolver__ = std::move(resolver__)](const uint32_t& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'aGeneration'
                    ((&(writer__)))->WriteSentinel(430179438);

                    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PGPUParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

                });
            };
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvRequestMemoryReport(std::move(generation), std::move(anonymize), std::move(minimizeMemoryUsage), std::move(DMDFile), std::move(resolver));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_ShutdownVR__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_ShutdownVR", OTHER);

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

            return MsgProcessed;
        }
    case PGPU::Msg_UpdatePerfStatsCollectionMask__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_UpdatePerfStatsCollectionMask", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& aMask = *maybe__aMask;
            // Sentinel = 'aMask'
            if ((!(((&(reader__)))->ReadSentinel(93454830)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvUpdatePerfStatsCollectionMask(std::move(aMask));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PGPU::Msg_CollectPerfStatsJSON__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_CollectPerfStatsJSON", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PGPU::Reply_CollectPerfStatsJSON(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            CollectPerfStatsJSONResolver resolver = [resolver__ = std::move(resolver__)](const nsACString& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'aStats'
                    ((&(writer__)))->WriteSentinel(137953905);

                    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PGPUParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

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

            return MsgProcessed;
        }
    case PGPU::Msg_FlushFOGData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_FlushFOGData", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PGPU::Reply_FlushFOGData(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            FlushFOGDataResolver resolver = [resolver__ = std::move(resolver__)](ByteBuf&& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), std::move(aParam));
                    // Sentinel = 'buf'
                    ((&(writer__)))->WriteSentinel(41484606);

                    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PGPUParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

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

            return MsgProcessed;
        }
    case PGPU::Msg_TestTriggerMetrics__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_TestTriggerMetrics", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            UniquePtr<IPC::Message> reply__(PGPU::Reply_TestTriggerMetrics(id__));
            reply__->set_seqno(msg__.seqno());

            RefPtr<mozilla::ipc::IPDLResolverInner> resolver__ =
                new mozilla::ipc::IPDLResolverInner(std::move(reply__), this);

            TestTriggerMetricsResolver resolver = [resolver__ = std::move(resolver__)](const bool& aParam) {
                resolver__->Resolve([&] (IPC::Message* reply__, IProtocol* self__) {
                    IPC::MessageWriter writer__(*reply__, self__);
                    IPC::WriteParam((&(writer__)), aParam);
                    // Sentinel = 'unused'
                    ((&(writer__)))->WriteSentinel(155517589);

                    if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                        mozilla::ipc::LogMessageForProtocol(
                            "PGPUParent",
                            self__->ToplevelProtocol()->OtherPidMaybeInvalid(),
                            "Sending reply ",
                            reply__->type(),
                            mozilla::ipc::MessageDirection::eSending);
                    }

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

            return MsgProcessed;
        }
    case PGPU::Msg_CrashProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_CrashProcess", OTHER);

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

            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    case SHMEM_CREATED_MESSAGE_TYPE:
        {
            if (!ShmemCreated(msg__)) {
                return MsgPayloadError;
            }
            return MsgProcessed;
        }
    case SHMEM_DESTROYED_MESSAGE_TYPE:
        {
            if (!ShmemDestroyed(msg__)) {
                return MsgPayloadError;
            }
            return MsgProcessed;
        }
    }
}

auto PGPUParent::OnMessageReceived(
        const Message& msg__,
        UniquePtr<Message>& reply__) -> PGPUParent::Result
{
    switch (msg__.type()) {
    case PGPU::Msg_AddLayerTreeIdMapping__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_AddLayerTreeIdMapping", OTHER);

            IPC::MessageReader reader__{
                    msg__,
                    this};

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

            }
            auto& mapping = *maybe__mapping;
            // Sentinel = 'mapping'
            if ((!(((&(reader__)))->ReadSentinel(196477677)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'LayerTreeIdMapping'");
                return MsgValueError;
            }
            reader__.EndRead();
            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvAddLayerTreeIdMapping(std::move(mapping));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PGPU::Reply_AddLayerTreeIdMapping(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    case PGPU::Msg_GetDeviceStatus__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Received ",
                    (&(msg__))->type(),
                    mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_GetDeviceStatus", OTHER);

            mozilla::ipc::ActorId id__ = MSG_ROUTING_CONTROL;
            GPUDeviceData status{};
            mozilla::ipc::IPCResult __ok = (static_cast<GPUParent*>(this))->RecvGetDeviceStatus((&(status)));
            if ((!(__ok))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            reply__ = PGPU::Reply_GetDeviceStatus(id__);
            IPC::MessageWriter writer__{
                    (*(reply__)),
                    this};

            IPC::WriteParam((&(writer__)), status);
            // Sentinel = 'status'
            ((&(writer__)))->WriteSentinel(154731173);
            if (mozilla::ipc::LoggingEnabledFor("PGPU", mozilla::ipc::ParentSide)) {
                mozilla::ipc::LogMessageForProtocol(
                    "PGPUParent",
                    this->ToplevelProtocol()->OtherPidMaybeInvalid(),
                    "Sending reply ",
                    reply__->type(),
                    mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    default:
        return MsgNotKnown;
    }
}



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

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

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

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

        return {};
    }
    return static_cast<::mozilla::gfx::PGPUParent*>(actor);
}

} // namespace IPC
