chromium/out/Default/gen/services/device/public/mojom/smart_card.mojom-blink.cc

// services/device/public/mojom/smart_card.mojom-blink.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 "services/device/public/mojom/smart_card.mojom-blink.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 "services/device/public/mojom/smart_card.mojom-params-data.h"
#include "services/device/public/mojom/smart_card.mojom-shared-message-ids.h"

#include "services/device/public/mojom/smart_card.mojom-blink-import-headers.h"
#include "services/device/public/mojom/smart_card.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace device::mojom::blink {
SmartCardReaderStateFlags::SmartCardReaderStateFlags()
    :{}

SmartCardReaderStateFlags::SmartCardReaderStateFlags(
    bool unaware_in,
    bool ignore_in,
    bool changed_in,
    bool unknown_in,
    bool unavailable_in,
    bool empty_in,
    bool present_in,
    bool exclusive_in,
    bool inuse_in,
    bool mute_in,
    bool unpowered_in)
    :{}

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

void SmartCardReaderStateFlags::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {}

bool SmartCardReaderStateFlags::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardReaderStateIn::SmartCardReaderStateIn()
    :{}

SmartCardReaderStateIn::SmartCardReaderStateIn(
    const WTF::String& reader_in,
    SmartCardReaderStateFlagsPtr current_state_in,
    uint16_t current_count_in)
    :{}

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

void SmartCardReaderStateIn::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {}

bool SmartCardReaderStateIn::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardReaderStateOut::SmartCardReaderStateOut()
    :{}

SmartCardReaderStateOut::SmartCardReaderStateOut(
    const WTF::String& reader_in,
    SmartCardReaderStateFlagsPtr event_state_in,
    uint16_t event_count_in,
    WTF::Vector<uint8_t> answer_to_reset_in)
    :{}

SmartCardReaderStateOut::~SmartCardReaderStateOut() = default;

void SmartCardReaderStateOut::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {}

bool SmartCardReaderStateOut::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardProtocols::SmartCardProtocols()
    :{}

SmartCardProtocols::SmartCardProtocols(
    bool t0_in,
    bool t1_in,
    bool raw_in)
    :{}

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

void SmartCardProtocols::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {}

bool SmartCardProtocols::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardStatus::SmartCardStatus()
    :{}

SmartCardStatus::SmartCardStatus(
    const WTF::String& reader_name_in,
    SmartCardConnectionState state_in,
    SmartCardProtocol protocol_in,
    WTF::Vector<uint8_t> answer_to_reset_in)
    :{}

SmartCardStatus::~SmartCardStatus() = default;

void SmartCardStatus::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {}

bool SmartCardStatus::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardConnectSuccess::SmartCardConnectSuccess()
    :{}

SmartCardConnectSuccess::SmartCardConnectSuccess(
    ::mojo::PendingRemote<SmartCardConnection> connection_in,
    SmartCardProtocol active_protocol_in)
    :{}

SmartCardConnectSuccess::~SmartCardConnectSuccess() = default;

void SmartCardConnectSuccess::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {}

bool SmartCardConnectSuccess::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardResult::SmartCardResult() :{}

SmartCardResult::~SmartCardResult() {}


void SmartCardResult::set_success(
    SmartCardSuccess success) {}
void SmartCardResult::set_error(
    SmartCardError error) {}

void SmartCardResult::DestroyActive() {}
size_t SmartCardResult::Hash(size_t seed) const {}

bool SmartCardResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardStatusChangeResult::SmartCardStatusChangeResult() :{}

SmartCardStatusChangeResult::~SmartCardStatusChangeResult() {}


void SmartCardStatusChangeResult::set_reader_states(
    WTF::Vector<SmartCardReaderStateOutPtr> reader_states) {}
void SmartCardStatusChangeResult::set_error(
    SmartCardError error) {}

void SmartCardStatusChangeResult::DestroyActive() {}

bool SmartCardStatusChangeResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardListReadersResult::SmartCardListReadersResult() :{}

SmartCardListReadersResult::~SmartCardListReadersResult() {}


void SmartCardListReadersResult::set_readers(
    WTF::Vector<WTF::String> readers) {}
void SmartCardListReadersResult::set_error(
    SmartCardError error) {}

void SmartCardListReadersResult::DestroyActive() {}

