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

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


#include "mozilla/ipc/PChildToParentStreamParent.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamParent.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/ipc/IPCStream.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct InputStreamParamsWithFds|
//
namespace mozilla {
namespace ipc {
auto InputStreamParamsWithFds::operator==(const InputStreamParamsWithFds& _o) const -> bool
{
    if ((!((stream()) == ((_o).stream())))) {
        return false;
    }
    if ((!((optionalFds()) == ((_o).optionalFds())))) {
        return false;
    }
    return true;
}

auto InputStreamParamsWithFds::operator!=(const InputStreamParamsWithFds& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::InputStreamParamsWithFds>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).stream());
    // Sentinel = 'stream'
    (aMsg)->WriteSentinel(4152748422);
    WriteIPDLParam(aMsg, aActor, (aVar).optionalFds());
    // Sentinel = 'optionalFds'
    (aMsg)->WriteSentinel(1021803302);
}

auto IPDLParamTraits<mozilla::ipc::InputStreamParamsWithFds>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stream())))))) {
        (aActor)->FatalError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
        return false;
    }
    // Sentinel = 'stream'
    if ((!((aMsg)->ReadSentinel(aIter, 4152748422)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stream' (InputStreamParams) member of 'InputStreamParamsWithFds'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->optionalFds())))))) {
        (aActor)->FatalError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
        return false;
    }
    // Sentinel = 'optionalFds'
    if ((!((aMsg)->ReadSentinel(aIter, 1021803302)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'optionalFds' (OptionalFileDescriptorSet) member of 'InputStreamParamsWithFds'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCRemoteStreamType|
//
namespace mozilla {
namespace ipc {
auto IPCRemoteStreamType::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TPChildToParentStreamParent:
        {
            (ptr_PChildToParentStreamParent())->~PChildToParentStreamParent__tdef();
            break;
        }
    case TPChildToParentStreamChild:
        {
            (ptr_PChildToParentStreamChild())->~PChildToParentStreamChild__tdef();
            break;
        }
    case TPParentToChildStreamParent:
        {
            (ptr_PParentToChildStreamParent())->~PParentToChildStreamParent__tdef();
            break;
        }
    case TPParentToChildStreamChild:
        {
            (ptr_PParentToChildStreamChild())->~PParentToChildStreamChild__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PChildToParentStreamParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*(const_cast<PChildToParentStreamParent*>(aOther));
    mType = TPChildToParentStreamParent;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PChildToParentStreamChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*(const_cast<PChildToParentStreamChild*>(aOther));
    mType = TPChildToParentStreamChild;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PParentToChildStreamParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*(const_cast<PParentToChildStreamParent*>(aOther));
    mType = TPParentToChildStreamParent;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(PParentToChildStreamChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*(const_cast<PParentToChildStreamChild*>(aOther));
    mType = TPParentToChildStreamChild;
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(const IPCRemoteStreamType& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TPChildToParentStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*(const_cast<PChildToParentStreamParent*>((aOther).get_PChildToParentStreamParent()));
            break;
        }
    case TPChildToParentStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*(const_cast<PChildToParentStreamChild*>((aOther).get_PChildToParentStreamChild()));
            break;
        }
    case TPParentToChildStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*(const_cast<PParentToChildStreamParent*>((aOther).get_PParentToChildStreamParent()));
            break;
        }
    case TPParentToChildStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*(const_cast<PParentToChildStreamChild*>((aOther).get_PParentToChildStreamChild()));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCRemoteStreamType::IPCRemoteStreamType(IPCRemoteStreamType&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TPChildToParentStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*(const_cast<PChildToParentStreamParent*>(std::move((aOther).get_PChildToParentStreamParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPChildToParentStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*(const_cast<PChildToParentStreamChild*>(std::move((aOther).get_PChildToParentStreamChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*(const_cast<PParentToChildStreamParent*>(std::move((aOther).get_PParentToChildStreamParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*(const_cast<PParentToChildStreamChild*>(std::move((aOther).get_PParentToChildStreamChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCRemoteStreamType::~IPCRemoteStreamType()
{
    static_cast<void>(MaybeDestroy(T__None));
}

auto IPCRemoteStreamType::operator=(PChildToParentStreamParent* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPChildToParentStreamParent)) {
        new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*;
    }
    (*(ptr_PChildToParentStreamParent())) = const_cast<PChildToParentStreamParent*>(aRhs);
    mType = TPChildToParentStreamParent;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(PChildToParentStreamChild* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPChildToParentStreamChild)) {
        new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*;
    }
    (*(ptr_PChildToParentStreamChild())) = const_cast<PChildToParentStreamChild*>(aRhs);
    mType = TPChildToParentStreamChild;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(PParentToChildStreamParent* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPParentToChildStreamParent)) {
        new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*;
    }
    (*(ptr_PParentToChildStreamParent())) = const_cast<PParentToChildStreamParent*>(aRhs);
    mType = TPParentToChildStreamParent;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(PParentToChildStreamChild* aRhs) -> IPCRemoteStreamType&
{
    if (MaybeDestroy(TPParentToChildStreamChild)) {
        new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*;
    }
    (*(ptr_PParentToChildStreamChild())) = const_cast<PParentToChildStreamChild*>(aRhs);
    mType = TPParentToChildStreamChild;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(const IPCRemoteStreamType& aRhs) -> IPCRemoteStreamType&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPChildToParentStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*;
            }
            (*(ptr_PChildToParentStreamParent())) = const_cast<PChildToParentStreamParent*>((aRhs).get_PChildToParentStreamParent());
            break;
        }
    case TPChildToParentStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*;
            }
            (*(ptr_PChildToParentStreamChild())) = const_cast<PChildToParentStreamChild*>((aRhs).get_PChildToParentStreamChild());
            break;
        }
    case TPParentToChildStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*;
            }
            (*(ptr_PParentToChildStreamParent())) = const_cast<PParentToChildStreamParent*>((aRhs).get_PParentToChildStreamParent());
            break;
        }
    case TPParentToChildStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*;
            }
            (*(ptr_PParentToChildStreamChild())) = const_cast<PParentToChildStreamChild*>((aRhs).get_PParentToChildStreamChild());
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCRemoteStreamType::operator=(IPCRemoteStreamType&& aRhs) -> IPCRemoteStreamType&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPChildToParentStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamParent()) PChildToParentStreamParent*;
            }
            (*(ptr_PChildToParentStreamParent())) = const_cast<PChildToParentStreamParent*>(std::move((aRhs).get_PChildToParentStreamParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPChildToParentStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PChildToParentStreamChild()) PChildToParentStreamChild*;
            }
            (*(ptr_PChildToParentStreamChild())) = const_cast<PChildToParentStreamChild*>(std::move((aRhs).get_PChildToParentStreamChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamParent()) PParentToChildStreamParent*;
            }
            (*(ptr_PParentToChildStreamParent())) = const_cast<PParentToChildStreamParent*>(std::move((aRhs).get_PParentToChildStreamParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPParentToChildStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PParentToChildStreamChild()) PParentToChildStreamChild*;
            }
            (*(ptr_PParentToChildStreamChild())) = const_cast<PParentToChildStreamChild*>(std::move((aRhs).get_PParentToChildStreamChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto IPCRemoteStreamType::operator==(PChildToParentStreamParent* aRhs) const -> bool
{
    return (get_PChildToParentStreamParent()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(PChildToParentStreamChild* aRhs) const -> bool
{
    return (get_PChildToParentStreamChild()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(PParentToChildStreamParent* aRhs) const -> bool
{
    return (get_PParentToChildStreamParent()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(PParentToChildStreamChild* aRhs) const -> bool
{
    return (get_PParentToChildStreamChild()) == (aRhs);
}

auto IPCRemoteStreamType::operator==(const IPCRemoteStreamType& aRhs) const -> bool
{
    if ((type()) != ((aRhs).type())) {
        return false;
    }

    switch (type()) {
    case TPChildToParentStreamParent:
        {
            return (get_PChildToParentStreamParent()) == ((aRhs).get_PChildToParentStreamParent());
        }
    case TPChildToParentStreamChild:
        {
            return (get_PChildToParentStreamChild()) == ((aRhs).get_PChildToParentStreamChild());
        }
    case TPParentToChildStreamParent:
        {
            return (get_PParentToChildStreamParent()) == ((aRhs).get_PParentToChildStreamParent());
        }
    case TPParentToChildStreamChild:
        {
            return (get_PParentToChildStreamChild()) == ((aRhs).get_PParentToChildStreamChild());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto IPCRemoteStreamType::get(PChildToParentStreamParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PChildToParentStreamParent();
}

auto IPCRemoteStreamType::get(PChildToParentStreamChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PChildToParentStreamChild();
}

auto IPCRemoteStreamType::get(PParentToChildStreamParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PParentToChildStreamParent();
}

auto IPCRemoteStreamType::get(PParentToChildStreamChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PParentToChildStreamChild();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IPCRemoteStreamType>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::IPCRemoteStreamType union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'IPCRemoteStreamType'
    (aMsg)->WriteSentinel(391674895);

    switch (type) {
    case union__::TPChildToParentStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PChildToParentStreamParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PChildToParentStreamParent());
                // Sentinel = 'TPChildToParentStreamParent'
                (aMsg)->WriteSentinel(2724777622);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPChildToParentStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PChildToParentStreamChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PChildToParentStreamChild());
                // Sentinel = 'TPChildToParentStreamChild'
                (aMsg)->WriteSentinel(1882094295);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPParentToChildStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PParentToChildStreamParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PParentToChildStreamParent());
                // Sentinel = 'TPParentToChildStreamParent'
                (aMsg)->WriteSentinel(3335986876);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPParentToChildStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PParentToChildStreamChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PParentToChildStreamChild());
                // Sentinel = 'TPParentToChildStreamChild'
                (aMsg)->WriteSentinel(190098493);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::IPCRemoteStreamType>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::IPCRemoteStreamType union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union IPCRemoteStreamType");
        return false;
    }
    // Sentinel = 'IPCRemoteStreamType'
    if ((!((aMsg)->ReadSentinel(aIter, 391674895)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCRemoteStreamType");
        return false;
    }

    switch (type) {
    case union__::TPChildToParentStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PChildToParentStreamChild* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PChildToParentStreamChild())))))) {
                (aActor)->FatalError("Error deserializing variant TPChildToParentStreamParent of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PChildToParentStreamChild()))))))) {
                (aActor)->FatalError("Error deserializing variant TPChildToParentStreamParent of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPChildToParentStreamParent'
            if ((!((aMsg)->ReadSentinel(aIter, 2724777622)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPChildToParentStreamParent of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    case union__::TPChildToParentStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PChildToParentStreamParent* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PChildToParentStreamParent())))))) {
                (aActor)->FatalError("Error deserializing variant TPChildToParentStreamChild of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PChildToParentStreamParent()))))))) {
                (aActor)->FatalError("Error deserializing variant TPChildToParentStreamChild of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPChildToParentStreamChild'
            if ((!((aMsg)->ReadSentinel(aIter, 1882094295)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPChildToParentStreamChild of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    case union__::TPParentToChildStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PParentToChildStreamChild* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PParentToChildStreamChild())))))) {
                (aActor)->FatalError("Error deserializing variant TPParentToChildStreamParent of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PParentToChildStreamChild()))))))) {
                (aActor)->FatalError("Error deserializing variant TPParentToChildStreamParent of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPParentToChildStreamParent'
            if ((!((aMsg)->ReadSentinel(aIter, 3335986876)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPParentToChildStreamParent of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    case union__::TPParentToChildStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PParentToChildStreamParent* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PParentToChildStreamParent())))))) {
                (aActor)->FatalError("Error deserializing variant TPParentToChildStreamChild of union IPCRemoteStreamType");
                return false;
            }
            if ((!((*((&((aVar)->get_PParentToChildStreamParent()))))))) {
                (aActor)->FatalError("Error deserializing variant TPParentToChildStreamChild of union IPCRemoteStreamType");
                return false;
            }
            // Sentinel = 'TPParentToChildStreamChild'
            if ((!((aMsg)->ReadSentinel(aIter, 190098493)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPParentToChildStreamChild of union IPCRemoteStreamType");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCRemoteStream|
//
namespace mozilla {
namespace ipc {
auto IPCRemoteStream::operator==(const IPCRemoteStream& _o) const -> bool
{
    if ((!((delayedStart()) == ((_o).delayedStart())))) {
        return false;
    }
    if ((!((stream()) == ((_o).stream())))) {
        return false;
    }
    if ((!((length()) == ((_o).length())))) {
        return false;
    }
    return true;
}

auto IPCRemoteStream::operator!=(const IPCRemoteStream& _o) const -> bool
{
    return (!(operator==(_o)));
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IPCRemoteStream>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).delayedStart());
    // Sentinel = 'delayedStart'
    (aMsg)->WriteSentinel(1491822294);
    WriteIPDLParam(aMsg, aActor, (aVar).stream());
    // Sentinel = 'stream'
    (aMsg)->WriteSentinel(4152748422);
    WriteIPDLParam(aMsg, aActor, (aVar).length());
    // Sentinel = 'length'
    (aMsg)->WriteSentinel(1726618354);
}

auto IPDLParamTraits<mozilla::ipc::IPCRemoteStream>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->delayedStart())))))) {
        (aActor)->FatalError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
        return false;
    }
    // Sentinel = 'delayedStart'
    if ((!((aMsg)->ReadSentinel(aIter, 1491822294)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'delayedStart' (bool) member of 'IPCRemoteStream'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->stream())))))) {
        (aActor)->FatalError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
        return false;
    }
    // Sentinel = 'stream'
    if ((!((aMsg)->ReadSentinel(aIter, 4152748422)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCRemoteStreamType) member of 'IPCRemoteStream'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->length())))))) {
        (aActor)->FatalError("Error deserializing 'length' (int64_t) member of 'IPCRemoteStream'");
        return false;
    }
    // Sentinel = 'length'
    if ((!((aMsg)->ReadSentinel(aIter, 1726618354)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'length' (int64_t) member of 'IPCRemoteStream'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCStream|
//
namespace mozilla {
namespace ipc {
auto IPCStream::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TInputStreamParamsWithFds:
        {
            (ptr_InputStreamParamsWithFds())->~InputStreamParamsWithFds__tdef();
            break;
        }
    case TIPCRemoteStream:
        {
            (ptr_IPCRemoteStream())->~IPCRemoteStream__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT IPCStream::IPCStream(const InputStreamParamsWithFds& aOther)
{
    new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds(aOther);
    mType = TInputStreamParamsWithFds;
}

MOZ_IMPLICIT IPCStream::IPCStream(InputStreamParamsWithFds&& aOther)
{
    new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds(std::move(aOther));
    mType = TInputStreamParamsWithFds;
}

MOZ_IMPLICIT IPCStream::IPCStream(const IPCRemoteStream& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream(aOther);
    mType = TIPCRemoteStream;
}

MOZ_IMPLICIT IPCStream::IPCStream(IPCRemoteStream&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream(std::move(aOther));
    mType = TIPCRemoteStream;
}

MOZ_IMPLICIT IPCStream::IPCStream(const IPCStream& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TInputStreamParamsWithFds:
        {
            new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds((aOther).get_InputStreamParamsWithFds());
            break;
        }
    case TIPCRemoteStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream((aOther).get_IPCRemoteStream());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCStream::IPCStream(IPCStream&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TInputStreamParamsWithFds:
        {
            new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds(std::move((aOther).get_InputStreamParamsWithFds()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIPCRemoteStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream(std::move((aOther).get_IPCRemoteStream()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

IPCStream::~IPCStream()
{
    static_cast<void>(MaybeDestroy(T__None));
}

auto IPCStream::operator=(const InputStreamParamsWithFds& aRhs) -> IPCStream&
{
    if (MaybeDestroy(TInputStreamParamsWithFds)) {
        new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds;
    }
    (*(ptr_InputStreamParamsWithFds())) = aRhs;
    mType = TInputStreamParamsWithFds;
    return (*(this));
}

auto IPCStream::operator=(InputStreamParamsWithFds&& aRhs) -> IPCStream&
{
    if (MaybeDestroy(TInputStreamParamsWithFds)) {
        new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds;
    }
    (*(ptr_InputStreamParamsWithFds())) = std::move(aRhs);
    mType = TInputStreamParamsWithFds;
    return (*(this));
}

auto IPCStream::operator=(const IPCRemoteStream& aRhs) -> IPCStream&
{
    if (MaybeDestroy(TIPCRemoteStream)) {
        new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream;
    }
    (*(ptr_IPCRemoteStream())) = aRhs;
    mType = TIPCRemoteStream;
    return (*(this));
}

auto IPCStream::operator=(IPCRemoteStream&& aRhs) -> IPCStream&
{
    if (MaybeDestroy(TIPCRemoteStream)) {
        new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream;
    }
    (*(ptr_IPCRemoteStream())) = std::move(aRhs);
    mType = TIPCRemoteStream;
    return (*(this));
}

auto IPCStream::operator=(const IPCStream& aRhs) -> IPCStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TInputStreamParamsWithFds:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds;
            }
            (*(ptr_InputStreamParamsWithFds())) = (aRhs).get_InputStreamParamsWithFds();
            break;
        }
    case TIPCRemoteStream:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream;
            }
            (*(ptr_IPCRemoteStream())) = (aRhs).get_IPCRemoteStream();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCStream::operator=(IPCStream&& aRhs) -> IPCStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TInputStreamParamsWithFds:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InputStreamParamsWithFds()) InputStreamParamsWithFds;
            }
            (*(ptr_InputStreamParamsWithFds())) = std::move((aRhs).get_InputStreamParamsWithFds());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TIPCRemoteStream:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCRemoteStream()) IPCRemoteStream;
            }
            (*(ptr_IPCRemoteStream())) = std::move((aRhs).get_IPCRemoteStream());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto IPCStream::operator==(const InputStreamParamsWithFds& aRhs) const -> bool
{
    return (get_InputStreamParamsWithFds()) == (aRhs);
}

auto IPCStream::operator==(const IPCRemoteStream& aRhs) const -> bool
{
    return (get_IPCRemoteStream()) == (aRhs);
}

auto IPCStream::operator==(const IPCStream& aRhs) const -> bool
{
    if ((type()) != ((aRhs).type())) {
        return false;
    }

    switch (type()) {
    case TInputStreamParamsWithFds:
        {
            return (get_InputStreamParamsWithFds()) == ((aRhs).get_InputStreamParamsWithFds());
        }
    case TIPCRemoteStream:
        {
            return (get_IPCRemoteStream()) == ((aRhs).get_IPCRemoteStream());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto IPCStream::get(InputStreamParamsWithFds* aOutValue) const -> void
{
    (*(aOutValue)) = get_InputStreamParamsWithFds();
}

auto IPCStream::get(IPCRemoteStream* aOutValue) const -> void
{
    (*(aOutValue)) = get_IPCRemoteStream();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::IPCStream>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::IPCStream union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'IPCStream'
    (aMsg)->WriteSentinel(442610715);

    switch (type) {
    case union__::TInputStreamParamsWithFds:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_InputStreamParamsWithFds());
            // Sentinel = 'TInputStreamParamsWithFds'
            (aMsg)->WriteSentinel(2170706066);
            return;
        }
    case union__::TIPCRemoteStream:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IPCRemoteStream());
            // Sentinel = 'TIPCRemoteStream'
            (aMsg)->WriteSentinel(2978132448);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::IPCStream>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::IPCStream union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union IPCStream");
        return false;
    }
    // Sentinel = 'IPCStream'
    if ((!((aMsg)->ReadSentinel(aIter, 442610715)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union IPCStream");
        return false;
    }

    switch (type) {
    case union__::TInputStreamParamsWithFds:
        {
            mozilla::ipc::InputStreamParamsWithFds tmp = mozilla::ipc::InputStreamParamsWithFds();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_InputStreamParamsWithFds())))))) {
                (aActor)->FatalError("Error deserializing variant TInputStreamParamsWithFds of union IPCStream");
                return false;
            }
            // Sentinel = 'TInputStreamParamsWithFds'
            if ((!((aMsg)->ReadSentinel(aIter, 2170706066)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TInputStreamParamsWithFds of union IPCStream");
                return false;
            }
            return true;
        }
    case union__::TIPCRemoteStream:
        {
            mozilla::ipc::IPCRemoteStream tmp = mozilla::ipc::IPCRemoteStream();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IPCRemoteStream())))))) {
                (aActor)->FatalError("Error deserializing variant TIPCRemoteStream of union IPCStream");
                return false;
            }
            // Sentinel = 'TIPCRemoteStream'
            if ((!((aMsg)->ReadSentinel(aIter, 2978132448)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCRemoteStream of union IPCStream");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OptionalIPCStream|
//
namespace mozilla {
namespace ipc {
auto OptionalIPCStream::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TIPCStream:
        {
            (ptr_IPCStream())->~IPCStream__tdef();
            break;
        }
    case Tvoid_t:
        {
            (ptr_void_t())->~void_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT OptionalIPCStream::OptionalIPCStream(const IPCStream& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(aOther);
    mType = TIPCStream;
}

MOZ_IMPLICIT OptionalIPCStream::OptionalIPCStream(IPCStream&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move(aOther));
    mType = TIPCStream;
}

MOZ_IMPLICIT OptionalIPCStream::OptionalIPCStream(const void_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
    mType = Tvoid_t;
}

MOZ_IMPLICIT OptionalIPCStream::OptionalIPCStream(void_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
    mType = Tvoid_t;
}

MOZ_IMPLICIT OptionalIPCStream::OptionalIPCStream(const OptionalIPCStream& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TIPCStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream((aOther).get_IPCStream());
            break;
        }
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT OptionalIPCStream::OptionalIPCStream(OptionalIPCStream&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TIPCStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move((aOther).get_IPCStream()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

OptionalIPCStream::~OptionalIPCStream()
{
    static_cast<void>(MaybeDestroy(T__None));
}

auto OptionalIPCStream::operator=(const IPCStream& aRhs) -> OptionalIPCStream&
{
    if (MaybeDestroy(TIPCStream)) {
        new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream;
    }
    (*(ptr_IPCStream())) = aRhs;
    mType = TIPCStream;
    return (*(this));
}

auto OptionalIPCStream::operator=(IPCStream&& aRhs) -> OptionalIPCStream&
{
    if (MaybeDestroy(TIPCStream)) {
        new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream;
    }
    (*(ptr_IPCStream())) = std::move(aRhs);
    mType = TIPCStream;
    return (*(this));
}

auto OptionalIPCStream::operator=(const void_t& aRhs) -> OptionalIPCStream&
{
    if (MaybeDestroy(Tvoid_t)) {
        new (mozilla::KnownNotNull, ptr_void_t()) void_t;
    }
    (*(ptr_void_t())) = aRhs;
    mType = Tvoid_t;
    return (*(this));
}

auto OptionalIPCStream::operator=(void_t&& aRhs) -> OptionalIPCStream&
{
    if (MaybeDestroy(Tvoid_t)) {
        new (mozilla::KnownNotNull, ptr_void_t()) void_t;
    }
    (*(ptr_void_t())) = std::move(aRhs);
    mType = Tvoid_t;
    return (*(this));
}

auto OptionalIPCStream::operator=(const OptionalIPCStream& aRhs) -> OptionalIPCStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCStream:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream;
            }
            (*(ptr_IPCStream())) = (aRhs).get_IPCStream();
            break;
        }
    case Tvoid_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_void_t()) void_t;
            }
            (*(ptr_void_t())) = (aRhs).get_void_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto OptionalIPCStream::operator=(OptionalIPCStream&& aRhs) -> OptionalIPCStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TIPCStream:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream;
            }
            (*(ptr_IPCStream())) = std::move((aRhs).get_IPCStream());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tvoid_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_void_t()) void_t;
            }
            (*(ptr_void_t())) = std::move((aRhs).get_void_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto OptionalIPCStream::operator==(const IPCStream& aRhs) const -> bool
{
    return (get_IPCStream()) == (aRhs);
}

auto OptionalIPCStream::operator==(const void_t& aRhs) const -> bool
{
    return (get_void_t()) == (aRhs);
}

auto OptionalIPCStream::operator==(const OptionalIPCStream& aRhs) const -> bool
{
    if ((type()) != ((aRhs).type())) {
        return false;
    }

    switch (type()) {
    case TIPCStream:
        {
            return (get_IPCStream()) == ((aRhs).get_IPCStream());
        }
    case Tvoid_t:
        {
            return (get_void_t()) == ((aRhs).get_void_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto OptionalIPCStream::get(IPCStream* aOutValue) const -> void
{
    (*(aOutValue)) = get_IPCStream();
}

auto OptionalIPCStream::get(void_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_void_t();
}

} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::ipc::OptionalIPCStream>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    typedef mozilla::ipc::OptionalIPCStream union__;
    int type;
    type = (aVar).type();
    WriteIPDLParam(aMsg, aActor, type);
    // Sentinel = 'OptionalIPCStream'
    (aMsg)->WriteSentinel(3815982647);

    switch (type) {
    case union__::TIPCStream:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IPCStream());
            // Sentinel = 'TIPCStream'
            (aMsg)->WriteSentinel(40701900);
            return;
        }
    case union__::Tvoid_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_void_t());
            // Sentinel = 'Tvoid_t'
            (aMsg)->WriteSentinel(3041273328);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::ipc::OptionalIPCStream>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::ipc::OptionalIPCStream union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union OptionalIPCStream");
        return false;
    }
    // Sentinel = 'OptionalIPCStream'
    if ((!((aMsg)->ReadSentinel(aIter, 3815982647)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union OptionalIPCStream");
        return false;
    }

    switch (type) {
    case union__::TIPCStream:
        {
            mozilla::ipc::IPCStream tmp = mozilla::ipc::IPCStream();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IPCStream())))))) {
                (aActor)->FatalError("Error deserializing variant TIPCStream of union OptionalIPCStream");
                return false;
            }
            // Sentinel = 'TIPCStream'
            if ((!((aMsg)->ReadSentinel(aIter, 40701900)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCStream of union OptionalIPCStream");
                return false;
            }
            return true;
        }
    case union__::Tvoid_t:
        {
            mozilla::void_t tmp = mozilla::void_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_void_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tvoid_t of union OptionalIPCStream");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union OptionalIPCStream");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53