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

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


#include "mozilla/gfx/PVRManagerChild.h"
#include "gfxVR.h"

#include "mozilla/gfx/PVRLayerChild.h"

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

namespace mozilla {
namespace gfx {


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

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

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

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

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

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

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

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

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

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

auto PVRManagerChild::ManagedPVRLayerChild(nsTArray<PVRLayerChild*>& aArr) const -> void
{
    (mManagedPVRLayerChild).ToArray(aArr);
}

auto PVRManagerChild::ManagedPVRLayerChild() const -> const ManagedContainer<PVRLayerChild>&
{
    return mManagedPVRLayerChild;
}

auto PVRManagerChild::SendPVRLayerConstructor(
        const uint32_t& aDisplayID,
        const uint32_t& aGroup) -> PVRLayerChild*
{
    return SendPVRLayerConstructor(AllocPVRLayerChild(aDisplayID, aGroup), aDisplayID, aGroup);
}

auto PVRManagerChild::SendPVRLayerConstructor(
        PVRLayerChild* actor,
        const uint32_t& aDisplayID,
        const uint32_t& aGroup) -> PVRLayerChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PVRLayerChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPVRLayerChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PVRManager::Msg_PVRLayerConstructor(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, aDisplayID);
    // Sentinel = 'aDisplayID'
    (msg__)->WriteSentinel(2139184880);
    WriteIPDLParam(msg__, this, aGroup);
    // Sentinel = 'aGroup'
    (msg__)->WriteSentinel(1323513608);



    if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
        mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PVRManager::Msg_PVRLayerConstructor", 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 PVRManagerChild::SendRefreshDisplays() -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_RefreshDisplays(MSG_ROUTING_CONTROL);





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

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

auto PVRManagerChild::SendResetSensor(const uint32_t& aDisplayID) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_ResetSensor(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDisplayID);
    // Sentinel = 'aDisplayID'
    (msg__)->WriteSentinel(2139184880);




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

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

auto PVRManagerChild::SendSetGroupMask(
        const uint32_t& aDisplayID,
        const uint32_t& aGroupMask) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_SetGroupMask(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDisplayID);
    // Sentinel = 'aDisplayID'
    (msg__)->WriteSentinel(2139184880);
    WriteIPDLParam(msg__, this, aGroupMask);
    // Sentinel = 'aGroupMask'
    (msg__)->WriteSentinel(4157390796);




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

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

auto PVRManagerChild::SendSetHaveEventListener(const bool& aHaveEventListener) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_SetHaveEventListener(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aHaveEventListener);
    // Sentinel = 'aHaveEventListener'
    (msg__)->WriteSentinel(3921043303);




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

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

auto PVRManagerChild::SendControllerListenerAdded() -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_ControllerListenerAdded(MSG_ROUTING_CONTROL);





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

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

auto PVRManagerChild::SendControllerListenerRemoved() -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_ControllerListenerRemoved(MSG_ROUTING_CONTROL);





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

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

auto PVRManagerChild::SendVibrateHaptic(
        const uint32_t& aControllerIdx,
        const uint32_t& aHapticIndex,
        const double& aIntensity,
        const double& aDuration,
        const uint32_t& aPromiseID) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_VibrateHaptic(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aControllerIdx);
    // Sentinel = 'aControllerIdx'
    (msg__)->WriteSentinel(1525026068);
    WriteIPDLParam(msg__, this, aHapticIndex);
    // Sentinel = 'aHapticIndex'
    (msg__)->WriteSentinel(3997306204);
    WriteIPDLParam(msg__, this, aIntensity);
    // Sentinel = 'aIntensity'
    (msg__)->WriteSentinel(701797642);
    WriteIPDLParam(msg__, this, aDuration);
    // Sentinel = 'aDuration'
    (msg__)->WriteSentinel(3213285508);
    WriteIPDLParam(msg__, this, aPromiseID);
    // Sentinel = 'aPromiseID'
    (msg__)->WriteSentinel(1396174117);




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

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

auto PVRManagerChild::SendStopVibrateHaptic(const uint32_t& aControllerIdx) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_StopVibrateHaptic(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aControllerIdx);
    // Sentinel = 'aControllerIdx'
    (msg__)->WriteSentinel(1525026068);




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

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

auto PVRManagerChild::SendCreateVRTestSystem() -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_CreateVRTestSystem(MSG_ROUTING_CONTROL);





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

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

auto PVRManagerChild::SendCreateVRServiceTestDisplay(
        const nsCString& aID,
        const uint32_t& aPromiseID) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_CreateVRServiceTestDisplay(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aPromiseID);
    // Sentinel = 'aPromiseID'
    (msg__)->WriteSentinel(1396174117);




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

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

auto PVRManagerChild::SendCreateVRServiceTestController(
        const nsCString& aID,
        const uint32_t& aPromiseID) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_CreateVRServiceTestController(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aID);
    // Sentinel = 'aID'
    (msg__)->WriteSentinel(2735041849);
    WriteIPDLParam(msg__, this, aPromiseID);
    // Sentinel = 'aPromiseID'
    (msg__)->WriteSentinel(1396174117);




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

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

auto PVRManagerChild::SendSetDisplayInfoToMockDisplay(
        const uint32_t& aDeviceID,
        const VRDisplayInfo& aDisplayInfo) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_SetDisplayInfoToMockDisplay(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);
    WriteIPDLParam(msg__, this, aDisplayInfo);
    // Sentinel = 'aDisplayInfo'
    (msg__)->WriteSentinel(2651062689);




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

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

auto PVRManagerChild::SendSetSensorStateToMockDisplay(
        const uint32_t& aDeviceID,
        const VRHMDSensorState& aSensorState) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_SetSensorStateToMockDisplay(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);
    WriteIPDLParam(msg__, this, aSensorState);
    // Sentinel = 'aSensorState'
    (msg__)->WriteSentinel(3074518118);




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

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

auto PVRManagerChild::SendNewButtonEventToMockController(
        const uint32_t& aDeviceID,
        const long& aButton,
        const bool& aPressed) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_NewButtonEventToMockController(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);
    WriteIPDLParam(msg__, this, aButton);
    // Sentinel = 'aButton'
    (msg__)->WriteSentinel(1126532398);
    WriteIPDLParam(msg__, this, aPressed);
    // Sentinel = 'aPressed'
    (msg__)->WriteSentinel(511193633);




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

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

auto PVRManagerChild::SendNewAxisMoveEventToMockController(
        const uint32_t& aDeviceID,
        const long& aAxis,
        const double& aValue) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_NewAxisMoveEventToMockController(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);
    WriteIPDLParam(msg__, this, aAxis);
    // Sentinel = 'aAxis'
    (msg__)->WriteSentinel(1730285743);
    WriteIPDLParam(msg__, this, aValue);
    // Sentinel = 'aValue'
    (msg__)->WriteSentinel(2522186438);




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

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

auto PVRManagerChild::SendNewPoseMoveToMockController(
        const uint32_t& aDeviceID,
        const GamepadPoseState& aPose) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_NewPoseMoveToMockController(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);
    WriteIPDLParam(msg__, this, aPose);
    // Sentinel = 'aPose'
    (msg__)->WriteSentinel(2231333587);




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

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

auto PVRManagerChild::SendStartVRNavigation(const uint32_t& aDeviceID) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_StartVRNavigation(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);




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

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

auto PVRManagerChild::SendStopVRNavigation(
        const uint32_t& aDeviceID,
        const TimeDuration& aDuration) -> bool
{
    IPC::Message* msg__ = PVRManager::Msg_StopVRNavigation(MSG_ROUTING_CONTROL);

    WriteIPDLParam(msg__, this, aDeviceID);
    // Sentinel = 'aDeviceID'
    (msg__)->WriteSentinel(1963457757);
    WriteIPDLParam(msg__, this, aDuration);
    // Sentinel = 'aDuration'
    (msg__)->WriteSentinel(3213285508);




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

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

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

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

auto PVRManagerChild::OnMessageReceived(const Message& msg__) -> PVRManagerChild::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 PVRManager::Reply_PVRLayerConstructor__ID:
        {
            return MsgProcessed;
        }
    case PVRManager::Msg_UpdateDisplayInfo__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
                mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVRManager::Msg_UpdateDisplayInfo", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<VRDisplayInfo> aDisplayUpdates;

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

            return MsgProcessed;
        }
    case PVRManager::Msg_DispatchSubmitFrameResult__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
                mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVRManager::Msg_DispatchSubmitFrameResult", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aDisplayID;
            VRSubmitFrameResultInfo aResult;

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

