/work/obj-fuzz/ipc/ipdl/IPCBlob.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/PIPCBlobInputStreamParent.h"
#include "mozilla/ipc/PIPCBlobInputStreamChild.h"
#include "mozilla/dom/IPCBlob.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCFile|
//
namespace mozilla {
namespace dom {
auto IPCFile::operator==(const IPCFile& _o) const -> bool
{
    if ((!((name()) == ((_o).name())))) {
        return false;
    }
    if ((!((lastModified()) == ((_o).lastModified())))) {
        return false;
    }
    if ((!((DOMPath()) == ((_o).DOMPath())))) {
        return false;
    }
    if ((!((fullPath()) == ((_o).fullPath())))) {
        return false;
    }
    if ((!((isDirectory()) == ((_o).isDirectory())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::IPCFile>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).name());
    // Sentinel = 'name'
    (aMsg)->WriteSentinel(15034981);
    WriteIPDLParam(aMsg, aActor, (aVar).lastModified());
    // Sentinel = 'lastModified'
    (aMsg)->WriteSentinel(3456113257);
    WriteIPDLParam(aMsg, aActor, (aVar).DOMPath());
    // Sentinel = 'DOMPath'
    (aMsg)->WriteSentinel(1724352494);
    WriteIPDLParam(aMsg, aActor, (aVar).fullPath());
    // Sentinel = 'fullPath'
    (aMsg)->WriteSentinel(385652698);
    WriteIPDLParam(aMsg, aActor, (aVar).isDirectory());
    // Sentinel = 'isDirectory'
    (aMsg)->WriteSentinel(2309743506);
}

auto IPDLParamTraits<mozilla::dom::IPCFile>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->name())))))) {
        (aActor)->FatalError("Error deserializing 'name' (nsString) member of 'IPCFile'");
        return false;
    }
    // Sentinel = 'name'
    if ((!((aMsg)->ReadSentinel(aIter, 15034981)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IPCFile'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->lastModified())))))) {
        (aActor)->FatalError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
        return false;
    }
    // Sentinel = 'lastModified'
    if ((!((aMsg)->ReadSentinel(aIter, 3456113257)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (int64_t) member of 'IPCFile'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->DOMPath())))))) {
        (aActor)->FatalError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
        return false;
    }
    // Sentinel = 'DOMPath'
    if ((!((aMsg)->ReadSentinel(aIter, 1724352494)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'DOMPath' (nsString) member of 'IPCFile'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fullPath())))))) {
        (aActor)->FatalError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
        return false;
    }
    // Sentinel = 'fullPath'
    if ((!((aMsg)->ReadSentinel(aIter, 385652698)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fullPath' (nsString) member of 'IPCFile'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->isDirectory())))))) {
        (aActor)->FatalError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
        return false;
    }
    // Sentinel = 'isDirectory'
    if ((!((aMsg)->ReadSentinel(aIter, 2309743506)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isDirectory' (bool) member of 'IPCFile'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

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

MOZ_IMPLICIT IPCFileUnion::IPCFileUnion(const IPCFile& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile(aOther);
    mType = TIPCFile;
}

MOZ_IMPLICIT IPCFileUnion::IPCFileUnion(IPCFile&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile(std::move(aOther));
    mType = TIPCFile;
}

MOZ_IMPLICIT IPCFileUnion::IPCFileUnion(const IPCFileUnion& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case TIPCFile:
        {
            new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile((aOther).get_IPCFile());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCFileUnion::IPCFileUnion(IPCFileUnion&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    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 TIPCFile:
        {
            new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile(std::move((aOther).get_IPCFile()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto IPCFileUnion::operator=(const IPCFile& aRhs) -> IPCFileUnion&
{
    if (MaybeDestroy(TIPCFile)) {
        new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile;
    }
    (*(ptr_IPCFile())) = aRhs;
    mType = TIPCFile;
    return (*(this));
}

auto IPCFileUnion::operator=(IPCFile&& aRhs) -> IPCFileUnion&
{
    if (MaybeDestroy(TIPCFile)) {
        new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile;
    }
    (*(ptr_IPCFile())) = std::move(aRhs);
    mType = TIPCFile;
    return (*(this));
}

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

auto IPCFileUnion::operator=(IPCFileUnion&& aRhs) -> IPCFileUnion&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    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 TIPCFile:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCFile()) IPCFile;
            }
            (*(ptr_IPCFile())) = std::move((aRhs).get_IPCFile());
            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 IPCFileUnion::operator==(const void_t& aRhs) const -> bool
{
    return (get_void_t()) == (aRhs);
}

auto IPCFileUnion::operator==(const IPCFile& aRhs) const -> bool
{
    return (get_IPCFile()) == (aRhs);
}

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

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

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

auto IPCFileUnion::get(IPCFile* aOutValue) const -> void
{
    (*(aOutValue)) = get_IPCFile();
}

} // namespace dom
} // namespace mozilla

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

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

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

    switch (type) {
    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 IPCFileUnion");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union IPCFileUnion");
                return false;
            }
            return true;
        }
    case union__::TIPCFile:
        {
            mozilla::dom::IPCFile tmp = mozilla::dom::IPCFile();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_IPCFile())))))) {
                (aActor)->FatalError("Error deserializing variant TIPCFile of union IPCFileUnion");
                return false;
            }
            // Sentinel = 'TIPCFile'
            if ((!((aMsg)->ReadSentinel(aIter, 3562676876)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCFile of union IPCFileUnion");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union IPCBlobStream|
//
namespace mozilla {
namespace dom {
auto IPCBlobStream::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TPIPCBlobInputStreamParent:
        {
            (ptr_PIPCBlobInputStreamParent())->~PIPCBlobInputStreamParent__tdef();
            break;
        }
    case TPIPCBlobInputStreamChild:
        {
            (ptr_PIPCBlobInputStreamChild())->~PIPCBlobInputStreamChild__tdef();
            break;
        }
    case TIPCStream:
        {
            (ptr_IPCStream())->~IPCStream__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT IPCBlobStream::IPCBlobStream(PIPCBlobInputStreamParent* aOther)
{
    new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamParent()) PIPCBlobInputStreamParent*(const_cast<PIPCBlobInputStreamParent*>(aOther));
    mType = TPIPCBlobInputStreamParent;
}

MOZ_IMPLICIT IPCBlobStream::IPCBlobStream(PIPCBlobInputStreamChild* aOther)
{
    new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamChild()) PIPCBlobInputStreamChild*(const_cast<PIPCBlobInputStreamChild*>(aOther));
    mType = TPIPCBlobInputStreamChild;
}

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

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

MOZ_IMPLICIT IPCBlobStream::IPCBlobStream(const IPCBlobStream& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TPIPCBlobInputStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamParent()) PIPCBlobInputStreamParent*(const_cast<PIPCBlobInputStreamParent*>((aOther).get_PIPCBlobInputStreamParent()));
            break;
        }
    case TPIPCBlobInputStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamChild()) PIPCBlobInputStreamChild*(const_cast<PIPCBlobInputStreamChild*>((aOther).get_PIPCBlobInputStreamChild()));
            break;
        }
    case TIPCStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream((aOther).get_IPCStream());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT IPCBlobStream::IPCBlobStream(IPCBlobStream&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TPIPCBlobInputStreamParent:
        {
            new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamParent()) PIPCBlobInputStreamParent*(const_cast<PIPCBlobInputStreamParent*>(std::move((aOther).get_PIPCBlobInputStreamParent())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPIPCBlobInputStreamChild:
        {
            new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamChild()) PIPCBlobInputStreamChild*(const_cast<PIPCBlobInputStreamChild*>(std::move((aOther).get_PIPCBlobInputStreamChild())));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TIPCStream:
        {
            new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream(std::move((aOther).get_IPCStream()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto IPCBlobStream::operator=(PIPCBlobInputStreamParent* aRhs) -> IPCBlobStream&
{
    if (MaybeDestroy(TPIPCBlobInputStreamParent)) {
        new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamParent()) PIPCBlobInputStreamParent*;
    }
    (*(ptr_PIPCBlobInputStreamParent())) = const_cast<PIPCBlobInputStreamParent*>(aRhs);
    mType = TPIPCBlobInputStreamParent;
    return (*(this));
}

auto IPCBlobStream::operator=(PIPCBlobInputStreamChild* aRhs) -> IPCBlobStream&
{
    if (MaybeDestroy(TPIPCBlobInputStreamChild)) {
        new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamChild()) PIPCBlobInputStreamChild*;
    }
    (*(ptr_PIPCBlobInputStreamChild())) = const_cast<PIPCBlobInputStreamChild*>(aRhs);
    mType = TPIPCBlobInputStreamChild;
    return (*(this));
}

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

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

auto IPCBlobStream::operator=(const IPCBlobStream& aRhs) -> IPCBlobStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPIPCBlobInputStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamParent()) PIPCBlobInputStreamParent*;
            }
            (*(ptr_PIPCBlobInputStreamParent())) = const_cast<PIPCBlobInputStreamParent*>((aRhs).get_PIPCBlobInputStreamParent());
            break;
        }
    case TPIPCBlobInputStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamChild()) PIPCBlobInputStreamChild*;
            }
            (*(ptr_PIPCBlobInputStreamChild())) = const_cast<PIPCBlobInputStreamChild*>((aRhs).get_PIPCBlobInputStreamChild());
            break;
        }
    case TIPCStream:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_IPCStream()) IPCStream;
            }
            (*(ptr_IPCStream())) = (aRhs).get_IPCStream();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto IPCBlobStream::operator=(IPCBlobStream&& aRhs) -> IPCBlobStream&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TPIPCBlobInputStreamParent:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamParent()) PIPCBlobInputStreamParent*;
            }
            (*(ptr_PIPCBlobInputStreamParent())) = const_cast<PIPCBlobInputStreamParent*>(std::move((aRhs).get_PIPCBlobInputStreamParent()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPIPCBlobInputStreamChild:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PIPCBlobInputStreamChild()) PIPCBlobInputStreamChild*;
            }
            (*(ptr_PIPCBlobInputStreamChild())) = const_cast<PIPCBlobInputStreamChild*>(std::move((aRhs).get_PIPCBlobInputStreamChild()));
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    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 T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto IPCBlobStream::operator==(PIPCBlobInputStreamParent* aRhs) const -> bool
{
    return (get_PIPCBlobInputStreamParent()) == (aRhs);
}

