smart_card.mojom.cc | Explore in Territory

// services/device/public/mojom/smart_card.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 "services/device/public/mojom/smart_card.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 "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-import-headers.h"
#include "services/device/public/mojom/smart_card.mojom-test-utils.h"


namespace device::mojom {
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 std::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 std::string& reader_in,
    SmartCardReaderStateFlagsPtr event_state_in,
    uint16_t event_count_in,
    std::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 std::string& reader_name_in,
    SmartCardConnectionState state_in,
    SmartCardProtocol protocol_in,
    std::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(
    std::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(
    std::vector<std::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(
    std::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 std::vector<uint8_t>& in_data, TransmitCallback callback) { … }

void SmartCardConnectionProxy::Control(
    uint32_t in_control_code, const std::vector<uint8_t>& in_data, ControlCallback callback) { … }

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

void SmartCardConnectionProxy::SetAttrib(
    uint32_t in_id, const std::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, std::vector<SmartCardReaderStateInPtr> in_reader_states, GetStatusChangeCallback callback) { … }

void SmartCardContextProxy::Cancel(
    CancelCallback callback) { … }

void SmartCardContextProxy::Connect(
    const std::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


namespace mojo {


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


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


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


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


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


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

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

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

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

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

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

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

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

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


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 std::vector<uint8_t>& data, TransmitCallback callback) { … }
void SmartCardConnectionInterceptorForTesting::Control(uint32_t control_code, const std::vector<uint8_t>& data, ControlCallback callback) { … }
void SmartCardConnectionInterceptorForTesting::GetAttrib(uint32_t id, GetAttribCallback callback) { … }
void SmartCardConnectionInterceptorForTesting::SetAttrib(uint32_t id, const std::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 std::vector<uint8_t>& data, SmartCardDataResultPtr* out_result) { … }

SmartCardDataResultPtr SmartCardConnectionAsyncWaiter::Transmit(
    SmartCardProtocol protocol, const std::vector<uint8_t>& data) { … }

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

SmartCardDataResultPtr SmartCardConnectionAsyncWaiter::Control(
    uint32_t control_code, const std::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 std::vector<uint8_t>& data, SmartCardResultPtr* out_result) { … }

SmartCardResultPtr SmartCardConnectionAsyncWaiter::SetAttrib(
    uint32_t id, const std::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, std::vector<SmartCardReaderStateInPtr> reader_states, GetStatusChangeCallback callback) { … }
void SmartCardContextInterceptorForTesting::Cancel(CancelCallback callback) { … }
void SmartCardContextInterceptorForTesting::Connect(const std::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, std::vector<SmartCardReaderStateInPtr> reader_states, SmartCardStatusChangeResultPtr* out_result) { … }

SmartCardStatusChangeResultPtr SmartCardContextAsyncWaiter::GetStatusChange(
    ::base::TimeDelta timeout, std::vector<SmartCardReaderStateInPtr> reader_states) { … }

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

SmartCardResultPtr SmartCardContextAsyncWaiter::Cancel(
    ) { … }

void SmartCardContextAsyncWaiter::Connect(
    const std::string& reader, SmartCardShareMode share_mode, SmartCardProtocolsPtr preferred_protocols, SmartCardConnectResultPtr* out_result) { … }

SmartCardConnectResultPtr SmartCardContextAsyncWaiter::Connect(
    const std::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


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/services/device/public/mojom/smart_card.mojom.cc