            return MsgProcessed;
        }
    case PVRManager::Msg_GamepadUpdate__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
                mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVRManager::Msg_GamepadUpdate", OTHER);

            PickleIterator iter__(msg__);
            GamepadChangeEvent aGamepadEvent;

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

            return MsgProcessed;
        }
    case PVRManager::Msg_ReplyGamepadVibrateHaptic__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
                mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVRManager::Msg_ReplyGamepadVibrateHaptic", OTHER);

            PickleIterator iter__(msg__);
            uint32_t aPromiseID;

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

            return MsgProcessed;
        }
    case PVRManager::Msg_ReplyCreateVRServiceTestDisplay__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
                mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVRManager::Msg_ReplyCreateVRServiceTestDisplay", OTHER);

            PickleIterator iter__(msg__);
            nsCString aID;
            uint32_t aPromiseID;
            uint32_t aDeviceID;

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

            return MsgProcessed;
        }
    case PVRManager::Msg_ReplyCreateVRServiceTestController__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVRManagerChild")) {
                mozilla::ipc::LogMessageForProtocol("PVRManagerChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVRManager::Msg_ReplyCreateVRServiceTestController", OTHER);

            PickleIterator iter__(msg__);
            nsCString aID;
            uint32_t aPromiseID;
            uint32_t aDeviceID;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aID)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'aID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2735041849)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aPromiseID)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aPromiseID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1396174117)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDeviceID)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'aDeviceID'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1963457757)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvReplyCreateVRServiceTestController(aID, aPromiseID, aDeviceID)))) {
                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 PVRManagerChild::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PVRManagerChild::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 PVRManagerChild::OnCallReceived(
        const Message& msg__,
        Message*& reply__) -> PVRManagerChild::Result
{
    MOZ_ASSERT_UNREACHABLE("message protocol not supported");
    return MsgNotKnown;
}

auto PVRManagerChild::GetProtocolTypeId() -> int32_t
{
    return PVRManagerMsgStart;
}

auto PVRManagerChild::OnChannelClose() -> void
{
    DestroySubtree(NormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPVRManagerChild();
}

auto PVRManagerChild::OnChannelError() -> void
{
    DestroySubtree(AbnormalShutdown);
    DeallocSubtree();
    DeallocShmems();
    DeallocPVRManagerChild();
}

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

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

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

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

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

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

auto PVRManagerChild::DeallocPVRManagerChild() -> void
{
}



} // namespace gfx
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::gfx::PVRManagerChild>::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::PVRManagerChild>::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, "PVRManager", PVRManagerMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

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

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53