auto IPCBlobStream::operator==(PIPCBlobInputStreamChild* aRhs) const -> bool
{
    return (get_PIPCBlobInputStreamChild()) == (aRhs);
}

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

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

    switch (type()) {
    case TPIPCBlobInputStreamParent:
        {
            return (get_PIPCBlobInputStreamParent()) == ((aRhs).get_PIPCBlobInputStreamParent());
        }
    case TPIPCBlobInputStreamChild:
        {
            return (get_PIPCBlobInputStreamChild()) == ((aRhs).get_PIPCBlobInputStreamChild());
        }
    case TIPCStream:
        {
            return (get_IPCStream()) == ((aRhs).get_IPCStream());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto IPCBlobStream::get(PIPCBlobInputStreamParent** aOutValue) const -> void
{
    (*(aOutValue)) = get_PIPCBlobInputStreamParent();
}

auto IPCBlobStream::get(PIPCBlobInputStreamChild** aOutValue) const -> void
{
    (*(aOutValue)) = get_PIPCBlobInputStreamChild();
}

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

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TPIPCBlobInputStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PIPCBlobInputStreamParent(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PIPCBlobInputStreamParent());
                // Sentinel = 'TPIPCBlobInputStreamParent'
                (aMsg)->WriteSentinel(2944059743);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TPIPCBlobInputStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                MOZ_RELEASE_ASSERT((aVar).get_PIPCBlobInputStreamChild(), "NULL actor value passed to non-nullable param");
                WriteIPDLParam(aMsg, aActor, (aVar).get_PIPCBlobInputStreamChild());
                // Sentinel = 'TPIPCBlobInputStreamChild'
                (aMsg)->WriteSentinel(3349556844);
            }
            else {
                (aActor)->FatalError("wrong side!");
            }
            return;
        }
    case union__::TIPCStream:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_IPCStream());
            // Sentinel = 'TIPCStream'
            (aMsg)->WriteSentinel(40701900);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TPIPCBlobInputStreamParent:
        {
            if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PIPCBlobInputStreamChild* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PIPCBlobInputStreamChild())))))) {
                (aActor)->FatalError("Error deserializing variant TPIPCBlobInputStreamParent of union IPCBlobStream");
                return false;
            }
            if ((!((*((&((aVar)->get_PIPCBlobInputStreamChild()))))))) {
                (aActor)->FatalError("Error deserializing variant TPIPCBlobInputStreamParent of union IPCBlobStream");
                return false;
            }
            // Sentinel = 'TPIPCBlobInputStreamParent'
            if ((!((aMsg)->ReadSentinel(aIter, 2944059743)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPIPCBlobInputStreamParent of union IPCBlobStream");
                return false;
            }
            return true;
        }
    case union__::TPIPCBlobInputStreamChild:
        {
            if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
                {
                    (aActor)->FatalError("wrong side!");
                    return false;
                }
            }
            mozilla::ipc::PIPCBlobInputStreamParent* tmp = nullptr;
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PIPCBlobInputStreamParent())))))) {
                (aActor)->FatalError("Error deserializing variant TPIPCBlobInputStreamChild of union IPCBlobStream");
                return false;
            }
            if ((!((*((&((aVar)->get_PIPCBlobInputStreamParent()))))))) {
                (aActor)->FatalError("Error deserializing variant TPIPCBlobInputStreamChild of union IPCBlobStream");
                return false;
            }
            // Sentinel = 'TPIPCBlobInputStreamChild'
            if ((!((aMsg)->ReadSentinel(aIter, 3349556844)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPIPCBlobInputStreamChild of union IPCBlobStream");
                return false;
            }
            return true;
        }
    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 IPCBlobStream");
                return false;
            }
            // Sentinel = 'TIPCStream'
            if ((!((aMsg)->ReadSentinel(aIter, 40701900)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TIPCStream of union IPCBlobStream");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCBlob|
//
namespace mozilla {
namespace dom {
auto IPCBlob::operator==(const IPCBlob& _o) const -> bool
{
    if ((!((type()) == ((_o).type())))) {
        return false;
    }
    if ((!((size()) == ((_o).size())))) {
        return false;
    }
    if ((!((inputStream()) == ((_o).inputStream())))) {
        return false;
    }
    if ((!((file()) == ((_o).file())))) {
        return false;
    }
    if ((!((fileId()) == ((_o).fileId())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::IPCBlob>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).type());
    // Sentinel = 'type'
    (aMsg)->WriteSentinel(2982068540);
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).inputStream());
    // Sentinel = 'inputStream'
    (aMsg)->WriteSentinel(2684883823);
    WriteIPDLParam(aMsg, aActor, (aVar).file());
    // Sentinel = 'file'
    (aMsg)->WriteSentinel(224874390);
    WriteIPDLParam(aMsg, aActor, (aVar).fileId());
    // Sentinel = 'fileId'
    (aMsg)->WriteSentinel(108004447);
}

auto IPDLParamTraits<mozilla::dom::IPCBlob>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->type())))))) {
        (aActor)->FatalError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
        return false;
    }
    // Sentinel = 'type'
    if ((!((aMsg)->ReadSentinel(aIter, 2982068540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsString) member of 'IPCBlob'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint64_t) member of 'IPCBlob'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->inputStream())))))) {
        (aActor)->FatalError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
        return false;
    }
    // Sentinel = 'inputStream'
    if ((!((aMsg)->ReadSentinel(aIter, 2684883823)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'inputStream' (IPCBlobStream) member of 'IPCBlob'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->file())))))) {
        (aActor)->FatalError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
        return false;
    }
    // Sentinel = 'file'
    if ((!((aMsg)->ReadSentinel(aIter, 224874390)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'file' (IPCFileUnion) member of 'IPCBlob'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fileId())))))) {
        (aActor)->FatalError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
        return false;
    }
    // Sentinel = 'fileId'
    if ((!((aMsg)->ReadSentinel(aIter, 108004447)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fileId' (int64_t) member of 'IPCBlob'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53