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

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


#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/dom/PWebAuthnTransaction.h"

namespace mozilla {
namespace dom {
namespace PWebAuthnTransaction {

nsresult
CreateEndpoints(
        base::ProcessId aParentDestPid,
        base::ProcessId aChildDestPid,
        mozilla::ipc::Endpoint<mozilla::dom::PWebAuthnTransactionParent>* aParent,
        mozilla::ipc::Endpoint<mozilla::dom::PWebAuthnTransactionChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(mozilla::ipc::PrivateIPDLInterface(), aParentDestPid, aChildDestPid, aParent, aChild);
}
IPC::Message*
Msg_RequestRegister(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestRegister__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_RequestSign(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestSign__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_RequestCancel(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_RequestCancel__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_DestroyMe(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_DestroyMe__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));
}
IPC::Message*
Msg_ConfirmRegister(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ConfirmRegister__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_ConfirmSign(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ConfirmSign__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_Abort(int32_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Abort__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 PWebAuthnTransaction
} // namespace dom
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnAuthenticatorSelection>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).requireResidentKey());
    // Sentinel = 'requireResidentKey'
    (aMsg)->WriteSentinel(3038925224);
    WriteIPDLParam(aMsg, aActor, (aVar).requireUserVerification());
    // Sentinel = 'requireUserVerification'
    (aMsg)->WriteSentinel(2015890210);
    WriteIPDLParam(aMsg, aActor, (aVar).requirePlatformAttachment());
    // Sentinel = 'requirePlatformAttachment'
    (aMsg)->WriteSentinel(1002097742);
}

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnScopedCredential>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).id());
    // Sentinel = 'id'
    (aMsg)->WriteSentinel(2794505629);
    WriteIPDLParam(aMsg, aActor, (aVar).transports());
    // Sentinel = 'transports'
    (aMsg)->WriteSentinel(4259540988);
}

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

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebAuthnExtension|
//
namespace mozilla {
namespace dom {
auto WebAuthnExtension::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TWebAuthnExtensionAppId:
        {
            (ptr_WebAuthnExtensionAppId())->~WebAuthnExtensionAppId__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtensionAppId& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId(aOther);
    mType = TWebAuthnExtensionAppId;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtensionAppId&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId(std::move(aOther));
    mType = TWebAuthnExtensionAppId;
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(const WebAuthnExtension& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TWebAuthnExtensionAppId:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId((aOther).get_WebAuthnExtensionAppId());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnExtension::WebAuthnExtension(WebAuthnExtension&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TWebAuthnExtensionAppId:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId(std::move((aOther).get_WebAuthnExtensionAppId()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebAuthnExtension::operator=(const WebAuthnExtensionAppId& aRhs) -> WebAuthnExtension&
{
    if (MaybeDestroy(TWebAuthnExtensionAppId)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId;
    }
    (*(ptr_WebAuthnExtensionAppId())) = aRhs;
    mType = TWebAuthnExtensionAppId;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtensionAppId&& aRhs) -> WebAuthnExtension&
{
    if (MaybeDestroy(TWebAuthnExtensionAppId)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId;
    }
    (*(ptr_WebAuthnExtensionAppId())) = std::move(aRhs);
    mType = TWebAuthnExtensionAppId;
    return (*(this));
}

auto WebAuthnExtension::operator=(const WebAuthnExtension& aRhs) -> WebAuthnExtension&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionAppId:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId;
            }
            (*(ptr_WebAuthnExtensionAppId())) = (aRhs).get_WebAuthnExtensionAppId();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebAuthnExtension::operator=(WebAuthnExtension&& aRhs) -> WebAuthnExtension&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionAppId:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnExtensionAppId()) WebAuthnExtensionAppId;
            }
            (*(ptr_WebAuthnExtensionAppId())) = std::move((aRhs).get_WebAuthnExtensionAppId());
            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 WebAuthnExtension::operator==(const WebAuthnExtensionAppId& aRhs) const -> bool
{
    return (get_WebAuthnExtensionAppId()) == (aRhs);
}

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

    switch (type()) {
    case TWebAuthnExtensionAppId:
        {
            return (get_WebAuthnExtensionAppId()) == ((aRhs).get_WebAuthnExtensionAppId());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto WebAuthnExtension::get(WebAuthnExtensionAppId* aOutValue) const -> void
{
    (*(aOutValue)) = get_WebAuthnExtensionAppId();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TWebAuthnExtensionAppId:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_WebAuthnExtensionAppId());
            // Sentinel = 'TWebAuthnExtensionAppId'
            (aMsg)->WriteSentinel(3592414022);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TWebAuthnExtensionAppId:
        {
            mozilla::dom::WebAuthnExtensionAppId tmp = mozilla::dom::WebAuthnExtensionAppId();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_WebAuthnExtensionAppId())))))) {
                (aActor)->FatalError("Error deserializing variant TWebAuthnExtensionAppId of union WebAuthnExtension");
                return false;
            }
            // Sentinel = 'TWebAuthnExtensionAppId'
            if ((!((aMsg)->ReadSentinel(aIter, 3592414022)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TWebAuthnExtensionAppId of union WebAuthnExtension");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

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

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebAuthnExtensionResult|
//
namespace mozilla {
namespace dom {
auto WebAuthnExtensionResult::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TWebAuthnExtensionResultAppId:
        {
            (ptr_WebAuthnExtensionResultAppId())->~WebAuthnExtensionResultAppId__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResultAppId& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(aOther);
    mType = TWebAuthnExtensionResultAppId;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResultAppId&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(std::move(aOther));
    mType = TWebAuthnExtensionResultAppId;
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(const WebAuthnExtensionResult& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TWebAuthnExtensionResultAppId:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId((aOther).get_WebAuthnExtensionResultAppId());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnExtensionResult::WebAuthnExtensionResult(WebAuthnExtensionResult&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TWebAuthnExtensionResultAppId:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId(std::move((aOther).get_WebAuthnExtensionResultAppId()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResultAppId& aRhs) -> WebAuthnExtensionResult&
{
    if (MaybeDestroy(TWebAuthnExtensionResultAppId)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId;
    }
    (*(ptr_WebAuthnExtensionResultAppId())) = aRhs;
    mType = TWebAuthnExtensionResultAppId;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResultAppId&& aRhs) -> WebAuthnExtensionResult&
{
    if (MaybeDestroy(TWebAuthnExtensionResultAppId)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId;
    }
    (*(ptr_WebAuthnExtensionResultAppId())) = std::move(aRhs);
    mType = TWebAuthnExtensionResultAppId;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(const WebAuthnExtensionResult& aRhs) -> WebAuthnExtensionResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionResultAppId:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId;
            }
            (*(ptr_WebAuthnExtensionResultAppId())) = (aRhs).get_WebAuthnExtensionResultAppId();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebAuthnExtensionResult::operator=(WebAuthnExtensionResult&& aRhs) -> WebAuthnExtensionResult&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnExtensionResultAppId:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnExtensionResultAppId()) WebAuthnExtensionResultAppId;
            }
            (*(ptr_WebAuthnExtensionResultAppId())) = std::move((aRhs).get_WebAuthnExtensionResultAppId());
            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 WebAuthnExtensionResult::operator==(const WebAuthnExtensionResultAppId& aRhs) const -> bool
{
    return (get_WebAuthnExtensionResultAppId()) == (aRhs);
}

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

    switch (type()) {
    case TWebAuthnExtensionResultAppId:
        {
            return (get_WebAuthnExtensionResultAppId()) == ((aRhs).get_WebAuthnExtensionResultAppId());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto WebAuthnExtensionResult::get(WebAuthnExtensionResultAppId* aOutValue) const -> void
{
    (*(aOutValue)) = get_WebAuthnExtensionResultAppId();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TWebAuthnExtensionResultAppId:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_WebAuthnExtensionResultAppId());
            // Sentinel = 'TWebAuthnExtensionResultAppId'
            (aMsg)->WriteSentinel(2012059377);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TWebAuthnExtensionResultAppId:
        {
            mozilla::dom::WebAuthnExtensionResultAppId tmp = mozilla::dom::WebAuthnExtensionResultAppId();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_WebAuthnExtensionResultAppId())))))) {
                (aActor)->FatalError("Error deserializing variant TWebAuthnExtensionResultAppId of union WebAuthnExtensionResult");
                return false;
            }
            // Sentinel = 'TWebAuthnExtensionResultAppId'
            if ((!((aMsg)->ReadSentinel(aIter, 2012059377)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TWebAuthnExtensionResultAppId of union WebAuthnExtensionResult");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnMakeCredentialExtraInfo>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aMsg)->WriteSentinel(77077076);
    WriteIPDLParam(aMsg, aActor, (aVar).AuthenticatorSelection());
    // Sentinel = 'AuthenticatorSelection'
    (aMsg)->WriteSentinel(2526840071);
    WriteIPDLParam(aMsg, aActor, (aVar).RequestDirectAttestation());
    // Sentinel = 'RequestDirectAttestation'
    (aMsg)->WriteSentinel(3849338194);
}

auto IPDLParamTraits<mozilla::dom::WebAuthnMakeCredentialExtraInfo>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Extensions())))))) {
        (aActor)->FatalError("Error deserializing 'Extensions' (WebAuthnExtension[]) member of 'WebAuthnMakeCredentialExtraInfo'");
        return false;
    }
    // Sentinel = 'Extensions'
    if ((!((aMsg)->ReadSentinel(aIter, 77077076)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extensions' (WebAuthnExtension[]) member of 'WebAuthnMakeCredentialExtraInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->AuthenticatorSelection())))))) {
        (aActor)->FatalError("Error deserializing 'AuthenticatorSelection' (WebAuthnAuthenticatorSelection) member of 'WebAuthnMakeCredentialExtraInfo'");
        return false;
    }
    // Sentinel = 'AuthenticatorSelection'
    if ((!((aMsg)->ReadSentinel(aIter, 2526840071)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AuthenticatorSelection' (WebAuthnAuthenticatorSelection) member of 'WebAuthnMakeCredentialExtraInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->RequestDirectAttestation())))))) {
        (aActor)->FatalError("Error deserializing 'RequestDirectAttestation' (bool) member of 'WebAuthnMakeCredentialExtraInfo'");
        return false;
    }
    // Sentinel = 'RequestDirectAttestation'
    if ((!((aMsg)->ReadSentinel(aIter, 3849338194)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RequestDirectAttestation' (bool) member of 'WebAuthnMakeCredentialExtraInfo'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebAuthnMaybeMakeCredentialExtraInfo|
//
namespace mozilla {
namespace dom {
auto WebAuthnMaybeMakeCredentialExtraInfo::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TWebAuthnMakeCredentialExtraInfo:
        {
            (ptr_WebAuthnMakeCredentialExtraInfo())->~WebAuthnMakeCredentialExtraInfo__tdef();
            break;
        }
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT WebAuthnMaybeMakeCredentialExtraInfo::WebAuthnMaybeMakeCredentialExtraInfo(const WebAuthnMakeCredentialExtraInfo& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo(aOther);
    mType = TWebAuthnMakeCredentialExtraInfo;
}

MOZ_IMPLICIT WebAuthnMaybeMakeCredentialExtraInfo::WebAuthnMaybeMakeCredentialExtraInfo(WebAuthnMakeCredentialExtraInfo&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo(std::move(aOther));
    mType = TWebAuthnMakeCredentialExtraInfo;
}

MOZ_IMPLICIT WebAuthnMaybeMakeCredentialExtraInfo::WebAuthnMaybeMakeCredentialExtraInfo(const null_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
    mType = Tnull_t;
}

MOZ_IMPLICIT WebAuthnMaybeMakeCredentialExtraInfo::WebAuthnMaybeMakeCredentialExtraInfo(null_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
    mType = Tnull_t;
}

MOZ_IMPLICIT WebAuthnMaybeMakeCredentialExtraInfo::WebAuthnMaybeMakeCredentialExtraInfo(const WebAuthnMaybeMakeCredentialExtraInfo& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TWebAuthnMakeCredentialExtraInfo:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo((aOther).get_WebAuthnMakeCredentialExtraInfo());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnMaybeMakeCredentialExtraInfo::WebAuthnMaybeMakeCredentialExtraInfo(WebAuthnMaybeMakeCredentialExtraInfo&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TWebAuthnMakeCredentialExtraInfo:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo(std::move((aOther).get_WebAuthnMakeCredentialExtraInfo()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebAuthnMaybeMakeCredentialExtraInfo::operator=(const WebAuthnMakeCredentialExtraInfo& aRhs) -> WebAuthnMaybeMakeCredentialExtraInfo&
{
    if (MaybeDestroy(TWebAuthnMakeCredentialExtraInfo)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo;
    }
    (*(ptr_WebAuthnMakeCredentialExtraInfo())) = aRhs;
    mType = TWebAuthnMakeCredentialExtraInfo;
    return (*(this));
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator=(WebAuthnMakeCredentialExtraInfo&& aRhs) -> WebAuthnMaybeMakeCredentialExtraInfo&
{
    if (MaybeDestroy(TWebAuthnMakeCredentialExtraInfo)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo;
    }
    (*(ptr_WebAuthnMakeCredentialExtraInfo())) = std::move(aRhs);
    mType = TWebAuthnMakeCredentialExtraInfo;
    return (*(this));
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator=(const null_t& aRhs) -> WebAuthnMaybeMakeCredentialExtraInfo&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = aRhs;
    mType = Tnull_t;
    return (*(this));
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator=(null_t&& aRhs) -> WebAuthnMaybeMakeCredentialExtraInfo&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = std::move(aRhs);
    mType = Tnull_t;
    return (*(this));
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator=(const WebAuthnMaybeMakeCredentialExtraInfo& aRhs) -> WebAuthnMaybeMakeCredentialExtraInfo&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnMakeCredentialExtraInfo:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo;
            }
            (*(ptr_WebAuthnMakeCredentialExtraInfo())) = (aRhs).get_WebAuthnMakeCredentialExtraInfo();
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator=(WebAuthnMaybeMakeCredentialExtraInfo&& aRhs) -> WebAuthnMaybeMakeCredentialExtraInfo&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnMakeCredentialExtraInfo:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnMakeCredentialExtraInfo()) WebAuthnMakeCredentialExtraInfo;
            }
            (*(ptr_WebAuthnMakeCredentialExtraInfo())) = std::move((aRhs).get_WebAuthnMakeCredentialExtraInfo());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator==(const WebAuthnMakeCredentialExtraInfo& aRhs) const -> bool
{
    return (get_WebAuthnMakeCredentialExtraInfo()) == (aRhs);
}

auto WebAuthnMaybeMakeCredentialExtraInfo::operator==(const null_t& aRhs) const -> bool
{
    return (get_null_t()) == (aRhs);
}

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

    switch (type()) {
    case TWebAuthnMakeCredentialExtraInfo:
        {
            return (get_WebAuthnMakeCredentialExtraInfo()) == ((aRhs).get_WebAuthnMakeCredentialExtraInfo());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto WebAuthnMaybeMakeCredentialExtraInfo::get(WebAuthnMakeCredentialExtraInfo* aOutValue) const -> void
{
    (*(aOutValue)) = get_WebAuthnMakeCredentialExtraInfo();
}

auto WebAuthnMaybeMakeCredentialExtraInfo::get(null_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_null_t();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TWebAuthnMakeCredentialExtraInfo:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_WebAuthnMakeCredentialExtraInfo());
            // Sentinel = 'TWebAuthnMakeCredentialExtraInfo'
            (aMsg)->WriteSentinel(2897113167);
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TWebAuthnMakeCredentialExtraInfo:
        {
            mozilla::dom::WebAuthnMakeCredentialExtraInfo tmp = mozilla::dom::WebAuthnMakeCredentialExtraInfo();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_WebAuthnMakeCredentialExtraInfo())))))) {
                (aActor)->FatalError("Error deserializing variant TWebAuthnMakeCredentialExtraInfo of union WebAuthnMaybeMakeCredentialExtraInfo");
                return false;
            }
            // Sentinel = 'TWebAuthnMakeCredentialExtraInfo'
            if ((!((aMsg)->ReadSentinel(aIter, 2897113167)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TWebAuthnMakeCredentialExtraInfo of union WebAuthnMaybeMakeCredentialExtraInfo");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union WebAuthnMaybeMakeCredentialExtraInfo");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union WebAuthnMaybeMakeCredentialExtraInfo");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct WebAuthnMakeCredentialInfo|
//
namespace mozilla {
namespace dom {
auto WebAuthnMakeCredentialInfo::operator==(const WebAuthnMakeCredentialInfo& _o) const -> bool
{
    if ((!((Origin()) == ((_o).Origin())))) {
        return false;
    }
    if ((!((RpId()) == ((_o).RpId())))) {
        return false;
    }
    if ((!((Challenge()) == ((_o).Challenge())))) {
        return false;
    }
    if ((!((ClientDataJSON()) == ((_o).ClientDataJSON())))) {
        return false;
    }
    if ((!((TimeoutMS()) == ((_o).TimeoutMS())))) {
        return false;
    }
    if ((!((ExcludeList()) == ((_o).ExcludeList())))) {
        return false;
    }
    if ((!((Extra()) == ((_o).Extra())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnMakeCredentialInfo>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).Origin());
    // Sentinel = 'Origin'
    (aMsg)->WriteSentinel(4053590112);
    WriteIPDLParam(aMsg, aActor, (aVar).RpId());
    // Sentinel = 'RpId'
    (aMsg)->WriteSentinel(2688815153);
    WriteIPDLParam(aMsg, aActor, (aVar).Challenge());
    // Sentinel = 'Challenge'
    (aMsg)->WriteSentinel(1381253706);
    WriteIPDLParam(aMsg, aActor, (aVar).ClientDataJSON());
    // Sentinel = 'ClientDataJSON'
    (aMsg)->WriteSentinel(3518101945);
    WriteIPDLParam(aMsg, aActor, (aVar).TimeoutMS());
    // Sentinel = 'TimeoutMS'
    (aMsg)->WriteSentinel(2549274784);
    WriteIPDLParam(aMsg, aActor, (aVar).ExcludeList());
    // Sentinel = 'ExcludeList'
    (aMsg)->WriteSentinel(2628186121);
    WriteIPDLParam(aMsg, aActor, (aVar).Extra());
    // Sentinel = 'Extra'
    (aMsg)->WriteSentinel(2419867879);
}

auto IPDLParamTraits<mozilla::dom::WebAuthnMakeCredentialInfo>::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' (nsString) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'Origin'
    if ((!((aMsg)->ReadSentinel(aIter, 4053590112)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Origin' (nsString) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->RpId())))))) {
        (aActor)->FatalError("Error deserializing 'RpId' (nsString) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'RpId'
    if ((!((aMsg)->ReadSentinel(aIter, 2688815153)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RpId' (nsString) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Challenge())))))) {
        (aActor)->FatalError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'Challenge'
    if ((!((aMsg)->ReadSentinel(aIter, 1381253706)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ClientDataJSON())))))) {
        (aActor)->FatalError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'ClientDataJSON'
    if ((!((aMsg)->ReadSentinel(aIter, 3518101945)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->TimeoutMS())))))) {
        (aActor)->FatalError("Error deserializing 'TimeoutMS' (uint32_t) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'TimeoutMS'
    if ((!((aMsg)->ReadSentinel(aIter, 2549274784)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TimeoutMS' (uint32_t) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ExcludeList())))))) {
        (aActor)->FatalError("Error deserializing 'ExcludeList' (WebAuthnScopedCredential[]) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'ExcludeList'
    if ((!((aMsg)->ReadSentinel(aIter, 2628186121)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ExcludeList' (WebAuthnScopedCredential[]) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Extra())))))) {
        (aActor)->FatalError("Error deserializing 'Extra' (WebAuthnMaybeMakeCredentialExtraInfo) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    // Sentinel = 'Extra'
    if ((!((aMsg)->ReadSentinel(aIter, 2419867879)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extra' (WebAuthnMaybeMakeCredentialExtraInfo) member of 'WebAuthnMakeCredentialInfo'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnMakeCredentialResult>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).ClientDataJSON());
    // Sentinel = 'ClientDataJSON'
    (aMsg)->WriteSentinel(3518101945);
    WriteIPDLParam(aMsg, aActor, (aVar).AttestationObject());
    // Sentinel = 'AttestationObject'
    (aMsg)->WriteSentinel(4271776302);
    WriteIPDLParam(aMsg, aActor, (aVar).KeyHandle());
    // Sentinel = 'KeyHandle'
    (aMsg)->WriteSentinel(2245515378);
    WriteIPDLParam(aMsg, aActor, (aVar).RegistrationData());
    // Sentinel = 'RegistrationData'
    (aMsg)->WriteSentinel(4070002651);
}

auto IPDLParamTraits<mozilla::dom::WebAuthnMakeCredentialResult>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ClientDataJSON())))))) {
        (aActor)->FatalError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    // Sentinel = 'ClientDataJSON'
    if ((!((aMsg)->ReadSentinel(aIter, 3518101945)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->AttestationObject())))))) {
        (aActor)->FatalError("Error deserializing 'AttestationObject' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    // Sentinel = 'AttestationObject'
    if ((!((aMsg)->ReadSentinel(aIter, 4271776302)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AttestationObject' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->KeyHandle())))))) {
        (aActor)->FatalError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    // Sentinel = 'KeyHandle'
    if ((!((aMsg)->ReadSentinel(aIter, 2245515378)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->RegistrationData())))))) {
        (aActor)->FatalError("Error deserializing 'RegistrationData' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    // Sentinel = 'RegistrationData'
    if ((!((aMsg)->ReadSentinel(aIter, 4070002651)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RegistrationData' (uint8_t[]) member of 'WebAuthnMakeCredentialResult'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

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

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnGetAssertionExtraInfo>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aMsg)->WriteSentinel(77077076);
    WriteIPDLParam(aMsg, aActor, (aVar).RequireUserVerification());
    // Sentinel = 'RequireUserVerification'
    (aMsg)->WriteSentinel(1708769026);
}

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

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union WebAuthnMaybeGetAssertionExtraInfo|
//
namespace mozilla {
namespace dom {
auto WebAuthnMaybeGetAssertionExtraInfo::MaybeDestroy(Type aNewType) -> bool
{
    if ((mType) == (T__None)) {
        return true;
    }
    if ((mType) == (aNewType)) {
        return false;
    }
    switch (mType) {
    case TWebAuthnGetAssertionExtraInfo:
        {
            (ptr_WebAuthnGetAssertionExtraInfo())->~WebAuthnGetAssertionExtraInfo__tdef();
            break;
        }
    case Tnull_t:
        {
            (ptr_null_t())->~null_t__tdef();
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("not reached");
            break;
        }
    }
    return true;
}

MOZ_IMPLICIT WebAuthnMaybeGetAssertionExtraInfo::WebAuthnMaybeGetAssertionExtraInfo(const WebAuthnGetAssertionExtraInfo& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo(aOther);
    mType = TWebAuthnGetAssertionExtraInfo;
}

MOZ_IMPLICIT WebAuthnMaybeGetAssertionExtraInfo::WebAuthnMaybeGetAssertionExtraInfo(WebAuthnGetAssertionExtraInfo&& aOther)
{
    new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo(std::move(aOther));
    mType = TWebAuthnGetAssertionExtraInfo;
}

MOZ_IMPLICIT WebAuthnMaybeGetAssertionExtraInfo::WebAuthnMaybeGetAssertionExtraInfo(const null_t& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
    mType = Tnull_t;
}

MOZ_IMPLICIT WebAuthnMaybeGetAssertionExtraInfo::WebAuthnMaybeGetAssertionExtraInfo(null_t&& aOther)
{
    new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
    mType = Tnull_t;
}

MOZ_IMPLICIT WebAuthnMaybeGetAssertionExtraInfo::WebAuthnMaybeGetAssertionExtraInfo(const WebAuthnMaybeGetAssertionExtraInfo& aOther)
{
    (aOther).AssertSanity();
    switch ((aOther).type()) {
    case TWebAuthnGetAssertionExtraInfo:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo((aOther).get_WebAuthnGetAssertionExtraInfo());
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    mType = (aOther).type();
}

MOZ_IMPLICIT WebAuthnMaybeGetAssertionExtraInfo::WebAuthnMaybeGetAssertionExtraInfo(WebAuthnMaybeGetAssertionExtraInfo&& aOther)
{
    (aOther).AssertSanity();
    Type t = (aOther).type();
    switch (t) {
    case TWebAuthnGetAssertionExtraInfo:
        {
            new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo(std::move((aOther).get_WebAuthnGetAssertionExtraInfo()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
            static_cast<void>((aOther).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return;
        }
    }
    (aOther).mType = T__None;
    mType = t;
}

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

auto WebAuthnMaybeGetAssertionExtraInfo::operator=(const WebAuthnGetAssertionExtraInfo& aRhs) -> WebAuthnMaybeGetAssertionExtraInfo&
{
    if (MaybeDestroy(TWebAuthnGetAssertionExtraInfo)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo;
    }
    (*(ptr_WebAuthnGetAssertionExtraInfo())) = aRhs;
    mType = TWebAuthnGetAssertionExtraInfo;
    return (*(this));
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator=(WebAuthnGetAssertionExtraInfo&& aRhs) -> WebAuthnMaybeGetAssertionExtraInfo&
{
    if (MaybeDestroy(TWebAuthnGetAssertionExtraInfo)) {
        new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo;
    }
    (*(ptr_WebAuthnGetAssertionExtraInfo())) = std::move(aRhs);
    mType = TWebAuthnGetAssertionExtraInfo;
    return (*(this));
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator=(const null_t& aRhs) -> WebAuthnMaybeGetAssertionExtraInfo&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = aRhs;
    mType = Tnull_t;
    return (*(this));
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator=(null_t&& aRhs) -> WebAuthnMaybeGetAssertionExtraInfo&
{
    if (MaybeDestroy(Tnull_t)) {
        new (mozilla::KnownNotNull, ptr_null_t()) null_t;
    }
    (*(ptr_null_t())) = std::move(aRhs);
    mType = Tnull_t;
    return (*(this));
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator=(const WebAuthnMaybeGetAssertionExtraInfo& aRhs) -> WebAuthnMaybeGetAssertionExtraInfo&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnGetAssertionExtraInfo:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo;
            }
            (*(ptr_WebAuthnGetAssertionExtraInfo())) = (aRhs).get_WebAuthnGetAssertionExtraInfo();
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = (aRhs).get_null_t();
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    mType = t;
    return (*(this));
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator=(WebAuthnMaybeGetAssertionExtraInfo&& aRhs) -> WebAuthnMaybeGetAssertionExtraInfo&
{
    (aRhs).AssertSanity();
    Type t = (aRhs).type();
    switch (t) {
    case TWebAuthnGetAssertionExtraInfo:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_WebAuthnGetAssertionExtraInfo()) WebAuthnGetAssertionExtraInfo;
            }
            (*(ptr_WebAuthnGetAssertionExtraInfo())) = std::move((aRhs).get_WebAuthnGetAssertionExtraInfo());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case Tnull_t:
        {
            if (MaybeDestroy(t)) {
                new (mozilla::KnownNotNull, ptr_null_t()) null_t;
            }
            (*(ptr_null_t())) = std::move((aRhs).get_null_t());
            static_cast<void>((aRhs).MaybeDestroy(T__None));
            break;
        }
    case T__None:
        {
            static_cast<void>(MaybeDestroy(t));
            break;
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            break;
        }
    }
    (aRhs).mType = T__None;
    mType = t;
    return (*(this));
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator==(const WebAuthnGetAssertionExtraInfo& aRhs) const -> bool
{
    return (get_WebAuthnGetAssertionExtraInfo()) == (aRhs);
}

auto WebAuthnMaybeGetAssertionExtraInfo::operator==(const null_t& aRhs) const -> bool
{
    return (get_null_t()) == (aRhs);
}

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

    switch (type()) {
    case TWebAuthnGetAssertionExtraInfo:
        {
            return (get_WebAuthnGetAssertionExtraInfo()) == ((aRhs).get_WebAuthnGetAssertionExtraInfo());
        }
    case Tnull_t:
        {
            return (get_null_t()) == ((aRhs).get_null_t());
        }
    default:
        {
            mozilla::ipc::LogicError("unreached");
            return false;
        }
    }
}

auto WebAuthnMaybeGetAssertionExtraInfo::get(WebAuthnGetAssertionExtraInfo* aOutValue) const -> void
{
    (*(aOutValue)) = get_WebAuthnGetAssertionExtraInfo();
}

auto WebAuthnMaybeGetAssertionExtraInfo::get(null_t* aOutValue) const -> void
{
    (*(aOutValue)) = get_null_t();
}

} // namespace dom
} // namespace mozilla

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

    switch (type) {
    case union__::TWebAuthnGetAssertionExtraInfo:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_WebAuthnGetAssertionExtraInfo());
            // Sentinel = 'TWebAuthnGetAssertionExtraInfo'
            (aMsg)->WriteSentinel(1350224354);
            return;
        }
    case union__::Tnull_t:
        {
            WriteIPDLParam(aMsg, aActor, (aVar).get_null_t());
            // Sentinel = 'Tnull_t'
            (aMsg)->WriteSentinel(3731137201);
            return;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return;
        }
    }
}

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

    switch (type) {
    case union__::TWebAuthnGetAssertionExtraInfo:
        {
            mozilla::dom::WebAuthnGetAssertionExtraInfo tmp = mozilla::dom::WebAuthnGetAssertionExtraInfo();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_WebAuthnGetAssertionExtraInfo())))))) {
                (aActor)->FatalError("Error deserializing variant TWebAuthnGetAssertionExtraInfo of union WebAuthnMaybeGetAssertionExtraInfo");
                return false;
            }
            // Sentinel = 'TWebAuthnGetAssertionExtraInfo'
            if ((!((aMsg)->ReadSentinel(aIter, 1350224354)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant TWebAuthnGetAssertionExtraInfo of union WebAuthnMaybeGetAssertionExtraInfo");
                return false;
            }
            return true;
        }
    case union__::Tnull_t:
        {
            mozilla::null_t tmp = mozilla::null_t();
            (*(aVar)) = tmp;
            if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->get_null_t())))))) {
                (aActor)->FatalError("Error deserializing variant Tnull_t of union WebAuthnMaybeGetAssertionExtraInfo");
                return false;
            }
            // Sentinel = 'Tnull_t'
            if ((!((aMsg)->ReadSentinel(aIter, 3731137201)))) {
                mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union WebAuthnMaybeGetAssertionExtraInfo");
                return false;
            }
            return true;
        }
    default:
        {
            (aActor)->FatalError("unknown union type");
            return false;
        }
    }
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct WebAuthnGetAssertionInfo|
//
namespace mozilla {
namespace dom {
auto WebAuthnGetAssertionInfo::operator==(const WebAuthnGetAssertionInfo& _o) const -> bool
{
    if ((!((Origin()) == ((_o).Origin())))) {
        return false;
    }
    if ((!((RpId()) == ((_o).RpId())))) {
        return false;
    }
    if ((!((Challenge()) == ((_o).Challenge())))) {
        return false;
    }
    if ((!((ClientDataJSON()) == ((_o).ClientDataJSON())))) {
        return false;
    }
    if ((!((TimeoutMS()) == ((_o).TimeoutMS())))) {
        return false;
    }
    if ((!((AllowList()) == ((_o).AllowList())))) {
        return false;
    }
    if ((!((Extra()) == ((_o).Extra())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnGetAssertionInfo>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).Origin());
    // Sentinel = 'Origin'
    (aMsg)->WriteSentinel(4053590112);
    WriteIPDLParam(aMsg, aActor, (aVar).RpId());
    // Sentinel = 'RpId'
    (aMsg)->WriteSentinel(2688815153);
    WriteIPDLParam(aMsg, aActor, (aVar).Challenge());
    // Sentinel = 'Challenge'
    (aMsg)->WriteSentinel(1381253706);
    WriteIPDLParam(aMsg, aActor, (aVar).ClientDataJSON());
    // Sentinel = 'ClientDataJSON'
    (aMsg)->WriteSentinel(3518101945);
    WriteIPDLParam(aMsg, aActor, (aVar).TimeoutMS());
    // Sentinel = 'TimeoutMS'
    (aMsg)->WriteSentinel(2549274784);
    WriteIPDLParam(aMsg, aActor, (aVar).AllowList());
    // Sentinel = 'AllowList'
    (aMsg)->WriteSentinel(1633896974);
    WriteIPDLParam(aMsg, aActor, (aVar).Extra());
    // Sentinel = 'Extra'
    (aMsg)->WriteSentinel(2419867879);
}

auto IPDLParamTraits<mozilla::dom::WebAuthnGetAssertionInfo>::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' (nsString) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'Origin'
    if ((!((aMsg)->ReadSentinel(aIter, 4053590112)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Origin' (nsString) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->RpId())))))) {
        (aActor)->FatalError("Error deserializing 'RpId' (nsString) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'RpId'
    if ((!((aMsg)->ReadSentinel(aIter, 2688815153)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'RpId' (nsString) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Challenge())))))) {
        (aActor)->FatalError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'Challenge'
    if ((!((aMsg)->ReadSentinel(aIter, 1381253706)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Challenge' (uint8_t[]) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ClientDataJSON())))))) {
        (aActor)->FatalError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'ClientDataJSON'
    if ((!((aMsg)->ReadSentinel(aIter, 3518101945)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->TimeoutMS())))))) {
        (aActor)->FatalError("Error deserializing 'TimeoutMS' (uint32_t) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'TimeoutMS'
    if ((!((aMsg)->ReadSentinel(aIter, 2549274784)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'TimeoutMS' (uint32_t) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->AllowList())))))) {
        (aActor)->FatalError("Error deserializing 'AllowList' (WebAuthnScopedCredential[]) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'AllowList'
    if ((!((aMsg)->ReadSentinel(aIter, 1633896974)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AllowList' (WebAuthnScopedCredential[]) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Extra())))))) {
        (aActor)->FatalError("Error deserializing 'Extra' (WebAuthnMaybeGetAssertionExtraInfo) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    // Sentinel = 'Extra'
    if ((!((aMsg)->ReadSentinel(aIter, 2419867879)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extra' (WebAuthnMaybeGetAssertionExtraInfo) member of 'WebAuthnGetAssertionInfo'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct WebAuthnGetAssertionResult|
//
namespace mozilla {
namespace dom {
auto WebAuthnGetAssertionResult::operator==(const WebAuthnGetAssertionResult& _o) const -> bool
{
    if ((!((ClientDataJSON()) == ((_o).ClientDataJSON())))) {
        return false;
    }
    if ((!((KeyHandle()) == ((_o).KeyHandle())))) {
        return false;
    }
    if ((!((Signature()) == ((_o).Signature())))) {
        return false;
    }
    if ((!((AuthenticatorData()) == ((_o).AuthenticatorData())))) {
        return false;
    }
    if ((!((Extensions()) == ((_o).Extensions())))) {
        return false;
    }
    if ((!((SignatureData()) == ((_o).SignatureData())))) {
        return false;
    }
    return true;
}

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

} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::WebAuthnGetAssertionResult>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    WriteIPDLParam(aMsg, aActor, (aVar).ClientDataJSON());
    // Sentinel = 'ClientDataJSON'
    (aMsg)->WriteSentinel(3518101945);
    WriteIPDLParam(aMsg, aActor, (aVar).KeyHandle());
    // Sentinel = 'KeyHandle'
    (aMsg)->WriteSentinel(2245515378);
    WriteIPDLParam(aMsg, aActor, (aVar).Signature());
    // Sentinel = 'Signature'
    (aMsg)->WriteSentinel(736866007);
    WriteIPDLParam(aMsg, aActor, (aVar).AuthenticatorData());
    // Sentinel = 'AuthenticatorData'
    (aMsg)->WriteSentinel(1133495140);
    WriteIPDLParam(aMsg, aActor, (aVar).Extensions());
    // Sentinel = 'Extensions'
    (aMsg)->WriteSentinel(77077076);
    WriteIPDLParam(aMsg, aActor, (aVar).SignatureData());
    // Sentinel = 'SignatureData'
    (aMsg)->WriteSentinel(4014511843);
}

auto IPDLParamTraits<mozilla::dom::WebAuthnGetAssertionResult>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->ClientDataJSON())))))) {
        (aActor)->FatalError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    // Sentinel = 'ClientDataJSON'
    if ((!((aMsg)->ReadSentinel(aIter, 3518101945)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'ClientDataJSON' (nsCString) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->KeyHandle())))))) {
        (aActor)->FatalError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    // Sentinel = 'KeyHandle'
    if ((!((aMsg)->ReadSentinel(aIter, 2245515378)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'KeyHandle' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Signature())))))) {
        (aActor)->FatalError("Error deserializing 'Signature' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    // Sentinel = 'Signature'
    if ((!((aMsg)->ReadSentinel(aIter, 736866007)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Signature' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->AuthenticatorData())))))) {
        (aActor)->FatalError("Error deserializing 'AuthenticatorData' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    // Sentinel = 'AuthenticatorData'
    if ((!((aMsg)->ReadSentinel(aIter, 1133495140)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'AuthenticatorData' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->Extensions())))))) {
        (aActor)->FatalError("Error deserializing 'Extensions' (WebAuthnExtensionResult[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    // Sentinel = 'Extensions'
    if ((!((aMsg)->ReadSentinel(aIter, 77077076)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'Extensions' (WebAuthnExtensionResult[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    if ((!(ReadIPDLParam(aMsg, aIter, aActor, (&((aVar)->SignatureData())))))) {
        (aActor)->FatalError("Error deserializing 'SignatureData' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    // Sentinel = 'SignatureData'
    if ((!((aMsg)->ReadSentinel(aIter, 4014511843)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'SignatureData' (uint8_t[]) member of 'WebAuthnGetAssertionResult'");
        return false;
    }
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53