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

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


#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/ipc/PPendingIPCBlob.h"

namespace mozilla {
namespace ipc {
namespace PPendingIPCBlob {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::ipc::PPendingIPCBlobParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::ipc::PPendingIPCBlobChild>* 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));
}

} // namespace PPendingIPCBlob
} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union PendingIPCFileUnion|
//
namespace mozilla {
namespace ipc {
auto PendingIPCFileUnion::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 TPendingIPCFileData:
        {
            (ptr_PendingIPCFileData())->~PendingIPCFileData__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(const PendingIPCFileData& aOther)
{
    new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData(aOther);
    mType = TPendingIPCFileData;
}

MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(PendingIPCFileData&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData(std::move(aOther));
    mType = TPendingIPCFileData;
}

MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(const PendingIPCFileUnion& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case TPendingIPCFileData:
        {
            new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData((aOther).get_PendingIPCFileData());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(PendingIPCFileUnion&& 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 TPendingIPCFileData:
        {
            new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData(std::move((aOther).get_PendingIPCFileData()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto PendingIPCFileUnion::operator=(const PendingIPCFileData& aRhs) -> PendingIPCFileUnion&
{
    if (MaybeDestroy(TPendingIPCFileData)) {
        new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
    }
    (*(ptr_PendingIPCFileData())) = aRhs;
    mType = TPendingIPCFileData;
    return (*(this));
}

auto PendingIPCFileUnion::operator=(PendingIPCFileData&& aRhs) -> PendingIPCFileUnion&
{
    if (MaybeDestroy(TPendingIPCFileData)) {
        new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
    }
    (*(ptr_PendingIPCFileData())) = std::move(aRhs);
    mType = TPendingIPCFileData;
    return (*(this));
}

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

auto PendingIPCFileUnion::operator=(PendingIPCFileUnion&& aRhs) -> PendingIPCFileUnion&
{
    (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 TPendingIPCFileData:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
            }
            (*(ptr_PendingIPCFileData())) = std::move((aRhs).get_PendingIPCFileData());
            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 PendingIPCFileUnion::operator==(const void_t& aRhs) const -> bool
{
    return (get_void_t()) == (aRhs);
}

auto PendingIPCFileUnion::operator==(const PendingIPCFileData& aRhs) const -> bool
{
    return (get_PendingIPCFileData()) == (aRhs);
}

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

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

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

auto PendingIPCFileUnion::get(PendingIPCFileData* aOutValue) const -> void
{
    (*(aOutValue)) = get_PendingIPCFileData();
}

} // namespace ipc
} // namespace mozilla

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

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		//
2		// Automatically generated by ipdlc.
3		// Edit at your own risk
4		//
5
6
7		#include "mozilla/ipc/PBackgroundParent.h"
8		#include "mozilla/ipc/PBackgroundChild.h"
9		#include "mozilla/ipc/PPendingIPCBlob.h"
10
11		namespace mozilla {
12		namespace ipc {
13		namespace PPendingIPCBlob {
14
15		nsresult
16		CreateEndpoints(
17		base::ProcessId aParentDestPid,
18		base::ProcessId aChildDestPid,
19		mozilla::ipc::Endpoint<mozilla::ipc::PPendingIPCBlobParent>* aParent,
20		mozilla::ipc::Endpoint<mozilla::ipc::PPendingIPCBlobChild>* aChild)
21	0	{
22	0	return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
23	0	}
24		IPC::Message*
25		Msg___delete__(int32_t routingId)
26	0	{
27	0	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));
28	0	}
29		IPC::Message*
30		Reply___delete__(int32_t routingId)
31	0	{
32	0	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));
33	0	}
34
35		} // namespace PPendingIPCBlob
36		} // namespace ipc
37		} // namespace mozilla
38
39		//-----------------------------------------------------------------------------
40		// Method definitions for the IPDL type \|struct PendingIPCFileData\|
41		//
42		namespace mozilla {
43		namespace ipc {
44		auto PendingIPCFileData::operator==(const PendingIPCFileData& _o) const -> bool
45	0	{
46	0	if ((!((name()) == ((_o).name())))) {
47	0	return false;
48	0	}
49	0	if ((!((lastModified()) == ((_o).lastModified())))) {
50	0	return false;
51	0	}
52	0	return true;
53	0	}
54
55		auto PendingIPCFileData::operator!=(const PendingIPCFileData& _o) const -> bool
56	0	{
57	0	return (!(operator==(_o)));
58	0	}
59
60		} // namespace ipc
61		} // namespace mozilla
62
63		namespace mozilla {
64		namespace ipc {
65		auto IPDLParamTraits<mozilla::ipc::PendingIPCFileData>::Write(
66		IPC::Message* aMsg,
67		mozilla::ipc::IProtocol* aActor,
68		const paramType& aVar) -> void
69	0	{
70	0	WriteIPDLParam(aMsg, aActor, (aVar).name());
71	0	// Sentinel = 'name'
72	0	(aMsg)->WriteSentinel(15034981);
73	0	WriteIPDLParam(aMsg, aActor, (aVar).lastModified());
74	0	// Sentinel = 'lastModified'
75	0	(aMsg)->WriteSentinel(3456113257);
76	0	}
77
78		auto IPDLParamTraits<mozilla::ipc::PendingIPCFileData>::Read(
79		const IPC::Message* aMsg,
80		PickleIterator* aIter,
81		mozilla::ipc::IProtocol* aActor,
82		paramType* aVar) -> bool
83	0	{
84	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->name())))))) {
85	0	(aActor)->FatalError("Error deserializing 'name' (nsString) member of 'PendingIPCFileData'");
86	0	return false;
87	0	}
88	0	// Sentinel = 'name'
89	0	if ((!((aMsg)->ReadSentinel(aIter, 15034981)))) {
90	0	mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'PendingIPCFileData'");
91	0	return false;
92	0	}
93	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->lastModified())))))) {
94	0	(aActor)->FatalError("Error deserializing 'lastModified' (int64_t) member of 'PendingIPCFileData'");
95	0	return false;
96	0	}
97	0	// Sentinel = 'lastModified'
98	0	if ((!((aMsg)->ReadSentinel(aIter, 3456113257)))) {
99	0	mozilla::ipc::SentinelReadError("Error deserializing 'lastModified' (int64_t) member of 'PendingIPCFileData'");
100	0	return false;
101	0	}
102	0	return true;
103	0	}
104
105		} // namespace ipc
106		} // namespace mozilla
107
108		//-----------------------------------------------------------------------------
109		// Method definitions for the IPDL type \|union PendingIPCFileUnion\|
110		//
111		namespace mozilla {
112		namespace ipc {
113		auto PendingIPCFileUnion::MaybeDestroy(Type aNewType) -> bool
114	0	{
115	0	if ((mType) == (T__None)) {
116	0	return true;
117	0	}
118	0	if ((mType) == (aNewType)) {
119	0	return false;
120	0	}
121	0	switch (mType) {
122	0	case Tvoid_t:
123	0	{
124	0	(ptr_void_t())->~void_t__tdef();
125	0	break;
126	0	}
127	0	case TPendingIPCFileData:
128	0	{
129	0	(ptr_PendingIPCFileData())->~PendingIPCFileData__tdef();
130	0	break;
131	0	}
132	0	default:
133	0	{
134	0	mozilla::ipc::LogicError("not reached");
135	0	break;
136	0	}
137	0	}
138	0	return true;
139	0	}
140
141		MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(const void_t& aOther)
142	0	{
143	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
144	0	mType = Tvoid_t;
145	0	}
146
147		MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(void_t&& aOther)
148	0	{
149	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
150	0	mType = Tvoid_t;
151	0	}
152
153		MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(const PendingIPCFileData& aOther)
154	0	{
155	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData(aOther);
156	0	mType = TPendingIPCFileData;
157	0	}
158
159		MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(PendingIPCFileData&& aOther)
160	0	{
161	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData(std::move(aOther));
162	0	mType = TPendingIPCFileData;
163	0	}
164
165		MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(const PendingIPCFileUnion& aOther)
166	0	{
167	0	(aOther).AssertSanity();
168	0	switch ((aOther).type()) {
169	0	case Tvoid_t:
170	0	{
171	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
172	0	break;
173	0	}
174	0	case TPendingIPCFileData:
175	0	{
176	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData((aOther).get_PendingIPCFileData());
177	0	break;
178	0	}
179	0	case T__None:
180	0	{
181	0	break;
182	0	}
183	0	default:
184	0	{
185	0	mozilla::ipc::LogicError("unreached");
186	0	return;
187	0	}
188	0	}
189	0	mType = (aOther).type();
190	0	}
191
192		MOZ_IMPLICIT PendingIPCFileUnion::PendingIPCFileUnion(PendingIPCFileUnion&& aOther)
193	0	{
194	0	(aOther).AssertSanity();
195	0	Type t = (aOther).type();
196	0	switch (t) {
197	0	case Tvoid_t:
198	0	{
199	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
200	0	static_cast<void>((aOther).MaybeDestroy(T__None));
201	0	break;
202	0	}
203	0	case TPendingIPCFileData:
204	0	{
205	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData(std::move((aOther).get_PendingIPCFileData()));
206	0	static_cast<void>((aOther).MaybeDestroy(T__None));
207	0	break;
208	0	}
209	0	case T__None:
210	0	{
211	0	break;
212	0	}
213	0	default:
214	0	{
215	0	mozilla::ipc::LogicError("unreached");
216	0	return;
217	0	}
218	0	}
219	0	(aOther).mType = T__None;
220	0	mType = t;
221	0	}
222
223		PendingIPCFileUnion::~PendingIPCFileUnion()
224	0	{
225	0	static_cast<void>(MaybeDestroy(T__None));
226	0	}
227
228		auto PendingIPCFileUnion::operator=(const void_t& aRhs) -> PendingIPCFileUnion&
229	0	{
230	0	if (MaybeDestroy(Tvoid_t)) {
231	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t;
232	0	}
233	0	(*(ptr_void_t())) = aRhs;
234	0	mType = Tvoid_t;
235	0	return (*(this));
236	0	}
237
238		auto PendingIPCFileUnion::operator=(void_t&& aRhs) -> PendingIPCFileUnion&
239	0	{
240	0	if (MaybeDestroy(Tvoid_t)) {
241	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t;
242	0	}
243	0	(*(ptr_void_t())) = std::move(aRhs);
244	0	mType = Tvoid_t;
245	0	return (*(this));
246	0	}
247
248		auto PendingIPCFileUnion::operator=(const PendingIPCFileData& aRhs) -> PendingIPCFileUnion&
249	0	{
250	0	if (MaybeDestroy(TPendingIPCFileData)) {
251	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
252	0	}
253	0	(*(ptr_PendingIPCFileData())) = aRhs;
254	0	mType = TPendingIPCFileData;
255	0	return (*(this));
256	0	}
257
258		auto PendingIPCFileUnion::operator=(PendingIPCFileData&& aRhs) -> PendingIPCFileUnion&
259	0	{
260	0	if (MaybeDestroy(TPendingIPCFileData)) {
261	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
262	0	}
263	0	(*(ptr_PendingIPCFileData())) = std::move(aRhs);
264	0	mType = TPendingIPCFileData;
265	0	return (*(this));
266	0	}
267
268		auto PendingIPCFileUnion::operator=(const PendingIPCFileUnion& aRhs) -> PendingIPCFileUnion&
269	0	{
270	0	(aRhs).AssertSanity();
271	0	Type t = (aRhs).type();
272	0	switch (t) {
273	0	case Tvoid_t:
274	0	{
275	0	if (MaybeDestroy(t)) {
276	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t;
277	0	}
278	0	(*(ptr_void_t())) = (aRhs).get_void_t();
279	0	break;
280	0	}
281	0	case TPendingIPCFileData:
282	0	{
283	0	if (MaybeDestroy(t)) {
284	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
285	0	}
286	0	(*(ptr_PendingIPCFileData())) = (aRhs).get_PendingIPCFileData();
287	0	break;
288	0	}
289	0	case T__None:
290	0	{
291	0	static_cast<void>(MaybeDestroy(t));
292	0	break;
293	0	}
294	0	default:
295	0	{
296	0	mozilla::ipc::LogicError("unreached");
297	0	break;
298	0	}
299	0	}
300	0	mType = t;
301	0	return (*(this));
302	0	}
303
304		auto PendingIPCFileUnion::operator=(PendingIPCFileUnion&& aRhs) -> PendingIPCFileUnion&
305	0	{
306	0	(aRhs).AssertSanity();
307	0	Type t = (aRhs).type();
308	0	switch (t) {
309	0	case Tvoid_t:
310	0	{
311	0	if (MaybeDestroy(t)) {
312	0	new (mozilla::KnownNotNull, ptr_void_t()) void_t;
313	0	}
314	0	(*(ptr_void_t())) = std::move((aRhs).get_void_t());
315	0	static_cast<void>((aRhs).MaybeDestroy(T__None));
316	0	break;
317	0	}
318	0	case TPendingIPCFileData:
319	0	{
320	0	if (MaybeDestroy(t)) {
321	0	new (mozilla::KnownNotNull, ptr_PendingIPCFileData()) PendingIPCFileData;
322	0	}
323	0	(*(ptr_PendingIPCFileData())) = std::move((aRhs).get_PendingIPCFileData());
324	0	static_cast<void>((aRhs).MaybeDestroy(T__None));
325	0	break;
326	0	}
327	0	case T__None:
328	0	{
329	0	static_cast<void>(MaybeDestroy(t));
330	0	break;
331	0	}
332	0	default:
333	0	{
334	0	mozilla::ipc::LogicError("unreached");
335	0	break;
336	0	}
337	0	}
338	0	(aRhs).mType = T__None;
339	0	mType = t;
340	0	return (*(this));
341	0	}
342
343		auto PendingIPCFileUnion::operator==(const void_t& aRhs) const -> bool
344	0	{
345	0	return (get_void_t()) == (aRhs);
346	0	}
347
348		auto PendingIPCFileUnion::operator==(const PendingIPCFileData& aRhs) const -> bool
349	0	{
350	0	return (get_PendingIPCFileData()) == (aRhs);
351	0	}
352
353		auto PendingIPCFileUnion::operator==(const PendingIPCFileUnion& aRhs) const -> bool
354	0	{
355	0	if ((type()) != ((aRhs).type())) {
356	0	return false;
357	0	}
358	0
359	0	switch (type()) {
360	0	case Tvoid_t:
361	0	{
362	0	return (get_void_t()) == ((aRhs).get_void_t());
363	0	}
364	0	case TPendingIPCFileData:
365	0	{
366	0	return (get_PendingIPCFileData()) == ((aRhs).get_PendingIPCFileData());
367	0	}
368	0	default:
369	0	{
370	0	mozilla::ipc::LogicError("unreached");
371	0	return false;
372	0	}
373	0	}
374	0	}
375
376		auto PendingIPCFileUnion::get(void_t* aOutValue) const -> void
377	0	{
378	0	(*(aOutValue)) = get_void_t();
379	0	}
380
381		auto PendingIPCFileUnion::get(PendingIPCFileData* aOutValue) const -> void
382	0	{
383	0	(*(aOutValue)) = get_PendingIPCFileData();
384	0	}
385
386		} // namespace ipc
387		} // namespace mozilla
388
389		namespace mozilla {
390		namespace ipc {
391		auto IPDLParamTraits<mozilla::ipc::PendingIPCFileUnion>::Write(
392		IPC::Message* aMsg,
393		mozilla::ipc::IProtocol* aActor,
394		const paramType& aVar) -> void
395		{
396		typedef mozilla::ipc::PendingIPCFileUnion union__;
397		int type;
398		type = (aVar).type();
399		WriteIPDLParam(aMsg, aActor, type);
400		// Sentinel = 'PendingIPCFileUnion'
401		(aMsg)->WriteSentinel(1596690423);
402
403		switch (type) {
404		case union__::Tvoid_t:
405		{
406		WriteIPDLParam(aMsg, aActor, (aVar).get_void_t());
407		// Sentinel = 'Tvoid_t'
408		(aMsg)->WriteSentinel(3041273328);
409		return;
410		}
411		case union__::TPendingIPCFileData:
412		{
413		WriteIPDLParam(aMsg, aActor, (aVar).get_PendingIPCFileData());
414		// Sentinel = 'TPendingIPCFileData'
415		(aMsg)->WriteSentinel(1894431344);
416		return;
417		}
418		default:
419		{
420		(aActor)->FatalError("unknown union type");
421		return;
422		}
423		}
424		}
425
426		auto IPDLParamTraits<mozilla::ipc::PendingIPCFileUnion>::Read(
427		const IPC::Message* aMsg,
428		PickleIterator* aIter,
429		mozilla::ipc::IProtocol* aActor,
430		paramType* aVar) -> bool
431	0	{
432	0	typedef mozilla::ipc::PendingIPCFileUnion union__;
433	0	int type;
434	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
435	0	(aActor)->FatalError("Error deserializing type of union PendingIPCFileUnion");
436	0	return false;
437	0	}
438	0	// Sentinel = 'PendingIPCFileUnion'
439	0	if ((!((aMsg)->ReadSentinel(aIter, 1596690423)))) {
440	0	mozilla::ipc::SentinelReadError("Error deserializing type of union PendingIPCFileUnion");
441	0	return false;
442	0	}
443	0
444	0	switch (type) {
445	0	case union__::Tvoid_t:
446	0	{
447	0	mozilla::void_t tmp = mozilla::void_t();
448	0	(*(aVar)) = tmp;
449	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_void_t())))))) {
450	0	(aActor)->FatalError("Error deserializing variant Tvoid_t of union PendingIPCFileUnion");
451	0	return false;
452	0	}
453	0	// Sentinel = 'Tvoid_t'
454	0	if ((!((aMsg)->ReadSentinel(aIter, 3041273328)))) {
455	0	mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union PendingIPCFileUnion");
456	0	return false;
457	0	}
458	0	return true;
459	0	}
460	0	case union__::TPendingIPCFileData:
461	0	{
462	0	mozilla::ipc::PendingIPCFileData tmp = mozilla::ipc::PendingIPCFileData();
463	0	(*(aVar)) = tmp;
464	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PendingIPCFileData())))))) {
465	0	(aActor)->FatalError("Error deserializing variant TPendingIPCFileData of union PendingIPCFileUnion");
466	0	return false;
467	0	}
468	0	// Sentinel = 'TPendingIPCFileData'
469	0	if ((!((aMsg)->ReadSentinel(aIter, 1894431344)))) {
470	0	mozilla::ipc::SentinelReadError("Error deserializing variant TPendingIPCFileData of union PendingIPCFileUnion");
471	0	return false;
472	0	}
473	0	return true;
474	0	}
475	0	default:
476	0	{
477	0	(aActor)->FatalError("unknown union type");
478	0	return false;
479	0	}
480	0	}
481	0	}
482
483		} // namespace ipc
484		} // namespace mozilla
485
486		//-----------------------------------------------------------------------------
487		// Method definitions for the IPDL type \|struct PendingIPCBlobData\|
488		//
489		namespace mozilla {
490		namespace ipc {
491		auto PendingIPCBlobData::operator==(const PendingIPCBlobData& _o) const -> bool
492	0	{
493	0	if ((!((type()) == ((_o).type())))) {
494	0	return false;
495	0	}
496	0	if ((!((size()) == ((_o).size())))) {
497	0	return false;
498	0	}
499	0	if ((!((file()) == ((_o).file())))) {
500	0	return false;
501	0	}
502	0	return true;
503	0	}
504
505		auto PendingIPCBlobData::operator!=(const PendingIPCBlobData& _o) const -> bool
506	0	{
507	0	return (!(operator==(_o)));
508	0	}
509
510		} // namespace ipc
511		} // namespace mozilla
512
513		namespace mozilla {
514		namespace ipc {
515		auto IPDLParamTraits<mozilla::ipc::PendingIPCBlobData>::Write(
516		IPC::Message* aMsg,
517		mozilla::ipc::IProtocol* aActor,
518		const paramType& aVar) -> void
519	0	{
520	0	WriteIPDLParam(aMsg, aActor, (aVar).type());
521	0	// Sentinel = 'type'
522	0	(aMsg)->WriteSentinel(2982068540);
523	0	WriteIPDLParam(aMsg, aActor, (aVar).size());
524	0	// Sentinel = 'size'
525	0	(aMsg)->WriteSentinel(931048223);
526	0	WriteIPDLParam(aMsg, aActor, (aVar).file());
527	0	// Sentinel = 'file'
528	0	(aMsg)->WriteSentinel(224874390);
529	0	}
530
531		auto IPDLParamTraits<mozilla::ipc::PendingIPCBlobData>::Read(
532		const IPC::Message* aMsg,
533		PickleIterator* aIter,
534		mozilla::ipc::IProtocol* aActor,
535		paramType* aVar) -> bool
536	0	{
537	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->type())))))) {
538	0	(aActor)->FatalError("Error deserializing 'type' (nsString) member of 'PendingIPCBlobData'");
539	0	return false;
540	0	}
541	0	// Sentinel = 'type'
542	0	if ((!((aMsg)->ReadSentinel(aIter, 2982068540)))) {
543	0	mozilla::ipc::SentinelReadError("Error deserializing 'type' (nsString) member of 'PendingIPCBlobData'");
544	0	return false;
545	0	}
546	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->size())))))) {
547	0	(aActor)->FatalError("Error deserializing 'size' (uint64_t) member of 'PendingIPCBlobData'");
548	0	return false;
549	0	}
550	0	// Sentinel = 'size'
551	0	if ((!((aMsg)->ReadSentinel(aIter, 931048223)))) {
552	0	mozilla::ipc::SentinelReadError("Error deserializing 'size' (uint64_t) member of 'PendingIPCBlobData'");
553	0	return false;
554	0	}
555	0	if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->file())))))) {
556	0	(aActor)->FatalError("Error deserializing 'file' (PendingIPCFileUnion) member of 'PendingIPCBlobData'");
557	0	return false;
558	0	}
559	0	// Sentinel = 'file'
560	0	if ((!((aMsg)->ReadSentinel(aIter, 224874390)))) {
561	0	mozilla::ipc::SentinelReadError("Error deserializing 'file' (PendingIPCFileUnion) member of 'PendingIPCBlobData'");
562	0	return false;
563	0	}
564	0	return true;
565	0	}
566
567		} // namespace ipc
568		} // namespace mozilla