bool SmartCardListReadersResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardCreateContextResult::SmartCardCreateContextResult() :{}

SmartCardCreateContextResult::~SmartCardCreateContextResult() {}


void SmartCardCreateContextResult::set_context(
    ::mojo::PendingRemote<SmartCardContext> context) {}
void SmartCardCreateContextResult::set_error(
    SmartCardError error) {}

void SmartCardCreateContextResult::DestroyActive() {}

bool SmartCardCreateContextResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardConnectResult::SmartCardConnectResult() :{}

SmartCardConnectResult::~SmartCardConnectResult() {}


void SmartCardConnectResult::set_success(
    SmartCardConnectSuccessPtr success) {}
void SmartCardConnectResult::set_error(
    SmartCardError error) {}

void SmartCardConnectResult::DestroyActive() {}

bool SmartCardConnectResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardDataResult::SmartCardDataResult() :{}

SmartCardDataResult::~SmartCardDataResult() {}


void SmartCardDataResult::set_data(
    WTF::Vector<uint8_t> data) {}
void SmartCardDataResult::set_error(
    SmartCardError error) {}

void SmartCardDataResult::DestroyActive() {}

bool SmartCardDataResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardStatusResult::SmartCardStatusResult() :{}

SmartCardStatusResult::~SmartCardStatusResult() {}


void SmartCardStatusResult::set_status(
    SmartCardStatusPtr status) {}
void SmartCardStatusResult::set_error(
    SmartCardError error) {}

void SmartCardStatusResult::DestroyActive() {}

bool SmartCardStatusResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {}
SmartCardTransactionResult::SmartCardTransactionResult() :{}

SmartCardTransactionResult::~SmartCardTransactionResult() {}


void SmartCardTransactionResult::set_transaction(
    ::mojo::PendingAssociatedRemote<SmartCardTransaction> transaction) {}
void SmartCardTransactionResult::set_error(
    SmartCardError error) {}

void SmartCardTransactionResult::DestroyActive() {}

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

SmartCardTransaction::IPCStableHashFunction SmartCardTransaction::MessageToMethodInfo_(mojo::Message& message) {}


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SmartCardTransaction::EndTransaction_Sym::IPCStableHash() {}
# endif // !BUILDFLAG(IS_FUCHSIA)

class SmartCardTransaction_EndTransaction_ForwardToCallback
    : public mojo::MessageReceiver {};

SmartCardTransactionProxy::SmartCardTransactionProxy(mojo::MessageReceiverWithResponder* receiver)
    :{}

void SmartCardTransactionProxy::EndTransaction(
    SmartCardDisposition in_disposition, EndTransactionCallback callback) {}
class SmartCardTransaction_EndTransaction_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardTransaction_EndTransaction_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardTransaction_EndTransaction_ProxyToResponder::Run(
    SmartCardResultPtr in_result) {}

// static
bool SmartCardTransactionStubDispatch::Accept(
    SmartCardTransaction* impl,
    mojo::Message* message) {}

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

bool SmartCardTransactionRequestValidator::Accept(mojo::Message* message) {}

bool SmartCardTransactionResponseValidator::Accept(mojo::Message* message) {}
const char SmartCardConnection::Name_[] =;

SmartCardConnection::IPCStableHashFunction SmartCardConnection::MessageToMethodInfo_(mojo::Message& message) {}


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SmartCardConnection::Disconnect_Sym::IPCStableHash() {}
uint32_t SmartCardConnection::Transmit_Sym::IPCStableHash() {}
uint32_t SmartCardConnection::Control_Sym::IPCStableHash() {}
uint32_t SmartCardConnection::GetAttrib_Sym::IPCStableHash() {}
uint32_t SmartCardConnection::SetAttrib_Sym::IPCStableHash() {}
uint32_t SmartCardConnection::Status_Sym::IPCStableHash() {}
uint32_t SmartCardConnection::BeginTransaction_Sym::IPCStableHash() {}
# endif // !BUILDFLAG(IS_FUCHSIA)

class SmartCardConnection_Disconnect_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardConnection_Transmit_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardConnection_Control_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardConnection_GetAttrib_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardConnection_SetAttrib_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardConnection_Status_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardConnection_BeginTransaction_ForwardToCallback
    : public mojo::MessageReceiver {};

