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

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


#include "mozilla/dom/PBackgroundFileRequestParent.h"
#include "mozilla/dom/PBackgroundFileRequestChild.h"
#include "mozilla/dom/PBackgroundMutableFileParent.h"
#include "mozilla/dom/PBackgroundMutableFileChild.h"
#include "mozilla/ipc/PChildToParentStreamParent.h"
#include "mozilla/ipc/PChildToParentStreamChild.h"
#include "mozilla/ipc/PFileDescriptorSetParent.h"
#include "mozilla/ipc/PFileDescriptorSetChild.h"
#include "mozilla/ipc/PIPCBlobInputStreamParent.h"
#include "mozilla/ipc/PIPCBlobInputStreamChild.h"
#include "mozilla/ipc/PParentToChildStreamParent.h"
#include "mozilla/ipc/PParentToChildStreamChild.h"
#include "mozilla/dom/PBackgroundFileHandle.h"

namespace mozilla {
namespace dom {
namespace PBackgroundFileHandle {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::PBackgroundFileHandleParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::PBackgroundFileHandleChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg_DeleteMe(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_DeleteMe__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*
Msg_Finish(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Finish__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*
Msg_Abort(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Abort__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*
Msg_PBackgroundFileRequestConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_PBackgroundFileRequestConstructor__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Reply_PBackgroundFileRequestConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_PBackgroundFileRequestConstructor__ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::REPLY));
}
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_Complete(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Complete__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 PBackgroundFileHandle
} // namespace dom
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::FileRequestGetMetadataParams>::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::FileRequestGetMetadataParams>::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' (bool) member of 'FileRequestGetMetadataParams'");
        return false;
    }
    // Sentinel = 'size'
    if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'size' (bool) member of 'FileRequestGetMetadataParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->lastModified())))))) {
        (aActor)->FatalError("Error deserializing 'lastModified' (bool) member of 'FileRequestGetMetadataParams'");
        return false;
    }
    // Sentinel = 'lastModified'
    if ((!((aMsg)->ReadSentinel(aIter, 3456113257)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (bool) member of 'FileRequestGetMetadataParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FileRequestData|
//
namespace mozilla {
namespace dom {
auto FileRequestData::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TFileRequestStringData:
        {
            (ptr_FileRequestStringData())->~FileRequestStringData__tdef();
            break;
        }
    case TFileRequestBlobData:
        {
            (ptr_FileRequestBlobData())->~FileRequestBlobData__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(const FileRequestStringData& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData(aOther);
    mType = TFileRequestStringData;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(FileRequestStringData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData(std::move(aOther));
    mType = TFileRequestStringData;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(const FileRequestBlobData& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData(aOther);
    mType = TFileRequestBlobData;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(FileRequestBlobData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData(std::move(aOther));
    mType = TFileRequestBlobData;
}

MOZ_IMPLICIT FileRequestData::FileRequestData(const FileRequestData& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TFileRequestStringData:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData((aOther).get_FileRequestStringData());
            break;
        }
    case TFileRequestBlobData:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData((aOther).get_FileRequestBlobData());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileRequestData::FileRequestData(FileRequestData&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TFileRequestStringData:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData(std::move((aOther).get_FileRequestStringData()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestBlobData:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData(std::move((aOther).get_FileRequestBlobData()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto FileRequestData::operator=(const FileRequestStringData& aRhs) -> FileRequestData&
{
    if (MaybeDestroy(TFileRequestStringData)) {
        new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData;
    }
    (*(ptr_FileRequestStringData())) = aRhs;
    mType = TFileRequestStringData;
    return (*(this));
}

auto FileRequestData::operator=(FileRequestStringData&& aRhs) -> FileRequestData&
{
    if (MaybeDestroy(TFileRequestStringData)) {
        new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData;
    }
    (*(ptr_FileRequestStringData())) = std::move(aRhs);
    mType = TFileRequestStringData;
    return (*(this));
}

auto FileRequestData::operator=(const FileRequestBlobData& aRhs) -> FileRequestData&
{
    if (MaybeDestroy(TFileRequestBlobData)) {
        new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData;
    }
    (*(ptr_FileRequestBlobData())) = aRhs;
    mType = TFileRequestBlobData;
    return (*(this));
}

auto FileRequestData::operator=(FileRequestBlobData&& aRhs) -> FileRequestData&
{
    if (MaybeDestroy(TFileRequestBlobData)) {
        new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData;
    }
    (*(ptr_FileRequestBlobData())) = std::move(aRhs);
    mType = TFileRequestBlobData;
    return (*(this));
}

auto FileRequestData::operator=(const FileRequestData& aRhs) -> FileRequestData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TFileRequestStringData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData;
            }
            (*(ptr_FileRequestStringData())) = (aRhs).get_FileRequestStringData();
            break;
        }
    case TFileRequestBlobData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData;
            }
            (*(ptr_FileRequestBlobData())) = (aRhs).get_FileRequestBlobData();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestData::operator=(FileRequestData&& aRhs) -> FileRequestData&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TFileRequestStringData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestStringData()) FileRequestStringData;
            }
            (*(ptr_FileRequestStringData())) = std::move((aRhs).get_FileRequestStringData());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestBlobData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestBlobData()) FileRequestBlobData;
            }
            (*(ptr_FileRequestBlobData())) = std::move((aRhs).get_FileRequestBlobData());
            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 FileRequestData::operator==(const FileRequestStringData& aRhs) const -> bool
{
    return (get_FileRequestStringData()) == (aRhs);
}

auto FileRequestData::operator==(const FileRequestBlobData& aRhs) const -> bool
{
    return (get_FileRequestBlobData()) == (aRhs);
}

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

    switch (type()) {
    case TFileRequestStringData:
        {
            return (get_FileRequestStringData()) == ((aRhs).get_FileRequestStringData());
        }
    case TFileRequestBlobData:
        {
            return (get_FileRequestBlobData()) == ((aRhs).get_FileRequestBlobData());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto FileRequestData::get(FileRequestStringData* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestStringData();
}

auto FileRequestData::get(FileRequestBlobData* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestBlobData();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TFileRequestStringData:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestStringData());
            // Sentinel = 'TFileRequestStringData'
            (aMsg)->WriteSentinel(3179014272);
            return;
        }
    case union__::TFileRequestBlobData:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestBlobData());
            // Sentinel = 'TFileRequestBlobData'
            (aMsg)->WriteSentinel(3085301148);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TFileRequestStringData:
        {
            mozilla::dom::FileRequestStringData tmp = mozilla::dom::FileRequestStringData();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestStringData())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestStringData of union FileRequestData");
                return false;
            }
            // Sentinel = 'TFileRequestStringData'
            if ((!((aMsg)->ReadSentinel(aIter, 3179014272)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestStringData of union FileRequestData");
                return false;
            }
            return true;
        }
    case union__::TFileRequestBlobData:
        {
            mozilla::dom::FileRequestBlobData tmp = mozilla::dom::FileRequestBlobData();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestBlobData())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestBlobData of union FileRequestData");
                return false;
            }
            // Sentinel = 'TFileRequestBlobData'
            if ((!((aMsg)->ReadSentinel(aIter, 3085301148)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestBlobData of union FileRequestData");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::FileRequestFlushParams>::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 FileRequestGetFileParams|
//
namespace mozilla {
namespace dom {
auto FileRequestGetFileParams::operator==(const FileRequestGetFileParams& _o) const -> bool
{
    return true;
}

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

} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::FileRequestGetFileParams>::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 |union FileRequestParams|
//
namespace mozilla {
namespace dom {
auto FileRequestParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TFileRequestGetMetadataParams:
        {
            (ptr_FileRequestGetMetadataParams())->~FileRequestGetMetadataParams__tdef();
            break;
        }
    case TFileRequestReadParams:
        {
            (ptr_FileRequestReadParams())->~FileRequestReadParams__tdef();
            break;
        }
    case TFileRequestWriteParams:
        {
            (ptr_FileRequestWriteParams())->~FileRequestWriteParams__tdef();
            break;
        }
    case TFileRequestTruncateParams:
        {
            (ptr_FileRequestTruncateParams())->~FileRequestTruncateParams__tdef();
            break;
        }
    case TFileRequestFlushParams:
        {
            (ptr_FileRequestFlushParams())->~FileRequestFlushParams__tdef();
            break;
        }
    case TFileRequestGetFileParams:
        {
            (ptr_FileRequestGetFileParams())->~FileRequestGetFileParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestGetMetadataParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams(aOther);
    mType = TFileRequestGetMetadataParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestGetMetadataParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams(std::move(aOther));
    mType = TFileRequestGetMetadataParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestReadParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams(aOther);
    mType = TFileRequestReadParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestReadParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams(std::move(aOther));
    mType = TFileRequestReadParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestWriteParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams(aOther);
    mType = TFileRequestWriteParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestWriteParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams(std::move(aOther));
    mType = TFileRequestWriteParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestTruncateParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams(aOther);
    mType = TFileRequestTruncateParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestTruncateParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams(std::move(aOther));
    mType = TFileRequestTruncateParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestFlushParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams(aOther);
    mType = TFileRequestFlushParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestFlushParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams(std::move(aOther));
    mType = TFileRequestFlushParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestGetFileParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams(aOther);
    mType = TFileRequestGetFileParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestGetFileParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams(std::move(aOther));
    mType = TFileRequestGetFileParams;
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(const FileRequestParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TFileRequestGetMetadataParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams((aOther).get_FileRequestGetMetadataParams());
            break;
        }
    case TFileRequestReadParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams((aOther).get_FileRequestReadParams());
            break;
        }
    case TFileRequestWriteParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams((aOther).get_FileRequestWriteParams());
            break;
        }
    case TFileRequestTruncateParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams((aOther).get_FileRequestTruncateParams());
            break;
        }
    case TFileRequestFlushParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams((aOther).get_FileRequestFlushParams());
            break;
        }
    case TFileRequestGetFileParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams((aOther).get_FileRequestGetFileParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT FileRequestParams::FileRequestParams(FileRequestParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TFileRequestGetMetadataParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams(std::move((aOther).get_FileRequestGetMetadataParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestReadParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams(std::move((aOther).get_FileRequestReadParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestWriteParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams(std::move((aOther).get_FileRequestWriteParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestTruncateParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams(std::move((aOther).get_FileRequestTruncateParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestFlushParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams(std::move((aOther).get_FileRequestFlushParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestGetFileParams:
        {
            new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams(std::move((aOther).get_FileRequestGetFileParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto FileRequestParams::operator=(const FileRequestGetMetadataParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestGetMetadataParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams;
    }
    (*(ptr_FileRequestGetMetadataParams())) = aRhs;
    mType = TFileRequestGetMetadataParams;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestGetMetadataParams&& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestGetMetadataParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams;
    }
    (*(ptr_FileRequestGetMetadataParams())) = std::move(aRhs);
    mType = TFileRequestGetMetadataParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestReadParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestReadParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams;
    }
    (*(ptr_FileRequestReadParams())) = aRhs;
    mType = TFileRequestReadParams;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestReadParams&& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestReadParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams;
    }
    (*(ptr_FileRequestReadParams())) = std::move(aRhs);
    mType = TFileRequestReadParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestWriteParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestWriteParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams;
    }
    (*(ptr_FileRequestWriteParams())) = aRhs;
    mType = TFileRequestWriteParams;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestWriteParams&& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestWriteParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams;
    }
    (*(ptr_FileRequestWriteParams())) = std::move(aRhs);
    mType = TFileRequestWriteParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestTruncateParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestTruncateParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams;
    }
    (*(ptr_FileRequestTruncateParams())) = aRhs;
    mType = TFileRequestTruncateParams;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestTruncateParams&& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestTruncateParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams;
    }
    (*(ptr_FileRequestTruncateParams())) = std::move(aRhs);
    mType = TFileRequestTruncateParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestFlushParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestFlushParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams;
    }
    (*(ptr_FileRequestFlushParams())) = aRhs;
    mType = TFileRequestFlushParams;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestFlushParams&& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestFlushParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams;
    }
    (*(ptr_FileRequestFlushParams())) = std::move(aRhs);
    mType = TFileRequestFlushParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestGetFileParams& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestGetFileParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams;
    }
    (*(ptr_FileRequestGetFileParams())) = aRhs;
    mType = TFileRequestGetFileParams;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestGetFileParams&& aRhs) -> FileRequestParams&
{
    if (MaybeDestroy(TFileRequestGetFileParams)) {
        new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams;
    }
    (*(ptr_FileRequestGetFileParams())) = std::move(aRhs);
    mType = TFileRequestGetFileParams;
    return (*(this));
}

auto FileRequestParams::operator=(const FileRequestParams& aRhs) -> FileRequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TFileRequestGetMetadataParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams;
            }
            (*(ptr_FileRequestGetMetadataParams())) = (aRhs).get_FileRequestGetMetadataParams();
            break;
        }
    case TFileRequestReadParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams;
            }
            (*(ptr_FileRequestReadParams())) = (aRhs).get_FileRequestReadParams();
            break;
        }
    case TFileRequestWriteParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams;
            }
            (*(ptr_FileRequestWriteParams())) = (aRhs).get_FileRequestWriteParams();
            break;
        }
    case TFileRequestTruncateParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams;
            }
            (*(ptr_FileRequestTruncateParams())) = (aRhs).get_FileRequestTruncateParams();
            break;
        }
    case TFileRequestFlushParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams;
            }
            (*(ptr_FileRequestFlushParams())) = (aRhs).get_FileRequestFlushParams();
            break;
        }
    case TFileRequestGetFileParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams;
            }
            (*(ptr_FileRequestGetFileParams())) = (aRhs).get_FileRequestGetFileParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto FileRequestParams::operator=(FileRequestParams&& aRhs) -> FileRequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TFileRequestGetMetadataParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetMetadataParams()) FileRequestGetMetadataParams;
            }
            (*(ptr_FileRequestGetMetadataParams())) = std::move((aRhs).get_FileRequestGetMetadataParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestReadParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestReadParams()) FileRequestReadParams;
            }
            (*(ptr_FileRequestReadParams())) = std::move((aRhs).get_FileRequestReadParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestWriteParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestWriteParams()) FileRequestWriteParams;
            }
            (*(ptr_FileRequestWriteParams())) = std::move((aRhs).get_FileRequestWriteParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestTruncateParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestTruncateParams()) FileRequestTruncateParams;
            }
            (*(ptr_FileRequestTruncateParams())) = std::move((aRhs).get_FileRequestTruncateParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestFlushParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestFlushParams()) FileRequestFlushParams;
            }
            (*(ptr_FileRequestFlushParams())) = std::move((aRhs).get_FileRequestFlushParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TFileRequestGetFileParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_FileRequestGetFileParams()) FileRequestGetFileParams;
            }
            (*(ptr_FileRequestGetFileParams())) = std::move((aRhs).get_FileRequestGetFileParams());
            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 FileRequestParams::operator==(const FileRequestGetMetadataParams& aRhs) const -> bool
{
    return (get_FileRequestGetMetadataParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestReadParams& aRhs) const -> bool
{
    return (get_FileRequestReadParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestWriteParams& aRhs) const -> bool
{
    return (get_FileRequestWriteParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestTruncateParams& aRhs) const -> bool
{
    return (get_FileRequestTruncateParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestFlushParams& aRhs) const -> bool
{
    return (get_FileRequestFlushParams()) == (aRhs);
}

auto FileRequestParams::operator==(const FileRequestGetFileParams& aRhs) const -> bool
{
    return (get_FileRequestGetFileParams()) == (aRhs);
}

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

    switch (type()) {
    case TFileRequestGetMetadataParams:
        {
            return (get_FileRequestGetMetadataParams()) == ((aRhs).get_FileRequestGetMetadataParams());
        }
    case TFileRequestReadParams:
        {
            return (get_FileRequestReadParams()) == ((aRhs).get_FileRequestReadParams());
        }
    case TFileRequestWriteParams:
        {
            return (get_FileRequestWriteParams()) == ((aRhs).get_FileRequestWriteParams());
        }
    case TFileRequestTruncateParams:
        {
            return (get_FileRequestTruncateParams()) == ((aRhs).get_FileRequestTruncateParams());
        }
    case TFileRequestFlushParams:
        {
            return (get_FileRequestFlushParams()) == ((aRhs).get_FileRequestFlushParams());
        }
    case TFileRequestGetFileParams:
        {
            return (get_FileRequestGetFileParams()) == ((aRhs).get_FileRequestGetFileParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto FileRequestParams::get(FileRequestGetMetadataParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestGetMetadataParams();
}

auto FileRequestParams::get(FileRequestReadParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestReadParams();
}

auto FileRequestParams::get(FileRequestWriteParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestWriteParams();
}

auto FileRequestParams::get(FileRequestTruncateParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestTruncateParams();
}

auto FileRequestParams::get(FileRequestFlushParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestFlushParams();
}

auto FileRequestParams::get(FileRequestGetFileParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_FileRequestGetFileParams();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TFileRequestGetMetadataParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestGetMetadataParams());
            // Sentinel = 'TFileRequestGetMetadataParams'
            (aMsg)->WriteSentinel(1166774555);
            return;
        }
    case union__::TFileRequestReadParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestReadParams());
            // Sentinel = 'TFileRequestReadParams'
            (aMsg)->WriteSentinel(1685693405);
            return;
        }
    case union__::TFileRequestWriteParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestWriteParams());
            // Sentinel = 'TFileRequestWriteParams'
            (aMsg)->WriteSentinel(2147439215);
            return;
        }
    case union__::TFileRequestTruncateParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestTruncateParams());
            // Sentinel = 'TFileRequestTruncateParams'
            (aMsg)->WriteSentinel(153458995);
            return;
        }
    case union__::TFileRequestFlushParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestFlushParams());
            // Sentinel = 'TFileRequestFlushParams'
            (aMsg)->WriteSentinel(258874732);
            return;
        }
    case union__::TFileRequestGetFileParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_FileRequestGetFileParams());
            // Sentinel = 'TFileRequestGetFileParams'
            (aMsg)->WriteSentinel(3815923694);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TFileRequestGetMetadataParams:
        {
            mozilla::dom::FileRequestGetMetadataParams tmp = mozilla::dom::FileRequestGetMetadataParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestGetMetadataParams())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestGetMetadataParams of union FileRequestParams");
                return false;
            }
            // Sentinel = 'TFileRequestGetMetadataParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1166774555)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestGetMetadataParams of union FileRequestParams");
                return false;
            }
            return true;
        }
    case union__::TFileRequestReadParams:
        {
            mozilla::dom::FileRequestReadParams tmp = mozilla::dom::FileRequestReadParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestReadParams())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestReadParams of union FileRequestParams");
                return false;
            }
            // Sentinel = 'TFileRequestReadParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1685693405)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestReadParams of union FileRequestParams");
                return false;
            }
            return true;
        }
    case union__::TFileRequestWriteParams:
        {
            mozilla::dom::FileRequestWriteParams tmp = mozilla::dom::FileRequestWriteParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestWriteParams())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestWriteParams of union FileRequestParams");
                return false;
            }
            // Sentinel = 'TFileRequestWriteParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2147439215)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestWriteParams of union FileRequestParams");
                return false;
            }
            return true;
        }
    case union__::TFileRequestTruncateParams:
        {
            mozilla::dom::FileRequestTruncateParams tmp = mozilla::dom::FileRequestTruncateParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestTruncateParams())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestTruncateParams of union FileRequestParams");
                return false;
            }
            // Sentinel = 'TFileRequestTruncateParams'
            if ((!((aMsg)->ReadSentinel(aIter, 153458995)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestTruncateParams of union FileRequestParams");
                return false;
            }
            return true;
        }
    case union__::TFileRequestFlushParams:
        {
            mozilla::dom::FileRequestFlushParams tmp = mozilla::dom::FileRequestFlushParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestFlushParams())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestFlushParams of union FileRequestParams");
                return false;
            }
            // Sentinel = 'TFileRequestFlushParams'
            if ((!((aMsg)->ReadSentinel(aIter, 258874732)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestFlushParams of union FileRequestParams");
                return false;
            }
            return true;
        }
    case union__::TFileRequestGetFileParams:
        {
            mozilla::dom::FileRequestGetFileParams tmp = mozilla::dom::FileRequestGetFileParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_FileRequestGetFileParams())))))) {
                (aActor)->FatalError("Error deserializing variant TFileRequestGetFileParams of union FileRequestParams");
                return false;
            }
            // Sentinel = 'TFileRequestGetFileParams'
            if ((!((aMsg)->ReadSentinel(aIter, 3815923694)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TFileRequestGetFileParams of union FileRequestParams");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53