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

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


#include "mozilla/dom/quota/SerializationHelpers.h"
#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/dom/quota/PQuotaRequestParent.h"
#include "mozilla/dom/quota/PQuotaRequestChild.h"
#include "mozilla/dom/quota/PQuotaUsageRequestParent.h"
#include "mozilla/dom/quota/PQuotaUsageRequestChild.h"
#include "mozilla/dom/quota/PQuota.h"

namespace mozilla {
namespace dom {
namespace quota {
namespace PQuota {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::quota::PQuotaParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::quota::PQuotaChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg___delete__(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::NOT_REPLY));
}
IPC::Message*
Reply___delete__(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_INTERRUPT, IPC::Message::REPLY));
}
IPC::Message*
Msg_PQuotaUsageRequestConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_PQuotaUsageRequestConstructor__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_PQuotaUsageRequestConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_PQuotaUsageRequestConstructor__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_PQuotaRequestConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_PQuotaRequestConstructor__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_PQuotaRequestConstructor(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_PQuotaRequestConstructor__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_StartIdleMaintenance(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_StartIdleMaintenance__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_StopIdleMaintenance(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_StopIdleMaintenance__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 PQuota
} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::quota::InitParams>::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 InitOriginParams|
//
namespace mozilla {
namespace dom {
namespace quota {
auto InitOriginParams::operator==(const InitOriginParams& _o) const -> bool
{
    if ((!((principalInfo()) == ((_o).principalInfo())))) {
        return false;
    }
    if ((!((persistenceType()) == ((_o).persistenceType())))) {
        return false;
    }
    return true;
}

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

} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::quota::InitOriginParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aMsg)->WriteSentinel(3386633731);
    WriteIPDLParam(aMsg, aActor, (aVar).persistenceType());
    // Sentinel = 'persistenceType'
    (aMsg)->WriteSentinel(3316493122);
}

auto IPDLParamTraits<mozilla::dom::quota::InitOriginParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->principalInfo())))))) {
        (aActor)->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'InitOriginParams'");
        return false;
    }
    // Sentinel = 'principalInfo'
    if ((!((aMsg)->ReadSentinel(aIter, 3386633731)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'InitOriginParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->persistenceType())))))) {
        (aActor)->FatalError("Error deserializing 'persistenceType' (PersistenceType) member of 'InitOriginParams'");
        return false;
    }
    // Sentinel = 'persistenceType'
    if ((!((aMsg)->ReadSentinel(aIter, 3316493122)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'InitOriginParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::quota::OriginUsageParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aMsg)->WriteSentinel(3386633731);
    WriteIPDLParam(aMsg, aActor, (aVar).getGroupUsage());
    // Sentinel = 'getGroupUsage'
    (aMsg)->WriteSentinel(4167744247);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union UsageRequestParams|
//
namespace mozilla {
namespace dom {
namespace quota {
auto UsageRequestParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TAllUsageParams:
        {
            (ptr_AllUsageParams())->~AllUsageParams__tdef();
            break;
        }
    case TOriginUsageParams:
        {
            (ptr_OriginUsageParams())->~OriginUsageParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(const AllUsageParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(aOther);
    mType = TAllUsageParams;
}

MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(AllUsageParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(std::move(aOther));
    mType = TAllUsageParams;
}

MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(const OriginUsageParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(aOther);
    mType = TOriginUsageParams;
}

MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(OriginUsageParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(std::move(aOther));
    mType = TOriginUsageParams;
}

MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(const UsageRequestParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TAllUsageParams:
        {
            new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams((aOther).get_AllUsageParams());
            break;
        }
    case TOriginUsageParams:
        {
            new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams((aOther).get_OriginUsageParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(UsageRequestParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TAllUsageParams:
        {
            new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(std::move((aOther).get_AllUsageParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOriginUsageParams:
        {
            new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(std::move((aOther).get_OriginUsageParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto UsageRequestParams::operator=(const AllUsageParams& aRhs) -> UsageRequestParams&
{
    if (MaybeDestroy(TAllUsageParams)) {
        new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams;
    }
    (*(ptr_AllUsageParams())) = aRhs;
    mType = TAllUsageParams;
    return (*(this));
}

auto UsageRequestParams::operator=(AllUsageParams&& aRhs) -> UsageRequestParams&
{
    if (MaybeDestroy(TAllUsageParams)) {
        new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams;
    }
    (*(ptr_AllUsageParams())) = std::move(aRhs);
    mType = TAllUsageParams;
    return (*(this));
}

auto UsageRequestParams::operator=(const OriginUsageParams& aRhs) -> UsageRequestParams&
{
    if (MaybeDestroy(TOriginUsageParams)) {
        new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams;
    }
    (*(ptr_OriginUsageParams())) = aRhs;
    mType = TOriginUsageParams;
    return (*(this));
}

auto UsageRequestParams::operator=(OriginUsageParams&& aRhs) -> UsageRequestParams&
{
    if (MaybeDestroy(TOriginUsageParams)) {
        new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams;
    }
    (*(ptr_OriginUsageParams())) = std::move(aRhs);
    mType = TOriginUsageParams;
    return (*(this));
}

auto UsageRequestParams::operator=(const UsageRequestParams& aRhs) -> UsageRequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TAllUsageParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams;
            }
            (*(ptr_AllUsageParams())) = (aRhs).get_AllUsageParams();
            break;
        }
    case TOriginUsageParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams;
            }
            (*(ptr_OriginUsageParams())) = (aRhs).get_OriginUsageParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto UsageRequestParams::operator=(UsageRequestParams&& aRhs) -> UsageRequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TAllUsageParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams;
            }
            (*(ptr_AllUsageParams())) = std::move((aRhs).get_AllUsageParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOriginUsageParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams;
            }
            (*(ptr_OriginUsageParams())) = std::move((aRhs).get_OriginUsageParams());
            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 UsageRequestParams::operator==(const AllUsageParams& aRhs) const -> bool
{
    return (get_AllUsageParams()) == (aRhs);
}

auto UsageRequestParams::operator==(const OriginUsageParams& aRhs) const -> bool
{
    return (get_OriginUsageParams()) == (aRhs);
}

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

    switch (type()) {
    case TAllUsageParams:
        {
            return (get_AllUsageParams()) == ((aRhs).get_AllUsageParams());
        }
    case TOriginUsageParams:
        {
            return (get_OriginUsageParams()) == ((aRhs).get_OriginUsageParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto UsageRequestParams::get(AllUsageParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_AllUsageParams();
}

auto UsageRequestParams::get(OriginUsageParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_OriginUsageParams();
}

} // namespace quota
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TAllUsageParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_AllUsageParams());
            // Sentinel = 'TAllUsageParams'
            (aMsg)->WriteSentinel(2435528059);
            return;
        }
    case union__::TOriginUsageParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OriginUsageParams());
            // Sentinel = 'TOriginUsageParams'
            (aMsg)->WriteSentinel(55992623);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TAllUsageParams:
        {
            mozilla::dom::quota::AllUsageParams tmp = mozilla::dom::quota::AllUsageParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_AllUsageParams())))))) {
                (aActor)->FatalError("Error deserializing variant TAllUsageParams of union UsageRequestParams");
                return false;
            }
            // Sentinel = 'TAllUsageParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2435528059)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TAllUsageParams of union UsageRequestParams");
                return false;
            }
            return true;
        }
    case union__::TOriginUsageParams:
        {
            mozilla::dom::quota::OriginUsageParams tmp = mozilla::dom::quota::OriginUsageParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OriginUsageParams())))))) {
                (aActor)->FatalError("Error deserializing variant TOriginUsageParams of union UsageRequestParams");
                return false;
            }
            // Sentinel = 'TOriginUsageParams'
            if ((!((aMsg)->ReadSentinel(aIter, 55992623)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOriginUsageParams of union UsageRequestParams");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::quota::ClearOriginParams>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).principalInfo());
    // Sentinel = 'principalInfo'
    (aMsg)->WriteSentinel(3386633731);
    WriteIPDLParam(aMsg, aActor, (aVar).persistenceType());
    // Sentinel = 'persistenceType'
    (aMsg)->WriteSentinel(3316493122);
    WriteIPDLParam(aMsg, aActor, (aVar).persistenceTypeIsExplicit());
    // Sentinel = 'persistenceTypeIsExplicit'
    (aMsg)->WriteSentinel(709480568);
    WriteIPDLParam(aMsg, aActor, (aVar).clearAll());
    // Sentinel = 'clearAll'
    (aMsg)->WriteSentinel(942773884);
}

auto IPDLParamTraits<mozilla::dom::quota::ClearOriginParams>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->principalInfo())))))) {
        (aActor)->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'ClearOriginParams'");
        return false;
    }
    // Sentinel = 'principalInfo'
    if ((!((aMsg)->ReadSentinel(aIter, 3386633731)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'ClearOriginParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->persistenceType())))))) {
        (aActor)->FatalError("Error deserializing 'persistenceType' (PersistenceType) member of 'ClearOriginParams'");
        return false;
    }
    // Sentinel = 'persistenceType'
    if ((!((aMsg)->ReadSentinel(aIter, 3316493122)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'ClearOriginParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->persistenceTypeIsExplicit())))))) {
        (aActor)->FatalError("Error deserializing 'persistenceTypeIsExplicit' (bool) member of 'ClearOriginParams'");
        return false;
    }
    // Sentinel = 'persistenceTypeIsExplicit'
    if ((!((aMsg)->ReadSentinel(aIter, 709480568)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'persistenceTypeIsExplicit' (bool) member of 'ClearOriginParams'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->clearAll())))))) {
        (aActor)->FatalError("Error deserializing 'clearAll' (bool) member of 'ClearOriginParams'");
        return false;
    }
    // Sentinel = 'clearAll'
    if ((!((aMsg)->ReadSentinel(aIter, 942773884)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'clearAll' (bool) member of 'ClearOriginParams'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

auto IPDLParamTraits<mozilla::dom::quota::ResetAllParams>::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 PersistedParams|
//
namespace mozilla {
namespace dom {
namespace quota {
auto PersistedParams::operator==(const PersistedParams& _o) const -> bool
{
    if ((!((principalInfo()) == ((_o).principalInfo())))) {
        return false;
    }
    return true;
}

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RequestParams|
//
namespace mozilla {
namespace dom {
namespace quota {
auto RequestParams::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TInitParams:
        {
            (ptr_InitParams())->~InitParams__tdef();
            break;
        }
    case TInitOriginParams:
        {
            (ptr_InitOriginParams())->~InitOriginParams__tdef();
            break;
        }
    case TClearOriginParams:
        {
            (ptr_ClearOriginParams())->~ClearOriginParams__tdef();
            break;
        }
    case TClearDataParams:
        {
            (ptr_ClearDataParams())->~ClearDataParams__tdef();
            break;
        }
    case TClearAllParams:
        {
            (ptr_ClearAllParams())->~ClearAllParams__tdef();
            break;
        }
    case TResetAllParams:
        {
            (ptr_ResetAllParams())->~ResetAllParams__tdef();
            break;
        }
    case TPersistedParams:
        {
            (ptr_PersistedParams())->~PersistedParams__tdef();
            break;
        }
    case TPersistParams:
        {
            (ptr_PersistParams())->~PersistParams__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT RequestParams::RequestParams(const InitParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitParams()) InitParams(aOther);
    mType = TInitParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(InitParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitParams()) InitParams(std::move(aOther));
    mType = TInitParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const InitOriginParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams(aOther);
    mType = TInitOriginParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(InitOriginParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams(std::move(aOther));
    mType = TInitOriginParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ClearOriginParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams(aOther);
    mType = TClearOriginParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ClearOriginParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams(std::move(aOther));
    mType = TClearOriginParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ClearDataParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams(aOther);
    mType = TClearDataParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ClearDataParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams(std::move(aOther));
    mType = TClearDataParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ClearAllParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams(aOther);
    mType = TClearAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ClearAllParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams(std::move(aOther));
    mType = TClearAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const ResetAllParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams(aOther);
    mType = TResetAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(ResetAllParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams(std::move(aOther));
    mType = TResetAllParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const PersistedParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(aOther);
    mType = TPersistedParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(PersistedParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(std::move(aOther));
    mType = TPersistedParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const PersistParams& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(aOther);
    mType = TPersistParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(PersistParams&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(std::move(aOther));
    mType = TPersistParams;
}

MOZ_IMPLICIT RequestParams::RequestParams(const RequestParams& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TInitParams:
        {
            new (mozilla::KnownNotNull, ptr_InitParams()) InitParams((aOther).get_InitParams());
            break;
        }
    case TInitOriginParams:
        {
            new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams((aOther).get_InitOriginParams());
            break;
        }
    case TClearOriginParams:
        {
            new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams((aOther).get_ClearOriginParams());
            break;
        }
    case TClearDataParams:
        {
            new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams((aOther).get_ClearDataParams());
            break;
        }
    case TClearAllParams:
        {
            new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams((aOther).get_ClearAllParams());
            break;
        }
    case TResetAllParams:
        {
            new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams((aOther).get_ResetAllParams());
            break;
        }
    case TPersistedParams:
        {
            new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams((aOther).get_PersistedParams());
            break;
        }
    case TPersistParams:
        {
            new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams((aOther).get_PersistParams());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT RequestParams::RequestParams(RequestParams&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TInitParams:
        {
            new (mozilla::KnownNotNull, ptr_InitParams()) InitParams(std::move((aOther).get_InitParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TInitOriginParams:
        {
            new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams(std::move((aOther).get_InitOriginParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TClearOriginParams:
        {
            new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams(std::move((aOther).get_ClearOriginParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TClearDataParams:
        {
            new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams(std::move((aOther).get_ClearDataParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TClearAllParams:
        {
            new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams(std::move((aOther).get_ClearAllParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TResetAllParams:
        {
            new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams(std::move((aOther).get_ResetAllParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPersistedParams:
        {
            new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(std::move((aOther).get_PersistedParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPersistParams:
        {
            new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(std::move((aOther).get_PersistParams()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto RequestParams::operator=(const InitParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TInitParams)) {
        new (mozilla::KnownNotNull, ptr_InitParams()) InitParams;
    }
    (*(ptr_InitParams())) = aRhs;
    mType = TInitParams;
    return (*(this));
}

auto RequestParams::operator=(InitParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TInitParams)) {
        new (mozilla::KnownNotNull, ptr_InitParams()) InitParams;
    }
    (*(ptr_InitParams())) = std::move(aRhs);
    mType = TInitParams;
    return (*(this));
}

auto RequestParams::operator=(const InitOriginParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TInitOriginParams)) {
        new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams;
    }
    (*(ptr_InitOriginParams())) = aRhs;
    mType = TInitOriginParams;
    return (*(this));
}

auto RequestParams::operator=(InitOriginParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TInitOriginParams)) {
        new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams;
    }
    (*(ptr_InitOriginParams())) = std::move(aRhs);
    mType = TInitOriginParams;
    return (*(this));
}

auto RequestParams::operator=(const ClearOriginParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TClearOriginParams)) {
        new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams;
    }
    (*(ptr_ClearOriginParams())) = aRhs;
    mType = TClearOriginParams;
    return (*(this));
}

auto RequestParams::operator=(ClearOriginParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TClearOriginParams)) {
        new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams;
    }
    (*(ptr_ClearOriginParams())) = std::move(aRhs);
    mType = TClearOriginParams;
    return (*(this));
}

auto RequestParams::operator=(const ClearDataParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TClearDataParams)) {
        new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams;
    }
    (*(ptr_ClearDataParams())) = aRhs;
    mType = TClearDataParams;
    return (*(this));
}

auto RequestParams::operator=(ClearDataParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TClearDataParams)) {
        new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams;
    }
    (*(ptr_ClearDataParams())) = std::move(aRhs);
    mType = TClearDataParams;
    return (*(this));
}

auto RequestParams::operator=(const ClearAllParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TClearAllParams)) {
        new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams;
    }
    (*(ptr_ClearAllParams())) = aRhs;
    mType = TClearAllParams;
    return (*(this));
}

auto RequestParams::operator=(ClearAllParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TClearAllParams)) {
        new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams;
    }
    (*(ptr_ClearAllParams())) = std::move(aRhs);
    mType = TClearAllParams;
    return (*(this));
}

auto RequestParams::operator=(const ResetAllParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TResetAllParams)) {
        new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams;
    }
    (*(ptr_ResetAllParams())) = aRhs;
    mType = TResetAllParams;
    return (*(this));
}

auto RequestParams::operator=(ResetAllParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TResetAllParams)) {
        new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams;
    }
    (*(ptr_ResetAllParams())) = std::move(aRhs);
    mType = TResetAllParams;
    return (*(this));
}

auto RequestParams::operator=(const PersistedParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TPersistedParams)) {
        new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams;
    }
    (*(ptr_PersistedParams())) = aRhs;
    mType = TPersistedParams;
    return (*(this));
}

auto RequestParams::operator=(PersistedParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TPersistedParams)) {
        new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams;
    }
    (*(ptr_PersistedParams())) = std::move(aRhs);
    mType = TPersistedParams;
    return (*(this));
}

auto RequestParams::operator=(const PersistParams& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TPersistParams)) {
        new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams;
    }
    (*(ptr_PersistParams())) = aRhs;
    mType = TPersistParams;
    return (*(this));
}

auto RequestParams::operator=(PersistParams&& aRhs) -> RequestParams&
{
    if (MaybeDestroy(TPersistParams)) {
        new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams;
    }
    (*(ptr_PersistParams())) = std::move(aRhs);
    mType = TPersistParams;
    return (*(this));
}

auto RequestParams::operator=(const RequestParams& aRhs) -> RequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TInitParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitParams()) InitParams;
            }
            (*(ptr_InitParams())) = (aRhs).get_InitParams();
            break;
        }
    case TInitOriginParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams;
            }
            (*(ptr_InitOriginParams())) = (aRhs).get_InitOriginParams();
            break;
        }
    case TClearOriginParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams;
            }
            (*(ptr_ClearOriginParams())) = (aRhs).get_ClearOriginParams();
            break;
        }
    case TClearDataParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams;
            }
            (*(ptr_ClearDataParams())) = (aRhs).get_ClearDataParams();
            break;
        }
    case TClearAllParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams;
            }
            (*(ptr_ClearAllParams())) = (aRhs).get_ClearAllParams();
            break;
        }
    case TResetAllParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams;
            }
            (*(ptr_ResetAllParams())) = (aRhs).get_ResetAllParams();
            break;
        }
    case TPersistedParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams;
            }
            (*(ptr_PersistedParams())) = (aRhs).get_PersistedParams();
            break;
        }
    case TPersistParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams;
            }
            (*(ptr_PersistParams())) = (aRhs).get_PersistParams();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto RequestParams::operator=(RequestParams&& aRhs) -> RequestParams&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TInitParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitParams()) InitParams;
            }
            (*(ptr_InitParams())) = std::move((aRhs).get_InitParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TInitOriginParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitOriginParams()) InitOriginParams;
            }
            (*(ptr_InitOriginParams())) = std::move((aRhs).get_InitOriginParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TClearOriginParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearOriginParams()) ClearOriginParams;
            }
            (*(ptr_ClearOriginParams())) = std::move((aRhs).get_ClearOriginParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TClearDataParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearDataParams()) ClearDataParams;
            }
            (*(ptr_ClearDataParams())) = std::move((aRhs).get_ClearDataParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TClearAllParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearAllParams()) ClearAllParams;
            }
            (*(ptr_ClearAllParams())) = std::move((aRhs).get_ClearAllParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TResetAllParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ResetAllParams()) ResetAllParams;
            }
            (*(ptr_ResetAllParams())) = std::move((aRhs).get_ResetAllParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPersistedParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams;
            }
            (*(ptr_PersistedParams())) = std::move((aRhs).get_PersistedParams());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPersistParams:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams;
            }
            (*(ptr_PersistParams())) = std::move((aRhs).get_PersistParams());
            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 RequestParams::operator==(const InitParams& aRhs) const -> bool
{
    return (get_InitParams()) == (aRhs);
}

