authenticator.mojom.cc | Explore in Territory

// third_party/blink/public/mojom/webauthn/authenticator.mojom.cc 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.

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "third_party/blink/public/mojom/webauthn/authenticator.mojom.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "third_party/blink/public/mojom/webauthn/authenticator.mojom-params-data.h"
#include "third_party/blink/public/mojom/webauthn/authenticator.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/webauthn/authenticator.mojom-import-headers.h"
#include "third_party/blink/public/mojom/webauthn/authenticator.mojom-test-utils.h"


namespace blink::mojom {
CommonCredentialInfo::CommonCredentialInfo()
    : … { … }

CommonCredentialInfo::CommonCredentialInfo(
    const std::string& id_in,
    std::vector<uint8_t> raw_id_in,
    std::vector<uint8_t> client_data_json_in,
    std::vector<uint8_t> authenticator_data_in)
    : … { … }

CommonCredentialInfo::~CommonCredentialInfo() = default;

void CommonCredentialInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CommonCredentialInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
SupplementalPubKeysResponse::SupplementalPubKeysResponse()
    : … { … }

SupplementalPubKeysResponse::SupplementalPubKeysResponse(
    std::vector<std::vector<uint8_t>> signatures_in)
    : … { … }

SupplementalPubKeysResponse::~SupplementalPubKeysResponse() = default;

void SupplementalPubKeysResponse::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool SupplementalPubKeysResponse::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
MakeCredentialAuthenticatorResponse::MakeCredentialAuthenticatorResponse()
    : … { … }

MakeCredentialAuthenticatorResponse::MakeCredentialAuthenticatorResponse(
    CommonCredentialInfoPtr info_in,
    ::device::AuthenticatorAttachment authenticator_attachment_in,
    std::vector<uint8_t> attestation_object_in,
    std::vector<::device::FidoTransportProtocol> transports_in,
    bool echo_hmac_create_secret_in,
    bool hmac_create_secret_in,
    bool echo_prf_in,
    bool prf_in,
    PRFValuesPtr prf_results_in,
    bool echo_cred_blob_in,
    bool cred_blob_in,
    std::optional<std::vector<uint8_t>> public_key_der_in,
    int32_t public_key_algo_in,
    bool echo_cred_props_in,
    bool has_cred_props_rk_in,
    bool cred_props_rk_in,
    bool echo_large_blob_in,
    bool supports_large_blob_in,
    SupplementalPubKeysResponsePtr supplemental_pub_keys_in)
    : … { … }

MakeCredentialAuthenticatorResponse::~MakeCredentialAuthenticatorResponse() = default;

void MakeCredentialAuthenticatorResponse::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool MakeCredentialAuthenticatorResponse::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
GetAssertionAuthenticatorResponse::GetAssertionAuthenticatorResponse()
    : … { … }

GetAssertionAuthenticatorResponse::GetAssertionAuthenticatorResponse(
    CommonCredentialInfoPtr info_in,
    ::device::AuthenticatorAttachment authenticator_attachment_in,
    std::vector<uint8_t> signature_in,
    std::optional<std::vector<uint8_t>> user_handle_in,
    AuthenticationExtensionsClientOutputsPtr extensions_in)
    : … { … }

GetAssertionAuthenticatorResponse::~GetAssertionAuthenticatorResponse() = default;

void GetAssertionAuthenticatorResponse::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool GetAssertionAuthenticatorResponse::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
AuthenticationExtensionsClientOutputs::AuthenticationExtensionsClientOutputs()
    : … { … }

AuthenticationExtensionsClientOutputs::AuthenticationExtensionsClientOutputs(
    bool echo_appid_extension_in,
    bool appid_extension_in,
    bool echo_prf_in,
    PRFValuesPtr prf_results_in,
    bool prf_not_evaluated_in,
    bool echo_large_blob_in,
    std::optional<std::vector<uint8_t>> large_blob_in,
    bool echo_large_blob_written_in,
    bool large_blob_written_in,
    std::optional<std::vector<uint8_t>> get_cred_blob_in,
    SupplementalPubKeysResponsePtr supplemental_pub_keys_in)
    : … { … }

AuthenticationExtensionsClientOutputs::~AuthenticationExtensionsClientOutputs() = default;

void AuthenticationExtensionsClientOutputs::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool AuthenticationExtensionsClientOutputs::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialRpEntity::PublicKeyCredentialRpEntity()
    : … { … }

PublicKeyCredentialRpEntity::PublicKeyCredentialRpEntity(
    const std::string& id_in,
    const std::string& name_in)
    : … { … }

PublicKeyCredentialRpEntity::~PublicKeyCredentialRpEntity() = default;

void PublicKeyCredentialRpEntity::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialRpEntity::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialUserEntity::PublicKeyCredentialUserEntity()
    : … { … }

PublicKeyCredentialUserEntity::PublicKeyCredentialUserEntity(
    std::vector<uint8_t> id_in,
    const std::string& name_in,
    const std::string& display_name_in)
    : … { … }

PublicKeyCredentialUserEntity::~PublicKeyCredentialUserEntity() = default;

void PublicKeyCredentialUserEntity::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialUserEntity::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialParameters::PublicKeyCredentialParameters()
    : … { … }

PublicKeyCredentialParameters::PublicKeyCredentialParameters(
    ::device::CredentialType type_in,
    int32_t algorithm_identifier_in)
    : … { … }

PublicKeyCredentialParameters::~PublicKeyCredentialParameters() = default;

void PublicKeyCredentialParameters::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialParameters::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CableAuthentication::CableAuthentication()
    : … { … }

CableAuthentication::CableAuthentication(
    uint8_t version_in,
    std::optional<std::vector<uint8_t>> client_eid_in,
    std::optional<std::vector<uint8_t>> authenticator_eid_in,
    std::optional<std::vector<uint8_t>> session_pre_key_in,
    std::optional<std::vector<uint8_t>> server_link_data_in,
    std::optional<std::vector<uint8_t>> experiments_in)
    : … { … }

CableAuthentication::~CableAuthentication() = default;

void CableAuthentication::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CableAuthentication::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PRFValues::PRFValues()
    : … { … }

PRFValues::PRFValues(
    std::optional<std::vector<uint8_t>> id_in,
    std::vector<uint8_t> first_in,
    std::optional<std::vector<uint8_t>> second_in)
    : … { … }

PRFValues::~PRFValues() = default;

void PRFValues::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PRFValues::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PaymentOptions::PaymentOptions()
    : … { … }

PaymentOptions::PaymentOptions(
    ::payments::mojom::PaymentCurrencyAmountPtr total_in,
    PaymentCredentialInstrumentPtr instrument_in,
    const std::optional<std::string>& payee_name_in,
    const std::optional<::url::Origin>& payee_origin_in)
    : … { … }

PaymentOptions::~PaymentOptions() = default;

void PaymentOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PaymentOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PaymentCredentialInstrument::PaymentCredentialInstrument()
    : … { … }

PaymentCredentialInstrument::PaymentCredentialInstrument(
    const std::string& display_name_in,
    const ::GURL& icon_in,
    bool iconMustBeShown_in)
    : … { … }

PaymentCredentialInstrument::~PaymentCredentialInstrument() = default;

void PaymentCredentialInstrument::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PaymentCredentialInstrument::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
RemoteDesktopClientOverride::RemoteDesktopClientOverride()
    : … { … }

RemoteDesktopClientOverride::RemoteDesktopClientOverride(
    const ::url::Origin& origin_in,
    bool same_origin_with_ancestors_in)
    : … { … }

RemoteDesktopClientOverride::~RemoteDesktopClientOverride() = default;

void RemoteDesktopClientOverride::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool RemoteDesktopClientOverride::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
SupplementalPubKeysRequest::SupplementalPubKeysRequest()
    : … { … }

SupplementalPubKeysRequest::SupplementalPubKeysRequest(
    bool device_scope_requested_in,
    bool provider_scope_requested_in,
    ::device::AttestationConveyancePreference attestation_in,
    std::vector<std::string> attestation_formats_in)
    : … { … }

SupplementalPubKeysRequest::~SupplementalPubKeysRequest() = default;

void SupplementalPubKeysRequest::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool SupplementalPubKeysRequest::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialRequestOptions::PublicKeyCredentialRequestOptions()
    : … { … }

PublicKeyCredentialRequestOptions::PublicKeyCredentialRequestOptions(
    bool is_conditional_in,
    std::vector<uint8_t> challenge_in,
    std::optional<::base::TimeDelta> timeout_in,
    const std::string& relying_party_id_in,
    std::vector<::device::PublicKeyCredentialDescriptor> allow_credentials_in,
    std::vector<Hint> hints_in,
    ::device::UserVerificationRequirement user_verification_in,
    AuthenticationExtensionsClientInputsPtr extensions_in)
    : … { … }

PublicKeyCredentialRequestOptions::~PublicKeyCredentialRequestOptions() = default;

void PublicKeyCredentialRequestOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialRequestOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
AuthenticationExtensionsClientInputs::AuthenticationExtensionsClientInputs()
    : … { … }

AuthenticationExtensionsClientInputs::AuthenticationExtensionsClientInputs(
    const std::optional<std::string>& appid_in,
    std::vector<::device::CableDiscoveryData> cable_authentication_data_in,
    bool prf_in,
    std::vector<PRFValuesPtr> prf_inputs_in,
    bool prf_inputs_hashed_in,
    bool large_blob_read_in,
    std::optional<std::vector<uint8_t>> large_blob_write_in,
    bool get_cred_blob_in,
    RemoteDesktopClientOverridePtr remote_desktop_client_override_in,
    SupplementalPubKeysRequestPtr supplemental_pub_keys_in)
    : … { … }

AuthenticationExtensionsClientInputs::~AuthenticationExtensionsClientInputs() = default;

void AuthenticationExtensionsClientInputs::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool AuthenticationExtensionsClientInputs::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
AuthenticatorSelectionCriteria::AuthenticatorSelectionCriteria()
    : … { … }

AuthenticatorSelectionCriteria::AuthenticatorSelectionCriteria(
    ::device::AuthenticatorAttachment authenticator_attachment_in,
    ResidentKeyRequirement resident_key_in,
    ::device::UserVerificationRequirement user_verification_in)
    : … { … }

AuthenticatorSelectionCriteria::~AuthenticatorSelectionCriteria() = default;

void AuthenticatorSelectionCriteria::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool AuthenticatorSelectionCriteria::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialCreationOptions::PublicKeyCredentialCreationOptions()
    : … { … }

PublicKeyCredentialCreationOptions::PublicKeyCredentialCreationOptions(
    const ::device::PublicKeyCredentialRpEntity& relying_party_in,
    const ::device::PublicKeyCredentialUserEntity& user_in,
    std::vector<uint8_t> challenge_in,
    std::vector<::device::PublicKeyCredentialParams::CredentialInfo> public_key_parameters_in,
    std::optional<::base::TimeDelta> timeout_in,
    std::vector<::device::PublicKeyCredentialDescriptor> exclude_credentials_in,
    const std::optional<::device::AuthenticatorSelectionCriteria>& authenticator_selection_in,
    std::vector<Hint> hints_in,
    ::device::AttestationConveyancePreference attestation_in,
    bool hmac_create_secret_in,
    bool prf_enable_in,
    PRFValuesPtr prf_input_in,
    ProtectionPolicy protection_policy_in,
    bool enforce_protection_policy_in,
    const std::optional<std::string>& appid_exclude_in,
    bool cred_props_in,
    ::device::LargeBlobSupport large_blob_enable_in,
    bool is_payment_credential_creation_in,
    std::optional<std::vector<uint8_t>> cred_blob_in,
    bool min_pin_length_requested_in,
    RemoteDesktopClientOverridePtr remote_desktop_client_override_in,
    SupplementalPubKeysRequestPtr supplemental_pub_keys_in,
    std::vector<std::string> attestation_formats_in)
    : … { … }

PublicKeyCredentialCreationOptions::~PublicKeyCredentialCreationOptions() = default;

void PublicKeyCredentialCreationOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialCreationOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialDescriptor::PublicKeyCredentialDescriptor()
    : … { … }

PublicKeyCredentialDescriptor::PublicKeyCredentialDescriptor(
    ::device::CredentialType type_in,
    std::vector<uint8_t> id_in,
    std::vector<::device::FidoTransportProtocol> transports_in)
    : … { … }

PublicKeyCredentialDescriptor::~PublicKeyCredentialDescriptor() = default;

void PublicKeyCredentialDescriptor::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialDescriptor::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
WebAuthnDOMExceptionDetails::WebAuthnDOMExceptionDetails()
    : … { … }

WebAuthnDOMExceptionDetails::WebAuthnDOMExceptionDetails(
    const std::string& name_in,
    const std::string& message_in)
    : … { … }

WebAuthnDOMExceptionDetails::~WebAuthnDOMExceptionDetails() = default;
size_t WebAuthnDOMExceptionDetails::Hash(size_t seed) const { … }

void WebAuthnDOMExceptionDetails::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool WebAuthnDOMExceptionDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PublicKeyCredentialReportOptions::PublicKeyCredentialReportOptions()
    : … { … }

PublicKeyCredentialReportOptions::PublicKeyCredentialReportOptions(
    const std::string& relying_party_id_in,
    std::optional<std::vector<uint8_t>> unknown_credential_id_in,
    AllAcceptedCredentialsOptionsPtr all_accepted_credentials_in,
    CurrentUserDetailsOptionsPtr current_user_details_in)
    : … { … }

PublicKeyCredentialReportOptions::~PublicKeyCredentialReportOptions() = default;

void PublicKeyCredentialReportOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool PublicKeyCredentialReportOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
AllAcceptedCredentialsOptions::AllAcceptedCredentialsOptions()
    : … { … }

AllAcceptedCredentialsOptions::AllAcceptedCredentialsOptions(
    std::vector<uint8_t> user_id_in,
    std::vector<std::vector<uint8_t>> all_accepted_credentials_ids_in)
    : … { … }

AllAcceptedCredentialsOptions::~AllAcceptedCredentialsOptions() = default;

void AllAcceptedCredentialsOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool AllAcceptedCredentialsOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CurrentUserDetailsOptions::CurrentUserDetailsOptions()
    : … { … }

CurrentUserDetailsOptions::CurrentUserDetailsOptions(
    std::vector<uint8_t> user_id_in,
    const std::string& name_in,
    const std::string& display_name_in)
    : … { … }

CurrentUserDetailsOptions::~CurrentUserDetailsOptions() = default;

void CurrentUserDetailsOptions::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CurrentUserDetailsOptions::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
WebAuthnClientCapability::WebAuthnClientCapability()
    : … { … }

WebAuthnClientCapability::WebAuthnClientCapability(
    const std::string& name_in,
    bool supported_in)
    : … { … }

WebAuthnClientCapability::~WebAuthnClientCapability() = default;
size_t WebAuthnClientCapability::Hash(size_t seed) const { … }

void WebAuthnClientCapability::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool WebAuthnClientCapability::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char Authenticator::Name_[] = …;

Authenticator::IPCStableHashFunction Authenticator::MessageToMethodInfo_(mojo::Message& message) { … }


const char* Authenticator::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t Authenticator::MakeCredential_Sym::IPCStableHash() { … }
uint32_t Authenticator::GetAssertion_Sym::IPCStableHash() { … }
uint32_t Authenticator::IsUserVerifyingPlatformAuthenticatorAvailable_Sym::IPCStableHash() { … }
uint32_t Authenticator::IsConditionalMediationAvailable_Sym::IPCStableHash() { … }
uint32_t Authenticator::Report_Sym::IPCStableHash() { … }
uint32_t Authenticator::GetClientCapabilities_Sym::IPCStableHash() { … }
uint32_t Authenticator::Cancel_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class Authenticator_MakeCredential_ForwardToCallback
    : public mojo::MessageReceiver { … };

class Authenticator_GetAssertion_ForwardToCallback
    : public mojo::MessageReceiver { … };

class Authenticator_IsUserVerifyingPlatformAuthenticatorAvailable_ForwardToCallback
    : public mojo::MessageReceiver { … };

class Authenticator_IsConditionalMediationAvailable_ForwardToCallback
    : public mojo::MessageReceiver { … };

class Authenticator_Report_ForwardToCallback
    : public mojo::MessageReceiver { … };

class Authenticator_GetClientCapabilities_ForwardToCallback
    : public mojo::MessageReceiver { … };

AuthenticatorProxy::AuthenticatorProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void AuthenticatorProxy::MakeCredential(
    PublicKeyCredentialCreationOptionsPtr in_options, MakeCredentialCallback callback) { … }

void AuthenticatorProxy::GetAssertion(
    PublicKeyCredentialRequestOptionsPtr in_options, GetAssertionCallback callback) { … }

void AuthenticatorProxy::IsUserVerifyingPlatformAuthenticatorAvailable(
    IsUserVerifyingPlatformAuthenticatorAvailableCallback callback) { … }

void AuthenticatorProxy::IsConditionalMediationAvailable(
    IsConditionalMediationAvailableCallback callback) { … }

void AuthenticatorProxy::Report(
    PublicKeyCredentialReportOptionsPtr in_options, ReportCallback callback) { … }

void AuthenticatorProxy::GetClientCapabilities(
    GetClientCapabilitiesCallback callback) { … }

void AuthenticatorProxy::Cancel(
    ) { … }
class Authenticator_MakeCredential_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool Authenticator_MakeCredential_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void Authenticator_MakeCredential_ProxyToResponder::Run(
    AuthenticatorStatus in_status, MakeCredentialAuthenticatorResponsePtr in_credential, WebAuthnDOMExceptionDetailsPtr in_dom_exception_details) { … }
class Authenticator_GetAssertion_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool Authenticator_GetAssertion_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void Authenticator_GetAssertion_ProxyToResponder::Run(
    AuthenticatorStatus in_status, GetAssertionAuthenticatorResponsePtr in_credential, WebAuthnDOMExceptionDetailsPtr in_dom_exception_details) { … }
class Authenticator_IsUserVerifyingPlatformAuthenticatorAvailable_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool Authenticator_IsUserVerifyingPlatformAuthenticatorAvailable_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void Authenticator_IsUserVerifyingPlatformAuthenticatorAvailable_ProxyToResponder::Run(
    bool in_available) { … }
class Authenticator_IsConditionalMediationAvailable_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool Authenticator_IsConditionalMediationAvailable_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void Authenticator_IsConditionalMediationAvailable_ProxyToResponder::Run(
    bool in_available) { … }
class Authenticator_Report_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool Authenticator_Report_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void Authenticator_Report_ProxyToResponder::Run(
    AuthenticatorStatus in_status, WebAuthnDOMExceptionDetailsPtr in_dom_exception_details) { … }
class Authenticator_GetClientCapabilities_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool Authenticator_GetClientCapabilities_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void Authenticator_GetClientCapabilities_ProxyToResponder::Run(
    std::vector<WebAuthnClientCapabilityPtr> in_capabilities) { … }

// static
bool AuthenticatorStubDispatch::Accept(
    Authenticator* impl,
    mojo::Message* message) { … }

// static
bool AuthenticatorStubDispatch::AcceptWithResponder(
    Authenticator* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kAuthenticatorValidationInfo[] = …;

bool AuthenticatorRequestValidator::Accept(mojo::Message* message) { … }

bool AuthenticatorResponseValidator::Accept(mojo::Message* message) { … }


}  // blink::mojom


namespace mojo {


// static
bool StructTraits<::blink::mojom::CommonCredentialInfo::DataView, ::blink::mojom::CommonCredentialInfoPtr>::Read(
    ::blink::mojom::CommonCredentialInfo::DataView input,
    ::blink::mojom::CommonCredentialInfoPtr* output) { … }


// static
bool StructTraits<::blink::mojom::SupplementalPubKeysResponse::DataView, ::blink::mojom::SupplementalPubKeysResponsePtr>::Read(
    ::blink::mojom::SupplementalPubKeysResponse::DataView input,
    ::blink::mojom::SupplementalPubKeysResponsePtr* output) { … }


// static
bool StructTraits<::blink::mojom::MakeCredentialAuthenticatorResponse::DataView, ::blink::mojom::MakeCredentialAuthenticatorResponsePtr>::Read(
    ::blink::mojom::MakeCredentialAuthenticatorResponse::DataView input,
    ::blink::mojom::MakeCredentialAuthenticatorResponsePtr* output) { … }


// static
bool StructTraits<::blink::mojom::GetAssertionAuthenticatorResponse::DataView, ::blink::mojom::GetAssertionAuthenticatorResponsePtr>::Read(
    ::blink::mojom::GetAssertionAuthenticatorResponse::DataView input,
    ::blink::mojom::GetAssertionAuthenticatorResponsePtr* output) { … }


// static
bool StructTraits<::blink::mojom::AuthenticationExtensionsClientOutputs::DataView, ::blink::mojom::AuthenticationExtensionsClientOutputsPtr>::Read(
    ::blink::mojom::AuthenticationExtensionsClientOutputs::DataView input,
    ::blink::mojom::AuthenticationExtensionsClientOutputsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialRpEntity::DataView, ::blink::mojom::PublicKeyCredentialRpEntityPtr>::Read(
    ::blink::mojom::PublicKeyCredentialRpEntity::DataView input,
    ::blink::mojom::PublicKeyCredentialRpEntityPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialUserEntity::DataView, ::blink::mojom::PublicKeyCredentialUserEntityPtr>::Read(
    ::blink::mojom::PublicKeyCredentialUserEntity::DataView input,
    ::blink::mojom::PublicKeyCredentialUserEntityPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialParameters::DataView, ::blink::mojom::PublicKeyCredentialParametersPtr>::Read(
    ::blink::mojom::PublicKeyCredentialParameters::DataView input,
    ::blink::mojom::PublicKeyCredentialParametersPtr* output) { … }


// static
bool StructTraits<::blink::mojom::CableAuthentication::DataView, ::blink::mojom::CableAuthenticationPtr>::Read(
    ::blink::mojom::CableAuthentication::DataView input,
    ::blink::mojom::CableAuthenticationPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PRFValues::DataView, ::blink::mojom::PRFValuesPtr>::Read(
    ::blink::mojom::PRFValues::DataView input,
    ::blink::mojom::PRFValuesPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PaymentOptions::DataView, ::blink::mojom::PaymentOptionsPtr>::Read(
    ::blink::mojom::PaymentOptions::DataView input,
    ::blink::mojom::PaymentOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PaymentCredentialInstrument::DataView, ::blink::mojom::PaymentCredentialInstrumentPtr>::Read(
    ::blink::mojom::PaymentCredentialInstrument::DataView input,
    ::blink::mojom::PaymentCredentialInstrumentPtr* output) { … }


// static
bool StructTraits<::blink::mojom::RemoteDesktopClientOverride::DataView, ::blink::mojom::RemoteDesktopClientOverridePtr>::Read(
    ::blink::mojom::RemoteDesktopClientOverride::DataView input,
    ::blink::mojom::RemoteDesktopClientOverridePtr* output) { … }


// static
bool StructTraits<::blink::mojom::SupplementalPubKeysRequest::DataView, ::blink::mojom::SupplementalPubKeysRequestPtr>::Read(
    ::blink::mojom::SupplementalPubKeysRequest::DataView input,
    ::blink::mojom::SupplementalPubKeysRequestPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialRequestOptions::DataView, ::blink::mojom::PublicKeyCredentialRequestOptionsPtr>::Read(
    ::blink::mojom::PublicKeyCredentialRequestOptions::DataView input,
    ::blink::mojom::PublicKeyCredentialRequestOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::AuthenticationExtensionsClientInputs::DataView, ::blink::mojom::AuthenticationExtensionsClientInputsPtr>::Read(
    ::blink::mojom::AuthenticationExtensionsClientInputs::DataView input,
    ::blink::mojom::AuthenticationExtensionsClientInputsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::AuthenticatorSelectionCriteria::DataView, ::blink::mojom::AuthenticatorSelectionCriteriaPtr>::Read(
    ::blink::mojom::AuthenticatorSelectionCriteria::DataView input,
    ::blink::mojom::AuthenticatorSelectionCriteriaPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialCreationOptions::DataView, ::blink::mojom::PublicKeyCredentialCreationOptionsPtr>::Read(
    ::blink::mojom::PublicKeyCredentialCreationOptions::DataView input,
    ::blink::mojom::PublicKeyCredentialCreationOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialDescriptor::DataView, ::blink::mojom::PublicKeyCredentialDescriptorPtr>::Read(
    ::blink::mojom::PublicKeyCredentialDescriptor::DataView input,
    ::blink::mojom::PublicKeyCredentialDescriptorPtr* output) { … }


// static
bool StructTraits<::blink::mojom::WebAuthnDOMExceptionDetails::DataView, ::blink::mojom::WebAuthnDOMExceptionDetailsPtr>::Read(
    ::blink::mojom::WebAuthnDOMExceptionDetails::DataView input,
    ::blink::mojom::WebAuthnDOMExceptionDetailsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::PublicKeyCredentialReportOptions::DataView, ::blink::mojom::PublicKeyCredentialReportOptionsPtr>::Read(
    ::blink::mojom::PublicKeyCredentialReportOptions::DataView input,
    ::blink::mojom::PublicKeyCredentialReportOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::AllAcceptedCredentialsOptions::DataView, ::blink::mojom::AllAcceptedCredentialsOptionsPtr>::Read(
    ::blink::mojom::AllAcceptedCredentialsOptions::DataView input,
    ::blink::mojom::AllAcceptedCredentialsOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::CurrentUserDetailsOptions::DataView, ::blink::mojom::CurrentUserDetailsOptionsPtr>::Read(
    ::blink::mojom::CurrentUserDetailsOptions::DataView input,
    ::blink::mojom::CurrentUserDetailsOptionsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::WebAuthnClientCapability::DataView, ::blink::mojom::WebAuthnClientCapabilityPtr>::Read(
    ::blink::mojom::WebAuthnClientCapability::DataView input,
    ::blink::mojom::WebAuthnClientCapabilityPtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace blink::mojom {


void AuthenticatorInterceptorForTesting::MakeCredential(PublicKeyCredentialCreationOptionsPtr options, MakeCredentialCallback callback) { … }
void AuthenticatorInterceptorForTesting::GetAssertion(PublicKeyCredentialRequestOptionsPtr options, GetAssertionCallback callback) { … }
void AuthenticatorInterceptorForTesting::IsUserVerifyingPlatformAuthenticatorAvailable(IsUserVerifyingPlatformAuthenticatorAvailableCallback callback) { … }
void AuthenticatorInterceptorForTesting::IsConditionalMediationAvailable(IsConditionalMediationAvailableCallback callback) { … }
void AuthenticatorInterceptorForTesting::Report(PublicKeyCredentialReportOptionsPtr options, ReportCallback callback) { … }
void AuthenticatorInterceptorForTesting::GetClientCapabilities(GetClientCapabilitiesCallback callback) { … }
void AuthenticatorInterceptorForTesting::Cancel() { … }
AuthenticatorAsyncWaiter::AuthenticatorAsyncWaiter(
    Authenticator* proxy) : … { … }

AuthenticatorAsyncWaiter::~AuthenticatorAsyncWaiter() = default;

void AuthenticatorAsyncWaiter::MakeCredential(
    PublicKeyCredentialCreationOptionsPtr options, AuthenticatorStatus* out_status, MakeCredentialAuthenticatorResponsePtr* out_credential, WebAuthnDOMExceptionDetailsPtr* out_dom_exception_details) { … }



void AuthenticatorAsyncWaiter::GetAssertion(
    PublicKeyCredentialRequestOptionsPtr options, AuthenticatorStatus* out_status, GetAssertionAuthenticatorResponsePtr* out_credential, WebAuthnDOMExceptionDetailsPtr* out_dom_exception_details) { … }



void AuthenticatorAsyncWaiter::IsUserVerifyingPlatformAuthenticatorAvailable(
    bool* out_available) { … }

bool AuthenticatorAsyncWaiter::IsUserVerifyingPlatformAuthenticatorAvailable(
    ) { … }

void AuthenticatorAsyncWaiter::IsConditionalMediationAvailable(
    bool* out_available) { … }

bool AuthenticatorAsyncWaiter::IsConditionalMediationAvailable(
    ) { … }

void AuthenticatorAsyncWaiter::Report(
    PublicKeyCredentialReportOptionsPtr options, AuthenticatorStatus* out_status, WebAuthnDOMExceptionDetailsPtr* out_dom_exception_details) { … }



void AuthenticatorAsyncWaiter::GetClientCapabilities(
    std::vector<WebAuthnClientCapabilityPtr>* out_capabilities) { … }

std::vector<WebAuthnClientCapabilityPtr> AuthenticatorAsyncWaiter::GetClientCapabilities(
    ) { … }






}  // blink::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/third_party/blink/public/mojom/webauthn/authenticator.mojom.cc
