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

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


#include "mozilla/dom/quota/PQuotaParent.h"
#include "mozilla/dom/quota/PQuotaChild.h"
#include "mozilla/dom/quota/PQuotaRequest.h"

namespace mozilla {
namespace dom {
namespace quota {
namespace PQuotaRequest {

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

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

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

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

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

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

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

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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

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

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RequestResponse|
//
namespace mozilla {
namespace dom {
namespace quota {
auto RequestResponse::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case Tnsresult:
        {
            (ptr_nsresult())->~nsresult__tdef();
            break;
        }
    case TInitResponse:
        {
            (ptr_InitResponse())->~InitResponse__tdef();
            break;
        }
    case TInitOriginResponse:
        {
            (ptr_InitOriginResponse())->~InitOriginResponse__tdef();
            break;
        }
    case TClearOriginResponse:
        {
            (ptr_ClearOriginResponse())->~ClearOriginResponse__tdef();
            break;
        }
    case TClearDataResponse:
        {
            (ptr_ClearDataResponse())->~ClearDataResponse__tdef();
            break;
        }
    case TClearAllResponse:
        {
            (ptr_ClearAllResponse())->~ClearAllResponse__tdef();
            break;
        }
    case TResetAllResponse:
        {
            (ptr_ResetAllResponse())->~ResetAllResponse__tdef();
            break;
        }
    case TPersistedResponse:
        {
            (ptr_PersistedResponse())->~PersistedResponse__tdef();
            break;
        }
    case TPersistResponse:
        {
            (ptr_PersistResponse())->~PersistResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT RequestResponse::RequestResponse(const InitResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse(aOther);
    mType = TInitResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(InitResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse(std::move(aOther));
    mType = TInitResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const InitOriginResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse(aOther);
    mType = TInitOriginResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(InitOriginResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse(std::move(aOther));
    mType = TInitOriginResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ClearOriginResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse(aOther);
    mType = TClearOriginResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ClearOriginResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse(std::move(aOther));
    mType = TClearOriginResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ClearDataResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse(aOther);
    mType = TClearDataResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ClearDataResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse(std::move(aOther));
    mType = TClearDataResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ClearAllResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse(aOther);
    mType = TClearAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ClearAllResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse(std::move(aOther));
    mType = TClearAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const ResetAllResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse(aOther);
    mType = TResetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(ResetAllResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse(std::move(aOther));
    mType = TResetAllResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const PersistedResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse(aOther);
    mType = TPersistedResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(PersistedResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse(std::move(aOther));
    mType = TPersistedResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const PersistResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse(aOther);
    mType = TPersistResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(PersistResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse(std::move(aOther));
    mType = TPersistResponse;
}

MOZ_IMPLICIT RequestResponse::RequestResponse(const RequestResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TInitResponse:
        {
            new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse((aOther).get_InitResponse());
            break;
        }
    case TInitOriginResponse:
        {
            new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse((aOther).get_InitOriginResponse());
            break;
        }
    case TClearOriginResponse:
        {
            new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse((aOther).get_ClearOriginResponse());
            break;
        }
    case TClearDataResponse:
        {
            new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse((aOther).get_ClearDataResponse());
            break;
        }
    case TClearAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse((aOther).get_ClearAllResponse());
            break;
        }
    case TResetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse((aOther).get_ResetAllResponse());
            break;
        }
    case TPersistedResponse:
        {
            new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse((aOther).get_PersistedResponse());
            break;
        }
    case TPersistResponse:
        {
            new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse((aOther).get_PersistResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT RequestResponse::RequestResponse(RequestResponse&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TInitResponse:
        {
            new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse(std::move((aOther).get_InitResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TInitOriginResponse:
        {
            new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse(std::move((aOther).get_InitOriginResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TClearOriginResponse:
        {
            new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse(std::move((aOther).get_ClearOriginResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TClearDataResponse:
        {
            new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse(std::move((aOther).get_ClearDataResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TClearAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse(std::move((aOther).get_ClearAllResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TResetAllResponse:
        {
            new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse(std::move((aOther).get_ResetAllResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPersistedResponse:
        {
            new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse(std::move((aOther).get_PersistedResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TPersistResponse:
        {
            new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse(std::move((aOther).get_PersistResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto RequestResponse::operator=(const InitResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TInitResponse)) {
        new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse;
    }
    (*(ptr_InitResponse())) = aRhs;
    mType = TInitResponse;
    return (*(this));
}

auto RequestResponse::operator=(InitResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TInitResponse)) {
        new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse;
    }
    (*(ptr_InitResponse())) = std::move(aRhs);
    mType = TInitResponse;
    return (*(this));
}

auto RequestResponse::operator=(const InitOriginResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TInitOriginResponse)) {
        new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse;
    }
    (*(ptr_InitOriginResponse())) = aRhs;
    mType = TInitOriginResponse;
    return (*(this));
}

auto RequestResponse::operator=(InitOriginResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TInitOriginResponse)) {
        new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse;
    }
    (*(ptr_InitOriginResponse())) = std::move(aRhs);
    mType = TInitOriginResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ClearOriginResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TClearOriginResponse)) {
        new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse;
    }
    (*(ptr_ClearOriginResponse())) = aRhs;
    mType = TClearOriginResponse;
    return (*(this));
}

auto RequestResponse::operator=(ClearOriginResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TClearOriginResponse)) {
        new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse;
    }
    (*(ptr_ClearOriginResponse())) = std::move(aRhs);
    mType = TClearOriginResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ClearDataResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TClearDataResponse)) {
        new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse;
    }
    (*(ptr_ClearDataResponse())) = aRhs;
    mType = TClearDataResponse;
    return (*(this));
}

auto RequestResponse::operator=(ClearDataResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TClearDataResponse)) {
        new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse;
    }
    (*(ptr_ClearDataResponse())) = std::move(aRhs);
    mType = TClearDataResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ClearAllResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TClearAllResponse)) {
        new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse;
    }
    (*(ptr_ClearAllResponse())) = aRhs;
    mType = TClearAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(ClearAllResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TClearAllResponse)) {
        new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse;
    }
    (*(ptr_ClearAllResponse())) = std::move(aRhs);
    mType = TClearAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(const ResetAllResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TResetAllResponse)) {
        new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse;
    }
    (*(ptr_ResetAllResponse())) = aRhs;
    mType = TResetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(ResetAllResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TResetAllResponse)) {
        new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse;
    }
    (*(ptr_ResetAllResponse())) = std::move(aRhs);
    mType = TResetAllResponse;
    return (*(this));
}

auto RequestResponse::operator=(const PersistedResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TPersistedResponse)) {
        new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse;
    }
    (*(ptr_PersistedResponse())) = aRhs;
    mType = TPersistedResponse;
    return (*(this));
}

auto RequestResponse::operator=(PersistedResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TPersistedResponse)) {
        new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse;
    }
    (*(ptr_PersistedResponse())) = std::move(aRhs);
    mType = TPersistedResponse;
    return (*(this));
}

auto RequestResponse::operator=(const PersistResponse& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TPersistResponse)) {
        new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse;
    }
    (*(ptr_PersistResponse())) = aRhs;
    mType = TPersistResponse;
    return (*(this));
}

auto RequestResponse::operator=(PersistResponse&& aRhs) -> RequestResponse&
{
    if (MaybeDestroy(TPersistResponse)) {
        new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse;
    }
    (*(ptr_PersistResponse())) = std::move(aRhs);
    mType = TPersistResponse;
    return (*(this));
}

auto RequestResponse::operator=(const RequestResponse& aRhs) -> RequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = (aRhs).get_nsresult();
            break;
        }
    case TInitResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse;
            }
            (*(ptr_InitResponse())) = (aRhs).get_InitResponse();
            break;
        }
    case TInitOriginResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse;
            }
            (*(ptr_InitOriginResponse())) = (aRhs).get_InitOriginResponse();
            break;
        }
    case TClearOriginResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse;
            }
            (*(ptr_ClearOriginResponse())) = (aRhs).get_ClearOriginResponse();
            break;
        }
    case TClearDataResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse;
            }
            (*(ptr_ClearDataResponse())) = (aRhs).get_ClearDataResponse();
            break;
        }
    case TClearAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse;
            }
            (*(ptr_ClearAllResponse())) = (aRhs).get_ClearAllResponse();
            break;
        }
    case TResetAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse;
            }
            (*(ptr_ResetAllResponse())) = (aRhs).get_ResetAllResponse();
            break;
        }
    case TPersistedResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse;
            }
            (*(ptr_PersistedResponse())) = (aRhs).get_PersistedResponse();
            break;
        }
    case TPersistResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse;
            }
            (*(ptr_PersistResponse())) = (aRhs).get_PersistResponse();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto RequestResponse::operator=(RequestResponse&& aRhs) -> RequestResponse&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case Tnsresult:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_nsresult()) nsresult;
            }
            (*(ptr_nsresult())) = std::move((aRhs).get_nsresult());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TInitResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitResponse()) InitResponse;
            }
            (*(ptr_InitResponse())) = std::move((aRhs).get_InitResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TInitOriginResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_InitOriginResponse()) InitOriginResponse;
            }
            (*(ptr_InitOriginResponse())) = std::move((aRhs).get_InitOriginResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TClearOriginResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearOriginResponse()) ClearOriginResponse;
            }
            (*(ptr_ClearOriginResponse())) = std::move((aRhs).get_ClearOriginResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TClearDataResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearDataResponse()) ClearDataResponse;
            }
            (*(ptr_ClearDataResponse())) = std::move((aRhs).get_ClearDataResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TClearAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ClearAllResponse()) ClearAllResponse;
            }
            (*(ptr_ClearAllResponse())) = std::move((aRhs).get_ClearAllResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TResetAllResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_ResetAllResponse()) ResetAllResponse;
            }
            (*(ptr_ResetAllResponse())) = std::move((aRhs).get_ResetAllResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPersistedResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistedResponse()) PersistedResponse;
            }
            (*(ptr_PersistedResponse())) = std::move((aRhs).get_PersistedResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TPersistResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_PersistResponse()) PersistResponse;
            }
            (*(ptr_PersistResponse())) = std::move((aRhs).get_PersistResponse());
            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 RequestResponse::operator==(const nsresult& aRhs) const -> bool
{
    return (get_nsresult()) == (aRhs);
}

