usb_device.mojom-blink.cc | Explore in Territory

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

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


namespace device::mojom::blink {
const char UsbControlTransferParams::kSecurityKeyAOAModel[] = …;
UsbEndpointInfo::UsbEndpointInfo()
    : … { … }

UsbEndpointInfo::UsbEndpointInfo(
    uint8_t endpoint_number_in,
    UsbTransferDirection direction_in,
    UsbTransferType type_in,
    uint32_t packet_size_in,
    UsbSynchronizationType synchronization_type_in,
    UsbUsageType usage_type_in,
    uint8_t polling_interval_in,
    WTF::Vector<uint8_t> extra_data_in)
    : … { … }

UsbEndpointInfo::~UsbEndpointInfo() = default;

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

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

UsbAlternateInterfaceInfo::UsbAlternateInterfaceInfo(
    uint8_t alternate_setting_in,
    uint8_t class_code_in,
    uint8_t subclass_code_in,
    uint8_t protocol_code_in,
    const ::WTF::String& interface_name_in,
    WTF::Vector<UsbEndpointInfoPtr> endpoints_in,
    WTF::Vector<uint8_t> extra_data_in)
    : … { … }

UsbAlternateInterfaceInfo::~UsbAlternateInterfaceInfo() = default;

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

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

UsbInterfaceInfo::UsbInterfaceInfo(
    uint8_t interface_number_in,
    uint8_t first_interface_in,
    WTF::Vector<UsbAlternateInterfaceInfoPtr> alternates_in)
    : … { … }

UsbInterfaceInfo::~UsbInterfaceInfo() = default;

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

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

UsbConfigurationInfo::UsbConfigurationInfo(
    uint8_t configuration_value_in,
    const ::WTF::String& configuration_name_in,
    bool self_powered_in,
    bool remote_wakeup_in,
    uint8_t maximum_power_in,
    WTF::Vector<UsbInterfaceInfoPtr> interfaces_in,
    WTF::Vector<uint8_t> extra_data_in)
    : … { … }

UsbConfigurationInfo::~UsbConfigurationInfo() = default;

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

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

UsbDeviceInfo::UsbDeviceInfo(
    const WTF::String& guid_in,
    uint8_t usb_version_major_in,
    uint8_t usb_version_minor_in,
    uint8_t usb_version_subminor_in,
    uint8_t class_code_in,
    uint8_t subclass_code_in,
    uint8_t protocol_code_in,
    uint32_t bus_number_in,
    uint32_t port_number_in,
    uint16_t vendor_id_in,
    uint16_t product_id_in,
    uint8_t device_version_major_in,
    uint8_t device_version_minor_in,
    uint8_t device_version_subminor_in,
    const ::WTF::String& manufacturer_name_in,
    const ::WTF::String& product_name_in,
    const ::WTF::String& serial_number_in,
    const std::optional<::blink::KURL>& webusb_landing_page_in,
    uint8_t active_configuration_in,
    WTF::Vector<UsbConfigurationInfoPtr> configurations_in)
    : … { … }

UsbDeviceInfo::~UsbDeviceInfo() = default;

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

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

UsbControlTransferParams::UsbControlTransferParams(
    UsbControlTransferType type_in,
    UsbControlTransferRecipient recipient_in,
    uint8_t request_in,
    uint16_t value_in,
    uint16_t index_in)
    : … { … }

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

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

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

UsbIsochronousPacket::UsbIsochronousPacket(
    uint32_t length_in,
    uint32_t transferred_length_in,
    UsbTransferStatus status_in)
    : … { … }

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

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

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

UsbOpenDeviceResult::~UsbOpenDeviceResult() { … }


void UsbOpenDeviceResult::set_success(
    UsbOpenDeviceSuccess success) { … }
void UsbOpenDeviceResult::set_error(
    UsbOpenDeviceError error) { … }

void UsbOpenDeviceResult::DestroyActive() { … }
size_t UsbOpenDeviceResult::Hash(size_t seed) const { … }

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t UsbDevice::Open_Sym::IPCStableHash() { … }
uint32_t UsbDevice::Close_Sym::IPCStableHash() { … }
uint32_t UsbDevice::SetConfiguration_Sym::IPCStableHash() { … }
uint32_t UsbDevice::ClaimInterface_Sym::IPCStableHash() { … }
uint32_t UsbDevice::ReleaseInterface_Sym::IPCStableHash() { … }
uint32_t UsbDevice::SetInterfaceAlternateSetting_Sym::IPCStableHash() { … }
uint32_t UsbDevice::Reset_Sym::IPCStableHash() { … }
uint32_t UsbDevice::ClearHalt_Sym::IPCStableHash() { … }
uint32_t UsbDevice::ControlTransferIn_Sym::IPCStableHash() { … }
uint32_t UsbDevice::ControlTransferOut_Sym::IPCStableHash() { … }
uint32_t UsbDevice::GenericTransferIn_Sym::IPCStableHash() { … }
uint32_t UsbDevice::GenericTransferOut_Sym::IPCStableHash() { … }
uint32_t UsbDevice::IsochronousTransferIn_Sym::IPCStableHash() { … }
uint32_t UsbDevice::IsochronousTransferOut_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void UsbDeviceProxy::Open(
    OpenCallback callback) { … }

void UsbDeviceProxy::Close(
    CloseCallback callback) { … }

void UsbDeviceProxy::SetConfiguration(
    uint8_t in_value, SetConfigurationCallback callback) { … }

void UsbDeviceProxy::ClaimInterface(
    uint8_t in_interface_number, ClaimInterfaceCallback callback) { … }

void UsbDeviceProxy::ReleaseInterface(
    uint8_t in_interface_number, ReleaseInterfaceCallback callback) { … }

void UsbDeviceProxy::SetInterfaceAlternateSetting(
    uint8_t in_interface_number, uint8_t in_alternate_setting, SetInterfaceAlternateSettingCallback callback) { … }

void UsbDeviceProxy::Reset(
    ResetCallback callback) { … }

void UsbDeviceProxy::ClearHalt(
    UsbTransferDirection in_direction, uint8_t in_endpoint_number, ClearHaltCallback callback) { … }

void UsbDeviceProxy::ControlTransferIn(
    UsbControlTransferParamsPtr in_params, uint32_t in_length, uint32_t in_timeout, ControlTransferInCallback callback) { … }

void UsbDeviceProxy::ControlTransferOut(
    UsbControlTransferParamsPtr in_params, ::base::span<const ::uint8_t> in_data, uint32_t in_timeout, ControlTransferOutCallback callback) { … }

void UsbDeviceProxy::GenericTransferIn(
    uint8_t in_endpoint_number, uint32_t in_length, uint32_t in_timeout, GenericTransferInCallback callback) { … }

void UsbDeviceProxy::GenericTransferOut(
    uint8_t in_endpoint_number, ::base::span<const ::uint8_t> in_data, uint32_t in_timeout, GenericTransferOutCallback callback) { … }

void UsbDeviceProxy::IsochronousTransferIn(
    uint8_t in_endpoint_number, const WTF::Vector<uint32_t>& in_packet_lengths, uint32_t in_timeout, IsochronousTransferInCallback callback) { … }

void UsbDeviceProxy::IsochronousTransferOut(
    uint8_t in_endpoint_number, ::base::span<const ::uint8_t> in_data, const WTF::Vector<uint32_t>& in_packet_lengths, uint32_t in_timeout, IsochronousTransferOutCallback callback) { … }
class UsbDevice_Open_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_Open_ProxyToResponder::Run(
    UsbOpenDeviceResultPtr in_result) { … }
class UsbDevice_Close_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_Close_ProxyToResponder::Run(
    ) { … }
class UsbDevice_SetConfiguration_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_SetConfiguration_ProxyToResponder::Run(
    bool in_success) { … }
class UsbDevice_ClaimInterface_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_ClaimInterface_ProxyToResponder::Run(
    UsbClaimInterfaceResult in_result) { … }
class UsbDevice_ReleaseInterface_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_ReleaseInterface_ProxyToResponder::Run(
    bool in_success) { … }
class UsbDevice_SetInterfaceAlternateSetting_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_SetInterfaceAlternateSetting_ProxyToResponder::Run(
    bool in_success) { … }
class UsbDevice_Reset_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_Reset_ProxyToResponder::Run(
    bool in_success) { … }
class UsbDevice_ClearHalt_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_ClearHalt_ProxyToResponder::Run(
    bool in_success) { … }
class UsbDevice_ControlTransferIn_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_ControlTransferIn_ProxyToResponder::Run(
    UsbTransferStatus in_status, ::base::span<const ::uint8_t> in_data) { … }
class UsbDevice_ControlTransferOut_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_ControlTransferOut_ProxyToResponder::Run(
    UsbTransferStatus in_status) { … }
class UsbDevice_GenericTransferIn_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_GenericTransferIn_ProxyToResponder::Run(
    UsbTransferStatus in_status, ::base::span<const ::uint8_t> in_data) { … }
class UsbDevice_GenericTransferOut_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_GenericTransferOut_ProxyToResponder::Run(
    UsbTransferStatus in_status) { … }
class UsbDevice_IsochronousTransferIn_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_IsochronousTransferIn_ProxyToResponder::Run(
    ::base::span<const ::uint8_t> in_data, WTF::Vector<UsbIsochronousPacketPtr> in_packets) { … }
class UsbDevice_IsochronousTransferOut_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void UsbDevice_IsochronousTransferOut_ProxyToResponder::Run(
    WTF::Vector<UsbIsochronousPacketPtr> in_packets) { … }

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

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

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

bool UsbDeviceResponseValidator::Accept(mojo::Message* message) { … }
const char UsbDeviceClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t UsbDeviceClient::OnDeviceOpened_Sym::IPCStableHash() { … }
uint32_t UsbDeviceClient::OnDeviceClosed_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void UsbDeviceClientProxy::OnDeviceOpened(
    ) { … }

void UsbDeviceClientProxy::OnDeviceClosed(
    ) { … }

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

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

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



}  // device::mojom::blink


