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

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


#include "mozilla/dom/IPCServiceWorkerDescriptor.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCServiceWorkerDescriptor|
//
namespace mozilla {
namespace dom {
auto IPCServiceWorkerDescriptor::operator==(const IPCServiceWorkerDescriptor& _o) const -> bool
{
    if ((!((id()) == ((_o).id())))) {
        return false;
    }
    if ((!((registrationId()) == ((_o).registrationId())))) {
        return false;
    }
    if ((!((registrationVersion()) == ((_o).registrationVersion())))) {
        return false;
    }
    if ((!((principalInfo()) == ((_o).principalInfo())))) {
        return false;
    }
    if ((!((scope()) == ((_o).scope())))) {
        return false;
    }
    if ((!((scriptURL()) == ((_o).scriptURL())))) {
        return false;
    }
    if ((!((state()) == ((_o).state())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::IPCServiceWorkerDescriptor>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).id());
    // Sentinel = 'id'
    (aMsg)->WriteSentinel(2794505629);
    WriteIPDLParam(aMsg, aActor, (aVar).registrationId());
    // Sentinel = 'registrationId'
    (aMsg)->WriteSentinel(1952609634);
    WriteIPDLParam(aMsg, aActor, (aVar).registrationVersion());
    // Sentinel = 'registrationVersion'
    (aMsg)->WriteSentinel(4113392442);
    WriteIPDLParam(aMsg, aActor, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aMsg)->WriteSentinel(3386633731);
    WriteIPDLParam(aMsg, aActor, (aVar).scope());
    // Sentinel = 'scope'
    (aMsg)->WriteSentinel(2191984953);
    WriteIPDLParam(aMsg, aActor, (aVar).scriptURL());
    // Sentinel = 'scriptURL'
    (aMsg)->WriteSentinel(812395477);
    WriteIPDLParam(aMsg, aActor, (aVar).state());
    // Sentinel = 'state'
    (aMsg)->WriteSentinel(2094644402);
}

auto IPDLParamTraits<mozilla::dom::IPCServiceWorkerDescriptor>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->id())))))) {
        (aActor)->FatalError("Error deserializing 'id' (uint64_t) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'id'
    if ((!((aMsg)->ReadSentinel(aIter, 2794505629)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'id' (uint64_t) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->registrationId())))))) {
        (aActor)->FatalError("Error deserializing 'registrationId' (uint64_t) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'registrationId'
    if ((!((aMsg)->ReadSentinel(aIter, 1952609634)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'registrationId' (uint64_t) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->registrationVersion())))))) {
        (aActor)->FatalError("Error deserializing 'registrationVersion' (uint64_t) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'registrationVersion'
    if ((!((aMsg)->ReadSentinel(aIter, 4113392442)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'registrationVersion' (uint64_t) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->principalInfo())))))) {
        (aActor)->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'principalInfo'
    if ((!((aMsg)->ReadSentinel(aIter, 3386633731)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scope())))))) {
        (aActor)->FatalError("Error deserializing 'scope' (nsCString) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'scope'
    if ((!((aMsg)->ReadSentinel(aIter, 2191984953)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scope' (nsCString) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->scriptURL())))))) {
        (aActor)->FatalError("Error deserializing 'scriptURL' (nsCString) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'scriptURL'
    if ((!((aMsg)->ReadSentinel(aIter, 812395477)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'scriptURL' (nsCString) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->state())))))) {
        (aActor)->FatalError("Error deserializing 'state' (ServiceWorkerState) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    // Sentinel = 'state'
    if ((!((aMsg)->ReadSentinel(aIter, 2094644402)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'state' (ServiceWorkerState) member of 'IPCServiceWorkerDescriptor'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

MOZ_IMPLICIT OptionalIPCServiceWorkerDescriptor::OptionalIPCServiceWorkerDescriptor(const IPCServiceWorkerDescriptor& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCServiceWorkerDescriptor()) IPCServiceWorkerDescriptor(aOther);
    mType = TIPCServiceWorkerDescriptor;
}

MOZ_IMPLICIT OptionalIPCServiceWorkerDescriptor::OptionalIPCServiceWorkerDescriptor(IPCServiceWorkerDescriptor&& aOther)
{
    new (mozilla::KnownNotNull, ptr_IPCServiceWorkerDescriptor()) IPCServiceWorkerDescriptor(std::move(aOther));
    mType = TIPCServiceWorkerDescriptor;
}

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

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

MOZ_IMPLICIT OptionalIPCServiceWorkerDescriptor::OptionalIPCServiceWorkerDescriptor(const OptionalIPCServiceWorkerDescriptor& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TIPCServiceWorkerDescriptor:
        {
            new (mozilla::KnownNotNull, ptr_IPCServiceWorkerDescriptor()) IPCServiceWorkerDescriptor((aOther).get_IPCServiceWorkerDescriptor());
            break;
        }
    case Tvoid_t:
        {
            new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

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

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

auto OptionalIPCServiceWorkerDescriptor::operator=(const IPCServiceWorkerDescriptor& aRhs) -> OptionalIPCServiceWorkerDescriptor&
{
    if (MaybeDestroy(TIPCServiceWorkerDescriptor)) {
        new (mozilla::KnownNotNull, ptr_IPCServiceWorkerDescriptor()) IPCServiceWorkerDescriptor;
    }
    (*(ptr_IPCServiceWorkerDescriptor())) = aRhs;
    mType = TIPCServiceWorkerDescriptor;
    return (*(this));
}

auto OptionalIPCServiceWorkerDescriptor::operator=(IPCServiceWorkerDescriptor&& aRhs) -> OptionalIPCServiceWorkerDescriptor&
{
    if (MaybeDestroy(TIPCServiceWorkerDescriptor)) {
        new (mozilla::KnownNotNull, ptr_IPCServiceWorkerDescriptor()) IPCServiceWorkerDescriptor;
    }
    (*(ptr_IPCServiceWorkerDescriptor())) = std::move(aRhs);
    mType = TIPCServiceWorkerDescriptor;
    return (*(this));
}

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

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

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

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

auto OptionalIPCServiceWorkerDescriptor::operator==(const IPCServiceWorkerDescriptor& aRhs) const -> bool
{
    return (get_IPCServiceWorkerDescriptor()) == (aRhs);
}

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

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

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

auto OptionalIPCServiceWorkerDescriptor::get(IPCServiceWorkerDescriptor* aOutValue) const -> void
{
    (*(aOutValue)) = get_IPCServiceWorkerDescriptor();
}

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

} // namespace dom
} // namespace mozilla

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

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

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

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

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