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


#include "mozilla/devtools/PHeapSnapshotTempFileHelperParent.h"

#include "mozilla/dom/PContentParent.h"

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

namespace mozilla {
namespace devtools {


auto PHeapSnapshotTempFileHelperParent::Recv__delete__() -> bool
{
    return true;
}


MOZ_IMPLICIT PHeapSnapshotTempFileHelperParent::PHeapSnapshotTempFileHelperParent() :
    mozilla::ipc::IProtocol(mozilla::ipc::ParentSide),
    mState(PHeapSnapshotTempFileHelper::__Dead)
{
    MOZ_COUNT_CTOR(PHeapSnapshotTempFileHelperParent);
}

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

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

auto PHeapSnapshotTempFileHelperParent::state() -> PHeapSnapshotTempFileHelper::State
{
    return mState;
}

auto PHeapSnapshotTempFileHelperParent::RemoveManagee(
        int32_t aProtocolId,
        ProtocolBase* aListener) -> void
{
    FatalError("unreached");
    return;
}

auto PHeapSnapshotTempFileHelperParent::OnMessageReceived(const Message& msg__) -> PHeapSnapshotTempFileHelperParent::Result
{
    switch ((msg__).type()) {
    case PHeapSnapshotTempFileHelper::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHeapSnapshotTempFileHelperParent")) {
                mozilla::ipc::LogMessageForProtocol("PHeapSnapshotTempFileHelperParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            PROFILER_LABEL("PHeapSnapshotTempFileHelper", "Msg___delete__", js::ProfileEntry::Category::OTHER);

            PickleIterator iter__ = PickleIterator(msg__);
            PHeapSnapshotTempFileHelperParent* actor;

            if ((!(Read((&(actor)), (&(msg__)), (&(iter__)), false)))) {
                FatalError("Error deserializing 'PHeapSnapshotTempFileHelperParent'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                FatalError("Error deserializing 'PHeapSnapshotTempFileHelperParent'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__);
            if ((!(PHeapSnapshotTempFileHelper::Transition(Trigger(Trigger::Recv, PHeapSnapshotTempFileHelper::Msg___delete____ID), (&(mState)))))) {
                NS_WARNING("bad state transition!");
            }
            if ((!(Recv__delete__()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                return MsgProcessingError;
            }


            (actor)->DestroySubtree(Deletion);
            (actor)->DeallocSubtree();
            ((actor)->Manager())->RemoveManagee(PHeapSnapshotTempFileHelperMsgStart, actor);

            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

auto PHeapSnapshotTempFileHelperParent::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PHeapSnapshotTempFileHelperParent::Result
{
    switch ((msg__).type()) {
    case PHeapSnapshotTempFileHelper::Msg_OpenHeapSnapshotTempFile__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PHeapSnapshotTempFileHelperParent")) {
                mozilla::ipc::LogMessageForProtocol("PHeapSnapshotTempFileHelperParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            PROFILER_LABEL("PHeapSnapshotTempFileHelper", "Msg_OpenHeapSnapshotTempFile", js::ProfileEntry::Category::OTHER);

            if ((!(PHeapSnapshotTempFileHelper::Transition(Trigger(Trigger::Recv, PHeapSnapshotTempFileHelper::Msg_OpenHeapSnapshotTempFile__ID), (&(mState)))))) {
                NS_WARNING("bad state transition!");
            }
            OpenHeapSnapshotTempFileResponse response;
            int32_t id__ = Id();
            if ((!(RecvOpenHeapSnapshotTempFile((&(response)))))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                return MsgProcessingError;
            }

            reply__ = PHeapSnapshotTempFileHelper::Reply_OpenHeapSnapshotTempFile(id__);

            Write(response, reply__);
            // Sentinel = 'response'
            (reply__)->WriteSentinel(2396115421);
            (reply__)->set_sync();
            (reply__)->set_reply();

            if (mozilla::ipc::LoggingEnabledFor("PHeapSnapshotTempFileHelperParent")) {
                mozilla::ipc::LogMessageForProtocol("PHeapSnapshotTempFileHelperParent", OtherPid(), "Sending reply ", (reply__)->type(), mozilla::ipc::MessageDirection::eSending);
            }
            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

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

auto PHeapSnapshotTempFileHelperParent::GetProtocolTypeId() -> int32_t
{
    return PHeapSnapshotTempFileHelperMsgStart;
}

auto PHeapSnapshotTempFileHelperParent::ProtocolName() const -> const char*
{
    return "PHeapSnapshotTempFileHelperParent";
}

auto PHeapSnapshotTempFileHelperParent::DestroySubtree(ActorDestroyReason why) -> void
{
    // Unregister from our manager.
    Unregister(Id());
    SetId(1);

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

auto PHeapSnapshotTempFileHelperParent::DeallocSubtree() -> void
{
}

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

    switch ((v__).type()) {
    case type__::Tnsresult:
        {
            Write((v__).get_nsresult(), msg__);
            // Sentinel = 'Tnsresult'
            (msg__)->WriteSentinel(2293764539);
            return;
        }
    case type__::TOpenedFile:
        {
            Write((v__).get_OpenedFile(), msg__);
            // Sentinel = 'TOpenedFile'
            (msg__)->WriteSentinel(218745554);
            return;
        }
    default:
        {
            FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case type__::Tnsresult:
        {
            nsresult tmp = nsresult();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_nsresult())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'Tnsresult'
            if ((!((msg__)->ReadSentinel(iter__, 2293764539)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    case type__::TOpenedFile:
        {
            OpenedFile tmp = OpenedFile();
            (*(v__)) = tmp;
            if ((!(Read((&((v__)->get_OpenedFile())), msg__, iter__)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            // Sentinel = 'TOpenedFile'
            if ((!((msg__)->ReadSentinel(iter__, 218745554)))) {
                FatalError("Error deserializing Union type");
                return false;
            }
            return true;
        }
    default:
        {
            FatalError("unknown union type");
            return false;
        }
    }
}

auto PHeapSnapshotTempFileHelperParent::Write(
        const FileDescriptor& v__,
        Message* msg__) -> void
{
    FileDescriptor::PickleType pfd = (v__).ShareTo(FileDescriptor::IPDLPrivate(), OtherPid());
    IPC::WriteParam(msg__, pfd);
}

auto PHeapSnapshotTempFileHelperParent::Read(
        FileDescriptor* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    FileDescriptor::PickleType pfd;
    if ((!(IPC::ReadParam(msg__, iter__, (&(pfd)))))) {
        return false;
    }

    FileDescriptor fd = FileDescriptor(FileDescriptor::IPDLPrivate(), pfd);
    if ((!((fd).IsValid()))) {
        mozilla::ipc::ProtocolErrorBreakpoint("[PHeapSnapshotTempFileHelperParent] Received an invalid file descriptor!");
    }

    (*(v__)) = fd;
    return true;
}

auto PHeapSnapshotTempFileHelperParent::Write(
        const OpenedFile& v__,
        Message* msg__) -> void
{
    Write((v__).path(), msg__);
    // Sentinel = 'path'
    (msg__)->WriteSentinel(913629401);
    Write((v__).descriptor(), msg__);
    // Sentinel = 'descriptor'
    (msg__)->WriteSentinel(2435877233);
}

auto PHeapSnapshotTempFileHelperParent::Read(
        OpenedFile* v__,
        const Message* msg__,
        PickleIterator* iter__) -> bool
{
    if ((!(Read((&((v__)->path())), msg__, iter__)))) {
        FatalError("Error deserializing 'path' (nsString) member of 'OpenedFile'");
        return false;
    }
    // Sentinel = 'path'
    if ((!((msg__)->ReadSentinel(iter__, 913629401)))) {
        FatalError("Error deserializing 'path' (nsString) member of 'OpenedFile'");
        return false;
    }
    if ((!(Read((&((v__)->descriptor())), msg__, iter__)))) {
        FatalError("Error deserializing 'descriptor' (FileDescriptor) member of 'OpenedFile'");
        return false;
    }
    // Sentinel = 'descriptor'
    if ((!((msg__)->ReadSentinel(iter__, 2435877233)))) {
        FatalError("Error deserializing 'descriptor' (FileDescriptor) member of 'OpenedFile'");
        return false;
    }
    return true;
}

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

    Write(id, msg__);
}

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

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



} // namespace devtools
} // namespace mozilla