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

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


#include "mozilla/gfx/PGPUChild.h"

#include "mozilla/layers/PAPZInputBridgeChild.h"
#include "mozilla/layers/PCompositorManagerChild.h"
#include "mozilla/layers/PImageBridgeChild.h"
#include "mozilla/PProfilerChild.h"
#include "mozilla/gfx/PVRGPUChild.h"
#include "mozilla/gfx/PVRManagerChild.h"
#include "mozilla/gfx/PVsyncBridgeChild.h"
#include "mozilla/layers/PUiCompositorControllerChild.h"
#include "mozilla/dom/PVideoDecoderManagerChild.h"

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

namespace mozilla {
namespace gfx {


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

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

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

auto PGPUChild::EnteredCxxStack() -> void
{
}

auto PGPUChild::ExitedCxxStack() -> void
{
}

auto PGPUChild::EnteredCall() -> void
{
}

auto PGPUChild::ExitedCall() -> void
{
}

MOZ_IMPLICIT PGPUChild::PGPUChild() :
    mozilla::ipc::IToplevelProtocol("PGPUChild", PGPUMsgStart, mozilla::ipc::ChildSide),
    mLivenessState(mozilla::ipc::LivenessState::Start)
{
    MOZ_COUNT_CTOR(PGPUChild);
}

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

auto PGPUChild::ManagedPAPZInputBridgeChild(nsTArray<PAPZInputBridgeChild*>& aArr) const -> void
{
    (mManagedPAPZInputBridgeChild).ToArray(aArr);
}

auto PGPUChild::ManagedPAPZInputBridgeChild() const -> const ManagedContainer<PAPZInputBridgeChild>&
{
    return mManagedPAPZInputBridgeChild;
}

auto PGPUChild::SendPAPZInputBridgeConstructor(const LayersId& aLayersId) -> PAPZInputBridgeChild*
{
    return SendPAPZInputBridgeConstructor(AllocPAPZInputBridgeChild(aLayersId), aLayersId);
}

auto PGPUChild::SendPAPZInputBridgeConstructor(
        PAPZInputBridgeChild* actor,
        const LayersId& aLayersId) -> PAPZInputBridgeChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PAPZInputBridgeChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPAPZInputBridgeChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PGPU::Msg_PAPZInputBridgeConstructor(MSG_ROUTING_CONTROL);

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



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

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

auto PGPUChild::SendInit(
        const nsTArray<GfxPrefSetting>& prefs,
        const nsTArray<GfxVarUpdate>& vars,
        const DevicePrefs& devicePrefs,
        const nsTArray<LayerTreeIdMapping>& mapping) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_Init(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, prefs);
    // Sentinel = 'prefs'
    (msg__)->WriteSentinel(3194398011);
    WriteIPDLParam(msg__, this, vars);
    // Sentinel = 'vars'
    (msg__)->WriteSentinel(2632090118);
    WriteIPDLParam(msg__, this, devicePrefs);
    // Sentinel = 'devicePrefs'
    (msg__)->WriteSentinel(2200416183);
    WriteIPDLParam(msg__, this, mapping);
    // Sentinel = 'mapping'
    (msg__)->WriteSentinel(601526733);




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

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

auto PGPUChild::SendInitCompositorManager(const Endpoint<mozilla::layers::PCompositorManagerParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitCompositorManager(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendInitVsyncBridge(const Endpoint<mozilla::gfx::PVsyncBridgeParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitVsyncBridge(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendInitImageBridge(const Endpoint<mozilla::layers::PImageBridgeParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitImageBridge(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendInitVRManager(const Endpoint<mozilla::gfx::PVRManagerParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitVRManager(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendInitUiCompositorController(
        const LayersId& rootLayerTreeId,
        const Endpoint<mozilla::layers::PUiCompositorControllerParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitUiCompositorController(MSG_ROUTING_CONTROL);

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




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

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

auto PGPUChild::SendInitProfiler(const Endpoint<mozilla::PProfilerChild>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitProfiler(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendInitVR(const Endpoint<mozilla::gfx::PVRGPUChild>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_InitVR(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendUpdatePref(const GfxPrefSetting& pref) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_UpdatePref(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, pref);
    // Sentinel = 'pref'
    (msg__)->WriteSentinel(3089393963);




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

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

auto PGPUChild::SendUpdateVar(const GfxVarUpdate& var) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_UpdateVar(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, var);
    // Sentinel = 'var'
    (msg__)->WriteSentinel(2283110200);




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

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

auto PGPUChild::SendNewContentCompositorManager(const Endpoint<mozilla::layers::PCompositorManagerParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_NewContentCompositorManager(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendNewContentImageBridge(const Endpoint<mozilla::layers::PImageBridgeParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_NewContentImageBridge(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendNewContentVRManager(const Endpoint<mozilla::gfx::PVRManagerParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_NewContentVRManager(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendNewContentVideoDecoderManager(const Endpoint<mozilla::dom::PVideoDecoderManagerParent>& endpoint) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_NewContentVideoDecoderManager(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, endpoint);
    // Sentinel = 'endpoint'
    (msg__)->WriteSentinel(3610972515);




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

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

auto PGPUChild::SendAddLayerTreeIdMapping(const LayerTreeIdMapping& mapping) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_AddLayerTreeIdMapping(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, mapping);
    // Sentinel = 'mapping'
    (msg__)->WriteSentinel(601526733);



    Message reply__;

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

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

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

    return true;
}

auto PGPUChild::SendRemoveLayerTreeIdMapping(const LayerTreeIdMapping& mapping) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_RemoveLayerTreeIdMapping(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, mapping);
    // Sentinel = 'mapping'
    (msg__)->WriteSentinel(601526733);




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

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

auto PGPUChild::SendGetDeviceStatus(GPUDeviceData* status) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_GetDeviceStatus(MSG_ROUTING_CONTROL);




    Message reply__;

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

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

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

    PickleIterator iter__(reply__);

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

    return true;
}

auto PGPUChild::SendSimulateDeviceReset(GPUDeviceData* status) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_SimulateDeviceReset(MSG_ROUTING_CONTROL);




    Message reply__;

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

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

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

    PickleIterator iter__(reply__);

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

    return true;
}

auto PGPUChild::SendNotifyGpuObservers(const nsCString& aTopic) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_NotifyGpuObservers(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aTopic);
    // Sentinel = 'aTopic'
    (msg__)->WriteSentinel(2759450316);




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

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

auto PGPUChild::SendRequestMemoryReport(
        const uint32_t& generation,
        const bool& anonymize,
        const bool& minimizeMemoryUsage,
        const MaybeFileDesc& DMDFile) -> bool
{
    IPC::Message* msg__ = PGPU::Msg_RequestMemoryReport(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, generation);
    // Sentinel = 'generation'
    (msg__)->WriteSentinel(1396961928);
    WriteIPDLParam(msg__, this, anonymize);
    // Sentinel = 'anonymize'
    (msg__)->WriteSentinel(3334711915);
    WriteIPDLParam(msg__, this, minimizeMemoryUsage);
    // Sentinel = 'minimizeMemoryUsage'
    (msg__)->WriteSentinel(3442464661);
    WriteIPDLParam(msg__, this, DMDFile);
    // Sentinel = 'DMDFile'
    (msg__)->WriteSentinel(3739167222);




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

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

auto PGPUChild::SendShutdownVR() -> bool
{
    IPC::Message* msg__ = PGPU::Msg_ShutdownVR(MSG_ROUTING_CONTROL);





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

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

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

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

auto PGPUChild::OnMessageReceived(const Message& msg__) -> PGPUChild::Result
{
    int32_t route__ = (msg__).routing_id();
    if ((MSG_ROUTING_CONTROL) != (route__)) {
        IProtocol* routed__ = Lookup(route__);
        if ((!(routed__))) {
            return MsgRouteError;
        }
        return (routed__)->OnMessageReceived(msg__);
    }

    switch ((msg__).type()) {
    case PGPU::Reply_PAPZInputBridgeConstructor__ID:
        {
            return MsgProcessed;
        }
    case PGPU::Msg_InitComplete__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitComplete", OTHER);

            PickleIterator iter__(msg__);
            GPUDeviceData data;

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

            return MsgProcessed;
        }
    case PGPU::Msg_ReportCheckerboard__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_ReportCheckerboard", OTHER);

            PickleIterator iter__(msg__);
            uint32_t severity;
            nsCString log;

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

            return MsgProcessed;
        }
    case PGPU::Msg_GraphicsError__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_GraphicsError", OTHER);

            PickleIterator iter__(msg__);
            nsCString aError;

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

            return MsgProcessed;
        }
    case PGPU::Msg_InitCrashReporter__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_InitCrashReporter", OTHER);

            PickleIterator iter__(msg__);
            Shmem shmem;
            NativeThreadId threadId;

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

            return MsgProcessed;
        }
    case PGPU::Msg_CreateVRProcess__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_CreateVRProcess", OTHER);

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

            return MsgProcessed;
        }
    case PGPU::Msg_NotifyUiObservers__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NotifyUiObservers", OTHER);

            PickleIterator iter__(msg__);
            nsCString aTopic;

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

            return MsgProcessed;
        }
    case PGPU::Msg_AccumulateChildHistograms__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_AccumulateChildHistograms", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<HistogramAccumulation> accumulations;

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

            return MsgProcessed;
        }
    case PGPU::Msg_AccumulateChildKeyedHistograms__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_AccumulateChildKeyedHistograms", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<KeyedHistogramAccumulation> accumulations;

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

            return MsgProcessed;
        }
    case PGPU::Msg_UpdateChildScalars__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_UpdateChildScalars", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<ScalarAction> actions;

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

            return MsgProcessed;
        }
    case PGPU::Msg_UpdateChildKeyedScalars__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_UpdateChildKeyedScalars", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<KeyedScalarAction> actions;

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

            return MsgProcessed;
        }
    case PGPU::Msg_RecordChildEvents__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_RecordChildEvents", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<ChildEventData> events;

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

            return MsgProcessed;
        }
    case PGPU::Msg_RecordDiscardedData__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_RecordDiscardedData", OTHER);

            PickleIterator iter__(msg__);
            DiscardedData data;

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

            return MsgProcessed;
        }
    case PGPU::Msg_NotifyDeviceReset__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_NotifyDeviceReset", OTHER);

            PickleIterator iter__(msg__);
            GPUDeviceData status;

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

            return MsgProcessed;
        }
    case PGPU::Msg_AddMemoryReport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_AddMemoryReport", OTHER);

            PickleIterator iter__(msg__);
            MemoryReport aReport;

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

            return MsgProcessed;
        }
    case PGPU::Msg_FinishMemoryReport__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_FinishMemoryReport", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aGeneration;

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

            return MsgProcessed;
        }
    case PGPU::Msg_UpdateFeature__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_UpdateFeature", OTHER);

            PickleIterator iter__(msg__);
            Feature aFeature;
            FeatureFailure aChange;

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

            return MsgProcessed;
        }
    case PGPU::Msg_UsedFallback__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_UsedFallback", OTHER);

            PickleIterator iter__(msg__);
            Fallback aFallback;
            nsCString message;

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

            return MsgProcessed;
        }
    case PGPU::Msg_BHRThreadHang__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PGPUChild")) {
                mozilla::ipc::LogMessageForProtocol("PGPUChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PGPU::Msg_BHRThreadHang", OTHER);

            PickleIterator iter__(msg__);
            HangDetails aDetails;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDetails)))))) {
                FatalError("Error deserializing 'HangDetails'");
                return MsgValueError;
            }
            // Sentinel = 'aDetails'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4067591305)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'HangDetails'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvBHRThreadHang(aDetails)))) {
                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 PGPUChild::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PGPUChild::Result
{
    int32_t route__ = (msg__).routing_id();
    if ((MSG_ROUTING_CONTROL) != (route__)) {
        IProtocol* routed__ = Lookup(route__);
        if ((!(routed__))) {
            return MsgRouteError;
        }
        return (routed__)->OnMessageReceived(msg__, reply__);
    }

    return MsgNotKnown;
}

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

auto PGPUChild::GetProtocolTypeId() -> int32_t
{
    return PGPUMsgStart;
}

auto PGPUChild::OnChannelClose() -> void
{
    DestroySubtree(NormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPGPUChild();
}

auto PGPUChild::OnChannelError() -> void
{
    DestroySubtree(AbnormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPGPUChild();
}

auto PGPUChild::DestroySubtree(ActorDestroyReason why) -> void
{
    ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);

    {
        // Recursively shutting down PAPZInputBridge kids
        nsTArray<PAPZInputBridgeChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPAPZInputBridgeChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPAPZInputBridgeChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

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

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

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

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

auto PGPUChild::DeallocPGPUChild() -> void
{
}



} // namespace gfx
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::gfx::PGPUChild>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    int32_t id;
    if ((!(aVar))) {
        id = 0;
    }
    else {
        id = (aVar)->Id();
        if ((1) == (id)) {
            (aActor)->FatalError("actor has been |delete|d");
        }
    }
    WriteIPDLParam(aMsg, aActor, id);
}

auto IPDLParamTraits<mozilla::gfx::PGPUChild>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PGPU", PGPUMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

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

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53