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

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


#include "mozilla/dom/PBackgroundFileHandleParent.h"
#include "mozilla/dom/PBackgroundFileHandleChild.h"
#include "mozilla/ipc/PPendingIPCBlobParent.h"
#include "mozilla/ipc/PPendingIPCBlobChild.h"
#include "mozilla/dom/PBackgroundFileRequest.h"

namespace mozilla {
namespace dom {
namespace PBackgroundFileRequest {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::PBackgroundFileRequestParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::PBackgroundFileRequestChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg___delete__(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Reply___delete__(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::REPLY));
}
IPC::Message*
Msg_Progress(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Progress__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}

} // namespace PBackgroundFileRequest
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileRequestSize|
//
namespace mozilla {
namespace dom {
auto FileRequestSize::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 Tuint64_t:
        {
            (ptr_uint64_t())->~uint64_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT FileRequestSize::FileRequestSize(const uint64_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aOther);
    mType = Tuint64_t;
}

MOZ_IMPLICIT FileRequestSize::FileRequestSize(uint64_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aOther));
    mType = Tuint64_t;
}

MOZ_IMPLICIT FileRequestSize::FileRequestSize(const FileRequestSize& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case Tuint64_t:
        {
            new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aOther).get_uint64_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileRequestSize::FileRequestSize(FileRequestSize&& 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 Tuint64_t:
        {
            new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aOther).get_uint64_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;
}

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

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

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

auto FileRequestSize::operator=(const uint64_t& aRhs) -> FileRequestSize&
{
    if (MaybeDestroy(Tuint64_t)) {
        new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t;
    }
    (*(ptr_uint64_t())) = aRhs;
    mType = Tuint64_t;
    return (*(this));
}

auto FileRequestSize::operator=(uint64_t&& aRhs) -> FileRequestSize&
{
    if (MaybeDestroy(Tuint64_t)) {
        new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t;
    }
    (*(ptr_uint64_t())) = std::move(aRhs);
    mType = Tuint64_t;
    return (*(this));
}

auto FileRequestSize::operator=(const FileRequestSize& aRhs) -> FileRequestSize&
{
    (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 Tuint64_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t;
            }
            (*(ptr_uint64_t())) = (aRhs).get_uint64_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestSize::operator=(FileRequestSize&& aRhs) -> FileRequestSize&
{
    (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 Tuint64_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t;
            }
            (*(ptr_uint64_t())) = std::move((aRhs).get_uint64_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 FileRequestSize::operator==(const void_t& aRhs) const -> bool
{
    return (get_void_t()) == (aRhs);
}

auto FileRequestSize::operator==(const uint64_t& aRhs) const -> bool
{
    return (get_uint64_t()) == (aRhs);
}

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

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

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

auto FileRequestSize::get(uint64_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_uint64_t();
}

} // namespace dom
} // namespace mozilla

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

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

auto IPDLParamTraits<mozilla::dom::FileRequestSize>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::dom::FileRequestSize union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union FileRequestSize");
        return false;
    }
    // Sentinel = 'FileRequestSize'
    if ((!((aMsg)->ReadSentinel(aIter, 1806056177)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union FileRequestSize");
        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 FileRequestSize");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union FileRequestSize");
                return false;
            }
            return true;
        }
    case union__::Tuint64_t:
        {
            uint64_t tmp = uint64_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_uint64_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tuint64_t of union FileRequestSize");
                return false;
            }
            // Sentinel = 'Tuint64_t'
            if ((!((aMsg)->ReadSentinel(aIter, 1935076742)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tuint64_t of union FileRequestSize");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileRequestLastModified|
//
namespace mozilla {
namespace dom {
auto FileRequestLastModified::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 Tint64_t:
        {
            (ptr_int64_t())->~int64_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT FileRequestLastModified::FileRequestLastModified(const int64_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_int64_t()) int64_t(aOther);
    mType = Tint64_t;
}

MOZ_IMPLICIT FileRequestLastModified::FileRequestLastModified(int64_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_int64_t()) int64_t(std::move(aOther));
    mType = Tint64_t;
}

MOZ_IMPLICIT FileRequestLastModified::FileRequestLastModified(const FileRequestLastModified& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case Tint64_t:
        {
            new (mozilla::KnownNotNull, ptr_int64_t()) int64_t((aOther).get_int64_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileRequestLastModified::FileRequestLastModified(FileRequestLastModified&& 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 Tint64_t:
        {
            new (mozilla::KnownNotNull, ptr_int64_t()) int64_t(std::move((aOther).get_int64_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;
}

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

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

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

auto FileRequestLastModified::operator=(const int64_t& aRhs) -> FileRequestLastModified&
{
    if (MaybeDestroy(Tint64_t)) {
        new (mozilla::KnownNotNull, ptr_int64_t()) int64_t;
    }
    (*(ptr_int64_t())) = aRhs;
    mType = Tint64_t;
    return (*(this));
}

auto FileRequestLastModified::operator=(int64_t&& aRhs) -> FileRequestLastModified&
{
    if (MaybeDestroy(Tint64_t)) {
        new (mozilla::KnownNotNull, ptr_int64_t()) int64_t;
    }
    (*(ptr_int64_t())) = std::move(aRhs);
    mType = Tint64_t;
    return (*(this));
}

auto FileRequestLastModified::operator=(const FileRequestLastModified& aRhs) -> FileRequestLastModified&
{
    (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 Tint64_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_int64_t()) int64_t;
            }
            (*(ptr_int64_t())) = (aRhs).get_int64_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestLastModified::operator=(FileRequestLastModified&& aRhs) -> FileRequestLastModified&
{
    (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 Tint64_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_int64_t()) int64_t;
            }
            (*(ptr_int64_t())) = std::move((aRhs).get_int64_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 FileRequestLastModified::operator==(const void_t& aRhs) const -> bool
{
    return (get_void_t()) == (aRhs);
}

auto FileRequestLastModified::operator==(const int64_t& aRhs) const -> bool
{
    return (get_int64_t()) == (aRhs);
}

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

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

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

auto FileRequestLastModified::get(int64_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_int64_t();
}

} // namespace dom
} // namespace mozilla

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

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

auto IPDLParamTraits<mozilla::dom::FileRequestLastModified>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::dom::FileRequestLastModified union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union FileRequestLastModified");
        return false;
    }
    // Sentinel = 'FileRequestLastModified'
    if ((!((aMsg)->ReadSentinel(aIter, 4176568879)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union FileRequestLastModified");
        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 FileRequestLastModified");
                return false;
            }
            // Sentinel = 'Tvoid_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union FileRequestLastModified");
                return false;
            }
            return true;
        }
    case union__::Tint64_t:
        {
            int64_t tmp = int64_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_int64_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tint64_t of union FileRequestLastModified");
                return false;
            }
            // Sentinel = 'Tint64_t'
            if ((!((aMsg)->ReadSentinel(aIter, 650728676)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tint64_t of union FileRequestLastModified");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestMetadata>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).size());
    // Sentinel = 'size'
    (aMsg)->WriteSentinel(931048223);
    WriteIPDLParam(aMsg, aActor, (aVar).lastModified());
    // Sentinel = 'lastModified'
    (aMsg)->WriteSentinel(3456113257);
}

auto IPDLParamTraits<mozilla::dom::FileRequestMetadata>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
        (aActor)->FatalError("Error deserializing 'size' (FileRequestSize) member of 'FileRequestMetadata'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (FileRequestSize) member of 'FileRequestMetadata'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->lastModified())))))) {
        (aActor)->FatalError("Error deserializing 'lastModified' (FileRequestLastModified) member of 'FileRequestMetadata'");
        return false;
    }
    // Sentinel = 'lastModified'
    if ((!((aMsg)->ReadSentinel(aIter, 3456113257)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (FileRequestLastModified) member of 'FileRequestMetadata'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestGetMetadataResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).metadata());
    // Sentinel = 'metadata'
    (aMsg)->WriteSentinel(541737151);
}

auto IPDLParamTraits<mozilla::dom::FileRequestGetMetadataResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->metadata())))))) {
        (aActor)->FatalError("Error deserializing 'metadata' (FileRequestMetadata) member of 'FileRequestGetMetadataResponse'");
        return false;
    }
    // Sentinel = 'metadata'
    if ((!((aMsg)->ReadSentinel(aIter, 541737151)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (FileRequestMetadata) member of 'FileRequestGetMetadataResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestReadResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).data());
    // Sentinel = 'data'
    (aMsg)->WriteSentinel(843352540);
}

auto IPDLParamTraits<mozilla::dom::FileRequestReadResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->data())))))) {
        (aActor)->FatalError("Error deserializing 'data' (nsCString) member of 'FileRequestReadResponse'");
        return false;
    }
    // Sentinel = 'data'
    if ((!((aMsg)->ReadSentinel(aIter, 843352540)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'data' (nsCString) member of 'FileRequestReadResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestWriteResponse|
//
namespace mozilla {
namespace dom {
auto FileRequestWriteResponse::operator==(const FileRequestWriteResponse& _o) const -> bool
{
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestWriteResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::FileRequestWriteResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestTruncateResponse|
//
namespace mozilla {
namespace dom {
auto FileRequestTruncateResponse::operator==(const FileRequestTruncateResponse& _o) const -> bool
{
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestTruncateResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::FileRequestTruncateResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestFlushResponse|
//
namespace mozilla {
namespace dom {
auto FileRequestFlushResponse::operator==(const FileRequestFlushResponse& _o) const -> bool
{
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestFlushResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
}

auto IPDLParamTraits<mozilla::dom::FileRequestFlushResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileRequestGetFileResponse|
//
namespace mozilla {
namespace dom {
auto FileRequestGetFileResponse::operator==(const FileRequestGetFileResponse& _o) const -> bool
{
    if ((!((fileParent()) == ((_o).fileParent())))) {
        return false;
    }
    if ((!((fileChild()) == ((_o).fileChild())))) {
        return false;
    }
    if ((!((metadata()) == ((_o).metadata())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestGetFileResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).fileParent(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).fileParent());
        // Sentinel = 'file'
        (aMsg)->WriteSentinel(224874390);
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        MOZ_RELEASE_ASSERT((aVar).fileChild(), "NULL actor value passed to non-nullable param");
        WriteIPDLParam(aMsg, aActor, (aVar).fileChild());
        // Sentinel = 'file'
        (aMsg)->WriteSentinel(224874390);
    }
    WriteIPDLParam(aMsg, aActor, (aVar).metadata());
    // Sentinel = 'metadata'
    (aMsg)->WriteSentinel(541737151);
}

auto IPDLParamTraits<mozilla::dom::FileRequestGetFileResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((mozilla::ipc::ParentSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fileParent())))))) {
            (aActor)->FatalError("Error deserializing 'fileParent' (PPendingIPCBlob) member of 'FileRequestGetFileResponse'");
            return false;
        }
        if ((!((*((&((aVar)->fileParent()))))))) {
            (aActor)->FatalError("Error deserializing 'fileParent' (PPendingIPCBlob) member of 'FileRequestGetFileResponse'");
            return false;
        }
        // Sentinel = 'file'
        if ((!((aMsg)->ReadSentinel(aIter, 224874390)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'fileParent' (PPendingIPCBlob) member of 'FileRequestGetFileResponse'");
            return false;
        }
    }
    if ((mozilla::ipc::ChildSide) == ((aActor)->GetSide())) {
        if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->fileChild())))))) {
            (aActor)->FatalError("Error deserializing 'fileChild' (PPendingIPCBlob) member of 'FileRequestGetFileResponse'");
            return false;
        }
        if ((!((*((&((aVar)->fileChild()))))))) {
            (aActor)->FatalError("Error deserializing 'fileChild' (PPendingIPCBlob) member of 'FileRequestGetFileResponse'");
            return false;
        }
        // Sentinel = 'file'
        if ((!((aMsg)->ReadSentinel(aIter, 224874390)))) {
            mozilla::ipc::SentinelReadError("Error deserializing 'fileChild' (PPendingIPCBlob) member of 'FileRequestGetFileResponse'");
            return false;
        }
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->metadata())))))) {
        (aActor)->FatalError("Error deserializing 'metadata' (FileRequestMetadata) member of 'FileRequestGetFileResponse'");
        return false;
    }
    // Sentinel = 'metadata'
    if ((!((aMsg)->ReadSentinel(aIter, 541737151)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (FileRequestMetadata) member of 'FileRequestGetFileResponse'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileRequestResponse|
//
namespace mozilla {
namespace dom {
auto FileRequestResponse::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TFileRequestGetMetadataResponse:
        {
            (ptr_FileRequestGetMetadataResponse())->~FileRequestGetMetadataResponse__tdef();
            break;
        }
    case TFileRequestReadResponse:
        {
            (ptr_FileRequestReadResponse())->~FileRequestReadResponse__tdef();
            break;
        }
    case TFileRequestWriteResponse:
        {
            (ptr_FileRequestWriteResponse())->~FileRequestWriteResponse__tdef();
            break;
        }
    case TFileRequestTruncateResponse:
        {
            (ptr_FileRequestTruncateResponse())->~FileRequestTruncateResponse__tdef();
            break;
        }
    case TFileRequestFlushResponse:
        {
            (ptr_FileRequestFlushResponse())->~FileRequestFlushResponse__tdef();
            break;
        }
    case TFileRequestGetFileResponse:
        {
            (ptr_FileRequestGetFileResponse())->~FileRequestGetFileResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const nsresult& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
    mType = Tnsresult;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(nsresult&& aOther)
{
    new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
    mType = Tnsresult;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestGetMetadataResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse(aOther);
    mType = TFileRequestGetMetadataResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestGetMetadataResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse(std::move(aOther));
    mType = TFileRequestGetMetadataResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestReadResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse(aOther);
    mType = TFileRequestReadResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestReadResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse(std::move(aOther));
    mType = TFileRequestReadResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestWriteResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse(aOther);
    mType = TFileRequestWriteResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestWriteResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse(std::move(aOther));
    mType = TFileRequestWriteResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestTruncateResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse(aOther);
    mType = TFileRequestTruncateResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestTruncateResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse(std::move(aOther));
    mType = TFileRequestTruncateResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestFlushResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse(aOther);
    mType = TFileRequestFlushResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestFlushResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse(std::move(aOther));
    mType = TFileRequestFlushResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestGetFileResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse(aOther);
    mType = TFileRequestGetFileResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestGetFileResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse(std::move(aOther));
    mType = TFileRequestGetFileResponse;
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(const FileRequestResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TFileRequestGetMetadataResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse((aOther).get_FileRequestGetMetadataResponse());
            break;
        }
    case TFileRequestReadResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse((aOther).get_FileRequestReadResponse());
            break;
        }
    case TFileRequestWriteResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse((aOther).get_FileRequestWriteResponse());
            break;
        }
    case TFileRequestTruncateResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse((aOther).get_FileRequestTruncateResponse());
            break;
        }
    case TFileRequestFlushResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse((aOther).get_FileRequestFlushResponse());
            break;
        }
    case TFileRequestGetFileResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse((aOther).get_FileRequestGetFileResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileRequestResponse::FileRequestResponse(FileRequestResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestGetMetadataResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse(std::move((aOther).get_FileRequestGetMetadataResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestReadResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse(std::move((aOther).get_FileRequestReadResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestWriteResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse(std::move((aOther).get_FileRequestWriteResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestTruncateResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse(std::move((aOther).get_FileRequestTruncateResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestFlushResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse(std::move((aOther).get_FileRequestFlushResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestGetFileResponse:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse(std::move((aOther).get_FileRequestGetFileResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto FileRequestResponse::operator=(const nsresult& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(Tnsresult)) {
        new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
    }
    (*(ptr_nsresult())) = aRhs;
    mType = Tnsresult;
    return (*(this));
}

auto FileRequestResponse::operator=(nsresult&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(Tnsresult)) {
        new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
    }
    (*(ptr_nsresult())) = std::move(aRhs);
    mType = Tnsresult;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestGetMetadataResponse& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestGetMetadataResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse;
    }
    (*(ptr_FileRequestGetMetadataResponse())) = aRhs;
    mType = TFileRequestGetMetadataResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestGetMetadataResponse&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestGetMetadataResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse;
    }
    (*(ptr_FileRequestGetMetadataResponse())) = std::move(aRhs);
    mType = TFileRequestGetMetadataResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestReadResponse& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestReadResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse;
    }
    (*(ptr_FileRequestReadResponse())) = aRhs;
    mType = TFileRequestReadResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestReadResponse&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestReadResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse;
    }
    (*(ptr_FileRequestReadResponse())) = std::move(aRhs);
    mType = TFileRequestReadResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestWriteResponse& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestWriteResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse;
    }
    (*(ptr_FileRequestWriteResponse())) = aRhs;
    mType = TFileRequestWriteResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestWriteResponse&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestWriteResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse;
    }
    (*(ptr_FileRequestWriteResponse())) = std::move(aRhs);
    mType = TFileRequestWriteResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestTruncateResponse& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestTruncateResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse;
    }
    (*(ptr_FileRequestTruncateResponse())) = aRhs;
    mType = TFileRequestTruncateResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestTruncateResponse&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestTruncateResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse;
    }
    (*(ptr_FileRequestTruncateResponse())) = std::move(aRhs);
    mType = TFileRequestTruncateResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestFlushResponse& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestFlushResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse;
    }
    (*(ptr_FileRequestFlushResponse())) = aRhs;
    mType = TFileRequestFlushResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestFlushResponse&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestFlushResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse;
    }
    (*(ptr_FileRequestFlushResponse())) = std::move(aRhs);
    mType = TFileRequestFlushResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestGetFileResponse& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestGetFileResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse;
    }
    (*(ptr_FileRequestGetFileResponse())) = aRhs;
    mType = TFileRequestGetFileResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestGetFileResponse&& aRhs) -> FileRequestResponse&
{
    if (MaybeDestroy(TFileRequestGetFileResponse)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse;
    }
    (*(ptr_FileRequestGetFileResponse())) = std::move(aRhs);
    mType = TFileRequestGetFileResponse;
    return (*(this));
}

auto FileRequestResponse::operator=(const FileRequestResponse& aRhs) -> FileRequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = (aRhs).get_nsresult();
            break;
        }
    case TFileRequestGetMetadataResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse;
            }
            (*(ptr_FileRequestGetMetadataResponse())) = (aRhs).get_FileRequestGetMetadataResponse();
            break;
        }
    case TFileRequestReadResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse;
            }
            (*(ptr_FileRequestReadResponse())) = (aRhs).get_FileRequestReadResponse();
            break;
        }
    case TFileRequestWriteResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse;
            }
            (*(ptr_FileRequestWriteResponse())) = (aRhs).get_FileRequestWriteResponse();
            break;
        }
    case TFileRequestTruncateResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse;
            }
            (*(ptr_FileRequestTruncateResponse())) = (aRhs).get_FileRequestTruncateResponse();
            break;
        }
    case TFileRequestFlushResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse;
            }
            (*(ptr_FileRequestFlushResponse())) = (aRhs).get_FileRequestFlushResponse();
            break;
        }
    case TFileRequestGetFileResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse;
            }
            (*(ptr_FileRequestGetFileResponse())) = (aRhs).get_FileRequestGetFileResponse();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestResponse::operator=(FileRequestResponse&& aRhs) -> FileRequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = std::move((aRhs).get_nsresult());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestGetMetadataResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataResponse()) FileRequestGetMetadataResponse;
            }
            (*(ptr_FileRequestGetMetadataResponse())) = std::move((aRhs).get_FileRequestGetMetadataResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestReadResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestReadResponse()) FileRequestReadResponse;
            }
            (*(ptr_FileRequestReadResponse())) = std::move((aRhs).get_FileRequestReadResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestWriteResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestWriteResponse()) FileRequestWriteResponse;
            }
            (*(ptr_FileRequestWriteResponse())) = std::move((aRhs).get_FileRequestWriteResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestTruncateResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestTruncateResponse()) FileRequestTruncateResponse;
            }
            (*(ptr_FileRequestTruncateResponse())) = std::move((aRhs).get_FileRequestTruncateResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestFlushResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestFlushResponse()) FileRequestFlushResponse;
            }
            (*(ptr_FileRequestFlushResponse())) = std::move((aRhs).get_FileRequestFlushResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestGetFileResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetFileResponse()) FileRequestGetFileResponse;
            }
            (*(ptr_FileRequestGetFileResponse())) = std::move((aRhs).get_FileRequestGetFileResponse());
            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 FileRequestResponse::operator==(const nsresult& aRhs) const -> bool
{
    return (get_nsresult()) == (aRhs);
}