auto RequestParams::operator==(const InitOriginParams& aRhs) const -> bool
{
    return (get_InitOriginParams()) == (aRhs);
}

auto RequestParams::operator==(const ClearOriginParams& aRhs) const -> bool
{
    return (get_ClearOriginParams()) == (aRhs);
}

auto RequestParams::operator==(const ClearDataParams& aRhs) const -> bool
{
    return (get_ClearDataParams()) == (aRhs);
}

auto RequestParams::operator==(const ClearAllParams& aRhs) const -> bool
{
    return (get_ClearAllParams()) == (aRhs);
}

auto RequestParams::operator==(const ResetAllParams& aRhs) const -> bool
{
    return (get_ResetAllParams()) == (aRhs);
}

auto RequestParams::operator==(const PersistedParams& aRhs) const -> bool
{
    return (get_PersistedParams()) == (aRhs);
}

auto RequestParams::operator==(const PersistParams& aRhs) const -> bool
{
    return (get_PersistParams()) == (aRhs);
}

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

    switch (type()) {
    case TInitParams:
        {
            return (get_InitParams()) == ((aRhs).get_InitParams());
        }
    case TInitOriginParams:
        {
            return (get_InitOriginParams()) == ((aRhs).get_InitOriginParams());
        }
    case TClearOriginParams:
        {
            return (get_ClearOriginParams()) == ((aRhs).get_ClearOriginParams());
        }
    case TClearDataParams:
        {
            return (get_ClearDataParams()) == ((aRhs).get_ClearDataParams());
        }
    case TClearAllParams:
        {
            return (get_ClearAllParams()) == ((aRhs).get_ClearAllParams());
        }
    case TResetAllParams:
        {
            return (get_ResetAllParams()) == ((aRhs).get_ResetAllParams());
        }
    case TPersistedParams:
        {
            return (get_PersistedParams()) == ((aRhs).get_PersistedParams());
        }
    case TPersistParams:
        {
            return (get_PersistParams()) == ((aRhs).get_PersistParams());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto RequestParams::get(InitParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_InitParams();
}

auto RequestParams::get(InitOriginParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_InitOriginParams();
}

auto RequestParams::get(ClearOriginParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_ClearOriginParams();
}

auto RequestParams::get(ClearDataParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_ClearDataParams();
}

auto RequestParams::get(ClearAllParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_ClearAllParams();
}

auto RequestParams::get(ResetAllParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_ResetAllParams();
}

auto RequestParams::get(PersistedParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_PersistedParams();
}

auto RequestParams::get(PersistParams* aOutValue) const -> void
{
    (*(aOutValue)) = get_PersistParams();
}

} // namespace quota
} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TInitParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_InitParams());
            // Sentinel = 'TInitParams'
            (aMsg)->WriteSentinel(1465472583);
            return;
        }
    case union__::TInitOriginParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_InitOriginParams());
            // Sentinel = 'TInitOriginParams'
            (aMsg)->WriteSentinel(2172042059);
            return;
        }
    case union__::TClearOriginParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ClearOriginParams());
            // Sentinel = 'TClearOriginParams'
            (aMsg)->WriteSentinel(2428997745);
            return;
        }
    case union__::TClearDataParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ClearDataParams());
            // Sentinel = 'TClearDataParams'
            (aMsg)->WriteSentinel(2645415261);
            return;
        }
    case union__::TClearAllParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ClearAllParams());
            // Sentinel = 'TClearAllParams'
            (aMsg)->WriteSentinel(4218667221);
            return;
        }
    case union__::TResetAllParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ResetAllParams());
            // Sentinel = 'TResetAllParams'
            (aMsg)->WriteSentinel(1597774515);
            return;
        }
    case union__::TPersistedParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_PersistedParams());
            // Sentinel = 'TPersistedParams'
            (aMsg)->WriteSentinel(2151579009);
            return;
        }
    case union__::TPersistParams:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_PersistParams());
            // Sentinel = 'TPersistParams'
            (aMsg)->WriteSentinel(610120232);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TInitParams:
        {
            mozilla::dom::quota::InitParams tmp = mozilla::dom::quota::InitParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_InitParams())))))) {
                (aActor)->FatalError("Error deserializing variant TInitParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TInitParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1465472583)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TInitParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TInitOriginParams:
        {
            mozilla::dom::quota::InitOriginParams tmp = mozilla::dom::quota::InitOriginParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_InitOriginParams())))))) {
                (aActor)->FatalError("Error deserializing variant TInitOriginParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TInitOriginParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2172042059)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TInitOriginParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TClearOriginParams:
        {
            mozilla::dom::quota::ClearOriginParams tmp = mozilla::dom::quota::ClearOriginParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ClearOriginParams())))))) {
                (aActor)->FatalError("Error deserializing variant TClearOriginParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TClearOriginParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2428997745)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TClearOriginParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TClearDataParams:
        {
            mozilla::dom::quota::ClearDataParams tmp = mozilla::dom::quota::ClearDataParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ClearDataParams())))))) {
                (aActor)->FatalError("Error deserializing variant TClearDataParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TClearDataParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2645415261)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TClearDataParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TClearAllParams:
        {
            mozilla::dom::quota::ClearAllParams tmp = mozilla::dom::quota::ClearAllParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ClearAllParams())))))) {
                (aActor)->FatalError("Error deserializing variant TClearAllParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TClearAllParams'
            if ((!((aMsg)->ReadSentinel(aIter, 4218667221)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TClearAllParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TResetAllParams:
        {
            mozilla::dom::quota::ResetAllParams tmp = mozilla::dom::quota::ResetAllParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ResetAllParams())))))) {
                (aActor)->FatalError("Error deserializing variant TResetAllParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TResetAllParams'
            if ((!((aMsg)->ReadSentinel(aIter, 1597774515)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TResetAllParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TPersistedParams:
        {
            mozilla::dom::quota::PersistedParams tmp = mozilla::dom::quota::PersistedParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PersistedParams())))))) {
                (aActor)->FatalError("Error deserializing variant TPersistedParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TPersistedParams'
            if ((!((aMsg)->ReadSentinel(aIter, 2151579009)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPersistedParams of union RequestParams");
                return false;
            }
            return true;
        }
    case union__::TPersistParams:
        {
            mozilla::dom::quota::PersistParams tmp = mozilla::dom::quota::PersistParams();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PersistParams())))))) {
                (aActor)->FatalError("Error deserializing variant TPersistParams of union RequestParams");
                return false;
            }
            // Sentinel = 'TPersistParams'
            if ((!((aMsg)->ReadSentinel(aIter, 610120232)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPersistParams of union RequestParams");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53