SmartCardConnectionProxy::SmartCardConnectionProxy(mojo::MessageReceiverWithResponder* receiver)
    :{}

void SmartCardConnectionProxy::Disconnect(
    SmartCardDisposition in_disposition, DisconnectCallback callback) {}

void SmartCardConnectionProxy::Transmit(
    SmartCardProtocol in_protocol, const WTF::Vector<uint8_t>& in_data, TransmitCallback callback) {}

void SmartCardConnectionProxy::Control(
    uint32_t in_control_code, const WTF::Vector<uint8_t>& in_data, ControlCallback callback) {}

void SmartCardConnectionProxy::GetAttrib(
    uint32_t in_id, GetAttribCallback callback) {}

void SmartCardConnectionProxy::SetAttrib(
    uint32_t in_id, const WTF::Vector<uint8_t>& in_data, SetAttribCallback callback) {}

void SmartCardConnectionProxy::Status(
    StatusCallback callback) {}

void SmartCardConnectionProxy::BeginTransaction(
    BeginTransactionCallback callback) {}
class SmartCardConnection_Disconnect_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_Disconnect_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_Disconnect_ProxyToResponder::Run(
    SmartCardResultPtr in_result) {}
class SmartCardConnection_Transmit_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_Transmit_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_Transmit_ProxyToResponder::Run(
    SmartCardDataResultPtr in_result) {}
class SmartCardConnection_Control_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_Control_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_Control_ProxyToResponder::Run(
    SmartCardDataResultPtr in_result) {}
class SmartCardConnection_GetAttrib_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_GetAttrib_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_GetAttrib_ProxyToResponder::Run(
    SmartCardDataResultPtr in_result) {}
class SmartCardConnection_SetAttrib_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_SetAttrib_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_SetAttrib_ProxyToResponder::Run(
    SmartCardResultPtr in_result) {}
class SmartCardConnection_Status_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_Status_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_Status_ProxyToResponder::Run(
    SmartCardStatusResultPtr in_result) {}
class SmartCardConnection_BeginTransaction_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardConnection_BeginTransaction_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardConnection_BeginTransaction_ProxyToResponder::Run(
    SmartCardTransactionResultPtr in_result) {}

// static
bool SmartCardConnectionStubDispatch::Accept(
    SmartCardConnection* impl,
    mojo::Message* message) {}

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

bool SmartCardConnectionRequestValidator::Accept(mojo::Message* message) {}

bool SmartCardConnectionResponseValidator::Accept(mojo::Message* message) {}
const char SmartCardContext::Name_[] =;

SmartCardContext::IPCStableHashFunction SmartCardContext::MessageToMethodInfo_(mojo::Message& message) {}


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SmartCardContext::ListReaders_Sym::IPCStableHash() {}
uint32_t SmartCardContext::GetStatusChange_Sym::IPCStableHash() {}
uint32_t SmartCardContext::Cancel_Sym::IPCStableHash() {}
uint32_t SmartCardContext::Connect_Sym::IPCStableHash() {}
# endif // !BUILDFLAG(IS_FUCHSIA)

class SmartCardContext_ListReaders_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardContext_GetStatusChange_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardContext_Cancel_ForwardToCallback
    : public mojo::MessageReceiver {};

class SmartCardContext_Connect_ForwardToCallback
    : public mojo::MessageReceiver {};

SmartCardContextProxy::SmartCardContextProxy(mojo::MessageReceiverWithResponder* receiver)
    :{}

void SmartCardContextProxy::ListReaders(
    ListReadersCallback callback) {}

void SmartCardContextProxy::GetStatusChange(
    ::base::TimeDelta in_timeout, WTF::Vector<SmartCardReaderStateInPtr> in_reader_states, GetStatusChangeCallback callback) {}

void SmartCardContextProxy::Cancel(
    CancelCallback callback) {}

void SmartCardContextProxy::Connect(
    const WTF::String& in_reader, SmartCardShareMode in_share_mode, SmartCardProtocolsPtr in_preferred_protocols, ConnectCallback callback) {}
class SmartCardContext_ListReaders_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardContext_ListReaders_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardContext_ListReaders_ProxyToResponder::Run(
    SmartCardListReadersResultPtr in_result) {}
