// components/unexportable_keys/mojom/unexportable_key_service.mojom.h is auto generated by mojom_bindings_generator.py, do not edit // Copyright 2013 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_H_ #define COMPONENTS_UNEXPORTABLE_KEYS_MOJOM_UNEXPORTABLE_KEY_SERVICE_MOJOM_H_ #include #include #include #include #include #include "mojo/public/cpp/bindings/clone_traits.h" #include "mojo/public/cpp/bindings/equals_traits.h" #include "mojo/public/cpp/bindings/struct_ptr.h" #include "mojo/public/cpp/bindings/struct_traits.h" #include "mojo/public/cpp/bindings/union_traits.h" #include "mojo/public/cpp/bindings/lib/serialization.h" #include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h" #include "components/unexportable_keys/mojom/unexportable_key_service.mojom-features.h" // IWYU pragma: export #include "components/unexportable_keys/mojom/unexportable_key_service.mojom-shared.h" // IWYU pragma: export #include "components/unexportable_keys/mojom/unexportable_key_service.mojom-forward.h" // IWYU pragma: export #include "mojo/public/mojom/base/time.mojom.h" #include "mojo/public/mojom/base/unguessable_token.mojom.h" #include #include #include "mojo/public/cpp/bindings/lib/control_message_handler.h" #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" #include "base/types/expected.h" #include "components/unexportable_keys/background_task_priority.h" #include "components/unexportable_keys/mojom/unexportable_keys_mojom_traits.h" #include "components/unexportable_keys/service_error.h" #include "components/unexportable_keys/unexportable_key_id.h" #include "crypto/signature_verifier.h" #include "crypto/unexportable_key.h" namespace unexportable_keys::mojom { class UnexportableKeyServiceProxy; template class UnexportableKeyServiceStub; class UnexportableKeyServiceRequestValidator; class UnexportableKeyServiceResponseValidator; class UnexportableKeyService : public UnexportableKeyServiceInterfaceBase { public: using IPCStableHashFunction = uint32_t(*)(); static constexpr const char* Name_ = "unexportable_keys.mojom.UnexportableKeyService"; static IPCStableHashFunction MessageToMethodInfo_(mojo::Message& message); static const char* MessageToMethodName_(mojo::Message& message); static constexpr uint32_t Version_ = 0; static constexpr bool PassesAssociatedKinds_ = false; static constexpr bool HasUninterruptableMethods_ = false; using Base_ = UnexportableKeyServiceInterfaceBase; using Proxy_ = UnexportableKeyServiceProxy; template using Stub_ = UnexportableKeyServiceStub; using RequestValidator_ = UnexportableKeyServiceRequestValidator; using ResponseValidator_ = UnexportableKeyServiceResponseValidator; enum MethodMinVersions : uint32_t { kGenerateSigningKeyMinVersion = 0, kFromWrappedSigningKeyMinVersion = 0, kGenerateAttestationKeyMinVersion = 0, kFromWrappedAttestationKeyMinVersion = 0, kSignMinVersion = 0, kCertifyMinVersion = 0, kGetAllKeysForGarbageCollectionMinVersion = 0, kDeleteKeysMinVersion = 0, kDeleteAllKeysMinVersion = 0, }; // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK // with not having this data in traces there. #if !BUILDFLAG(IS_FUCHSIA) struct GenerateSigningKey_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct FromWrappedSigningKey_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct GenerateAttestationKey_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct FromWrappedAttestationKey_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct Sign_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct Certify_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct GetAllKeysForGarbageCollection_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct DeleteKeys_Sym { NOINLINE static uint32_t IPCStableHash(); }; struct DeleteAllKeys_Sym { NOINLINE static uint32_t IPCStableHash(); }; #endif // !BUILDFLAG(IS_FUCHSIA) virtual ~UnexportableKeyService() = default; using GenerateSigningKeyCallback = base::OnceCallback)>; using GenerateSigningKeyResult = base::expected< NewSigningKeyDataPtr, ::unexportable_keys::ServiceError>; using GenerateSigningKeyMojoCallback = base::OnceCallback; virtual void GenerateSigningKey(const std::vector<::crypto::SignatureVerifier::SignatureAlgorithm>& acceptable_algorithms, ::unexportable_keys::BackgroundTaskPriority priority, GenerateSigningKeyCallback callback) = 0; using FromWrappedSigningKeyCallback = base::OnceCallback)>; using FromWrappedSigningKeyResult = base::expected< NewSigningKeyDataPtr, ::unexportable_keys::ServiceError>; using FromWrappedSigningKeyMojoCallback = base::OnceCallback; virtual void FromWrappedSigningKey(const std::vector& wrapped_key, ::unexportable_keys::BackgroundTaskPriority priority, FromWrappedSigningKeyCallback callback) = 0; using GenerateAttestationKeyCallback = base::OnceCallback)>; using GenerateAttestationKeyResult = base::expected< NewAttestationKeyDataPtr, ::unexportable_keys::ServiceError>; using GenerateAttestationKeyMojoCallback = base::OnceCallback; virtual void GenerateAttestationKey(const std::vector<::crypto::SignatureVerifier::SignatureAlgorithm>& acceptable_algorithms, ::unexportable_keys::BackgroundTaskPriority priority, GenerateAttestationKeyCallback callback) = 0; using FromWrappedAttestationKeyCallback = base::OnceCallback)>; using FromWrappedAttestationKeyResult = base::expected< NewAttestationKeyDataPtr, ::unexportable_keys::ServiceError>; using FromWrappedAttestationKeyMojoCallback = base::OnceCallback; virtual void FromWrappedAttestationKey(const std::vector& wrapped_key, ::unexportable_keys::BackgroundTaskPriority priority, FromWrappedAttestationKeyCallback callback) = 0; using SignCallback = base::OnceCallback, ::unexportable_keys::ServiceError>)>; using SignResult = base::expected< std::vector, ::unexportable_keys::ServiceError>; using SignMojoCallback = base::OnceCallback; virtual void Sign(const ::unexportable_keys::UnexportableSigningKeyId& key_id, const std::vector& data, ::unexportable_keys::BackgroundTaskPriority priority, SignCallback callback) = 0; using CertifyCallback = base::OnceCallback)>; using CertifyResult = base::expected< ::crypto::AttestationStatement, ::unexportable_keys::ServiceError>; using CertifyMojoCallback = base::OnceCallback; virtual void Certify(const ::unexportable_keys::UnexportableAttestationKeyId& attestation_key_id, const ::unexportable_keys::UnexportableSigningKeyId& signing_key_id, const std::vector& challenge, ::unexportable_keys::BackgroundTaskPriority priority, CertifyCallback callback) = 0; using GetAllKeysForGarbageCollectionCallback = base::OnceCallback, ::unexportable_keys::ServiceError>)>; using GetAllKeysForGarbageCollectionResult = base::expected< std::vector, ::unexportable_keys::ServiceError>; using GetAllKeysForGarbageCollectionMojoCallback = base::OnceCallback; virtual void GetAllKeysForGarbageCollection(::unexportable_keys::BackgroundTaskPriority priority, GetAllKeysForGarbageCollectionCallback callback) = 0; using DeleteKeysCallback = base::OnceCallback)>; using DeleteKeysResult = base::expected< uint64_t, ::unexportable_keys::ServiceError>; using DeleteKeysMojoCallback = base::OnceCallback; virtual void DeleteKeys(const std::vector<::unexportable_keys::UnexportableSigningKeyId>& key_ids, ::unexportable_keys::BackgroundTaskPriority priority, DeleteKeysCallback callback) = 0; using DeleteAllKeysCallback = base::OnceCallback)>; using DeleteAllKeysResult = base::expected< uint64_t, ::unexportable_keys::ServiceError>; using DeleteAllKeysMojoCallback = base::OnceCallback; virtual void DeleteAllKeys(DeleteAllKeysCallback callback) = 0; }; class UnexportableKeyServiceProxy : public UnexportableKeyService { public: using InterfaceType = UnexportableKeyService; explicit UnexportableKeyServiceProxy(mojo::MessageReceiverWithResponder* receiver); void GenerateSigningKey(const std::vector<::crypto::SignatureVerifier::SignatureAlgorithm>& acceptable_algorithms, ::unexportable_keys::BackgroundTaskPriority priority, GenerateSigningKeyCallback callback) final; void FromWrappedSigningKey(const std::vector& wrapped_key, ::unexportable_keys::BackgroundTaskPriority priority, FromWrappedSigningKeyCallback callback) final; void GenerateAttestationKey(const std::vector<::crypto::SignatureVerifier::SignatureAlgorithm>& acceptable_algorithms, ::unexportable_keys::BackgroundTaskPriority priority, GenerateAttestationKeyCallback callback) final; void FromWrappedAttestationKey(const std::vector& wrapped_key, ::unexportable_keys::BackgroundTaskPriority priority, FromWrappedAttestationKeyCallback callback) final; void Sign(const ::unexportable_keys::UnexportableSigningKeyId& key_id, const std::vector& data, ::unexportable_keys::BackgroundTaskPriority priority, SignCallback callback) final; void Certify(const ::unexportable_keys::UnexportableAttestationKeyId& attestation_key_id, const ::unexportable_keys::UnexportableSigningKeyId& signing_key_id, const std::vector& challenge, ::unexportable_keys::BackgroundTaskPriority priority, CertifyCallback callback) final; void GetAllKeysForGarbageCollection(::unexportable_keys::BackgroundTaskPriority priority, GetAllKeysForGarbageCollectionCallback callback) final; void DeleteKeys(const std::vector<::unexportable_keys::UnexportableSigningKeyId>& key_ids, ::unexportable_keys::BackgroundTaskPriority priority, DeleteKeysCallback callback) final; void DeleteAllKeys(DeleteAllKeysCallback callback) final; private: mojo::MessageReceiverWithResponder* receiver_; }; class UnexportableKeyServiceStubDispatch { public: static bool Accept(UnexportableKeyService* impl, mojo::Message* message); static bool AcceptWithResponder( UnexportableKeyService* impl, mojo::Message* message, std::unique_ptr responder); }; template > class UnexportableKeyServiceStub : public mojo::MessageReceiverWithResponderStatus { public: using ImplPointerType = typename ImplRefTraits::PointerType; UnexportableKeyServiceStub() = default; ~UnexportableKeyServiceStub() override = default; void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } ImplPointerType& sink() { return sink_; } bool Accept(mojo::Message* message) override { if (ImplRefTraits::IsNull(sink_)) return false; return UnexportableKeyServiceStubDispatch::Accept( ImplRefTraits::GetRawPointer(&sink_), message); } bool AcceptWithResponder( mojo::Message* message, std::unique_ptr responder) override { if (ImplRefTraits::IsNull(sink_)) return false; return UnexportableKeyServiceStubDispatch::AcceptWithResponder( ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); } private: ImplPointerType sink_; }; class UnexportableKeyServiceRequestValidator : public mojo::MessageReceiver { public: bool Accept(mojo::Message* message) override; }; class UnexportableKeyServiceResponseValidator : public mojo::MessageReceiver { public: bool Accept(mojo::Message* message) override; }; class UnexportableKeyService_GenerateSigningKey_ResponseParam_Result { public: using DataView = UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_GenerateSigningKey_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_GenerateSigningKey_ResponseParam_Result_Tag; template static UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultPtr NewSuccess( NewSigningKeyDataPtr value); // Construct an instance holding |failure|. static UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_GenerateSigningKey_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_GenerateSigningKey_ResponseParam_Result(const UnexportableKeyService_GenerateSigningKey_ResponseParam_Result& other) = delete; UnexportableKeyService_GenerateSigningKey_ResponseParam_Result& operator=(const UnexportableKeyService_GenerateSigningKey_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_GenerateSigningKey_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const NewSigningKeyDataPtr& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } NewSigningKeyDataPtr& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(NewSigningKeyDataPtr success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_GenerateSigningKey_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, NewSigningKeyDataPtr value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} NewSigningKeyDataPtr success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_GenerateSigningKey_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, NewSigningKeyDataPtr value); UnexportableKeyService_GenerateSigningKey_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result { public: using DataView = UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result_Tag; template static UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultPtr NewSuccess( NewSigningKeyDataPtr value); // Construct an instance holding |failure|. static UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result(const UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result& other) = delete; UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result& operator=(const UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_FromWrappedSigningKey_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const NewSigningKeyDataPtr& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } NewSigningKeyDataPtr& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(NewSigningKeyDataPtr success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, NewSigningKeyDataPtr value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} NewSigningKeyDataPtr success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, NewSigningKeyDataPtr value); UnexportableKeyService_FromWrappedSigningKey_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result { public: using DataView = UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result_Tag; template static UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultPtr NewSuccess( NewAttestationKeyDataPtr value); // Construct an instance holding |failure|. static UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result(const UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result& other) = delete; UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result& operator=(const UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_GenerateAttestationKey_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const NewAttestationKeyDataPtr& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } NewAttestationKeyDataPtr& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(NewAttestationKeyDataPtr success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, NewAttestationKeyDataPtr value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} NewAttestationKeyDataPtr success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, NewAttestationKeyDataPtr value); UnexportableKeyService_GenerateAttestationKey_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result { public: using DataView = UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result_Tag; template static UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultPtr NewSuccess( NewAttestationKeyDataPtr value); // Construct an instance holding |failure|. static UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result(const UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result& other) = delete; UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result& operator=(const UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const NewAttestationKeyDataPtr& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } NewAttestationKeyDataPtr& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(NewAttestationKeyDataPtr success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, NewAttestationKeyDataPtr value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} NewAttestationKeyDataPtr success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, NewAttestationKeyDataPtr value); UnexportableKeyService_FromWrappedAttestationKey_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_Sign_ResponseParam_Result { public: using DataView = UnexportableKeyService_Sign_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_Sign_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_Sign_ResponseParam_Result_Tag; template static UnexportableKeyService_Sign_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_Sign_ResponseParam_ResultPtr NewSuccess( std::vector value); // Construct an instance holding |failure|. static UnexportableKeyService_Sign_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_Sign_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_Sign_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_Sign_ResponseParam_Result(const UnexportableKeyService_Sign_ResponseParam_Result& other) = delete; UnexportableKeyService_Sign_ResponseParam_Result& operator=(const UnexportableKeyService_Sign_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_Sign_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const std::vector& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } std::vector& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(std::vector success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_Sign_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, std::vector value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} std::vector success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_Sign_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, std::vector value); UnexportableKeyService_Sign_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_Certify_ResponseParam_Result { public: using DataView = UnexportableKeyService_Certify_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_Certify_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_Certify_ResponseParam_Result_Tag; template static UnexportableKeyService_Certify_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_Certify_ResponseParam_ResultPtr NewSuccess( const ::crypto::AttestationStatement& value); // Construct an instance holding |failure|. static UnexportableKeyService_Certify_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_Certify_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_Certify_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_Certify_ResponseParam_Result(const UnexportableKeyService_Certify_ResponseParam_Result& other) = delete; UnexportableKeyService_Certify_ResponseParam_Result& operator=(const UnexportableKeyService_Certify_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_Certify_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const ::crypto::AttestationStatement& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } ::crypto::AttestationStatement& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(const ::crypto::AttestationStatement& success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_Certify_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, const ::crypto::AttestationStatement& value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} ::crypto::AttestationStatement success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_Certify_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, const ::crypto::AttestationStatement& value); UnexportableKeyService_Certify_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result { public: using DataView = UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result_Tag; template static UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultPtr NewSuccess( std::vector value); // Construct an instance holding |failure|. static UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result(); // Delete the copy constructor and copy assignment operators because `data_` // contains raw pointers that must not be copied. UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result(const UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result& other) = delete; UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result& operator=(const UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result& other) = delete; // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } const std::vector& get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } std::vector& get_success() { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(std::vector success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, std::vector value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} std::vector success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, std::vector value); UnexportableKeyService_GetAllKeysForGarbageCollection_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_DeleteKeys_ResponseParam_Result { public: using DataView = UnexportableKeyService_DeleteKeys_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_DeleteKeys_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_DeleteKeys_ResponseParam_Result_Tag; template static UnexportableKeyService_DeleteKeys_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_DeleteKeys_ResponseParam_ResultPtr NewSuccess( uint64_t value); // Construct an instance holding |failure|. static UnexportableKeyService_DeleteKeys_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_DeleteKeys_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_DeleteKeys_ResponseParam_Result(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_DeleteKeys_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } uint64_t get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(uint64_t success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_DeleteKeys_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, uint64_t value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} uint64_t success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_DeleteKeys_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, uint64_t value); UnexportableKeyService_DeleteKeys_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableKeyService_DeleteAllKeys_ResponseParam_Result { public: using DataView = UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultDataView; using Data_ = internal::UnexportableKeyService_DeleteAllKeys_ResponseParam_Result_Data; using Tag = Data_::UnexportableKeyService_DeleteAllKeys_ResponseParam_Result_Tag; template static UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultPtr New(Args&&... args) { static_assert( sizeof...(args) < 0, "Do not use Union::New(); to create a union of a given subtype, use " "New(), not New() followed by set_(). To represent " "an empty union, mark the field or parameter as nullable in the mojom " "definition."); return nullptr; } // Construct an instance holding |success|. static UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultPtr NewSuccess( uint64_t value); // Construct an instance holding |failure|. static UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultPtr NewFailure( ::unexportable_keys::ServiceError value); template static UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } ~UnexportableKeyService_DeleteAllKeys_ResponseParam_Result(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableKeyService_DeleteAllKeys_ResponseParam_ResultPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template ::value>::type* = nullptr> bool Equals(const T& other) const; template ::value>::type* = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } Tag which() const { return tag_; } bool is_success() const { return tag_ == Tag::kSuccess; } uint64_t get_success() const { CHECK(tag_ == Tag::kSuccess); return data_.success; } void set_success(uint64_t success); bool is_failure() const { return tag_ == Tag::kFailure; } ::unexportable_keys::ServiceError get_failure() const { CHECK(tag_ == Tag::kFailure); return data_.failure; } void set_failure(::unexportable_keys::ServiceError failure); template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableKeyService_DeleteAllKeys_ResponseParam_Result::DataView>(input); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } private: template friend class ::mojo::InlinedStructPtr; template friend class ::mojo::StructPtr; union Union_ { Union_( std::in_place_index_t(Tag::kSuccess)>, uint64_t value); Union_( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); // The contents of the union are explicitly destroyed by `DestroyActive()`. ~Union_() {} uint64_t success; ::unexportable_keys::ServiceError failure; }; UnexportableKeyService_DeleteAllKeys_ResponseParam_Result( std::in_place_index_t(Tag::kSuccess)>, uint64_t value); UnexportableKeyService_DeleteAllKeys_ResponseParam_Result( std::in_place_index_t(Tag::kFailure)>, ::unexportable_keys::ServiceError value); static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); void DestroyActive(); Tag tag_; Union_ data_; }; class UnexportableSigningKeyId { public: template using EnableIfSame = std::enable_if_t::value>; using DataView = UnexportableSigningKeyIdDataView; using Data_ = internal::UnexportableSigningKeyId_Data; template static UnexportableSigningKeyIdPtr New(Args&&... args) { return UnexportableSigningKeyIdPtr( std::in_place, std::forward(args)...); } template static UnexportableSigningKeyIdPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } UnexportableSigningKeyId(); explicit UnexportableSigningKeyId( const ::base::UnguessableToken& key_id); ~UnexportableSigningKeyId(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableSigningKeyIdPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template * = nullptr> bool Equals(const T& other) const; template * = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } template * = nullptr> bool operator!=(const T& rhs) const { return !operator==(rhs); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< UnexportableSigningKeyId::DataView, std::vector, send_validation>(input); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< UnexportableSigningKeyId::DataView, std::vector>(input); } template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableSigningKeyId::DataView>(input); } // The returned Message is serialized only if the message is moved // cross-process or cross-language. Otherwise if the message is Deserialized // as the same UserType |input| will just be moved to |output| in // DeserializeFromMessage. template static mojo::Message WrapAsMessage(UserType input) { return mojo::Message(std::make_unique< internal::UnexportableSigningKeyId_UnserializedMessageContext< UserType, UnexportableSigningKeyId::DataView>>(0, 0, std::move(input)), MOJO_CREATE_MESSAGE_FLAG_NONE); } template static bool Deserialize(const void* data, size_t data_num_bytes, UserType* output) { mojo::Message message; return mojo::internal::DeserializeImpl( message, data, data_num_bytes, output, Validate); } template static bool Deserialize(base::span input, UserType* output) { return UnexportableSigningKeyId::Deserialize( input.empty() ? nullptr : input.data(), input.size(), output); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { auto context = input.TakeUnserializedContext< internal::UnexportableSigningKeyId_UnserializedMessageContext< UserType, UnexportableSigningKeyId::DataView>>(); if (context) { *output = std::move(context->TakeData()); return true; } input.SerializeIfNecessary(); return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } ::base::UnguessableToken key_id; // Serialise this struct into a trace. void WriteIntoTrace(perfetto::TracedValue traced_context) const; private: static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); }; // The comparison operators are templates, so they are only instantiated if they // are used. Thus, the bindings generator does not need to know whether // comparison operators are available for members. template * = nullptr> bool operator<(const T& lhs, const T& rhs); template * = nullptr> bool operator<=(const T& lhs, const T& rhs) { return !(rhs < lhs); } template * = nullptr> bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; } template * = nullptr> bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); } class UnexportableAttestationKeyId { public: template using EnableIfSame = std::enable_if_t::value>; using DataView = UnexportableAttestationKeyIdDataView; using Data_ = internal::UnexportableAttestationKeyId_Data; template static UnexportableAttestationKeyIdPtr New(Args&&... args) { return UnexportableAttestationKeyIdPtr( std::in_place, std::forward(args)...); } template static UnexportableAttestationKeyIdPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } UnexportableAttestationKeyId(); explicit UnexportableAttestationKeyId( const ::base::UnguessableToken& key_id); ~UnexportableAttestationKeyId(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template UnexportableAttestationKeyIdPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template * = nullptr> bool Equals(const T& other) const; template * = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } template * = nullptr> bool operator!=(const T& rhs) const { return !operator==(rhs); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< UnexportableAttestationKeyId::DataView, std::vector, send_validation>(input); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< UnexportableAttestationKeyId::DataView, std::vector>(input); } template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< UnexportableAttestationKeyId::DataView>(input); } // The returned Message is serialized only if the message is moved // cross-process or cross-language. Otherwise if the message is Deserialized // as the same UserType |input| will just be moved to |output| in // DeserializeFromMessage. template static mojo::Message WrapAsMessage(UserType input) { return mojo::Message(std::make_unique< internal::UnexportableAttestationKeyId_UnserializedMessageContext< UserType, UnexportableAttestationKeyId::DataView>>(0, 0, std::move(input)), MOJO_CREATE_MESSAGE_FLAG_NONE); } template static bool Deserialize(const void* data, size_t data_num_bytes, UserType* output) { mojo::Message message; return mojo::internal::DeserializeImpl( message, data, data_num_bytes, output, Validate); } template static bool Deserialize(base::span input, UserType* output) { return UnexportableAttestationKeyId::Deserialize( input.empty() ? nullptr : input.data(), input.size(), output); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { auto context = input.TakeUnserializedContext< internal::UnexportableAttestationKeyId_UnserializedMessageContext< UserType, UnexportableAttestationKeyId::DataView>>(); if (context) { *output = std::move(context->TakeData()); return true; } input.SerializeIfNecessary(); return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } ::base::UnguessableToken key_id; // Serialise this struct into a trace. void WriteIntoTrace(perfetto::TracedValue traced_context) const; private: static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); }; // The comparison operators are templates, so they are only instantiated if they // are used. Thus, the bindings generator does not need to know whether // comparison operators are available for members. template * = nullptr> bool operator<(const T& lhs, const T& rhs); template * = nullptr> bool operator<=(const T& lhs, const T& rhs) { return !(rhs < lhs); } template * = nullptr> bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; } template * = nullptr> bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); } class NewKeyMetadata { public: template using EnableIfSame = std::enable_if_t::value>; using DataView = NewKeyMetadataDataView; using Data_ = internal::NewKeyMetadata_Data; template static NewKeyMetadataPtr New(Args&&... args) { return NewKeyMetadataPtr( std::in_place, std::forward(args)...); } template static NewKeyMetadataPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } NewKeyMetadata(); NewKeyMetadata( std::vector subject_public_key_info, std::vector wrapped_key, ::crypto::SignatureVerifier::SignatureAlgorithm algorithm, const std::optional& key_tag, std::optional<::base::Time> creation_time); ~NewKeyMetadata(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template NewKeyMetadataPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template * = nullptr> bool Equals(const T& other) const; template * = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } template * = nullptr> bool operator!=(const T& rhs) const { return !operator==(rhs); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< NewKeyMetadata::DataView, std::vector, send_validation>(input); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< NewKeyMetadata::DataView, std::vector>(input); } template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< NewKeyMetadata::DataView>(input); } // The returned Message is serialized only if the message is moved // cross-process or cross-language. Otherwise if the message is Deserialized // as the same UserType |input| will just be moved to |output| in // DeserializeFromMessage. template static mojo::Message WrapAsMessage(UserType input) { return mojo::Message(std::make_unique< internal::NewKeyMetadata_UnserializedMessageContext< UserType, NewKeyMetadata::DataView>>(0, 0, std::move(input)), MOJO_CREATE_MESSAGE_FLAG_NONE); } template static bool Deserialize(const void* data, size_t data_num_bytes, UserType* output) { mojo::Message message; return mojo::internal::DeserializeImpl( message, data, data_num_bytes, output, Validate); } template static bool Deserialize(base::span input, UserType* output) { return NewKeyMetadata::Deserialize( input.empty() ? nullptr : input.data(), input.size(), output); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { auto context = input.TakeUnserializedContext< internal::NewKeyMetadata_UnserializedMessageContext< UserType, NewKeyMetadata::DataView>>(); if (context) { *output = std::move(context->TakeData()); return true; } input.SerializeIfNecessary(); return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } std::vector subject_public_key_info; std::vector wrapped_key; ::crypto::SignatureVerifier::SignatureAlgorithm algorithm; std::optional key_tag; std::optional<::base::Time> creation_time; // Serialise this struct into a trace. void WriteIntoTrace(perfetto::TracedValue traced_context) const; private: static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); }; // The comparison operators are templates, so they are only instantiated if they // are used. Thus, the bindings generator does not need to know whether // comparison operators are available for members. template * = nullptr> bool operator<(const T& lhs, const T& rhs); template * = nullptr> bool operator<=(const T& lhs, const T& rhs) { return !(rhs < lhs); } template * = nullptr> bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; } template * = nullptr> bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); } class NewSigningKeyData { public: template using EnableIfSame = std::enable_if_t::value>; using DataView = NewSigningKeyDataDataView; using Data_ = internal::NewSigningKeyData_Data; template static NewSigningKeyDataPtr New(Args&&... args) { return NewSigningKeyDataPtr( std::in_place, std::forward(args)...); } template static NewSigningKeyDataPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } NewSigningKeyData(); NewSigningKeyData( const ::unexportable_keys::UnexportableSigningKeyId& key_id, NewKeyMetadataPtr metadata); NewSigningKeyData(const NewSigningKeyData&) = delete; NewSigningKeyData& operator=(const NewSigningKeyData&) = delete; ~NewSigningKeyData(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template NewSigningKeyDataPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template * = nullptr> bool Equals(const T& other) const; template * = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } template * = nullptr> bool operator!=(const T& rhs) const { return !operator==(rhs); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< NewSigningKeyData::DataView, std::vector, send_validation>(input); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< NewSigningKeyData::DataView, std::vector>(input); } template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< NewSigningKeyData::DataView>(input); } // The returned Message is serialized only if the message is moved // cross-process or cross-language. Otherwise if the message is Deserialized // as the same UserType |input| will just be moved to |output| in // DeserializeFromMessage. template static mojo::Message WrapAsMessage(UserType input) { return mojo::Message(std::make_unique< internal::NewSigningKeyData_UnserializedMessageContext< UserType, NewSigningKeyData::DataView>>(0, 0, std::move(input)), MOJO_CREATE_MESSAGE_FLAG_NONE); } template static bool Deserialize(const void* data, size_t data_num_bytes, UserType* output) { mojo::Message message; return mojo::internal::DeserializeImpl( message, data, data_num_bytes, output, Validate); } template static bool Deserialize(base::span input, UserType* output) { return NewSigningKeyData::Deserialize( input.empty() ? nullptr : input.data(), input.size(), output); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { auto context = input.TakeUnserializedContext< internal::NewSigningKeyData_UnserializedMessageContext< UserType, NewSigningKeyData::DataView>>(); if (context) { *output = std::move(context->TakeData()); return true; } input.SerializeIfNecessary(); return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } ::unexportable_keys::UnexportableSigningKeyId key_id; NewKeyMetadataPtr metadata; // Serialise this struct into a trace. void WriteIntoTrace(perfetto::TracedValue traced_context) const; private: static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); }; // The comparison operators are templates, so they are only instantiated if they // are used. Thus, the bindings generator does not need to know whether // comparison operators are available for members. template * = nullptr> bool operator<(const T& lhs, const T& rhs); template * = nullptr> bool operator<=(const T& lhs, const T& rhs) { return !(rhs < lhs); } template * = nullptr> bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; } template * = nullptr> bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); } class NewAttestationKeyData { public: template using EnableIfSame = std::enable_if_t::value>; using DataView = NewAttestationKeyDataDataView; using Data_ = internal::NewAttestationKeyData_Data; template static NewAttestationKeyDataPtr New(Args&&... args) { return NewAttestationKeyDataPtr( std::in_place, std::forward(args)...); } template static NewAttestationKeyDataPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } NewAttestationKeyData(); NewAttestationKeyData( const ::unexportable_keys::UnexportableAttestationKeyId& key_id, NewKeyMetadataPtr metadata); NewAttestationKeyData(const NewAttestationKeyData&) = delete; NewAttestationKeyData& operator=(const NewAttestationKeyData&) = delete; ~NewAttestationKeyData(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template NewAttestationKeyDataPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template * = nullptr> bool Equals(const T& other) const; template * = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } template * = nullptr> bool operator!=(const T& rhs) const { return !operator==(rhs); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< NewAttestationKeyData::DataView, std::vector, send_validation>(input); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< NewAttestationKeyData::DataView, std::vector>(input); } template static mojo::Message SerializeAsMessage(UserType* input) { return mojo::internal::SerializeAsMessageImpl< NewAttestationKeyData::DataView>(input); } // The returned Message is serialized only if the message is moved // cross-process or cross-language. Otherwise if the message is Deserialized // as the same UserType |input| will just be moved to |output| in // DeserializeFromMessage. template static mojo::Message WrapAsMessage(UserType input) { return mojo::Message(std::make_unique< internal::NewAttestationKeyData_UnserializedMessageContext< UserType, NewAttestationKeyData::DataView>>(0, 0, std::move(input)), MOJO_CREATE_MESSAGE_FLAG_NONE); } template static bool Deserialize(const void* data, size_t data_num_bytes, UserType* output) { mojo::Message message; return mojo::internal::DeserializeImpl( message, data, data_num_bytes, output, Validate); } template static bool Deserialize(base::span input, UserType* output) { return NewAttestationKeyData::Deserialize( input.empty() ? nullptr : input.data(), input.size(), output); } template static bool DeserializeFromMessage(mojo::Message input, UserType* output) { auto context = input.TakeUnserializedContext< internal::NewAttestationKeyData_UnserializedMessageContext< UserType, NewAttestationKeyData::DataView>>(); if (context) { *output = std::move(context->TakeData()); return true; } input.SerializeIfNecessary(); return mojo::internal::DeserializeImpl( input, input.payload(), input.payload_num_bytes(), output, Validate); } ::unexportable_keys::UnexportableAttestationKeyId key_id; NewKeyMetadataPtr metadata; // Serialise this struct into a trace. void WriteIntoTrace(perfetto::TracedValue traced_context) const; private: static bool Validate(const void* data, mojo::internal::ValidationContext* validation_context); }; // The comparison operators are templates, so they are only instantiated if they // are used. Thus, the bindings generator does not need to know whether // comparison operators are available for members. template * = nullptr> bool operator<(const T& lhs, const T& rhs); template * = nullptr> bool operator<=(const T& lhs, const T& rhs) { return !(rhs < lhs); } template * = nullptr> bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; } template * = nullptr> bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); } class AttestationStatement { public: template using EnableIfSame = std::enable_if_t::value>; using DataView = AttestationStatementDataView; using Data_ = internal::AttestationStatement_Data; template static AttestationStatementPtr New(Args&&... args) { return AttestationStatementPtr( std::in_place, std::forward(args)...); } template static AttestationStatementPtr From(const U& u) { return mojo::TypeConverter::Convert(u); } template U To() const { return mojo::TypeConverter::Convert(*this); } AttestationStatement(); AttestationStatement( ::crypto::AttestationStatement::Format format, std::vector statement, std::vector signature); ~AttestationStatement(); // Clone() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Clone() or copy // constructor/assignment are available for members. template AttestationStatementPtr Clone() const; // Equals() is a template so it is only instantiated if it is used. Thus, the // bindings generator does not need to know whether Equals() or == operator // are available for members. template * = nullptr> bool Equals(const T& other) const; template * = nullptr> bool operator==(const T& rhs) const { return Equals(rhs); } template * = nullptr> bool operator!=(const T& rhs) const { return !operator==(rhs); } template static std::vector Serialize(UserType* input) { return mojo::internal::SerializeImpl< AttestationStatement::DataView, std::vector, send_validation>(input); } template static std::vector