Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PBackgroundSharedTypes_h
#define PBackgroundSharedTypes_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/BackgroundUtils.h"
#include "mozilla/ipc/IPDLStructMember.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ContentSecurityPolicy|
//
namespace mozilla {
namespace ipc {
class ContentSecurityPolicy 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
ContentSecurityPolicy() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ContentSecurityPolicy(
const nsString& _policy,
const bool& _reportOnlyFlag,
const bool& _deliveredViaMetaTagFlag) :
policy_(_policy),
reportOnlyFlag_(_reportOnlyFlag),
deliveredViaMetaTagFlag_(_deliveredViaMetaTagFlag)
{
}
MOZ_IMPLICIT ContentSecurityPolicy(
nsString&& _policy,
bool&& _reportOnlyFlag,
bool&& _deliveredViaMetaTagFlag) :
policy_(std::move(_policy)),
reportOnlyFlag_(std::move(_reportOnlyFlag)),
deliveredViaMetaTagFlag_(std::move(_deliveredViaMetaTagFlag))
{
}
bool
operator==(const ContentSecurityPolicy& _o) const;
bool
operator!=(const ContentSecurityPolicy& _o) const;
nsString&
policy()
{
return policy_;
}
const nsString&
policy() const
{
return policy_;
}
bool&
reportOnlyFlag()
{
return reportOnlyFlag_;
}
const bool&
reportOnlyFlag() const
{
return reportOnlyFlag_;
}
bool&
deliveredViaMetaTagFlag()
{
return deliveredViaMetaTagFlag_;
}
const bool&
deliveredViaMetaTagFlag() const
{
return deliveredViaMetaTagFlag_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> policy_;
::mozilla::ipc::IPDLStructMember<bool> reportOnlyFlag_;
::mozilla::ipc::IPDLStructMember<bool> deliveredViaMetaTagFlag_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::ContentSecurityPolicy>
{
typedef ::mozilla::ipc::ContentSecurityPolicy 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 ContentPrincipalInfo|
//
namespace mozilla {
namespace ipc {
class ContentPrincipalInfo final
{
private:
typedef ::mozilla::OriginAttributes OriginAttributes;
typedef ::nsCString nsCString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ContentPrincipalInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ContentPrincipalInfo(
const OriginAttributes& _attrs,
const nsCString& _originNoSuffix,
const nsCString& _spec,
const mozilla::Maybe<nsCString>& _domain,
const nsCString& _baseDomain) :
attrs_(_attrs),
originNoSuffix_(_originNoSuffix),
spec_(_spec),
domain_(_domain),
baseDomain_(_baseDomain)
{
}
MOZ_IMPLICIT ContentPrincipalInfo(
OriginAttributes&& _attrs,
nsCString&& _originNoSuffix,
nsCString&& _spec,
mozilla::Maybe<nsCString>&& _domain,
nsCString&& _baseDomain) :
attrs_(std::move(_attrs)),
originNoSuffix_(std::move(_originNoSuffix)),
spec_(std::move(_spec)),
domain_(std::move(_domain)),
baseDomain_(std::move(_baseDomain))
{
}
bool
operator==(const ContentPrincipalInfo& _o) const;
bool
operator!=(const ContentPrincipalInfo& _o) const;
OriginAttributes&
attrs()
{
return attrs_;
}
const OriginAttributes&
attrs() const
{
return attrs_;
}
nsCString&
originNoSuffix()
{
return originNoSuffix_;
}
const nsCString&
originNoSuffix() const
{
return originNoSuffix_;
}
nsCString&
spec()
{
return spec_;
}
const nsCString&
spec() const
{
return spec_;
}
mozilla::Maybe<nsCString>&
domain()
{
return domain_;
}
const mozilla::Maybe<nsCString>&
domain() const
{
return domain_;
}
nsCString&
baseDomain()
{
return baseDomain_;
}
const nsCString&
baseDomain() const
{
return baseDomain_;
}
private:
::mozilla::ipc::IPDLStructMember<OriginAttributes> attrs_;
::mozilla::ipc::IPDLStructMember<nsCString> originNoSuffix_;
::mozilla::ipc::IPDLStructMember<nsCString> spec_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> domain_;
::mozilla::ipc::IPDLStructMember<nsCString> baseDomain_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::ContentPrincipalInfo>
{
typedef ::mozilla::ipc::ContentPrincipalInfo 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 SystemPrincipalInfo|
//
namespace mozilla {
namespace ipc {
class SystemPrincipalInfo final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
SystemPrincipalInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
bool
operator==(const SystemPrincipalInfo& _o) const;
bool
operator!=(const SystemPrincipalInfo& _o) const;
private:
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::SystemPrincipalInfo>
{
typedef ::mozilla::ipc::SystemPrincipalInfo 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 NullPrincipalInfo|
//
namespace mozilla {
namespace ipc {
class NullPrincipalInfo final
{
private:
typedef ::mozilla::OriginAttributes OriginAttributes;
typedef ::nsCString nsCString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
NullPrincipalInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT NullPrincipalInfo(
const OriginAttributes& _attrs,
const nsCString& _spec) :
attrs_(_attrs),
spec_(_spec)
{
}
MOZ_IMPLICIT NullPrincipalInfo(
OriginAttributes&& _attrs,
nsCString&& _spec) :
attrs_(std::move(_attrs)),
spec_(std::move(_spec))
{
}
bool
operator==(const NullPrincipalInfo& _o) const;
bool
operator!=(const NullPrincipalInfo& _o) const;
OriginAttributes&
attrs()
{
return attrs_;
}
const OriginAttributes&
attrs() const
{
return attrs_;
}
nsCString&
spec()
{
return spec_;
}
const nsCString&
spec() const
{
return spec_;
}
private:
::mozilla::ipc::IPDLStructMember<OriginAttributes> attrs_;
::mozilla::ipc::IPDLStructMember<nsCString> spec_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::NullPrincipalInfo>
{
typedef ::mozilla::ipc::NullPrincipalInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace ipc {
class ExpandedPrincipalInfo;
} // namespace ipc
} // namespace mozilla
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union PrincipalInfo|
//
namespace mozilla {
namespace ipc {
class PrincipalInfo final
{
public:
enum Type {
T__None,
TContentPrincipalInfo = 1,
TSystemPrincipalInfo,
TNullPrincipalInfo,
TExpandedPrincipalInfo,
T__Last = TExpandedPrincipalInfo
};
private:
typedef ::mozilla::ipc::ContentPrincipalInfo ContentPrincipalInfo;
typedef ::mozilla::ipc::SystemPrincipalInfo SystemPrincipalInfo;
typedef ::mozilla::ipc::NullPrincipalInfo NullPrincipalInfo;
typedef ::mozilla::ipc::ExpandedPrincipalInfo ExpandedPrincipalInfo;
typedef ContentPrincipalInfo ContentPrincipalInfo__tdef;
typedef SystemPrincipalInfo SystemPrincipalInfo__tdef;
typedef NullPrincipalInfo NullPrincipalInfo__tdef;
typedef ExpandedPrincipalInfo* ExpandedPrincipalInfo__tdef;
union Value {
mozilla::AlignedStorage2<ContentPrincipalInfo> VContentPrincipalInfo;
mozilla::AlignedStorage2<SystemPrincipalInfo> VSystemPrincipalInfo;
mozilla::AlignedStorage2<NullPrincipalInfo> VNullPrincipalInfo;
ExpandedPrincipalInfo* VExpandedPrincipalInfo;
};
ContentPrincipalInfo*
ptr_ContentPrincipalInfo()
{
return ((mValue).VContentPrincipalInfo).addr();
}
const ContentPrincipalInfo*
constptr_ContentPrincipalInfo() const
{
return ((mValue).VContentPrincipalInfo).addr();
}
SystemPrincipalInfo*
ptr_SystemPrincipalInfo()
{
return ((mValue).VSystemPrincipalInfo).addr();
}
const SystemPrincipalInfo*
constptr_SystemPrincipalInfo() const
{
return ((mValue).VSystemPrincipalInfo).addr();
}
NullPrincipalInfo*
ptr_NullPrincipalInfo()
{
return ((mValue).VNullPrincipalInfo).addr();
}
const NullPrincipalInfo*
constptr_NullPrincipalInfo() const
{
return ((mValue).VNullPrincipalInfo).addr();
}
ExpandedPrincipalInfo*&
ptr_ExpandedPrincipalInfo()
{
return (mValue).VExpandedPrincipalInfo;
}
const ExpandedPrincipalInfo*
constptr_ExpandedPrincipalInfo() const
{
return (mValue).VExpandedPrincipalInfo;
}
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 PrincipalInfo() :
mType(T__None)
{
}
MOZ_IMPLICIT PrincipalInfo(const ContentPrincipalInfo& aOther);
MOZ_IMPLICIT PrincipalInfo(ContentPrincipalInfo&& aOther);
MOZ_IMPLICIT PrincipalInfo(const SystemPrincipalInfo& aOther);
MOZ_IMPLICIT PrincipalInfo(SystemPrincipalInfo&& aOther);
MOZ_IMPLICIT PrincipalInfo(const NullPrincipalInfo& aOther);
MOZ_IMPLICIT PrincipalInfo(NullPrincipalInfo&& aOther);
MOZ_IMPLICIT PrincipalInfo(const ExpandedPrincipalInfo& aOther);
MOZ_IMPLICIT PrincipalInfo(ExpandedPrincipalInfo&& aOther);
MOZ_IMPLICIT PrincipalInfo(const PrincipalInfo& aOther);
MOZ_IMPLICIT PrincipalInfo(PrincipalInfo&& aOther);
~PrincipalInfo();
Type
type() const
{
return mType;
}
PrincipalInfo&
operator=(const ContentPrincipalInfo& aRhs);
PrincipalInfo&
operator=(ContentPrincipalInfo&& aRhs);
PrincipalInfo&
operator=(const SystemPrincipalInfo& aRhs);
PrincipalInfo&
operator=(SystemPrincipalInfo&& aRhs);
PrincipalInfo&
operator=(const NullPrincipalInfo& aRhs);
PrincipalInfo&
operator=(NullPrincipalInfo&& aRhs);
PrincipalInfo&
operator=(const ExpandedPrincipalInfo& aRhs);
PrincipalInfo&
operator=(ExpandedPrincipalInfo&& aRhs);
PrincipalInfo&
operator=(const PrincipalInfo& aRhs);
PrincipalInfo&
operator=(PrincipalInfo&& aRhs);
bool
operator==(const ContentPrincipalInfo& aRhs) const;
bool
operator==(const SystemPrincipalInfo& aRhs) const;
bool
operator==(const NullPrincipalInfo& aRhs) const;
bool
operator==(const ExpandedPrincipalInfo& aRhs) const;
bool
operator==(const PrincipalInfo& aRhs) const;
ContentPrincipalInfo&
get_ContentPrincipalInfo()
{
AssertSanity(TContentPrincipalInfo);
return (*(ptr_ContentPrincipalInfo()));
}
const ContentPrincipalInfo&
get_ContentPrincipalInfo() const
{
AssertSanity(TContentPrincipalInfo);
return (*(constptr_ContentPrincipalInfo()));
}
operator ContentPrincipalInfo&()
{
return get_ContentPrincipalInfo();
}
operator const ContentPrincipalInfo&() const
{
return get_ContentPrincipalInfo();
}
SystemPrincipalInfo&
get_SystemPrincipalInfo()
{
AssertSanity(TSystemPrincipalInfo);
return (*(ptr_SystemPrincipalInfo()));
}
const SystemPrincipalInfo&
get_SystemPrincipalInfo() const
{
AssertSanity(TSystemPrincipalInfo);
return (*(constptr_SystemPrincipalInfo()));
}
operator SystemPrincipalInfo&()
{
return get_SystemPrincipalInfo();
}
operator const SystemPrincipalInfo&() const
{
return get_SystemPrincipalInfo();
}
NullPrincipalInfo&
get_NullPrincipalInfo()
{
AssertSanity(TNullPrincipalInfo);
return (*(ptr_NullPrincipalInfo()));
}
const NullPrincipalInfo&
get_NullPrincipalInfo() const
{
AssertSanity(TNullPrincipalInfo);
return (*(constptr_NullPrincipalInfo()));
}
operator NullPrincipalInfo&()
{
return get_NullPrincipalInfo();
}
operator const NullPrincipalInfo&() const
{
return get_NullPrincipalInfo();
}
ExpandedPrincipalInfo&
get_ExpandedPrincipalInfo()
{
AssertSanity(TExpandedPrincipalInfo);
return (*(ptr_ExpandedPrincipalInfo()));
}
const ExpandedPrincipalInfo&
get_ExpandedPrincipalInfo() const
{
AssertSanity(TExpandedPrincipalInfo);
return (*(constptr_ExpandedPrincipalInfo()));
}
operator ExpandedPrincipalInfo&()
{
return get_ExpandedPrincipalInfo();
}
operator const ExpandedPrincipalInfo&() const
{
return get_ExpandedPrincipalInfo();
}
private:
Value mValue;
Type mType;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::PrincipalInfo>
{
typedef ::mozilla::ipc::PrincipalInfo 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 ExpandedPrincipalInfo|
//
namespace mozilla {
namespace ipc {
class ExpandedPrincipalInfo final
{
private:
typedef ::mozilla::OriginAttributes OriginAttributes;
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ExpandedPrincipalInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ExpandedPrincipalInfo(
const OriginAttributes& _attrs,
const nsTArray<PrincipalInfo>& _allowlist) :
attrs_(_attrs),
allowlist_(_allowlist)
{
}
MOZ_IMPLICIT ExpandedPrincipalInfo(
OriginAttributes&& _attrs,
nsTArray<PrincipalInfo>&& _allowlist) :
attrs_(std::move(_attrs)),
allowlist_(std::move(_allowlist))
{
}
bool
operator==(const ExpandedPrincipalInfo& _o) const;
bool
operator!=(const ExpandedPrincipalInfo& _o) const;
OriginAttributes&
attrs()
{
return attrs_;
}
const OriginAttributes&
attrs() const
{
return attrs_;
}
nsTArray<PrincipalInfo>&
allowlist()
{
return allowlist_;
}
const nsTArray<PrincipalInfo>&
allowlist() const
{
return allowlist_;
}
private:
::mozilla::ipc::IPDLStructMember<OriginAttributes> attrs_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<PrincipalInfo>> allowlist_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::ExpandedPrincipalInfo>
{
typedef ::mozilla::ipc::ExpandedPrincipalInfo 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 CSPInfo|
//
namespace mozilla {
namespace ipc {
class CSPInfo final
{
private:
typedef ::mozilla::ipc::ContentSecurityPolicy ContentSecurityPolicy;
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::nsCString nsCString;
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
CSPInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CSPInfo(
const nsTArray<ContentSecurityPolicy>& _policyInfos,
const PrincipalInfo& _requestPrincipalInfo,
const nsCString& _selfURISpec,
const nsCString& _referrer,
const uint64_t& _innerWindowID,
const bool& _skipAllowInlineStyleCheck) :
policyInfos_(_policyInfos),
requestPrincipalInfo_(_requestPrincipalInfo),
selfURISpec_(_selfURISpec),
referrer_(_referrer),
skipAllowInlineStyleCheck_(_skipAllowInlineStyleCheck),
innerWindowID_(_innerWindowID)
{
}
MOZ_IMPLICIT CSPInfo(
nsTArray<ContentSecurityPolicy>&& _policyInfos,
PrincipalInfo&& _requestPrincipalInfo,
nsCString&& _selfURISpec,
nsCString&& _referrer,
uint64_t&& _innerWindowID,
bool&& _skipAllowInlineStyleCheck) :
policyInfos_(std::move(_policyInfos)),
requestPrincipalInfo_(std::move(_requestPrincipalInfo)),
selfURISpec_(std::move(_selfURISpec)),
referrer_(std::move(_referrer)),
skipAllowInlineStyleCheck_(std::move(_skipAllowInlineStyleCheck)),
innerWindowID_(std::move(_innerWindowID))
{
}
bool
operator==(const CSPInfo& _o) const;
bool
operator!=(const CSPInfo& _o) const;
nsTArray<ContentSecurityPolicy>&
policyInfos()
{
return policyInfos_;
}
const nsTArray<ContentSecurityPolicy>&
policyInfos() const
{
return policyInfos_;
}
PrincipalInfo&
requestPrincipalInfo()
{
return requestPrincipalInfo_;
}
const PrincipalInfo&
requestPrincipalInfo() const
{
return requestPrincipalInfo_;
}
nsCString&
selfURISpec()
{
return selfURISpec_;
}
const nsCString&
selfURISpec() const
{
return selfURISpec_;
}
nsCString&
referrer()
{
return referrer_;
}
const nsCString&
referrer() const
{
return referrer_;
}
uint64_t&
innerWindowID()
{
return innerWindowID_;
}
const uint64_t&
innerWindowID() const
{
return innerWindowID_;
}
bool&
skipAllowInlineStyleCheck()
{
return skipAllowInlineStyleCheck_;
}
const bool&
skipAllowInlineStyleCheck() const
{
return skipAllowInlineStyleCheck_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<ContentSecurityPolicy>> policyInfos_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> requestPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<nsCString> selfURISpec_;
::mozilla::ipc::IPDLStructMember<nsCString> referrer_;
::mozilla::ipc::IPDLStructMember<bool> skipAllowInlineStyleCheck_;
::mozilla::ipc::IPDLStructMember<uint64_t> innerWindowID_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::CSPInfo>
{
typedef ::mozilla::ipc::CSPInfo 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 WebTransportHash|
//
namespace mozilla {
namespace ipc {
class WebTransportHash final
{
private:
typedef ::nsCString nsCString;
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
WebTransportHash() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT WebTransportHash(
const nsCString& _algorithm,
const nsTArray<uint8_t>& _value) :
algorithm_(_algorithm),
value_(_value)
{
}
MOZ_IMPLICIT WebTransportHash(
nsCString&& _algorithm,
nsTArray<uint8_t>&& _value) :
algorithm_(std::move(_algorithm)),
value_(std::move(_value))
{
}
bool
operator==(const WebTransportHash& _o) const;
bool
operator!=(const WebTransportHash& _o) const;
nsCString&
algorithm()
{
return algorithm_;
}
const nsCString&
algorithm() const
{
return algorithm_;
}
nsTArray<uint8_t>&
value()
{
return value_;
}
const nsTArray<uint8_t>&
value() const
{
return value_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> algorithm_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> value_;
};
} // namespace ipc
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::ipc::WebTransportHash>
{
typedef ::mozilla::ipc::WebTransportHash paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef PBackgroundSharedTypes_h