class SmartCardContext_GetStatusChange_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardContext_GetStatusChange_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardContext_GetStatusChange_ProxyToResponder::Run(
    SmartCardStatusChangeResultPtr in_result) {}
class SmartCardContext_Cancel_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardContext_Cancel_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardContext_Cancel_ProxyToResponder::Run(
    SmartCardResultPtr in_result) {}
class SmartCardContext_Connect_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardContext_Connect_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardContext_Connect_ProxyToResponder::Run(
    SmartCardConnectResultPtr in_result) {}

// static
bool SmartCardContextStubDispatch::Accept(
    SmartCardContext* impl,
    mojo::Message* message) {}

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

bool SmartCardContextRequestValidator::Accept(mojo::Message* message) {}

bool SmartCardContextResponseValidator::Accept(mojo::Message* message) {}
const char SmartCardContextFactory::Name_[] =;

SmartCardContextFactory::IPCStableHashFunction SmartCardContextFactory::MessageToMethodInfo_(mojo::Message& message) {}


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t SmartCardContextFactory::CreateContext_Sym::IPCStableHash() {}
# endif // !BUILDFLAG(IS_FUCHSIA)

class SmartCardContextFactory_CreateContext_ForwardToCallback
    : public mojo::MessageReceiver {};

SmartCardContextFactoryProxy::SmartCardContextFactoryProxy(mojo::MessageReceiverWithResponder* receiver)
    :{}

void SmartCardContextFactoryProxy::CreateContext(
    CreateContextCallback callback) {}
class SmartCardContextFactory_CreateContext_ProxyToResponder : public ::mojo::internal::ProxyToResponder {};

bool SmartCardContextFactory_CreateContext_ForwardToCallback::Accept(
    mojo::Message* message) {}

void SmartCardContextFactory_CreateContext_ProxyToResponder::Run(
    SmartCardCreateContextResultPtr in_result) {}

// static
bool SmartCardContextFactoryStubDispatch::Accept(
    SmartCardContextFactory* impl,
    mojo::Message* message) {}

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

bool SmartCardContextFactoryRequestValidator::Accept(mojo::Message* message) {}

bool SmartCardContextFactoryResponseValidator::Accept(mojo::Message* message) {}


}  // device::mojom::blink


