hid.mojom.cc | Explore in Territory

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

#include "services/device/public/mojom/hid.mojom-import-headers.h"
#include "services/device/public/mojom/hid.mojom-test-utils.h"


namespace device::mojom {
HidUsageAndPage::HidUsageAndPage()
    : … { … }

HidUsageAndPage::HidUsageAndPage(
    uint16_t usage_in,
    uint16_t usage_page_in)
    : … { … }

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

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

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

HidReportItem::HidReportItem(
    bool is_range_in,
    bool is_constant_in,
    bool is_variable_in,
    bool is_relative_in,
    bool wrap_in,
    bool is_non_linear_in,
    bool no_preferred_state_in,
    bool has_null_position_in,
    bool is_volatile_in,
    bool is_buffered_bytes_in,
    std::vector<HidUsageAndPagePtr> usages_in,
    HidUsageAndPagePtr usage_minimum_in,
    HidUsageAndPagePtr usage_maximum_in,
    uint32_t designator_minimum_in,
    uint32_t designator_maximum_in,
    uint32_t string_minimum_in,
    uint32_t string_maximum_in,
    int32_t logical_minimum_in,
    int32_t logical_maximum_in,
    int32_t physical_minimum_in,
    int32_t physical_maximum_in,
    uint32_t unit_exponent_in,
    uint32_t unit_in,
    uint32_t report_size_in,
    uint32_t report_count_in)
    : … { … }

HidReportItem::~HidReportItem() = default;

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

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

HidReportDescription::HidReportDescription(
    uint8_t report_id_in,
    std::vector<HidReportItemPtr> items_in)
    : … { … }

HidReportDescription::~HidReportDescription() = default;

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

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

HidCollectionInfo::HidCollectionInfo(
    HidUsageAndPagePtr usage_in,
    std::vector<uint8_t> report_ids_in,
    uint32_t collection_type_in,
    std::vector<HidReportDescriptionPtr> input_reports_in,
    std::vector<HidReportDescriptionPtr> output_reports_in,
    std::vector<HidReportDescriptionPtr> feature_reports_in,
    std::vector<HidCollectionInfoPtr> children_in)
    : … { … }

HidCollectionInfo::~HidCollectionInfo() = default;

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

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

HidDeviceInfo::HidDeviceInfo(
    const std::string& guid_in,
    const std::string& physical_device_id_in,
    uint16_t vendor_id_in,
    uint16_t product_id_in,
    const std::string& product_name_in,
    const std::string& serial_number_in,
    HidBusType bus_type_in,
    std::vector<uint8_t> report_descriptor_in,
    std::vector<HidCollectionInfoPtr> collections_in,
    bool has_report_id_in,
    uint64_t max_input_report_size_in,
    uint64_t max_output_report_size_in,
    uint64_t max_feature_report_size_in,
    const std::string& device_node_in)
    : … { … }

HidDeviceInfo::HidDeviceInfo(
    const std::string& guid_in,
    const std::string& physical_device_id_in,
    uint16_t vendor_id_in,
    uint16_t product_id_in,
    const std::string& product_name_in,
    const std::string& serial_number_in,
    HidBusType bus_type_in,
    std::vector<uint8_t> report_descriptor_in,
    std::vector<HidCollectionInfoPtr> collections_in,
    bool has_report_id_in,
    uint64_t max_input_report_size_in,
    uint64_t max_output_report_size_in,
    uint64_t max_feature_report_size_in,
    const std::string& device_node_in,
    std::optional<std::vector<uint8_t>> protected_input_report_ids_in,
    std::optional<std::vector<uint8_t>> protected_output_report_ids_in,
    std::optional<std::vector<uint8_t>> protected_feature_report_ids_in)
    : … { … }

HidDeviceInfo::HidDeviceInfo(
    const std::string& guid_in,
    const std::string& physical_device_id_in,
    uint16_t vendor_id_in,
    uint16_t product_id_in,
    const std::string& product_name_in,
    const std::string& serial_number_in,
    HidBusType bus_type_in,
    std::vector<uint8_t> report_descriptor_in,
    std::vector<HidCollectionInfoPtr> collections_in,
    bool has_report_id_in,
    uint64_t max_input_report_size_in,
    uint64_t max_output_report_size_in,
    uint64_t max_feature_report_size_in,
    const std::string& device_node_in,
    std::optional<std::vector<uint8_t>> protected_input_report_ids_in,
    std::optional<std::vector<uint8_t>> protected_output_report_ids_in,
    std::optional<std::vector<uint8_t>> protected_feature_report_ids_in,
    bool is_excluded_by_blocklist_in)
    : … { … }

HidDeviceInfo::~HidDeviceInfo() = default;

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

bool HidDeviceInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char HidManagerClient::Name_[] = …;
constexpr base::Token HidManagerClient::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HidManagerClient::DeviceAdded_Sym::IPCStableHash() { … }
uint32_t HidManagerClient::DeviceRemoved_Sym::IPCStableHash() { … }
uint32_t HidManagerClient::DeviceChanged_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void HidManagerClientProxy::DeviceAdded(
    HidDeviceInfoPtr in_device_info) { … }

void HidManagerClientProxy::DeviceRemoved(
    HidDeviceInfoPtr in_device_info) { … }

void HidManagerClientProxy::DeviceChanged(
    HidDeviceInfoPtr in_device_info) { … }

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

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

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

const char HidManager::Name_[] = …;
constexpr base::Token HidManager::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HidManager::GetDevicesAndSetClient_Sym::IPCStableHash() { … }
uint32_t HidManager::GetDevices_Sym::IPCStableHash() { … }
uint32_t HidManager::Connect_Sym::IPCStableHash() { … }
uint32_t HidManager::AddReceiver_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

void HidManagerProxy::GetDevicesAndSetClient(
    ::mojo::PendingAssociatedRemote<HidManagerClient> in_client, GetDevicesAndSetClientCallback callback) { … }

void HidManagerProxy::GetDevices(
    GetDevicesCallback callback) { … }

void HidManagerProxy::Connect(
    const std::string& in_device_guid, ::mojo::PendingRemote<HidConnectionClient> in_connection_client, ::mojo::PendingRemote<HidConnectionWatcher> in_watcher, bool in_allow_protected_reports, bool in_allow_fido_reports, ConnectCallback callback) { … }

void HidManagerProxy::AddReceiver(
    ::mojo::PendingReceiver<HidManager> in_receiver) { … }
class HidManager_GetDevicesAndSetClient_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HidManager_GetDevicesAndSetClient_ProxyToResponder::Run(
    std::vector<HidDeviceInfoPtr> in_devices) { … }
class HidManager_GetDevices_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HidManager_GetDevices_ProxyToResponder::Run(
    std::vector<HidDeviceInfoPtr> in_devices) { … }
class HidManager_Connect_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HidManager_Connect_ProxyToResponder::Run(
    ::mojo::PendingRemote<HidConnection> in_connection) { … }

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

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

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

bool HidManagerResponseValidator::Accept(mojo::Message* message) { … }
const char HidConnection::Name_[] = …;
constexpr base::Token HidConnection::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HidConnection::Read_Sym::IPCStableHash() { … }
uint32_t HidConnection::Write_Sym::IPCStableHash() { … }
uint32_t HidConnection::GetFeatureReport_Sym::IPCStableHash() { … }
uint32_t HidConnection::SendFeatureReport_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

void HidConnectionProxy::Read(
    ReadCallback callback) { … }

void HidConnectionProxy::Write(
    uint8_t in_report_id, const std::vector<uint8_t>& in_buffer, WriteCallback callback) { … }

void HidConnectionProxy::GetFeatureReport(
    uint8_t in_report_id, GetFeatureReportCallback callback) { … }

void HidConnectionProxy::SendFeatureReport(
    uint8_t in_report_id, const std::vector<uint8_t>& in_buffer, SendFeatureReportCallback callback) { … }
class HidConnection_Read_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HidConnection_Read_ProxyToResponder::Run(
    bool in_success, uint8_t in_report_id, const std::optional<std::vector<uint8_t>>& in_buffer) { … }
class HidConnection_Write_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

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

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

void HidConnection_GetFeatureReport_ProxyToResponder::Run(
    bool in_success, const std::optional<std::vector<uint8_t>>& in_buffer) { … }
class HidConnection_SendFeatureReport_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void HidConnection_SendFeatureReport_ProxyToResponder::Run(
    bool in_success) { … }

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

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

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

bool HidConnectionResponseValidator::Accept(mojo::Message* message) { … }
const char HidConnectionClient::Name_[] = …;
constexpr base::Token HidConnectionClient::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t HidConnectionClient::OnInputReport_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void HidConnectionClientProxy::OnInputReport(
    uint8_t in_report_id, const std::vector<uint8_t>& in_buffer) { … }

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

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

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

const char HidConnectionWatcher::Name_[] = …;
constexpr base::Token HidConnectionWatcher::Uuid_;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

// static
bool HidConnectionWatcherStubDispatch::AcceptWithResponder(
    HidConnectionWatcher* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace

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



}  // device::mojom


namespace mojo {


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


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


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


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


// static
bool StructTraits<::device::mojom::HidDeviceInfo::DataView, ::device::mojom::HidDeviceInfoPtr>::Read(
    ::device::mojom::HidDeviceInfo::DataView input,
    ::device::mojom::HidDeviceInfoPtr* 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 HidManagerClientInterceptorForTesting::DeviceAdded(HidDeviceInfoPtr device_info) { … }
void HidManagerClientInterceptorForTesting::DeviceRemoved(HidDeviceInfoPtr device_info) { … }
void HidManagerClientInterceptorForTesting::DeviceChanged(HidDeviceInfoPtr device_info) { … }
HidManagerClientAsyncWaiter::HidManagerClientAsyncWaiter(
    HidManagerClient* proxy) : … { … }

HidManagerClientAsyncWaiter::~HidManagerClientAsyncWaiter() = default;




void HidManagerInterceptorForTesting::GetDevicesAndSetClient(::mojo::PendingAssociatedRemote<HidManagerClient> client, GetDevicesAndSetClientCallback callback) { … }
void HidManagerInterceptorForTesting::GetDevices(GetDevicesCallback callback) { … }
void HidManagerInterceptorForTesting::Connect(const std::string& device_guid, ::mojo::PendingRemote<HidConnectionClient> connection_client, ::mojo::PendingRemote<HidConnectionWatcher> watcher, bool allow_protected_reports, bool allow_fido_reports, ConnectCallback callback) { … }
void HidManagerInterceptorForTesting::AddReceiver(::mojo::PendingReceiver<HidManager> receiver) { … }
HidManagerAsyncWaiter::HidManagerAsyncWaiter(
    HidManager* proxy) : … { … }

HidManagerAsyncWaiter::~HidManagerAsyncWaiter() = default;

void HidManagerAsyncWaiter::GetDevicesAndSetClient(
    ::mojo::PendingAssociatedRemote<HidManagerClient> client, std::vector<HidDeviceInfoPtr>* out_devices) { … }

std::vector<HidDeviceInfoPtr> HidManagerAsyncWaiter::GetDevicesAndSetClient(
    ::mojo::PendingAssociatedRemote<HidManagerClient> client) { … }

void HidManagerAsyncWaiter::GetDevices(
    std::vector<HidDeviceInfoPtr>* out_devices) { … }

std::vector<HidDeviceInfoPtr> HidManagerAsyncWaiter::GetDevices(
    ) { … }

void HidManagerAsyncWaiter::Connect(
    const std::string& device_guid, ::mojo::PendingRemote<HidConnectionClient> connection_client, ::mojo::PendingRemote<HidConnectionWatcher> watcher, bool allow_protected_reports, bool allow_fido_reports, ::mojo::PendingRemote<HidConnection>* out_connection) { … }

::mojo::PendingRemote<HidConnection> HidManagerAsyncWaiter::Connect(
    const std::string& device_guid, ::mojo::PendingRemote<HidConnectionClient> connection_client, ::mojo::PendingRemote<HidConnectionWatcher> watcher, bool allow_protected_reports, bool allow_fido_reports) { … }




void HidConnectionInterceptorForTesting::Read(ReadCallback callback) { … }
void HidConnectionInterceptorForTesting::Write(uint8_t report_id, const std::vector<uint8_t>& buffer, WriteCallback callback) { … }
void HidConnectionInterceptorForTesting::GetFeatureReport(uint8_t report_id, GetFeatureReportCallback callback) { … }
void HidConnectionInterceptorForTesting::SendFeatureReport(uint8_t report_id, const std::vector<uint8_t>& buffer, SendFeatureReportCallback callback) { … }
HidConnectionAsyncWaiter::HidConnectionAsyncWaiter(
    HidConnection* proxy) : … { … }

HidConnectionAsyncWaiter::~HidConnectionAsyncWaiter() = default;

void HidConnectionAsyncWaiter::Read(
    bool* out_success, uint8_t* out_report_id, std::optional<std::vector<uint8_t>>* out_buffer) { … }



void HidConnectionAsyncWaiter::Write(
    uint8_t report_id, const std::vector<uint8_t>& buffer, bool* out_success) { … }

bool HidConnectionAsyncWaiter::Write(
    uint8_t report_id, const std::vector<uint8_t>& buffer) { … }

void HidConnectionAsyncWaiter::GetFeatureReport(
    uint8_t report_id, bool* out_success, std::optional<std::vector<uint8_t>>* out_buffer) { … }



void HidConnectionAsyncWaiter::SendFeatureReport(
    uint8_t report_id, const std::vector<uint8_t>& buffer, bool* out_success) { … }

bool HidConnectionAsyncWaiter::SendFeatureReport(
    uint8_t report_id, const std::vector<uint8_t>& buffer) { … }




void HidConnectionClientInterceptorForTesting::OnInputReport(uint8_t report_id, const std::vector<uint8_t>& buffer) { … }
HidConnectionClientAsyncWaiter::HidConnectionClientAsyncWaiter(
    HidConnectionClient* proxy) : … { … }

HidConnectionClientAsyncWaiter::~HidConnectionClientAsyncWaiter() = default;




HidConnectionWatcherAsyncWaiter::HidConnectionWatcherAsyncWaiter(
    HidConnectionWatcher* proxy) : … { … }

HidConnectionWatcherAsyncWaiter::~HidConnectionWatcherAsyncWaiter() = default;






}  // device::mojom


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