auto RequestResponse::operator==(const InitResponse& aRhs) const -> bool
{
    return (get_InitResponse()) == (aRhs);
}

auto RequestResponse::operator==(const InitOriginResponse& aRhs) const -> bool
{
    return (get_InitOriginResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ClearOriginResponse& aRhs) const -> bool
{
    return (get_ClearOriginResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ClearDataResponse& aRhs) const -> bool
{
    return (get_ClearDataResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ClearAllResponse& aRhs) const -> bool
{
    return (get_ClearAllResponse()) == (aRhs);
}

auto RequestResponse::operator==(const ResetAllResponse& aRhs) const -> bool
{
    return (get_ResetAllResponse()) == (aRhs);
}

auto RequestResponse::operator==(const PersistedResponse& aRhs) const -> bool
{
    return (get_PersistedResponse()) == (aRhs);
}

auto RequestResponse::operator==(const PersistResponse& aRhs) const -> bool
{
    return (get_PersistResponse()) == (aRhs);
}

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

    switch (type()) {
    case Tnsresult:
        {
            return (get_nsresult()) == ((aRhs).get_nsresult());
        }
    case TInitResponse:
        {
            return (get_InitResponse()) == ((aRhs).get_InitResponse());
        }
    case TInitOriginResponse:
        {
            return (get_InitOriginResponse()) == ((aRhs).get_InitOriginResponse());
        }
    case TClearOriginResponse:
        {
            return (get_ClearOriginResponse()) == ((aRhs).get_ClearOriginResponse());
        }
    case TClearDataResponse:
        {
            return (get_ClearDataResponse()) == ((aRhs).get_ClearDataResponse());
        }
    case TClearAllResponse:
        {
            return (get_ClearAllResponse()) == ((aRhs).get_ClearAllResponse());
        }
    case TResetAllResponse:
        {
            return (get_ResetAllResponse()) == ((aRhs).get_ResetAllResponse());
        }
    case TPersistedResponse:
        {
            return (get_PersistedResponse()) == ((aRhs).get_PersistedResponse());
        }
    case TPersistResponse:
        {
            return (get_PersistResponse()) == ((aRhs).get_PersistResponse());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

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

auto RequestResponse::get(InitResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_InitResponse();
}

auto RequestResponse::get(InitOriginResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_InitOriginResponse();
}

auto RequestResponse::get(ClearOriginResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ClearOriginResponse();
}

auto RequestResponse::get(ClearDataResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ClearDataResponse();
}

auto RequestResponse::get(ClearAllResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ClearAllResponse();
}

auto RequestResponse::get(ResetAllResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_ResetAllResponse();
}

auto RequestResponse::get(PersistedResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_PersistedResponse();
}

auto RequestResponse::get(PersistResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_PersistResponse();
}

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

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

    switch (type) {
    case union__::Tnsresult:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aMsg)->WriteSentinel(2293764539);
            return;
        }
    case union__::TInitResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_InitResponse());
            // Sentinel = 'TInitResponse'
            (aMsg)->WriteSentinel(941770198);
            return;
        }
    case union__::TInitOriginResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_InitOriginResponse());
            // Sentinel = 'TInitOriginResponse'
            (aMsg)->WriteSentinel(3039434590);
            return;
        }
    case union__::TClearOriginResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ClearOriginResponse());
            // Sentinel = 'TClearOriginResponse'
            (aMsg)->WriteSentinel(2032369236);
            return;
        }
    case union__::TClearDataResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ClearDataResponse());
            // Sentinel = 'TClearDataResponse'
            (aMsg)->WriteSentinel(1322469308);
            return;
        }
    case union__::TClearAllResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ClearAllResponse());
            // Sentinel = 'TClearAllResponse'
            (aMsg)->WriteSentinel(2851178716);
            return;
        }
    case union__::TResetAllResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_ResetAllResponse());
            // Sentinel = 'TResetAllResponse'
            (aMsg)->WriteSentinel(706855290);
            return;
        }
    case union__::TPersistedResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_PersistedResponse());
            // Sentinel = 'TPersistedResponse'
            (aMsg)->WriteSentinel(1830900968);
            return;
        }
    case union__::TPersistResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_PersistResponse());
            // Sentinel = 'TPersistResponse'
            (aMsg)->WriteSentinel(3249867633);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::Tnsresult:
        {
            nsresult tmp = nsresult();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_nsresult())))))) {
                (aActor)->FatalError("Error deserializing variant Tnsresult of union RequestResponse");
                return false;
            }
            // Sentinel = 'Tnsresult'
            if ((!((aMsg)->ReadSentinel(aIter, 2293764539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TInitResponse:
        {
            mozilla::dom::quota::InitResponse tmp = mozilla::dom::quota::InitResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_InitResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TInitResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TInitResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 941770198)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TInitResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TInitOriginResponse:
        {
            mozilla::dom::quota::InitOriginResponse tmp = mozilla::dom::quota::InitOriginResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_InitOriginResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TInitOriginResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TInitOriginResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3039434590)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TInitOriginResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TClearOriginResponse:
        {
            mozilla::dom::quota::ClearOriginResponse tmp = mozilla::dom::quota::ClearOriginResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ClearOriginResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TClearOriginResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TClearOriginResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 2032369236)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TClearOriginResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TClearDataResponse:
        {
            mozilla::dom::quota::ClearDataResponse tmp = mozilla::dom::quota::ClearDataResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ClearDataResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TClearDataResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TClearDataResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1322469308)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TClearDataResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TClearAllResponse:
        {
            mozilla::dom::quota::ClearAllResponse tmp = mozilla::dom::quota::ClearAllResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ClearAllResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TClearAllResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TClearAllResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 2851178716)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TClearAllResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TResetAllResponse:
        {
            mozilla::dom::quota::ResetAllResponse tmp = mozilla::dom::quota::ResetAllResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_ResetAllResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TResetAllResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TResetAllResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 706855290)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TResetAllResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TPersistedResponse:
        {
            mozilla::dom::quota::PersistedResponse tmp = mozilla::dom::quota::PersistedResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PersistedResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TPersistedResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TPersistedResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1830900968)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPersistedResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    case union__::TPersistResponse:
        {
            mozilla::dom::quota::PersistResponse tmp = mozilla::dom::quota::PersistResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_PersistResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TPersistResponse of union RequestResponse");
                return false;
            }
            // Sentinel = 'TPersistResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3249867633)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TPersistResponse of union RequestResponse");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53