namespace mojo {


// static
bool StructTraits<::device::mojom::blink::SmartCardReaderStateFlags::DataView, ::device::mojom::blink::SmartCardReaderStateFlagsPtr>::Read(
    ::device::mojom::blink::SmartCardReaderStateFlags::DataView input,
    ::device::mojom::blink::SmartCardReaderStateFlagsPtr* output) {}


// static
bool StructTraits<::device::mojom::blink::SmartCardReaderStateIn::DataView, ::device::mojom::blink::SmartCardReaderStateInPtr>::Read(
    ::device::mojom::blink::SmartCardReaderStateIn::DataView input,
    ::device::mojom::blink::SmartCardReaderStateInPtr* output) {}


// static
bool StructTraits<::device::mojom::blink::SmartCardReaderStateOut::DataView, ::device::mojom::blink::SmartCardReaderStateOutPtr>::Read(
    ::device::mojom::blink::SmartCardReaderStateOut::DataView input,
    ::device::mojom::blink::SmartCardReaderStateOutPtr* output) {}


// static
bool StructTraits<::device::mojom::blink::SmartCardProtocols::DataView, ::device::mojom::blink::SmartCardProtocolsPtr>::Read(
    ::device::mojom::blink::SmartCardProtocols::DataView input,
    ::device::mojom::blink::SmartCardProtocolsPtr* output) {}


// static
bool StructTraits<::device::mojom::blink::SmartCardStatus::DataView, ::device::mojom::blink::SmartCardStatusPtr>::Read(
    ::device::mojom::blink::SmartCardStatus::DataView input,
    ::device::mojom::blink::SmartCardStatusPtr* output) {}


// static
bool StructTraits<::device::mojom::blink::SmartCardConnectSuccess::DataView, ::device::mojom::blink::SmartCardConnectSuccessPtr>::Read(
    ::device::mojom::blink::SmartCardConnectSuccess::DataView input,
    ::device::mojom::blink::SmartCardConnectSuccessPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardResult::DataView, ::device::mojom::blink::SmartCardResultPtr>::Read(
    ::device::mojom::blink::SmartCardResult::DataView input,
    ::device::mojom::blink::SmartCardResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardStatusChangeResult::DataView, ::device::mojom::blink::SmartCardStatusChangeResultPtr>::Read(
    ::device::mojom::blink::SmartCardStatusChangeResult::DataView input,
    ::device::mojom::blink::SmartCardStatusChangeResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardListReadersResult::DataView, ::device::mojom::blink::SmartCardListReadersResultPtr>::Read(
    ::device::mojom::blink::SmartCardListReadersResult::DataView input,
    ::device::mojom::blink::SmartCardListReadersResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardCreateContextResult::DataView, ::device::mojom::blink::SmartCardCreateContextResultPtr>::Read(
    ::device::mojom::blink::SmartCardCreateContextResult::DataView input,
    ::device::mojom::blink::SmartCardCreateContextResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardConnectResult::DataView, ::device::mojom::blink::SmartCardConnectResultPtr>::Read(
    ::device::mojom::blink::SmartCardConnectResult::DataView input,
    ::device::mojom::blink::SmartCardConnectResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardDataResult::DataView, ::device::mojom::blink::SmartCardDataResultPtr>::Read(
    ::device::mojom::blink::SmartCardDataResult::DataView input,
    ::device::mojom::blink::SmartCardDataResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardStatusResult::DataView, ::device::mojom::blink::SmartCardStatusResultPtr>::Read(
    ::device::mojom::blink::SmartCardStatusResult::DataView input,
    ::device::mojom::blink::SmartCardStatusResultPtr* output) {}

// static
bool UnionTraits<::device::mojom::blink::SmartCardTransactionResult::DataView, ::device::mojom::blink::SmartCardTransactionResultPtr>::Read(
    ::device::mojom::blink::SmartCardTransactionResult::DataView input,
    ::device::mojom::blink::SmartCardTransactionResultPtr* 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 device::mojom::blink {


void SmartCardTransactionInterceptorForTesting::EndTransaction(SmartCardDisposition disposition, EndTransactionCallback callback) {}
SmartCardTransactionAsyncWaiter::SmartCardTransactionAsyncWaiter(
    SmartCardTransaction* proxy) :{}

SmartCardTransactionAsyncWaiter::~SmartCardTransactionAsyncWaiter() = default;

void SmartCardTransactionAsyncWaiter::EndTransaction(
    SmartCardDisposition disposition, SmartCardResultPtr* out_result) {}

SmartCardResultPtr SmartCardTransactionAsyncWaiter::EndTransaction(
    SmartCardDisposition disposition) {}




void SmartCardConnectionInterceptorForTesting::Disconnect(SmartCardDisposition disposition, DisconnectCallback callback) {}
void SmartCardConnectionInterceptorForTesting::Transmit(SmartCardProtocol protocol, const WTF::Vector<uint8_t>& data, TransmitCallback callback) {}
void SmartCardConnectionInterceptorForTesting::Control(uint32_t control_code, const WTF::Vector<uint8_t>& data, ControlCallback callback) {}
void SmartCardConnectionInterceptorForTesting::GetAttrib(uint32_t id, GetAttribCallback callback) {}
void SmartCardConnectionInterceptorForTesting::SetAttrib(uint32_t id, const WTF::Vector<uint8_t>& data, SetAttribCallback callback) {}
void SmartCardConnectionInterceptorForTesting::Status(StatusCallback callback) {}
void SmartCardConnectionInterceptorForTesting::BeginTransaction(BeginTransactionCallback callback) {}
SmartCardConnectionAsyncWaiter::SmartCardConnectionAsyncWaiter(
    SmartCardConnection* proxy) :{}

SmartCardConnectionAsyncWaiter::~SmartCardConnectionAsyncWaiter() = default;

void SmartCardConnectionAsyncWaiter::Disconnect(
    SmartCardDisposition disposition, SmartCardResultPtr* out_result) {}

SmartCardResultPtr SmartCardConnectionAsyncWaiter::Disconnect(
    SmartCardDisposition disposition) {}

void SmartCardConnectionAsyncWaiter::Transmit(
    SmartCardProtocol protocol, const WTF::Vector<uint8_t>& data, SmartCardDataResultPtr* out_result) {}

SmartCardDataResultPtr SmartCardConnectionAsyncWaiter::Transmit(
    SmartCardProtocol protocol, const WTF::Vector<uint8_t>& data) {}

void SmartCardConnectionAsyncWaiter::Control(
    uint32_t control_code, const WTF::Vector<uint8_t>& data, SmartCardDataResultPtr* out_result) {}

SmartCardDataResultPtr SmartCardConnectionAsyncWaiter::Control(
    uint32_t control_code, const WTF::Vector<uint8_t>& data) {}

void SmartCardConnectionAsyncWaiter::GetAttrib(
    uint32_t id, SmartCardDataResultPtr* out_result) {}

SmartCardDataResultPtr SmartCardConnectionAsyncWaiter::GetAttrib(
    uint32_t id) {}

void SmartCardConnectionAsyncWaiter::SetAttrib(
    uint32_t id, const WTF::Vector<uint8_t>& data, SmartCardResultPtr* out_result) {}

SmartCardResultPtr SmartCardConnectionAsyncWaiter::SetAttrib(
    uint32_t id, const WTF::Vector<uint8_t>& data) {}

void SmartCardConnectionAsyncWaiter::Status(
    SmartCardStatusResultPtr* out_result) {}

SmartCardStatusResultPtr SmartCardConnectionAsyncWaiter::Status(
    ) {}

void SmartCardConnectionAsyncWaiter::BeginTransaction(
    SmartCardTransactionResultPtr* out_result) {}

SmartCardTransactionResultPtr SmartCardConnectionAsyncWaiter::BeginTransaction(
    ) {}




void SmartCardContextInterceptorForTesting::ListReaders(ListReadersCallback callback) {}
void SmartCardContextInterceptorForTesting::GetStatusChange(::base::TimeDelta timeout, WTF::Vector<SmartCardReaderStateInPtr> reader_states, GetStatusChangeCallback callback) {}
void SmartCardContextInterceptorForTesting::Cancel(CancelCallback callback) {}
void SmartCardContextInterceptorForTesting::Connect(const WTF::String& reader, SmartCardShareMode share_mode, SmartCardProtocolsPtr preferred_protocols, ConnectCallback callback) {}
SmartCardContextAsyncWaiter::SmartCardContextAsyncWaiter(
    SmartCardContext* proxy) :{}

SmartCardContextAsyncWaiter::~SmartCardContextAsyncWaiter() = default;

void SmartCardContextAsyncWaiter::ListReaders(
    SmartCardListReadersResultPtr* out_result) {}

SmartCardListReadersResultPtr SmartCardContextAsyncWaiter::ListReaders(
    ) {}

void SmartCardContextAsyncWaiter::GetStatusChange(
    ::base::TimeDelta timeout, WTF::Vector<SmartCardReaderStateInPtr> reader_states, SmartCardStatusChangeResultPtr* out_result) {}

SmartCardStatusChangeResultPtr SmartCardContextAsyncWaiter::GetStatusChange(
    ::base::TimeDelta timeout, WTF::Vector<SmartCardReaderStateInPtr> reader_states) {}

void SmartCardContextAsyncWaiter::Cancel(
    SmartCardResultPtr* out_result) {}

SmartCardResultPtr SmartCardContextAsyncWaiter::Cancel(
    ) {}

void SmartCardContextAsyncWaiter::Connect(
    const WTF::String& reader, SmartCardShareMode share_mode, SmartCardProtocolsPtr preferred_protocols, SmartCardConnectResultPtr* out_result) {}

SmartCardConnectResultPtr SmartCardContextAsyncWaiter::Connect(
    const WTF::String& reader, SmartCardShareMode share_mode, SmartCardProtocolsPtr preferred_protocols) {}




void SmartCardContextFactoryInterceptorForTesting::CreateContext(CreateContextCallback callback) {}
SmartCardContextFactoryAsyncWaiter::SmartCardContextFactoryAsyncWaiter(
    SmartCardContextFactory* proxy) :{}

SmartCardContextFactoryAsyncWaiter::~SmartCardContextFactoryAsyncWaiter() = default;

void SmartCardContextFactoryAsyncWaiter::CreateContext(
    SmartCardCreateContextResultPtr* out_result) {}

SmartCardCreateContextResultPtr SmartCardContextFactoryAsyncWaiter::CreateContext(
    ) {}






}  // device::mojom::blink


#if defined(__clang__)
#pragma clang diagnostic pop
#endif