Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PWebAuthnTransaction_h
#define PWebAuthnTransaction_h
#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"
// Headers for typedefs
#include "mozilla/dom/WebAuthenticationBinding.h"
#include "mozilla/ipc/IPDLStructMember.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnAuthenticatorSelection|
//
namespace mozilla {
namespace dom {
class WebAuthnAuthenticatorSelection final
{
private:
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnAuthenticatorSelection() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnAuthenticatorSelection(
const nsString& _residentKey,
const nsString& _userVerificationRequirement,
const mozilla::Maybe<nsString>& _authenticatorAttachment) :
residentKey_(_residentKey),
userVerificationRequirement_(_userVerificationRequirement),
authenticatorAttachment_(_authenticatorAttachment)
{
}
MOZ_IMPLICIT WebAuthnAuthenticatorSelection(
nsString&& _residentKey,
nsString&& _userVerificationRequirement,
mozilla::Maybe<nsString>&& _authenticatorAttachment) :
residentKey_(std::move(_residentKey)),
userVerificationRequirement_(std::move(_userVerificationRequirement)),
authenticatorAttachment_(std::move(_authenticatorAttachment))
{
}
nsString&
residentKey()
{
return residentKey_;
}
const nsString&
residentKey() const
{
return residentKey_;
}
nsString&
userVerificationRequirement()
{
return userVerificationRequirement_;
}
const nsString&
userVerificationRequirement() const
{
return userVerificationRequirement_;
}
mozilla::Maybe<nsString>&
authenticatorAttachment()
{
return authenticatorAttachment_;
}
const mozilla::Maybe<nsString>&
authenticatorAttachment() const
{
return authenticatorAttachment_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> residentKey_;
::mozilla::ipc::IPDLStructMember<nsString> userVerificationRequirement_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> authenticatorAttachment_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnAuthenticatorSelection>
{
typedef ::mozilla::dom::WebAuthnAuthenticatorSelection paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnScopedCredential|
//
namespace mozilla {
namespace dom {
class WebAuthnScopedCredential final
{
private:
typedef ::uint8_t uint8_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnScopedCredential() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnScopedCredential(
const nsTArray<uint8_t>& _id,
const uint8_t& _transports) :
id_(_id),
transports_(_transports)
{
}
MOZ_IMPLICIT WebAuthnScopedCredential(
nsTArray<uint8_t>&& _id,
uint8_t&& _transports) :
id_(std::move(_id)),
transports_(std::move(_transports))
{
}
nsTArray<uint8_t>&
id()
{
return id_;
}
const nsTArray<uint8_t>&
id() const
{
return id_;
}
uint8_t&
transports()
{
return transports_;
}
const uint8_t&
transports() const
{
return transports_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> id_;
::mozilla::ipc::IPDLStructMember<uint8_t> transports_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnScopedCredential>
{
typedef ::mozilla::dom::WebAuthnScopedCredential paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionCredProtect|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionCredProtect final
{
private:
typedef ::mozilla::dom::CredentialProtectionPolicy CredentialProtectionPolicy;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionCredProtect() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionCredProtect(
const CredentialProtectionPolicy& _policy,
const bool& _required) :
policy_(_policy),
required_(_required)
{
}
MOZ_IMPLICIT WebAuthnExtensionCredProtect(
CredentialProtectionPolicy&& _policy,
bool&& _required) :
policy_(std::move(_policy)),
required_(std::move(_required))
{
}
CredentialProtectionPolicy&
policy()
{
return policy_;
}
const CredentialProtectionPolicy&
policy() const
{
return policy_;
}
bool&
required()
{
return required_;
}
const bool&
required() const
{
return required_;
}
private:
::mozilla::ipc::IPDLStructMember<CredentialProtectionPolicy> policy_;
::mozilla::ipc::IPDLStructMember<bool> required_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionCredProtect>
{
typedef ::mozilla::dom::WebAuthnExtensionCredProtect paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionCredProps|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionCredProps final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionCredProps() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionCredProps(const bool& _credProps) :
credProps_(_credProps)
{
}
MOZ_IMPLICIT WebAuthnExtensionCredProps(bool&& _credProps) :
credProps_(std::move(_credProps))
{
}
bool&
credProps()
{
return credProps_;
}
const bool&
credProps() const
{
return credProps_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> credProps_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionCredProps>
{
typedef ::mozilla::dom::WebAuthnExtensionCredProps paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionHmacSecret|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionHmacSecret final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionHmacSecret() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionHmacSecret(const bool& _hmacCreateSecret) :
hmacCreateSecret_(_hmacCreateSecret)
{
}
MOZ_IMPLICIT WebAuthnExtensionHmacSecret(bool&& _hmacCreateSecret) :
hmacCreateSecret_(std::move(_hmacCreateSecret))
{
}
bool&
hmacCreateSecret()
{
return hmacCreateSecret_;
}
const bool&
hmacCreateSecret() const
{
return hmacCreateSecret_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> hmacCreateSecret_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionHmacSecret>
{
typedef ::mozilla::dom::WebAuthnExtensionHmacSecret paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionLargeBlob|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionLargeBlob final
{
private:
typedef ::uint8_t uint8_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionLargeBlob() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionLargeBlob(
const mozilla::Maybe<bool>& _flag,
const nsTArray<uint8_t>& _write) :
flag_(_flag),
write_(_write)
{
}
MOZ_IMPLICIT WebAuthnExtensionLargeBlob(
mozilla::Maybe<bool>&& _flag,
nsTArray<uint8_t>&& _write) :
flag_(std::move(_flag)),
write_(std::move(_write))
{
}
mozilla::Maybe<bool>&
flag()
{
return flag_;
}
const mozilla::Maybe<bool>&
flag() const
{
return flag_;
}
nsTArray<uint8_t>&
write()
{
return write_;
}
const nsTArray<uint8_t>&
write() const
{
return write_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> flag_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> write_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionLargeBlob>
{
typedef ::mozilla::dom::WebAuthnExtensionLargeBlob paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionMinPinLength|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionMinPinLength final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionMinPinLength() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionMinPinLength(const bool& _minPinLength) :
minPinLength_(_minPinLength)
{
}
MOZ_IMPLICIT WebAuthnExtensionMinPinLength(bool&& _minPinLength) :
minPinLength_(std::move(_minPinLength))
{
}
bool&
minPinLength()
{
return minPinLength_;
}
const bool&
minPinLength() const
{
return minPinLength_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> minPinLength_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionMinPinLength>
{
typedef ::mozilla::dom::WebAuthnExtensionMinPinLength paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionPrfValues|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionPrfValues final
{
private:
typedef ::uint8_t uint8_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionPrfValues() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionPrfValues(
const nsTArray<uint8_t>& _first,
const bool& _secondMaybe,
const nsTArray<uint8_t>& _second) :
first_(_first),
secondMaybe_(_secondMaybe),
second_(_second)
{
}
MOZ_IMPLICIT WebAuthnExtensionPrfValues(
nsTArray<uint8_t>&& _first,
bool&& _secondMaybe,
nsTArray<uint8_t>&& _second) :
first_(std::move(_first)),
secondMaybe_(std::move(_secondMaybe)),
second_(std::move(_second))
{
}
nsTArray<uint8_t>&
first()
{
return first_;
}
const nsTArray<uint8_t>&
first() const
{
return first_;
}
bool&
secondMaybe()
{
return secondMaybe_;
}
const bool&
secondMaybe() const
{
return secondMaybe_;
}
nsTArray<uint8_t>&
second()
{
return second_;
}
const nsTArray<uint8_t>&
second() const
{
return second_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> first_;
::mozilla::ipc::IPDLStructMember<bool> secondMaybe_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> second_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionPrfValues>
{
typedef ::mozilla::dom::WebAuthnExtensionPrfValues paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionPrfEvalByCredentialEntry|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionPrfEvalByCredentialEntry final
{
private:
typedef ::uint8_t uint8_t;
typedef ::mozilla::dom::WebAuthnExtensionPrfValues WebAuthnExtensionPrfValues;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionPrfEvalByCredentialEntry() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionPrfEvalByCredentialEntry(
const nsTArray<uint8_t>& _credentialId,
const WebAuthnExtensionPrfValues& _eval) :
credentialId_(_credentialId),
eval_(_eval)
{
}
MOZ_IMPLICIT WebAuthnExtensionPrfEvalByCredentialEntry(
nsTArray<uint8_t>&& _credentialId,
WebAuthnExtensionPrfValues&& _eval) :
credentialId_(std::move(_credentialId)),
eval_(std::move(_eval))
{
}
nsTArray<uint8_t>&
credentialId()
{
return credentialId_;
}
const nsTArray<uint8_t>&
credentialId() const
{
return credentialId_;
}
WebAuthnExtensionPrfValues&
eval()
{
return eval_;
}
const WebAuthnExtensionPrfValues&
eval() const
{
return eval_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> credentialId_;
::mozilla::ipc::IPDLStructMember<WebAuthnExtensionPrfValues> eval_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry>
{
typedef ::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionPrf|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionPrf final
{
private:
typedef ::mozilla::dom::WebAuthnExtensionPrfValues WebAuthnExtensionPrfValues;
typedef ::mozilla::dom::WebAuthnExtensionPrfEvalByCredentialEntry WebAuthnExtensionPrfEvalByCredentialEntry;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionPrf() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionPrf(
const mozilla::Maybe<WebAuthnExtensionPrfValues>& _eval,
const bool& _evalByCredentialMaybe,
const nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>& _evalByCredential) :
eval_(_eval),
evalByCredentialMaybe_(_evalByCredentialMaybe),
evalByCredential_(_evalByCredential)
{
}
MOZ_IMPLICIT WebAuthnExtensionPrf(
mozilla::Maybe<WebAuthnExtensionPrfValues>&& _eval,
bool&& _evalByCredentialMaybe,
nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>&& _evalByCredential) :
eval_(std::move(_eval)),
evalByCredentialMaybe_(std::move(_evalByCredentialMaybe)),
evalByCredential_(std::move(_evalByCredential))
{
}
mozilla::Maybe<WebAuthnExtensionPrfValues>&
eval()
{
return eval_;
}
const mozilla::Maybe<WebAuthnExtensionPrfValues>&
eval() const
{
return eval_;
}
bool&
evalByCredentialMaybe()
{
return evalByCredentialMaybe_;
}
const bool&
evalByCredentialMaybe() const
{
return evalByCredentialMaybe_;
}
nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>&
evalByCredential()
{
return evalByCredential_;
}
const nsTArray<WebAuthnExtensionPrfEvalByCredentialEntry>&
evalByCredential() const
{
return evalByCredential_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<WebAuthnExtensionPrfValues>> eval_;
::mozilla::ipc::IPDLStructMember<bool> evalByCredentialMaybe_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtensionPrfEvalByCredentialEntry>> evalByCredential_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionPrf>
{
typedef ::mozilla::dom::WebAuthnExtensionPrf paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WebAuthnExtension|
//
namespace mozilla {
namespace dom {
class WebAuthnExtension final
{
public:
enum Type {
T__None,
TWebAuthnExtensionCredProtect = 1,
TWebAuthnExtensionCredProps,
TWebAuthnExtensionHmacSecret,
TWebAuthnExtensionLargeBlob,
TWebAuthnExtensionMinPinLength,
TWebAuthnExtensionPrf,
T__Last = TWebAuthnExtensionPrf
};
private:
typedef ::mozilla::dom::WebAuthnExtensionCredProtect WebAuthnExtensionCredProtect;
typedef ::mozilla::dom::WebAuthnExtensionCredProps WebAuthnExtensionCredProps;
typedef ::mozilla::dom::WebAuthnExtensionHmacSecret WebAuthnExtensionHmacSecret;
typedef ::mozilla::dom::WebAuthnExtensionLargeBlob WebAuthnExtensionLargeBlob;
typedef ::mozilla::dom::WebAuthnExtensionMinPinLength WebAuthnExtensionMinPinLength;
typedef ::mozilla::dom::WebAuthnExtensionPrf WebAuthnExtensionPrf;
typedef WebAuthnExtensionCredProtect WebAuthnExtensionCredProtect__tdef;
typedef WebAuthnExtensionCredProps WebAuthnExtensionCredProps__tdef;
typedef WebAuthnExtensionHmacSecret WebAuthnExtensionHmacSecret__tdef;
typedef WebAuthnExtensionLargeBlob WebAuthnExtensionLargeBlob__tdef;
typedef WebAuthnExtensionMinPinLength WebAuthnExtensionMinPinLength__tdef;
typedef WebAuthnExtensionPrf WebAuthnExtensionPrf__tdef;
WebAuthnExtensionCredProtect*
ptr_WebAuthnExtensionCredProtect()
{
return (&(mVWebAuthnExtensionCredProtect));
}
const WebAuthnExtensionCredProtect*
constptr_WebAuthnExtensionCredProtect() const
{
return (&(mVWebAuthnExtensionCredProtect));
}
WebAuthnExtensionCredProps*
ptr_WebAuthnExtensionCredProps()
{
return (&(mVWebAuthnExtensionCredProps));
}
const WebAuthnExtensionCredProps*
constptr_WebAuthnExtensionCredProps() const
{
return (&(mVWebAuthnExtensionCredProps));
}
WebAuthnExtensionHmacSecret*
ptr_WebAuthnExtensionHmacSecret()
{
return (&(mVWebAuthnExtensionHmacSecret));
}
const WebAuthnExtensionHmacSecret*
constptr_WebAuthnExtensionHmacSecret() const
{
return (&(mVWebAuthnExtensionHmacSecret));
}
WebAuthnExtensionLargeBlob*
ptr_WebAuthnExtensionLargeBlob()
{
return (&(mVWebAuthnExtensionLargeBlob));
}
const WebAuthnExtensionLargeBlob*
constptr_WebAuthnExtensionLargeBlob() const
{
return (&(mVWebAuthnExtensionLargeBlob));
}
WebAuthnExtensionMinPinLength*
ptr_WebAuthnExtensionMinPinLength()
{
return (&(mVWebAuthnExtensionMinPinLength));
}
const WebAuthnExtensionMinPinLength*
constptr_WebAuthnExtensionMinPinLength() const
{
return (&(mVWebAuthnExtensionMinPinLength));
}
WebAuthnExtensionPrf*
ptr_WebAuthnExtensionPrf()
{
return (&(mVWebAuthnExtensionPrf));
}
const WebAuthnExtensionPrf*
constptr_WebAuthnExtensionPrf() const
{
return (&(mVWebAuthnExtensionPrf));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT WebAuthnExtension() :
mType(T__None)
{
}
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionCredProtect& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionCredProtect&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionCredProps& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionCredProps&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionHmacSecret& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionHmacSecret&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionLargeBlob& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionLargeBlob&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionMinPinLength& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionMinPinLength&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtensionPrf& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionPrf&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtension& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtension&& aOther);
~WebAuthnExtension();
Type
type() const
{
return mType;
}
WebAuthnExtension&
operator=(const WebAuthnExtensionCredProtect& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionCredProtect&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionCredProps& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionCredProps&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionHmacSecret& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionHmacSecret&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionLargeBlob& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionLargeBlob&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionMinPinLength& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionMinPinLength&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionPrf& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionPrf&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtension& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtension&& aRhs);
WebAuthnExtensionCredProtect&
get_WebAuthnExtensionCredProtect()
{
AssertSanity(TWebAuthnExtensionCredProtect);
return (*(ptr_WebAuthnExtensionCredProtect()));
}
const WebAuthnExtensionCredProtect&
get_WebAuthnExtensionCredProtect() const
{
AssertSanity(TWebAuthnExtensionCredProtect);
return (*(constptr_WebAuthnExtensionCredProtect()));
}
operator WebAuthnExtensionCredProtect&()
{
return get_WebAuthnExtensionCredProtect();
}
operator const WebAuthnExtensionCredProtect&() const
{
return get_WebAuthnExtensionCredProtect();
}
WebAuthnExtensionCredProps&
get_WebAuthnExtensionCredProps()
{
AssertSanity(TWebAuthnExtensionCredProps);
return (*(ptr_WebAuthnExtensionCredProps()));
}
const WebAuthnExtensionCredProps&
get_WebAuthnExtensionCredProps() const
{
AssertSanity(TWebAuthnExtensionCredProps);
return (*(constptr_WebAuthnExtensionCredProps()));
}
operator WebAuthnExtensionCredProps&()
{
return get_WebAuthnExtensionCredProps();
}
operator const WebAuthnExtensionCredProps&() const
{
return get_WebAuthnExtensionCredProps();
}
WebAuthnExtensionHmacSecret&
get_WebAuthnExtensionHmacSecret()
{
AssertSanity(TWebAuthnExtensionHmacSecret);
return (*(ptr_WebAuthnExtensionHmacSecret()));
}
const WebAuthnExtensionHmacSecret&
get_WebAuthnExtensionHmacSecret() const
{
AssertSanity(TWebAuthnExtensionHmacSecret);
return (*(constptr_WebAuthnExtensionHmacSecret()));
}
operator WebAuthnExtensionHmacSecret&()
{
return get_WebAuthnExtensionHmacSecret();
}
operator const WebAuthnExtensionHmacSecret&() const
{
return get_WebAuthnExtensionHmacSecret();
}
WebAuthnExtensionLargeBlob&
get_WebAuthnExtensionLargeBlob()
{
AssertSanity(TWebAuthnExtensionLargeBlob);
return (*(ptr_WebAuthnExtensionLargeBlob()));
}
const WebAuthnExtensionLargeBlob&
get_WebAuthnExtensionLargeBlob() const
{
AssertSanity(TWebAuthnExtensionLargeBlob);
return (*(constptr_WebAuthnExtensionLargeBlob()));
}
operator WebAuthnExtensionLargeBlob&()
{
return get_WebAuthnExtensionLargeBlob();
}
operator const WebAuthnExtensionLargeBlob&() const
{
return get_WebAuthnExtensionLargeBlob();
}
WebAuthnExtensionMinPinLength&
get_WebAuthnExtensionMinPinLength()
{
AssertSanity(TWebAuthnExtensionMinPinLength);
return (*(ptr_WebAuthnExtensionMinPinLength()));
}
const WebAuthnExtensionMinPinLength&
get_WebAuthnExtensionMinPinLength() const
{
AssertSanity(TWebAuthnExtensionMinPinLength);
return (*(constptr_WebAuthnExtensionMinPinLength()));
}
operator WebAuthnExtensionMinPinLength&()
{
return get_WebAuthnExtensionMinPinLength();
}
operator const WebAuthnExtensionMinPinLength&() const
{
return get_WebAuthnExtensionMinPinLength();
}
WebAuthnExtensionPrf&
get_WebAuthnExtensionPrf()
{
AssertSanity(TWebAuthnExtensionPrf);
return (*(ptr_WebAuthnExtensionPrf()));
}
const WebAuthnExtensionPrf&
get_WebAuthnExtensionPrf() const
{
AssertSanity(TWebAuthnExtensionPrf);
return (*(constptr_WebAuthnExtensionPrf()));
}
operator WebAuthnExtensionPrf&()
{
return get_WebAuthnExtensionPrf();
}
operator const WebAuthnExtensionPrf&() const
{
return get_WebAuthnExtensionPrf();
}
private:
union {
WebAuthnExtensionCredProtect mVWebAuthnExtensionCredProtect;
WebAuthnExtensionCredProps mVWebAuthnExtensionCredProps;
WebAuthnExtensionHmacSecret mVWebAuthnExtensionHmacSecret;
WebAuthnExtensionLargeBlob mVWebAuthnExtensionLargeBlob;
WebAuthnExtensionMinPinLength mVWebAuthnExtensionMinPinLength;
WebAuthnExtensionPrf mVWebAuthnExtensionPrf;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtension>
{
typedef ::mozilla::dom::WebAuthnExtension paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultAppId|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultAppId final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionResultAppId() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionResultAppId(const bool& _AppId) :
AppId_(_AppId)
{
}
MOZ_IMPLICIT WebAuthnExtensionResultAppId(bool&& _AppId) :
AppId_(std::move(_AppId))
{
}
bool&
AppId()
{
return AppId_;
}
const bool&
AppId() const
{
return AppId_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> AppId_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionResultAppId>
{
typedef ::mozilla::dom::WebAuthnExtensionResultAppId paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultCredProps|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultCredProps final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionResultCredProps() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionResultCredProps(const bool& _rk) :
rk_(_rk)
{
}
MOZ_IMPLICIT WebAuthnExtensionResultCredProps(bool&& _rk) :
rk_(std::move(_rk))
{
}
bool&
rk()
{
return rk_;
}
const bool&
rk() const
{
return rk_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> rk_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionResultCredProps>
{
typedef ::mozilla::dom::WebAuthnExtensionResultCredProps paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultHmacSecret|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultHmacSecret final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionResultHmacSecret() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionResultHmacSecret(const bool& _hmacCreateSecret) :
hmacCreateSecret_(_hmacCreateSecret)
{
}
MOZ_IMPLICIT WebAuthnExtensionResultHmacSecret(bool&& _hmacCreateSecret) :
hmacCreateSecret_(std::move(_hmacCreateSecret))
{
}
bool&
hmacCreateSecret()
{
return hmacCreateSecret_;
}
const bool&
hmacCreateSecret() const
{
return hmacCreateSecret_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> hmacCreateSecret_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionResultHmacSecret>
{
typedef ::mozilla::dom::WebAuthnExtensionResultHmacSecret paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultLargeBlob|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultLargeBlob final
{
private:
typedef ::uint8_t uint8_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionResultLargeBlob() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionResultLargeBlob(
const bool& _flag,
const nsTArray<uint8_t>& _blob,
const bool& _written) :
flag_(_flag),
blob_(_blob),
written_(_written)
{
}
MOZ_IMPLICIT WebAuthnExtensionResultLargeBlob(
bool&& _flag,
nsTArray<uint8_t>&& _blob,
bool&& _written) :
flag_(std::move(_flag)),
blob_(std::move(_blob)),
written_(std::move(_written))
{
}
bool&
flag()
{
return flag_;
}
const bool&
flag() const
{
return flag_;
}
nsTArray<uint8_t>&
blob()
{
return blob_;
}
const nsTArray<uint8_t>&
blob() const
{
return blob_;
}
bool&
written()
{
return written_;
}
const bool&
written() const
{
return written_;
}
private:
::mozilla::ipc::IPDLStructMember<bool> flag_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> blob_;
::mozilla::ipc::IPDLStructMember<bool> written_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionResultLargeBlob>
{
typedef ::mozilla::dom::WebAuthnExtensionResultLargeBlob paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnExtensionResultPrf|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResultPrf final
{
private:
typedef ::mozilla::dom::WebAuthnExtensionPrfValues WebAuthnExtensionPrfValues;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnExtensionResultPrf() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionResultPrf(
const mozilla::Maybe<bool>& _enabled,
const mozilla::Maybe<WebAuthnExtensionPrfValues>& _results) :
enabled_(_enabled),
results_(_results)
{
}
MOZ_IMPLICIT WebAuthnExtensionResultPrf(
mozilla::Maybe<bool>&& _enabled,
mozilla::Maybe<WebAuthnExtensionPrfValues>&& _results) :
enabled_(std::move(_enabled)),
results_(std::move(_results))
{
}
mozilla::Maybe<bool>&
enabled()
{
return enabled_;
}
const mozilla::Maybe<bool>&
enabled() const
{
return enabled_;
}
mozilla::Maybe<WebAuthnExtensionPrfValues>&
results()
{
return results_;
}
const mozilla::Maybe<WebAuthnExtensionPrfValues>&
results() const
{
return results_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> enabled_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<WebAuthnExtensionPrfValues>> results_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionResultPrf>
{
typedef ::mozilla::dom::WebAuthnExtensionResultPrf paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WebAuthnExtensionResult|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResult final
{
public:
enum Type {
T__None,
TWebAuthnExtensionResultAppId = 1,
TWebAuthnExtensionResultCredProps,
TWebAuthnExtensionResultHmacSecret,
TWebAuthnExtensionResultLargeBlob,
TWebAuthnExtensionResultPrf,
T__Last = TWebAuthnExtensionResultPrf
};
private:
typedef ::mozilla::dom::WebAuthnExtensionResultAppId WebAuthnExtensionResultAppId;
typedef ::mozilla::dom::WebAuthnExtensionResultCredProps WebAuthnExtensionResultCredProps;
typedef ::mozilla::dom::WebAuthnExtensionResultHmacSecret WebAuthnExtensionResultHmacSecret;
typedef ::mozilla::dom::WebAuthnExtensionResultLargeBlob WebAuthnExtensionResultLargeBlob;
typedef ::mozilla::dom::WebAuthnExtensionResultPrf WebAuthnExtensionResultPrf;
typedef WebAuthnExtensionResultAppId WebAuthnExtensionResultAppId__tdef;
typedef WebAuthnExtensionResultCredProps WebAuthnExtensionResultCredProps__tdef;
typedef WebAuthnExtensionResultHmacSecret WebAuthnExtensionResultHmacSecret__tdef;
typedef WebAuthnExtensionResultLargeBlob WebAuthnExtensionResultLargeBlob__tdef;
typedef WebAuthnExtensionResultPrf WebAuthnExtensionResultPrf__tdef;
WebAuthnExtensionResultAppId*
ptr_WebAuthnExtensionResultAppId()
{
return (&(mVWebAuthnExtensionResultAppId));
}
const WebAuthnExtensionResultAppId*
constptr_WebAuthnExtensionResultAppId() const
{
return (&(mVWebAuthnExtensionResultAppId));
}
WebAuthnExtensionResultCredProps*
ptr_WebAuthnExtensionResultCredProps()
{
return (&(mVWebAuthnExtensionResultCredProps));
}
const WebAuthnExtensionResultCredProps*
constptr_WebAuthnExtensionResultCredProps() const
{
return (&(mVWebAuthnExtensionResultCredProps));
}
WebAuthnExtensionResultHmacSecret*
ptr_WebAuthnExtensionResultHmacSecret()
{
return (&(mVWebAuthnExtensionResultHmacSecret));
}
const WebAuthnExtensionResultHmacSecret*
constptr_WebAuthnExtensionResultHmacSecret() const
{
return (&(mVWebAuthnExtensionResultHmacSecret));
}
WebAuthnExtensionResultLargeBlob*
ptr_WebAuthnExtensionResultLargeBlob()
{
return (&(mVWebAuthnExtensionResultLargeBlob));
}
const WebAuthnExtensionResultLargeBlob*
constptr_WebAuthnExtensionResultLargeBlob() const
{
return (&(mVWebAuthnExtensionResultLargeBlob));
}
WebAuthnExtensionResultPrf*
ptr_WebAuthnExtensionResultPrf()
{
return (&(mVWebAuthnExtensionResultPrf));
}
const WebAuthnExtensionResultPrf*
constptr_WebAuthnExtensionResultPrf() const
{
return (&(mVWebAuthnExtensionResultPrf));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT WebAuthnExtensionResult() :
mType(T__None)
{
}
MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultAppId& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultAppId&& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultCredProps& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultCredProps&& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultHmacSecret& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultHmacSecret&& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultLargeBlob& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultLargeBlob&& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResultPrf& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResultPrf&& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(const WebAuthnExtensionResult& aOther);
MOZ_IMPLICIT WebAuthnExtensionResult(WebAuthnExtensionResult&& aOther);
~WebAuthnExtensionResult();
Type
type() const
{
return mType;
}
WebAuthnExtensionResult&
operator=(const WebAuthnExtensionResultAppId& aRhs);
WebAuthnExtensionResult&
operator=(WebAuthnExtensionResultAppId&& aRhs);
WebAuthnExtensionResult&
operator=(const WebAuthnExtensionResultCredProps& aRhs);
WebAuthnExtensionResult&
operator=(WebAuthnExtensionResultCredProps&& aRhs);
WebAuthnExtensionResult&
operator=(const WebAuthnExtensionResultHmacSecret& aRhs);
WebAuthnExtensionResult&
operator=(WebAuthnExtensionResultHmacSecret&& aRhs);
WebAuthnExtensionResult&
operator=(const WebAuthnExtensionResultLargeBlob& aRhs);
WebAuthnExtensionResult&
operator=(WebAuthnExtensionResultLargeBlob&& aRhs);
WebAuthnExtensionResult&
operator=(const WebAuthnExtensionResultPrf& aRhs);
WebAuthnExtensionResult&
operator=(WebAuthnExtensionResultPrf&& aRhs);
WebAuthnExtensionResult&
operator=(const WebAuthnExtensionResult& aRhs);
WebAuthnExtensionResult&
operator=(WebAuthnExtensionResult&& aRhs);
WebAuthnExtensionResultAppId&
get_WebAuthnExtensionResultAppId()
{
AssertSanity(TWebAuthnExtensionResultAppId);
return (*(ptr_WebAuthnExtensionResultAppId()));
}
const WebAuthnExtensionResultAppId&
get_WebAuthnExtensionResultAppId() const
{
AssertSanity(TWebAuthnExtensionResultAppId);
return (*(constptr_WebAuthnExtensionResultAppId()));
}
operator WebAuthnExtensionResultAppId&()
{
return get_WebAuthnExtensionResultAppId();
}
operator const WebAuthnExtensionResultAppId&() const
{
return get_WebAuthnExtensionResultAppId();
}
WebAuthnExtensionResultCredProps&
get_WebAuthnExtensionResultCredProps()
{
AssertSanity(TWebAuthnExtensionResultCredProps);
return (*(ptr_WebAuthnExtensionResultCredProps()));
}
const WebAuthnExtensionResultCredProps&
get_WebAuthnExtensionResultCredProps() const
{
AssertSanity(TWebAuthnExtensionResultCredProps);
return (*(constptr_WebAuthnExtensionResultCredProps()));
}
operator WebAuthnExtensionResultCredProps&()
{
return get_WebAuthnExtensionResultCredProps();
}
operator const WebAuthnExtensionResultCredProps&() const
{
return get_WebAuthnExtensionResultCredProps();
}
WebAuthnExtensionResultHmacSecret&
get_WebAuthnExtensionResultHmacSecret()
{
AssertSanity(TWebAuthnExtensionResultHmacSecret);
return (*(ptr_WebAuthnExtensionResultHmacSecret()));
}
const WebAuthnExtensionResultHmacSecret&
get_WebAuthnExtensionResultHmacSecret() const
{
AssertSanity(TWebAuthnExtensionResultHmacSecret);
return (*(constptr_WebAuthnExtensionResultHmacSecret()));
}
operator WebAuthnExtensionResultHmacSecret&()
{
return get_WebAuthnExtensionResultHmacSecret();
}
operator const WebAuthnExtensionResultHmacSecret&() const
{
return get_WebAuthnExtensionResultHmacSecret();
}
WebAuthnExtensionResultLargeBlob&
get_WebAuthnExtensionResultLargeBlob()
{
AssertSanity(TWebAuthnExtensionResultLargeBlob);
return (*(ptr_WebAuthnExtensionResultLargeBlob()));
}
const WebAuthnExtensionResultLargeBlob&
get_WebAuthnExtensionResultLargeBlob() const
{
AssertSanity(TWebAuthnExtensionResultLargeBlob);
return (*(constptr_WebAuthnExtensionResultLargeBlob()));
}
operator WebAuthnExtensionResultLargeBlob&()
{
return get_WebAuthnExtensionResultLargeBlob();
}
operator const WebAuthnExtensionResultLargeBlob&() const
{
return get_WebAuthnExtensionResultLargeBlob();
}
WebAuthnExtensionResultPrf&
get_WebAuthnExtensionResultPrf()
{
AssertSanity(TWebAuthnExtensionResultPrf);
return (*(ptr_WebAuthnExtensionResultPrf()));
}
const WebAuthnExtensionResultPrf&
get_WebAuthnExtensionResultPrf() const
{
AssertSanity(TWebAuthnExtensionResultPrf);
return (*(constptr_WebAuthnExtensionResultPrf()));
}
operator WebAuthnExtensionResultPrf&()
{
return get_WebAuthnExtensionResultPrf();
}
operator const WebAuthnExtensionResultPrf&() const
{
return get_WebAuthnExtensionResultPrf();
}
private:
union {
WebAuthnExtensionResultAppId mVWebAuthnExtensionResultAppId;
WebAuthnExtensionResultCredProps mVWebAuthnExtensionResultCredProps;
WebAuthnExtensionResultHmacSecret mVWebAuthnExtensionResultHmacSecret;
WebAuthnExtensionResultLargeBlob mVWebAuthnExtensionResultLargeBlob;
WebAuthnExtensionResultPrf mVWebAuthnExtensionResultPrf;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionResult>
{
typedef ::mozilla::dom::WebAuthnExtensionResult paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialRpInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialRpInfo final
{
private:
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnMakeCredentialRpInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnMakeCredentialRpInfo(const nsString& _Name) :
Name_(_Name)
{
}
MOZ_IMPLICIT WebAuthnMakeCredentialRpInfo(nsString&& _Name) :
Name_(std::move(_Name))
{
}
nsString&
Name()
{
return Name_;
}
const nsString&
Name() const
{
return Name_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> Name_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnMakeCredentialRpInfo>
{
typedef ::mozilla::dom::WebAuthnMakeCredentialRpInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialUserInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialUserInfo final
{
private:
typedef ::uint8_t uint8_t;
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnMakeCredentialUserInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnMakeCredentialUserInfo(
const nsTArray<uint8_t>& _Id,
const nsString& _Name,
const nsString& _DisplayName) :
Id_(_Id),
Name_(_Name),
DisplayName_(_DisplayName)
{
}
MOZ_IMPLICIT WebAuthnMakeCredentialUserInfo(
nsTArray<uint8_t>&& _Id,
nsString&& _Name,
nsString&& _DisplayName) :
Id_(std::move(_Id)),
Name_(std::move(_Name)),
DisplayName_(std::move(_DisplayName))
{
}
nsTArray<uint8_t>&
Id()
{
return Id_;
}
const nsTArray<uint8_t>&
Id() const
{
return Id_;
}
nsString&
Name()
{
return Name_;
}
const nsString&
Name() const
{
return Name_;
}
nsString&
DisplayName()
{
return DisplayName_;
}
const nsString&
DisplayName() const
{
return DisplayName_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Id_;
::mozilla::ipc::IPDLStructMember<nsString> Name_;
::mozilla::ipc::IPDLStructMember<nsString> DisplayName_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnMakeCredentialUserInfo>
{
typedef ::mozilla::dom::WebAuthnMakeCredentialUserInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct CoseAlg|
//
namespace mozilla {
namespace dom {
class CoseAlg final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CoseAlg() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CoseAlg(const long& _alg) :
alg_(_alg)
{
}
MOZ_IMPLICIT CoseAlg(long&& _alg) :
alg_(std::move(_alg))
{
}
long&
alg()
{
return alg_;
}
const long&
alg() const
{
return alg_;
}
private:
::mozilla::ipc::IPDLStructMember<long> alg_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::CoseAlg>
{
typedef ::mozilla::dom::CoseAlg paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialInfo final
{
private:
typedef ::nsCString nsCString;
typedef ::uint8_t uint8_t;
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::WebAuthnScopedCredential WebAuthnScopedCredential;
typedef ::mozilla::dom::WebAuthnMakeCredentialRpInfo WebAuthnMakeCredentialRpInfo;
typedef ::mozilla::dom::WebAuthnMakeCredentialUserInfo WebAuthnMakeCredentialUserInfo;
typedef ::mozilla::dom::CoseAlg CoseAlg;
typedef ::mozilla::dom::WebAuthnExtension WebAuthnExtension;
typedef ::mozilla::dom::WebAuthnAuthenticatorSelection WebAuthnAuthenticatorSelection;
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnMakeCredentialInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnMakeCredentialInfo(
const nsCString& _RpId,
const nsTArray<uint8_t>& _Challenge,
const uint32_t& _TimeoutMS,
const nsTArray<WebAuthnScopedCredential>& _ExcludeList,
const WebAuthnMakeCredentialRpInfo& _Rp,
const WebAuthnMakeCredentialUserInfo& _User,
const nsTArray<CoseAlg>& _coseAlgs,
const nsTArray<WebAuthnExtension>& _Extensions,
const WebAuthnAuthenticatorSelection& _AuthenticatorSelection,
const nsString& _attestationConveyancePreference) :
RpId_(_RpId),
Challenge_(_Challenge),
ExcludeList_(_ExcludeList),
Rp_(_Rp),
User_(_User),
coseAlgs_(_coseAlgs),
Extensions_(_Extensions),
AuthenticatorSelection_(_AuthenticatorSelection),
attestationConveyancePreference_(_attestationConveyancePreference),
TimeoutMS_(_TimeoutMS)
{
}
MOZ_IMPLICIT WebAuthnMakeCredentialInfo(
nsCString&& _RpId,
nsTArray<uint8_t>&& _Challenge,
uint32_t&& _TimeoutMS,
nsTArray<WebAuthnScopedCredential>&& _ExcludeList,
WebAuthnMakeCredentialRpInfo&& _Rp,
WebAuthnMakeCredentialUserInfo&& _User,
nsTArray<CoseAlg>&& _coseAlgs,
nsTArray<WebAuthnExtension>&& _Extensions,
WebAuthnAuthenticatorSelection&& _AuthenticatorSelection,
nsString&& _attestationConveyancePreference) :
RpId_(std::move(_RpId)),
Challenge_(std::move(_Challenge)),
ExcludeList_(std::move(_ExcludeList)),
Rp_(std::move(_Rp)),
User_(std::move(_User)),
coseAlgs_(std::move(_coseAlgs)),
Extensions_(std::move(_Extensions)),
AuthenticatorSelection_(std::move(_AuthenticatorSelection)),
attestationConveyancePreference_(std::move(_attestationConveyancePreference)),
TimeoutMS_(std::move(_TimeoutMS))
{
}
nsCString&
RpId()
{
return RpId_;
}
const nsCString&
RpId() const
{
return RpId_;
}
nsTArray<uint8_t>&
Challenge()
{
return Challenge_;
}
const nsTArray<uint8_t>&
Challenge() const
{
return Challenge_;
}
uint32_t&
TimeoutMS()
{
return TimeoutMS_;
}
const uint32_t&
TimeoutMS() const
{
return TimeoutMS_;
}
nsTArray<WebAuthnScopedCredential>&
ExcludeList()
{
return ExcludeList_;
}
const nsTArray<WebAuthnScopedCredential>&
ExcludeList() const
{
return ExcludeList_;
}
WebAuthnMakeCredentialRpInfo&
Rp()
{
return Rp_;
}
const WebAuthnMakeCredentialRpInfo&
Rp() const
{
return Rp_;
}
WebAuthnMakeCredentialUserInfo&
User()
{
return User_;
}
const WebAuthnMakeCredentialUserInfo&
User() const
{
return User_;
}
nsTArray<CoseAlg>&
coseAlgs()
{
return coseAlgs_;
}
const nsTArray<CoseAlg>&
coseAlgs() const
{
return coseAlgs_;
}
nsTArray<WebAuthnExtension>&
Extensions()
{
return Extensions_;
}
const nsTArray<WebAuthnExtension>&
Extensions() const
{
return Extensions_;
}
WebAuthnAuthenticatorSelection&
AuthenticatorSelection()
{
return AuthenticatorSelection_;
}
const WebAuthnAuthenticatorSelection&
AuthenticatorSelection() const
{
return AuthenticatorSelection_;
}
nsString&
attestationConveyancePreference()
{
return attestationConveyancePreference_;
}
const nsString&
attestationConveyancePreference() const
{
return attestationConveyancePreference_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> RpId_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Challenge_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnScopedCredential>> ExcludeList_;
::mozilla::ipc::IPDLStructMember<WebAuthnMakeCredentialRpInfo> Rp_;
::mozilla::ipc::IPDLStructMember<WebAuthnMakeCredentialUserInfo> User_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<CoseAlg>> coseAlgs_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtension>> Extensions_;
::mozilla::ipc::IPDLStructMember<WebAuthnAuthenticatorSelection> AuthenticatorSelection_;
::mozilla::ipc::IPDLStructMember<nsString> attestationConveyancePreference_;
::mozilla::ipc::IPDLStructMember<uint32_t> TimeoutMS_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnMakeCredentialInfo>
{
typedef ::mozilla::dom::WebAuthnMakeCredentialInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnMakeCredentialResult|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialResult final
{
private:
typedef ::nsCString nsCString;
typedef ::uint8_t uint8_t;
typedef ::nsString nsString;
typedef ::mozilla::dom::WebAuthnExtensionResult WebAuthnExtensionResult;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnMakeCredentialResult() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnMakeCredentialResult(
const nsCString& _ClientDataJSON,
const nsTArray<uint8_t>& _AttestationObject,
const nsTArray<uint8_t>& _KeyHandle,
const nsTArray<nsString>& _Transports,
const nsTArray<WebAuthnExtensionResult>& _Extensions,
const mozilla::Maybe<nsString>& _AuthenticatorAttachment) :
ClientDataJSON_(_ClientDataJSON),
AttestationObject_(_AttestationObject),
KeyHandle_(_KeyHandle),
Transports_(_Transports),
Extensions_(_Extensions),
AuthenticatorAttachment_(_AuthenticatorAttachment)
{
}
MOZ_IMPLICIT WebAuthnMakeCredentialResult(
nsCString&& _ClientDataJSON,
nsTArray<uint8_t>&& _AttestationObject,
nsTArray<uint8_t>&& _KeyHandle,
nsTArray<nsString>&& _Transports,
nsTArray<WebAuthnExtensionResult>&& _Extensions,
mozilla::Maybe<nsString>&& _AuthenticatorAttachment) :
ClientDataJSON_(std::move(_ClientDataJSON)),
AttestationObject_(std::move(_AttestationObject)),
KeyHandle_(std::move(_KeyHandle)),
Transports_(std::move(_Transports)),
Extensions_(std::move(_Extensions)),
AuthenticatorAttachment_(std::move(_AuthenticatorAttachment))
{
}
nsCString&
ClientDataJSON()
{
return ClientDataJSON_;
}
const nsCString&
ClientDataJSON() const
{
return ClientDataJSON_;
}
nsTArray<uint8_t>&
AttestationObject()
{
return AttestationObject_;
}
const nsTArray<uint8_t>&
AttestationObject() const
{
return AttestationObject_;
}
nsTArray<uint8_t>&
KeyHandle()
{
return KeyHandle_;
}
const nsTArray<uint8_t>&
KeyHandle() const
{
return KeyHandle_;
}
nsTArray<nsString>&
Transports()
{
return Transports_;
}
const nsTArray<nsString>&
Transports() const
{
return Transports_;
}
nsTArray<WebAuthnExtensionResult>&
Extensions()
{
return Extensions_;
}
const nsTArray<WebAuthnExtensionResult>&
Extensions() const
{
return Extensions_;
}
mozilla::Maybe<nsString>&
AuthenticatorAttachment()
{
return AuthenticatorAttachment_;
}
const mozilla::Maybe<nsString>&
AuthenticatorAttachment() const
{
return AuthenticatorAttachment_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> ClientDataJSON_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> AttestationObject_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> KeyHandle_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> Transports_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtensionResult>> Extensions_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> AuthenticatorAttachment_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnMakeCredentialResult>
{
typedef ::mozilla::dom::WebAuthnMakeCredentialResult paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WebAuthnMakeCredentialResponse|
//
namespace mozilla {
namespace dom {
class WebAuthnMakeCredentialResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TWebAuthnMakeCredentialResult,
T__Last = TWebAuthnMakeCredentialResult
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::WebAuthnMakeCredentialResult WebAuthnMakeCredentialResult;
typedef nsresult nsresult__tdef;
typedef WebAuthnMakeCredentialResult WebAuthnMakeCredentialResult__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
WebAuthnMakeCredentialResult*
ptr_WebAuthnMakeCredentialResult()
{
return (&(mVWebAuthnMakeCredentialResult));
}
const WebAuthnMakeCredentialResult*
constptr_WebAuthnMakeCredentialResult() const
{
return (&(mVWebAuthnMakeCredentialResult));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT WebAuthnMakeCredentialResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT WebAuthnMakeCredentialResponse(const nsresult& aOther);
MOZ_IMPLICIT WebAuthnMakeCredentialResponse(nsresult&& aOther);
MOZ_IMPLICIT WebAuthnMakeCredentialResponse(const WebAuthnMakeCredentialResult& aOther);
MOZ_IMPLICIT WebAuthnMakeCredentialResponse(WebAuthnMakeCredentialResult&& aOther);
MOZ_IMPLICIT WebAuthnMakeCredentialResponse(const WebAuthnMakeCredentialResponse& aOther);
MOZ_IMPLICIT WebAuthnMakeCredentialResponse(WebAuthnMakeCredentialResponse&& aOther);
~WebAuthnMakeCredentialResponse();
Type
type() const
{
return mType;
}
WebAuthnMakeCredentialResponse&
operator=(const nsresult& aRhs);
WebAuthnMakeCredentialResponse&
operator=(nsresult&& aRhs);
WebAuthnMakeCredentialResponse&
operator=(const WebAuthnMakeCredentialResult& aRhs);
WebAuthnMakeCredentialResponse&
operator=(WebAuthnMakeCredentialResult&& aRhs);
WebAuthnMakeCredentialResponse&
operator=(const WebAuthnMakeCredentialResponse& aRhs);
WebAuthnMakeCredentialResponse&
operator=(WebAuthnMakeCredentialResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
WebAuthnMakeCredentialResult&
get_WebAuthnMakeCredentialResult()
{
AssertSanity(TWebAuthnMakeCredentialResult);
return (*(ptr_WebAuthnMakeCredentialResult()));
}
const WebAuthnMakeCredentialResult&
get_WebAuthnMakeCredentialResult() const
{
AssertSanity(TWebAuthnMakeCredentialResult);
return (*(constptr_WebAuthnMakeCredentialResult()));
}
operator WebAuthnMakeCredentialResult&()
{
return get_WebAuthnMakeCredentialResult();
}
operator const WebAuthnMakeCredentialResult&() const
{
return get_WebAuthnMakeCredentialResult();
}
private:
union {
nsresult mVnsresult;
WebAuthnMakeCredentialResult mVWebAuthnMakeCredentialResult;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnMakeCredentialResponse>
{
typedef ::mozilla::dom::WebAuthnMakeCredentialResponse paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnGetAssertionInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnGetAssertionInfo final
{
private:
typedef ::nsCString nsCString;
typedef ::uint8_t uint8_t;
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::WebAuthnScopedCredential WebAuthnScopedCredential;
typedef ::mozilla::dom::WebAuthnExtension WebAuthnExtension;
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnGetAssertionInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnGetAssertionInfo(
const nsCString& _RpId,
const mozilla::Maybe<nsCString>& _AppId,
const nsTArray<uint8_t>& _Challenge,
const uint32_t& _TimeoutMS,
const nsTArray<WebAuthnScopedCredential>& _AllowList,
const nsTArray<WebAuthnExtension>& _Extensions,
const nsString& _userVerificationRequirement,
const bool& _ConditionallyMediated) :
RpId_(_RpId),
AppId_(_AppId),
Challenge_(_Challenge),
AllowList_(_AllowList),
Extensions_(_Extensions),
userVerificationRequirement_(_userVerificationRequirement),
ConditionallyMediated_(_ConditionallyMediated),
TimeoutMS_(_TimeoutMS)
{
}
MOZ_IMPLICIT WebAuthnGetAssertionInfo(
nsCString&& _RpId,
mozilla::Maybe<nsCString>&& _AppId,
nsTArray<uint8_t>&& _Challenge,
uint32_t&& _TimeoutMS,
nsTArray<WebAuthnScopedCredential>&& _AllowList,
nsTArray<WebAuthnExtension>&& _Extensions,
nsString&& _userVerificationRequirement,
bool&& _ConditionallyMediated) :
RpId_(std::move(_RpId)),
AppId_(std::move(_AppId)),
Challenge_(std::move(_Challenge)),
AllowList_(std::move(_AllowList)),
Extensions_(std::move(_Extensions)),
userVerificationRequirement_(std::move(_userVerificationRequirement)),
ConditionallyMediated_(std::move(_ConditionallyMediated)),
TimeoutMS_(std::move(_TimeoutMS))
{
}
nsCString&
RpId()
{
return RpId_;
}
const nsCString&
RpId() const
{
return RpId_;
}
mozilla::Maybe<nsCString>&
AppId()
{
return AppId_;
}
const mozilla::Maybe<nsCString>&
AppId() const
{
return AppId_;
}
nsTArray<uint8_t>&
Challenge()
{
return Challenge_;
}
const nsTArray<uint8_t>&
Challenge() const
{
return Challenge_;
}
uint32_t&
TimeoutMS()
{
return TimeoutMS_;
}
const uint32_t&
TimeoutMS() const
{
return TimeoutMS_;
}
nsTArray<WebAuthnScopedCredential>&
AllowList()
{
return AllowList_;
}
const nsTArray<WebAuthnScopedCredential>&
AllowList() const
{
return AllowList_;
}
nsTArray<WebAuthnExtension>&
Extensions()
{
return Extensions_;
}
const nsTArray<WebAuthnExtension>&
Extensions() const
{
return Extensions_;
}
nsString&
userVerificationRequirement()
{
return userVerificationRequirement_;
}
const nsString&
userVerificationRequirement() const
{
return userVerificationRequirement_;
}
bool&
ConditionallyMediated()
{
return ConditionallyMediated_;
}
const bool&
ConditionallyMediated() const
{
return ConditionallyMediated_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> RpId_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> AppId_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Challenge_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnScopedCredential>> AllowList_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtension>> Extensions_;
::mozilla::ipc::IPDLStructMember<nsString> userVerificationRequirement_;
::mozilla::ipc::IPDLStructMember<bool> ConditionallyMediated_;
::mozilla::ipc::IPDLStructMember<uint32_t> TimeoutMS_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnGetAssertionInfo>
{
typedef ::mozilla::dom::WebAuthnGetAssertionInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct WebAuthnGetAssertionResult|
//
namespace mozilla {
namespace dom {
class WebAuthnGetAssertionResult final
{
private:
typedef ::nsCString nsCString;
typedef ::uint8_t uint8_t;
typedef ::mozilla::dom::WebAuthnExtensionResult WebAuthnExtensionResult;
typedef ::nsString nsString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
WebAuthnGetAssertionResult() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnGetAssertionResult(
const nsCString& _ClientDataJSON,
const nsTArray<uint8_t>& _KeyHandle,
const nsTArray<uint8_t>& _Signature,
const nsTArray<uint8_t>& _AuthenticatorData,
const nsTArray<WebAuthnExtensionResult>& _Extensions,
const nsTArray<uint8_t>& _UserHandle,
const mozilla::Maybe<nsString>& _AuthenticatorAttachment) :
ClientDataJSON_(_ClientDataJSON),
KeyHandle_(_KeyHandle),
Signature_(_Signature),
AuthenticatorData_(_AuthenticatorData),
Extensions_(_Extensions),
UserHandle_(_UserHandle),
AuthenticatorAttachment_(_AuthenticatorAttachment)
{
}
MOZ_IMPLICIT WebAuthnGetAssertionResult(
nsCString&& _ClientDataJSON,
nsTArray<uint8_t>&& _KeyHandle,
nsTArray<uint8_t>&& _Signature,
nsTArray<uint8_t>&& _AuthenticatorData,
nsTArray<WebAuthnExtensionResult>&& _Extensions,
nsTArray<uint8_t>&& _UserHandle,
mozilla::Maybe<nsString>&& _AuthenticatorAttachment) :
ClientDataJSON_(std::move(_ClientDataJSON)),
KeyHandle_(std::move(_KeyHandle)),
Signature_(std::move(_Signature)),
AuthenticatorData_(std::move(_AuthenticatorData)),
Extensions_(std::move(_Extensions)),
UserHandle_(std::move(_UserHandle)),
AuthenticatorAttachment_(std::move(_AuthenticatorAttachment))
{
}
nsCString&
ClientDataJSON()
{
return ClientDataJSON_;
}
const nsCString&
ClientDataJSON() const
{
return ClientDataJSON_;
}
nsTArray<uint8_t>&
KeyHandle()
{
return KeyHandle_;
}
const nsTArray<uint8_t>&
KeyHandle() const
{
return KeyHandle_;
}
nsTArray<uint8_t>&
Signature()
{
return Signature_;
}
const nsTArray<uint8_t>&
Signature() const
{
return Signature_;
}
nsTArray<uint8_t>&
AuthenticatorData()
{
return AuthenticatorData_;
}
const nsTArray<uint8_t>&
AuthenticatorData() const
{
return AuthenticatorData_;
}
nsTArray<WebAuthnExtensionResult>&
Extensions()
{
return Extensions_;
}
const nsTArray<WebAuthnExtensionResult>&
Extensions() const
{
return Extensions_;
}
nsTArray<uint8_t>&
UserHandle()
{
return UserHandle_;
}
const nsTArray<uint8_t>&
UserHandle() const
{
return UserHandle_;
}
mozilla::Maybe<nsString>&
AuthenticatorAttachment()
{
return AuthenticatorAttachment_;
}
const mozilla::Maybe<nsString>&
AuthenticatorAttachment() const
{
return AuthenticatorAttachment_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> ClientDataJSON_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> KeyHandle_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Signature_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> AuthenticatorData_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<WebAuthnExtensionResult>> Extensions_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> UserHandle_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> AuthenticatorAttachment_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnGetAssertionResult>
{
typedef ::mozilla::dom::WebAuthnGetAssertionResult paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union WebAuthnGetAssertionResponse|
//
namespace mozilla {
namespace dom {
class WebAuthnGetAssertionResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TWebAuthnGetAssertionResult,
T__Last = TWebAuthnGetAssertionResult
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::WebAuthnGetAssertionResult WebAuthnGetAssertionResult;
typedef nsresult nsresult__tdef;
typedef WebAuthnGetAssertionResult WebAuthnGetAssertionResult__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
WebAuthnGetAssertionResult*
ptr_WebAuthnGetAssertionResult()
{
return (&(mVWebAuthnGetAssertionResult));
}
const WebAuthnGetAssertionResult*
constptr_WebAuthnGetAssertionResult() const
{
return (&(mVWebAuthnGetAssertionResult));
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT WebAuthnGetAssertionResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT WebAuthnGetAssertionResponse(const nsresult& aOther);
MOZ_IMPLICIT WebAuthnGetAssertionResponse(nsresult&& aOther);
MOZ_IMPLICIT WebAuthnGetAssertionResponse(const WebAuthnGetAssertionResult& aOther);
MOZ_IMPLICIT WebAuthnGetAssertionResponse(WebAuthnGetAssertionResult&& aOther);
MOZ_IMPLICIT WebAuthnGetAssertionResponse(const WebAuthnGetAssertionResponse& aOther);
MOZ_IMPLICIT WebAuthnGetAssertionResponse(WebAuthnGetAssertionResponse&& aOther);
~WebAuthnGetAssertionResponse();
Type
type() const
{
return mType;
}
WebAuthnGetAssertionResponse&
operator=(const nsresult& aRhs);
WebAuthnGetAssertionResponse&
operator=(nsresult&& aRhs);
WebAuthnGetAssertionResponse&
operator=(const WebAuthnGetAssertionResult& aRhs);
WebAuthnGetAssertionResponse&
operator=(WebAuthnGetAssertionResult&& aRhs);
WebAuthnGetAssertionResponse&
operator=(const WebAuthnGetAssertionResponse& aRhs);
WebAuthnGetAssertionResponse&
operator=(WebAuthnGetAssertionResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
WebAuthnGetAssertionResult&
get_WebAuthnGetAssertionResult()
{
AssertSanity(TWebAuthnGetAssertionResult);
return (*(ptr_WebAuthnGetAssertionResult()));
}
const WebAuthnGetAssertionResult&
get_WebAuthnGetAssertionResult() const
{
AssertSanity(TWebAuthnGetAssertionResult);
return (*(constptr_WebAuthnGetAssertionResult()));
}
operator WebAuthnGetAssertionResult&()
{
return get_WebAuthnGetAssertionResult();
}
operator const WebAuthnGetAssertionResult&() const
{
return get_WebAuthnGetAssertionResult();
}
private:
union {
nsresult mVnsresult;
WebAuthnGetAssertionResult mVWebAuthnGetAssertionResult;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnGetAssertionResponse>
{
typedef ::mozilla::dom::WebAuthnGetAssertionResponse paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace dom {
class PWebAuthnTransactionParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PWebAuthnTransactionChild;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PWebAuthnTransactionChild and PWebAuthnTransactionParent
//
namespace mozilla {
namespace dom {
namespace PWebAuthnTransaction {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionChild>* aChild);
nsresult
CreateEndpoints(
mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionChild>* aChild);
enum MessageType {
PWebAuthnTransactionStart = PWebAuthnTransactionMsgStart << 16,
Msg_RequestRegister__ID,
Reply_RequestRegister__ID,
Msg_RequestSign__ID,
Reply_RequestSign__ID,
Msg_RequestIsUVPAA__ID,
Reply_RequestIsUVPAA__ID,
Msg_RequestCancel__ID,
Msg___delete____ID,
Reply___delete____ID,
PWebAuthnTransactionEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_RequestRegister(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_RequestRegister(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestSign(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_RequestSign(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestIsUVPAA(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_RequestIsUVPAA(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestCancel(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);
} // namespace PWebAuthnTransaction
} // namespace dom
} // namespace mozilla
#endif // ifndef PWebAuthnTransaction_h