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/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 WebAuthnExtensionAppId|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionAppId 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
WebAuthnExtensionAppId() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebAuthnExtensionAppId(const nsString& _appIdentifier) :
appIdentifier_(_appIdentifier)
{
}
MOZ_IMPLICIT WebAuthnExtensionAppId(nsString&& _appIdentifier) :
appIdentifier_(std::move(_appIdentifier))
{
}
nsString&
appIdentifier()
{
return appIdentifier_;
}
const nsString&
appIdentifier() const
{
return appIdentifier_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> appIdentifier_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebAuthnExtensionAppId>
{
typedef ::mozilla::dom::WebAuthnExtensionAppId 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 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 |union WebAuthnExtension|
//
namespace mozilla {
namespace dom {
class WebAuthnExtension final
{
public:
enum Type {
T__None,
TWebAuthnExtensionAppId = 1,
TWebAuthnExtensionCredProps,
TWebAuthnExtensionHmacSecret,
TWebAuthnExtensionMinPinLength,
T__Last = TWebAuthnExtensionMinPinLength
};
private:
typedef ::mozilla::dom::WebAuthnExtensionAppId WebAuthnExtensionAppId;
typedef ::mozilla::dom::WebAuthnExtensionCredProps WebAuthnExtensionCredProps;
typedef ::mozilla::dom::WebAuthnExtensionHmacSecret WebAuthnExtensionHmacSecret;
typedef ::mozilla::dom::WebAuthnExtensionMinPinLength WebAuthnExtensionMinPinLength;
typedef WebAuthnExtensionAppId WebAuthnExtensionAppId__tdef;
typedef WebAuthnExtensionCredProps WebAuthnExtensionCredProps__tdef;
typedef WebAuthnExtensionHmacSecret WebAuthnExtensionHmacSecret__tdef;
typedef WebAuthnExtensionMinPinLength WebAuthnExtensionMinPinLength__tdef;
union Value {
mozilla::AlignedStorage2<WebAuthnExtensionAppId> VWebAuthnExtensionAppId;
mozilla::AlignedStorage2<WebAuthnExtensionCredProps> VWebAuthnExtensionCredProps;
mozilla::AlignedStorage2<WebAuthnExtensionHmacSecret> VWebAuthnExtensionHmacSecret;
mozilla::AlignedStorage2<WebAuthnExtensionMinPinLength> VWebAuthnExtensionMinPinLength;
};
WebAuthnExtensionAppId*
ptr_WebAuthnExtensionAppId()
{
return ((mValue).VWebAuthnExtensionAppId).addr();
}
const WebAuthnExtensionAppId*
constptr_WebAuthnExtensionAppId() const
{
return ((mValue).VWebAuthnExtensionAppId).addr();
}
WebAuthnExtensionCredProps*
ptr_WebAuthnExtensionCredProps()
{
return ((mValue).VWebAuthnExtensionCredProps).addr();
}
const WebAuthnExtensionCredProps*
constptr_WebAuthnExtensionCredProps() const
{
return ((mValue).VWebAuthnExtensionCredProps).addr();
}
WebAuthnExtensionHmacSecret*
ptr_WebAuthnExtensionHmacSecret()
{
return ((mValue).VWebAuthnExtensionHmacSecret).addr();
}
const WebAuthnExtensionHmacSecret*
constptr_WebAuthnExtensionHmacSecret() const
{
return ((mValue).VWebAuthnExtensionHmacSecret).addr();
}
WebAuthnExtensionMinPinLength*
ptr_WebAuthnExtensionMinPinLength()
{
return ((mValue).VWebAuthnExtensionMinPinLength).addr();
}
const WebAuthnExtensionMinPinLength*
constptr_WebAuthnExtensionMinPinLength() const
{
return ((mValue).VWebAuthnExtensionMinPinLength).addr();
}
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 WebAuthnExtensionAppId& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionAppId&& 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 WebAuthnExtensionMinPinLength& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtensionMinPinLength&& aOther);
MOZ_IMPLICIT WebAuthnExtension(const WebAuthnExtension& aOther);
MOZ_IMPLICIT WebAuthnExtension(WebAuthnExtension&& aOther);
~WebAuthnExtension();
Type
type() const
{
return mType;
}
WebAuthnExtension&
operator=(const WebAuthnExtensionAppId& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionAppId&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionCredProps& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionCredProps&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionHmacSecret& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionHmacSecret&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtensionMinPinLength& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtensionMinPinLength&& aRhs);
WebAuthnExtension&
operator=(const WebAuthnExtension& aRhs);
WebAuthnExtension&
operator=(WebAuthnExtension&& aRhs);
WebAuthnExtensionAppId&
get_WebAuthnExtensionAppId()
{
AssertSanity(TWebAuthnExtensionAppId);
return (*(ptr_WebAuthnExtensionAppId()));
}
const WebAuthnExtensionAppId&
get_WebAuthnExtensionAppId() const
{
AssertSanity(TWebAuthnExtensionAppId);
return (*(constptr_WebAuthnExtensionAppId()));
}
operator WebAuthnExtensionAppId&()
{
return get_WebAuthnExtensionAppId();
}
operator const WebAuthnExtensionAppId&() const
{
return get_WebAuthnExtensionAppId();
}
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();
}
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();
}
private:
Value mValue;
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 |union WebAuthnExtensionResult|
//
namespace mozilla {
namespace dom {
class WebAuthnExtensionResult final
{
public:
enum Type {
T__None,
TWebAuthnExtensionResultAppId = 1,
TWebAuthnExtensionResultCredProps,
TWebAuthnExtensionResultHmacSecret,
T__Last = TWebAuthnExtensionResultHmacSecret
};
private:
typedef ::mozilla::dom::WebAuthnExtensionResultAppId WebAuthnExtensionResultAppId;
typedef ::mozilla::dom::WebAuthnExtensionResultCredProps WebAuthnExtensionResultCredProps;
typedef ::mozilla::dom::WebAuthnExtensionResultHmacSecret WebAuthnExtensionResultHmacSecret;
typedef WebAuthnExtensionResultAppId WebAuthnExtensionResultAppId__tdef;
typedef WebAuthnExtensionResultCredProps WebAuthnExtensionResultCredProps__tdef;
typedef WebAuthnExtensionResultHmacSecret WebAuthnExtensionResultHmacSecret__tdef;
union Value {
mozilla::AlignedStorage2<WebAuthnExtensionResultAppId> VWebAuthnExtensionResultAppId;
mozilla::AlignedStorage2<WebAuthnExtensionResultCredProps> VWebAuthnExtensionResultCredProps;
mozilla::AlignedStorage2<WebAuthnExtensionResultHmacSecret> VWebAuthnExtensionResultHmacSecret;
};
WebAuthnExtensionResultAppId*
ptr_WebAuthnExtensionResultAppId()
{
return ((mValue).VWebAuthnExtensionResultAppId).addr();
}
const WebAuthnExtensionResultAppId*
constptr_WebAuthnExtensionResultAppId() const
{
return ((mValue).VWebAuthnExtensionResultAppId).addr();
}
WebAuthnExtensionResultCredProps*
ptr_WebAuthnExtensionResultCredProps()
{
return ((mValue).VWebAuthnExtensionResultCredProps).addr();
}
const WebAuthnExtensionResultCredProps*
constptr_WebAuthnExtensionResultCredProps() const
{
return ((mValue).VWebAuthnExtensionResultCredProps).addr();
}
WebAuthnExtensionResultHmacSecret*
ptr_WebAuthnExtensionResultHmacSecret()
{
return ((mValue).VWebAuthnExtensionResultHmacSecret).addr();
}
const WebAuthnExtensionResultHmacSecret*
constptr_WebAuthnExtensionResultHmacSecret() const
{
return ((mValue).VWebAuthnExtensionResultHmacSecret).addr();
}
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 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 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();
}
private:
Value mValue;
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 ::nsString nsString;
typedef ::uint8_t uint8_t;
typedef ::nsCString nsCString;
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 ::uint64_t uint64_t;
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 nsString& _Origin,
const nsString& _RpId,
const nsTArray<uint8_t>& _Challenge,
const nsCString& _ClientDataJSON,
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,
const uint64_t& _BrowsingContextId) :
Origin_(_Origin),
RpId_(_RpId),
Challenge_(_Challenge),
ClientDataJSON_(_ClientDataJSON),
ExcludeList_(_ExcludeList),
Rp_(_Rp),
User_(_User),
coseAlgs_(_coseAlgs),
Extensions_(_Extensions),
AuthenticatorSelection_(_AuthenticatorSelection),
attestationConveyancePreference_(_attestationConveyancePreference),
BrowsingContextId_(_BrowsingContextId),
TimeoutMS_(_TimeoutMS)
{
}
MOZ_IMPLICIT WebAuthnMakeCredentialInfo(
nsString&& _Origin,
nsString&& _RpId,
nsTArray<uint8_t>&& _Challenge,
nsCString&& _ClientDataJSON,
uint32_t&& _TimeoutMS,
nsTArray<WebAuthnScopedCredential>&& _ExcludeList,
WebAuthnMakeCredentialRpInfo&& _Rp,
WebAuthnMakeCredentialUserInfo&& _User,
nsTArray<CoseAlg>&& _coseAlgs,
nsTArray<WebAuthnExtension>&& _Extensions,
WebAuthnAuthenticatorSelection&& _AuthenticatorSelection,
nsString&& _attestationConveyancePreference,
uint64_t&& _BrowsingContextId) :
Origin_(std::move(_Origin)),
RpId_(std::move(_RpId)),
Challenge_(std::move(_Challenge)),
ClientDataJSON_(std::move(_ClientDataJSON)),
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)),
BrowsingContextId_(std::move(_BrowsingContextId)),
TimeoutMS_(std::move(_TimeoutMS))
{
}
nsString&
Origin()
{
return Origin_;
}
const nsString&
Origin() const
{
return Origin_;
}
nsString&
RpId()
{
return RpId_;
}
const nsString&
RpId() const
{
return RpId_;
}
nsTArray<uint8_t>&
Challenge()
{
return Challenge_;
}
const nsTArray<uint8_t>&
Challenge() const
{
return Challenge_;
}
nsCString&
ClientDataJSON()
{
return ClientDataJSON_;
}
const nsCString&
ClientDataJSON() const
{
return ClientDataJSON_;
}
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_;
}
uint64_t&
BrowsingContextId()
{
return BrowsingContextId_;
}
const uint64_t&
BrowsingContextId() const
{
return BrowsingContextId_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> Origin_;
::mozilla::ipc::IPDLStructMember<nsString> RpId_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Challenge_;
::mozilla::ipc::IPDLStructMember<nsCString> ClientDataJSON_;
::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<uint64_t> BrowsingContextId_;
::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 |struct WebAuthnGetAssertionInfo|
//
namespace mozilla {
namespace dom {
class WebAuthnGetAssertionInfo final
{
private:
typedef ::nsString nsString;
typedef ::uint8_t uint8_t;
typedef ::nsCString nsCString;
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::WebAuthnScopedCredential WebAuthnScopedCredential;
typedef ::mozilla::dom::WebAuthnExtension WebAuthnExtension;
typedef ::uint64_t uint64_t;
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 nsString& _Origin,
const nsString& _RpId,
const nsTArray<uint8_t>& _Challenge,
const nsCString& _ClientDataJSON,
const uint32_t& _TimeoutMS,
const nsTArray<WebAuthnScopedCredential>& _AllowList,
const nsTArray<WebAuthnExtension>& _Extensions,
const nsString& _userVerificationRequirement,
const bool& _ConditionallyMediated,
const uint64_t& _BrowsingContextId) :
Origin_(_Origin),
RpId_(_RpId),
Challenge_(_Challenge),
ClientDataJSON_(_ClientDataJSON),
AllowList_(_AllowList),
Extensions_(_Extensions),
userVerificationRequirement_(_userVerificationRequirement),
ConditionallyMediated_(_ConditionallyMediated),
BrowsingContextId_(_BrowsingContextId),
TimeoutMS_(_TimeoutMS)
{
}
MOZ_IMPLICIT WebAuthnGetAssertionInfo(
nsString&& _Origin,
nsString&& _RpId,
nsTArray<uint8_t>&& _Challenge,
nsCString&& _ClientDataJSON,
uint32_t&& _TimeoutMS,
nsTArray<WebAuthnScopedCredential>&& _AllowList,
nsTArray<WebAuthnExtension>&& _Extensions,
nsString&& _userVerificationRequirement,
bool&& _ConditionallyMediated,
uint64_t&& _BrowsingContextId) :
Origin_(std::move(_Origin)),
RpId_(std::move(_RpId)),
Challenge_(std::move(_Challenge)),
ClientDataJSON_(std::move(_ClientDataJSON)),
AllowList_(std::move(_AllowList)),
Extensions_(std::move(_Extensions)),
userVerificationRequirement_(std::move(_userVerificationRequirement)),
ConditionallyMediated_(std::move(_ConditionallyMediated)),
BrowsingContextId_(std::move(_BrowsingContextId)),
TimeoutMS_(std::move(_TimeoutMS))
{
}
nsString&
Origin()
{
return Origin_;
}
const nsString&
Origin() const
{
return Origin_;
}
nsString&
RpId()
{
return RpId_;
}
const nsString&
RpId() const
{
return RpId_;
}
nsTArray<uint8_t>&
Challenge()
{
return Challenge_;
}
const nsTArray<uint8_t>&
Challenge() const
{
return Challenge_;
}
nsCString&
ClientDataJSON()
{
return ClientDataJSON_;
}
const nsCString&
ClientDataJSON() const
{
return ClientDataJSON_;
}
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_;
}
uint64_t&
BrowsingContextId()
{
return BrowsingContextId_;
}
const uint64_t&
BrowsingContextId() const
{
return BrowsingContextId_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> Origin_;
::mozilla::ipc::IPDLStructMember<nsString> RpId_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> Challenge_;
::mozilla::ipc::IPDLStructMember<nsCString> ClientDataJSON_;
::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<uint64_t> BrowsingContextId_;
::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
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(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebAuthnTransactionChild>* aChild);
enum MessageType {
PWebAuthnTransactionStart = PWebAuthnTransactionMsgStart << 16,
Msg_RequestRegister__ID,
Msg_RequestSign__ID,
Msg_RequestIsUVPAA__ID,
Reply_RequestIsUVPAA__ID,
Msg_RequestCancel__ID,
Msg_DestroyMe__ID,
Msg___delete____ID,
Reply___delete____ID,
Msg_ConfirmRegister__ID,
Msg_ConfirmSign__ID,
Msg_Abort__ID,
PWebAuthnTransactionEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_RequestRegister(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestSign(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestIsUVPAA(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_RequestIsUVPAA(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestCancel(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_DestroyMe(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ConfirmRegister(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ConfirmSign(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Abort(int32_t routingId);
} // namespace PWebAuthnTransaction
} // namespace dom
} // namespace mozilla
#endif // ifndef PWebAuthnTransaction_h