/work/obj-fuzz/ipc/ipdl/PQuotaUsageRequest.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/PQuotaUsageRequest.h"

namespace mozilla {
namespace dom {
namespace quota {
namespace PQuotaUsageRequest {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::quota::PQuotaUsageRequestParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::quota::PQuotaUsageRequestChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg_Cancel(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Cancel__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___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 PQuotaUsageRequest
} // namespace quota
} // namespace dom
} // namespace mozilla

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

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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

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

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

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

} // namespace ipc
} // namespace mozilla

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

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

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

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::quota::OriginUsageResponse>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).usage());
    // Sentinel = 'usage'
    (aMsg)->WriteSentinel(3419176504);
    WriteIPDLParam(aMsg, aActor, (aVar).fileUsage());
    // Sentinel = 'fileUsage'
    (aMsg)->WriteSentinel(3321971858);
    WriteIPDLParam(aMsg, aActor, (aVar).limit());
    // Sentinel = 'limit'
    (aMsg)->WriteSentinel(3880566644);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union UsageRequestResponse|
//
namespace mozilla {
namespace dom {
namespace quota {
auto UsageRequestResponse::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 TAllUsageResponse:
        {
            (ptr_AllUsageResponse())->~AllUsageResponse__tdef();
            break;
        }
    case TOriginUsageResponse:
        {
            (ptr_OriginUsageResponse())->~OriginUsageResponse__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

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

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

MOZ_IMPLICIT UsageRequestResponse::UsageRequestResponse(const AllUsageResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse(aOther);
    mType = TAllUsageResponse;
}

MOZ_IMPLICIT UsageRequestResponse::UsageRequestResponse(AllUsageResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse(std::move(aOther));
    mType = TAllUsageResponse;
}

MOZ_IMPLICIT UsageRequestResponse::UsageRequestResponse(const OriginUsageResponse& aOther)
{
    new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse(aOther);
    mType = TOriginUsageResponse;
}

MOZ_IMPLICIT UsageRequestResponse::UsageRequestResponse(OriginUsageResponse&& aOther)
{
    new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse(std::move(aOther));
    mType = TOriginUsageResponse;
}

MOZ_IMPLICIT UsageRequestResponse::UsageRequestResponse(const UsageRequestResponse& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case Tnsresult:
        {
            new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
            break;
        }
    case TAllUsageResponse:
        {
            new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse((aOther).get_AllUsageResponse());
            break;
        }
    case TOriginUsageResponse:
        {
            new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse((aOther).get_OriginUsageResponse());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT UsageRequestResponse::UsageRequestResponse(UsageRequestResponse&& 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 TAllUsageResponse:
        {
            new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse(std::move((aOther).get_AllUsageResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case TOriginUsageResponse:
        {
            new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse(std::move((aOther).get_OriginUsageResponse()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

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

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

auto UsageRequestResponse::operator=(const AllUsageResponse& aRhs) -> UsageRequestResponse&
{
    if (MaybeDestroy(TAllUsageResponse)) {
        new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse;
    }
    (*(ptr_AllUsageResponse())) = aRhs;
    mType = TAllUsageResponse;
    return (*(this));
}

auto UsageRequestResponse::operator=(AllUsageResponse&& aRhs) -> UsageRequestResponse&
{
    if (MaybeDestroy(TAllUsageResponse)) {
        new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse;
    }
    (*(ptr_AllUsageResponse())) = std::move(aRhs);
    mType = TAllUsageResponse;
    return (*(this));
}

auto UsageRequestResponse::operator=(const OriginUsageResponse& aRhs) -> UsageRequestResponse&
{
    if (MaybeDestroy(TOriginUsageResponse)) {
        new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse;
    }
    (*(ptr_OriginUsageResponse())) = aRhs;
    mType = TOriginUsageResponse;
    return (*(this));
}

auto UsageRequestResponse::operator=(OriginUsageResponse&& aRhs) -> UsageRequestResponse&
{
    if (MaybeDestroy(TOriginUsageResponse)) {
        new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse;
    }
    (*(ptr_OriginUsageResponse())) = std::move(aRhs);
    mType = TOriginUsageResponse;
    return (*(this));
}

auto UsageRequestResponse::operator=(const UsageRequestResponse& aRhs) -> UsageRequestResponse&
{
    (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 TAllUsageResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse;
            }
            (*(ptr_AllUsageResponse())) = (aRhs).get_AllUsageResponse();
            break;
        }
    case TOriginUsageResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse;
            }
            (*(ptr_OriginUsageResponse())) = (aRhs).get_OriginUsageResponse();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto UsageRequestResponse::operator=(UsageRequestResponse&& aRhs) -> UsageRequestResponse&
{
    (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 TAllUsageResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_AllUsageResponse()) AllUsageResponse;
            }
            (*(ptr_AllUsageResponse())) = std::move((aRhs).get_AllUsageResponse());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case TOriginUsageResponse:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_OriginUsageResponse()) OriginUsageResponse;
            }
            (*(ptr_OriginUsageResponse())) = std::move((aRhs).get_OriginUsageResponse());
            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 UsageRequestResponse::operator==(const nsresult& aRhs) const -> bool
{
    return (get_nsresult()) == (aRhs);
}

auto UsageRequestResponse::operator==(const AllUsageResponse& aRhs) const -> bool
{
    return (get_AllUsageResponse()) == (aRhs);
}

auto UsageRequestResponse::operator==(const OriginUsageResponse& aRhs) const -> bool
{
    return (get_OriginUsageResponse()) == (aRhs);
}

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

    switch (type()) {
    case Tnsresult:
        {
            return (get_nsresult()) == ((aRhs).get_nsresult());
        }
    case TAllUsageResponse:
        {
            return (get_AllUsageResponse()) == ((aRhs).get_AllUsageResponse());
        }
    case TOriginUsageResponse:
        {
            return (get_OriginUsageResponse()) == ((aRhs).get_OriginUsageResponse());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

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

auto UsageRequestResponse::get(AllUsageResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_AllUsageResponse();
}

auto UsageRequestResponse::get(OriginUsageResponse* aOutValue) const -> void
{
    (*(aOutValue)) = get_OriginUsageResponse();
}

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

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

    switch (type) {
    case union__::Tnsresult:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_nsresult());
            // Sentinel = 'Tnsresult'
            (aMsg)->WriteSentinel(2293764539);
            return;
        }
    case union__::TAllUsageResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_AllUsageResponse());
            // Sentinel = 'TAllUsageResponse'
            (aMsg)->WriteSentinel(3226243202);
            return;
        }
    case union__::TOriginUsageResponse:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_OriginUsageResponse());
            // Sentinel = 'TOriginUsageResponse'
            (aMsg)->WriteSentinel(1702568234);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

auto IPDLParamTraits<mozilla::dom::quota::UsageRequestResponse>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    typedef mozilla::dom::quota::UsageRequestResponse union__;
    int type;
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&(type)))))) {
        (aActor)->FatalError("Error deserializing type of union UsageRequestResponse");
        return false;
    }
    // Sentinel = 'UsageRequestResponse'
    if ((!((aMsg)->ReadSentinel(aIter, 3872348009)))) {
        mozilla::ipc::SentinelReadError("Error deserializing type of union UsageRequestResponse");
        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 UsageRequestResponse");
                return false;
            }
            // Sentinel = 'Tnsresult'
            if ((!((aMsg)->ReadSentinel(aIter, 2293764539)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union UsageRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TAllUsageResponse:
        {
            mozilla::dom::quota::AllUsageResponse tmp = mozilla::dom::quota::AllUsageResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_AllUsageResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TAllUsageResponse of union UsageRequestResponse");
                return false;
            }
            // Sentinel = 'TAllUsageResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 3226243202)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TAllUsageResponse of union UsageRequestResponse");
                return false;
            }
            return true;
        }
    case union__::TOriginUsageResponse:
        {
            mozilla::dom::quota::OriginUsageResponse tmp = mozilla::dom::quota::OriginUsageResponse();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_OriginUsageResponse())))))) {
                (aActor)->FatalError("Error deserializing variant TOriginUsageResponse of union UsageRequestResponse");
                return false;
            }
            // Sentinel = 'TOriginUsageResponse'
            if ((!((aMsg)->ReadSentinel(aIter, 1702568234)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TOriginUsageResponse of union UsageRequestResponse");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53