auto FileRequestResponse::operator==(const FileRequestGetMetadataResponse& aRhs) const -> bool
{
    return (get_FileRequestGetMetadataResponse()) == (aRhs);
}

auto FileRequestResponse::operator==(const FileRequestReadResponse& aRhs) const -> bool
{
    return (get_FileRequestReadResponse()) == (aRhs);
}

auto FileRequestResponse::operator==(const FileRequestWriteResponse& aRhs) const -> bool
{
    return (get_FileRequestWriteResponse()) == (aRhs);
}

auto FileRequestResponse::operator==(const FileRequestTruncateResponse& aRhs) const -> bool
{
    return (get_FileRequestTruncateResponse()) == (aRhs);
}

auto FileRequestResponse::operator==(const FileRequestFlushResponse& aRhs) const -> bool
{
    return (get_FileRequestFlushResponse()) == (aRhs);
}

auto FileRequestResponse::operator==(const FileRequestGetFileResponse& aRhs) const -> bool
{
    return (get_FileRequestGetFileResponse()) == (aRhs);
}

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

    switch (type()) {
    case Tnsresult:
        {
            return (get_nsresult()) == ((aRhs).get_nsresult());
        }
    case TFileRequestGetMetadataResponse:
        {
            return (get_FileRequestGetMetadataResponse()) == ((aRhs).get_FileRequestGetMetadataResponse());
        }
    case TFileRequestReadResponse:
        {
            return (get_FileRequestReadResponse()) == ((aRhs).get_FileRequestReadResponse());
        }
    case TFileRequestWriteResponse:
        {
            return (get_FileRequestWriteResponse()) == ((aRhs).get_FileRequestWriteResponse());
        }
    case TFileRequestTruncateResponse:
        {
            return (get_FileRequestTruncateResponse()) == ((aRhs).get_FileRequestTruncateResponse());
        }
    case TFileRequestFlushResponse:
        {
            return (get_FileRequestFlushResponse()) == ((aRhs).get_FileRequestFlushResponse());
        }
    case TFileRequestGetFileResponse:
        {
            return (get_FileRequestGetFileResponse()) == ((aRhs).get_FileRequestGetFileResponse());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto FileRequestResponse::get(nsresult* aOutValue) const -> void
{
    (*(aOutValue)) = get_nsresult();
}

auto FileRequestResponse::get(FileRequestGetMetadataResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestGetMetadataResponse();
}

auto FileRequestResponse::get(FileRequestReadResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestReadResponse();
}

auto FileRequestResponse::get(FileRequestWriteResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestWriteResponse();
}

auto FileRequestResponse::get(FileRequestTruncateResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestTruncateResponse();
}

auto FileRequestResponse::get(FileRequestFlushResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestFlushResponse();
}

auto FileRequestResponse::get(FileRequestGetFileResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestGetFileResponse();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::Tnsresult:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aMsg)->WriteSentinel(2293764539);
            return;
        }
    case union__::TFileRequestGetMetadataResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestGetMetadataResponse());
            // Sentinel = 'TFileRequestGetMetadataResponse'
            (aMsg)->WriteSentinel(18882654);
            return;
        }
    case union__::TFileRequestReadResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestReadResponse());
            // Sentinel = 'TFileRequestReadResponse'
            (aMsg)->WriteSentinel(817963328);
            return;
        }
    case union__::TFileRequestWriteResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestWriteResponse());
            // Sentinel = 'TFileRequestWriteResponse'
            (aMsg)->WriteSentinel(1937414566);
            return;
        }
    case union__::TFileRequestTruncateResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestTruncateResponse());
            // Sentinel = 'TFileRequestTruncateResponse'
            (aMsg)->WriteSentinel(2329312254);
            return;
        }
    case union__::TFileRequestFlushResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestFlushResponse());
            // Sentinel = 'TFileRequestFlushResponse'
            (aMsg)->WriteSentinel(4234370673);
            return;
        }
    case union__::TFileRequestGetFileResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestGetFileResponse());
            // Sentinel = 'TFileRequestGetFileResponse'
            (aMsg)->WriteSentinel(2486481847);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnsresult:
        {
            nsresult tmp = nsresult();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_nsresult())))))) {
                (aActor)->FatalError("Error deserializing variant Tnsresult of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'Tnsresult'
            if ((!((aMsg)->ReadSentinel(aIter, 2293764539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union FileRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TFileRequestGetMetadataResponse:
        {
            mozilla::dom::FileRequestGetMetadataResponse tmp = mozilla::dom::FileRequestGetMetadataResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestGetMetadataResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestGetMetadataResponse of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'TFileRequestGetMetadataResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 18882654)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestGetMetadataResponse of union FileRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TFileRequestReadResponse:
        {
            mozilla::dom::FileRequestReadResponse tmp = mozilla::dom::FileRequestReadResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestReadResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestReadResponse of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'TFileRequestReadResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 817963328)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestReadResponse of union FileRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TFileRequestWriteResponse:
        {
            mozilla::dom::FileRequestWriteResponse tmp = mozilla::dom::FileRequestWriteResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestWriteResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestWriteResponse of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'TFileRequestWriteResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1937414566)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestWriteResponse of union FileRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TFileRequestTruncateResponse:
        {
            mozilla::dom::FileRequestTruncateResponse tmp = mozilla::dom::FileRequestTruncateResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestTruncateResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestTruncateResponse of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'TFileRequestTruncateResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 2329312254)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestTruncateResponse of union FileRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TFileRequestFlushResponse:
        {
            mozilla::dom::FileRequestFlushResponse tmp = mozilla::dom::FileRequestFlushResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestFlushResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestFlushResponse of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'TFileRequestFlushResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 4234370673)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestFlushResponse of union FileRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TFileRequestGetFileResponse:
        {
            mozilla::dom::FileRequestGetFileResponse tmp = mozilla::dom::FileRequestGetFileResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestGetFileResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestGetFileResponse of union FileRequestResponse");
                return false;
            }
            // Sentinel = 'TFileRequestGetFileResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 2486481847)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestGetFileResponse of union FileRequestResponse");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53