namespace mojo {


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


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


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


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


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


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


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

// static
bool UnionTraits<::device::mojom::blink::UsbOpenDeviceResult::DataView, ::device::mojom::blink::UsbOpenDeviceResultPtr>::Read(
    ::device::mojom::blink::UsbOpenDeviceResult::DataView input,
    ::device::mojom::blink::UsbOpenDeviceResultPtr* 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 UsbDeviceInterceptorForTesting::Open(OpenCallback callback) { … }
void UsbDeviceInterceptorForTesting::Close(CloseCallback callback) { … }
void UsbDeviceInterceptorForTesting::SetConfiguration(uint8_t value, SetConfigurationCallback callback) { … }
void UsbDeviceInterceptorForTesting::ClaimInterface(uint8_t interface_number, ClaimInterfaceCallback callback) { … }
void UsbDeviceInterceptorForTesting::ReleaseInterface(uint8_t interface_number, ReleaseInterfaceCallback callback) { … }
void UsbDeviceInterceptorForTesting::SetInterfaceAlternateSetting(uint8_t interface_number, uint8_t alternate_setting, SetInterfaceAlternateSettingCallback callback) { … }
void UsbDeviceInterceptorForTesting::Reset(ResetCallback callback) { … }
void UsbDeviceInterceptorForTesting::ClearHalt(UsbTransferDirection direction, uint8_t endpoint_number, ClearHaltCallback callback) { … }
void UsbDeviceInterceptorForTesting::ControlTransferIn(UsbControlTransferParamsPtr params, uint32_t length, uint32_t timeout, ControlTransferInCallback callback) { … }
void UsbDeviceInterceptorForTesting::ControlTransferOut(UsbControlTransferParamsPtr params, ::base::span<const ::uint8_t> data, uint32_t timeout, ControlTransferOutCallback callback) { … }
void UsbDeviceInterceptorForTesting::GenericTransferIn(uint8_t endpoint_number, uint32_t length, uint32_t timeout, GenericTransferInCallback callback) { … }
void UsbDeviceInterceptorForTesting::GenericTransferOut(uint8_t endpoint_number, ::base::span<const ::uint8_t> data, uint32_t timeout, GenericTransferOutCallback callback) { … }
void UsbDeviceInterceptorForTesting::IsochronousTransferIn(uint8_t endpoint_number, const WTF::Vector<uint32_t>& packet_lengths, uint32_t timeout, IsochronousTransferInCallback callback) { … }
void UsbDeviceInterceptorForTesting::IsochronousTransferOut(uint8_t endpoint_number, ::base::span<const ::uint8_t> data, const WTF::Vector<uint32_t>& packet_lengths, uint32_t timeout, IsochronousTransferOutCallback callback) { … }
UsbDeviceAsyncWaiter::UsbDeviceAsyncWaiter(
    UsbDevice* proxy) : … { … }

UsbDeviceAsyncWaiter::~UsbDeviceAsyncWaiter() = default;

void UsbDeviceAsyncWaiter::Open(
    UsbOpenDeviceResultPtr* out_result) { … }

UsbOpenDeviceResultPtr UsbDeviceAsyncWaiter::Open(
    ) { … }

void UsbDeviceAsyncWaiter::Close(
    ) { … }



void UsbDeviceAsyncWaiter::SetConfiguration(
    uint8_t value, bool* out_success) { … }

bool UsbDeviceAsyncWaiter::SetConfiguration(
    uint8_t value) { … }

void UsbDeviceAsyncWaiter::ClaimInterface(
    uint8_t interface_number, UsbClaimInterfaceResult* out_result) { … }

UsbClaimInterfaceResult UsbDeviceAsyncWaiter::ClaimInterface(
    uint8_t interface_number) { … }

void UsbDeviceAsyncWaiter::ReleaseInterface(
    uint8_t interface_number, bool* out_success) { … }

bool UsbDeviceAsyncWaiter::ReleaseInterface(
    uint8_t interface_number) { … }

void UsbDeviceAsyncWaiter::SetInterfaceAlternateSetting(
    uint8_t interface_number, uint8_t alternate_setting, bool* out_success) { … }

bool UsbDeviceAsyncWaiter::SetInterfaceAlternateSetting(
    uint8_t interface_number, uint8_t alternate_setting) { … }

void UsbDeviceAsyncWaiter::Reset(
    bool* out_success) { … }

bool UsbDeviceAsyncWaiter::Reset(
    ) { … }

void UsbDeviceAsyncWaiter::ClearHalt(
    UsbTransferDirection direction, uint8_t endpoint_number, bool* out_success) { … }

bool UsbDeviceAsyncWaiter::ClearHalt(
    UsbTransferDirection direction, uint8_t endpoint_number) { … }

void UsbDeviceAsyncWaiter::ControlTransferIn(
    UsbControlTransferParamsPtr params, uint32_t length, uint32_t timeout, UsbTransferStatus* out_status, ::base::span<const ::uint8_t>* out_data) { … }



void UsbDeviceAsyncWaiter::ControlTransferOut(
    UsbControlTransferParamsPtr params, ::base::span<const ::uint8_t> data, uint32_t timeout, UsbTransferStatus* out_status) { … }

UsbTransferStatus UsbDeviceAsyncWaiter::ControlTransferOut(
    UsbControlTransferParamsPtr params, ::base::span<const ::uint8_t> data, uint32_t timeout) { … }

void UsbDeviceAsyncWaiter::GenericTransferIn(
    uint8_t endpoint_number, uint32_t length, uint32_t timeout, UsbTransferStatus* out_status, ::base::span<const ::uint8_t>* out_data) { … }



void UsbDeviceAsyncWaiter::GenericTransferOut(
    uint8_t endpoint_number, ::base::span<const ::uint8_t> data, uint32_t timeout, UsbTransferStatus* out_status) { … }

UsbTransferStatus UsbDeviceAsyncWaiter::GenericTransferOut(
    uint8_t endpoint_number, ::base::span<const ::uint8_t> data, uint32_t timeout) { … }

void UsbDeviceAsyncWaiter::IsochronousTransferIn(
    uint8_t endpoint_number, const WTF::Vector<uint32_t>& packet_lengths, uint32_t timeout, ::base::span<const ::uint8_t>* out_data, WTF::Vector<UsbIsochronousPacketPtr>* out_packets) { … }



void UsbDeviceAsyncWaiter::IsochronousTransferOut(
    uint8_t endpoint_number, ::base::span<const ::uint8_t> data, const WTF::Vector<uint32_t>& packet_lengths, uint32_t timeout, WTF::Vector<UsbIsochronousPacketPtr>* out_packets) { … }

WTF::Vector<UsbIsochronousPacketPtr> UsbDeviceAsyncWaiter::IsochronousTransferOut(
    uint8_t endpoint_number, ::base::span<const ::uint8_t> data, const WTF::Vector<uint32_t>& packet_lengths, uint32_t timeout) { … }




void UsbDeviceClientInterceptorForTesting::OnDeviceOpened() { … }
void UsbDeviceClientInterceptorForTesting::OnDeviceClosed() { … }
UsbDeviceClientAsyncWaiter::UsbDeviceClientAsyncWaiter(
    UsbDeviceClient* proxy) : … { … }

UsbDeviceClientAsyncWaiter::~UsbDeviceClientAsyncWaiter() = default;






}  // device::mojom::blink


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