web_bluetooth.mojom.cc | Explore in Territory

// third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

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

#include "third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom.h"

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

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

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

#include "third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom-import-headers.h"
#include "third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom-test-utils.h"


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

WebBluetoothLeScanFilter::WebBluetoothLeScanFilter(
    std::optional<std::vector<::device::BluetoothUUID>> services_in,
    const std::optional<std::string>& name_in,
    const std::optional<std::string>& name_prefix_in,
    std::optional<base::flat_map<WebBluetoothCompanyPtr, std::vector<WebBluetoothDataFilterPtr>>> manufacturer_data_in)
    : … { … }

WebBluetoothLeScanFilter::~WebBluetoothLeScanFilter() = default;

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

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

WebBluetoothCompany::WebBluetoothCompany(
    uint16_t id_in)
    : … { … }

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

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

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

WebBluetoothDataFilter::WebBluetoothDataFilter(
    uint8_t data_in,
    uint8_t mask_in)
    : … { … }

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

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

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

WebBluetoothRequestDeviceOptions::WebBluetoothRequestDeviceOptions(
    std::optional<std::vector<WebBluetoothLeScanFilterPtr>> filters_in,
    std::optional<std::vector<WebBluetoothLeScanFilterPtr>> exclusion_filters_in,
    std::vector<::device::BluetoothUUID> optional_services_in,
    std::vector<uint16_t> optional_manufacturer_data_in,
    bool accept_all_devices_in)
    : … { … }

WebBluetoothRequestDeviceOptions::~WebBluetoothRequestDeviceOptions() = default;

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

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

WebBluetoothRequestLEScanOptions::WebBluetoothRequestLEScanOptions(
    std::optional<std::vector<WebBluetoothLeScanFilterPtr>> filters_in,
    bool keep_repeated_devices_in,
    bool accept_all_advertisements_in)
    : … { … }

WebBluetoothRequestLEScanOptions::~WebBluetoothRequestLEScanOptions() = default;

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

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

WebBluetoothDeviceId::WebBluetoothDeviceId(
    std::vector<uint8_t> device_id_in)
    : … { … }

WebBluetoothDeviceId::~WebBluetoothDeviceId() = default;

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

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

WebBluetoothDevice::WebBluetoothDevice(
    const ::blink::WebBluetoothDeviceId& id_in,
    const std::optional<std::string>& name_in)
    : … { … }

WebBluetoothDevice::~WebBluetoothDevice() = default;

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

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

WebBluetoothRemoteGATTService::WebBluetoothRemoteGATTService(
    const std::string& instance_id_in,
    const ::device::BluetoothUUID& uuid_in)
    : … { … }

WebBluetoothRemoteGATTService::~WebBluetoothRemoteGATTService() = default;

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

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

WebBluetoothRemoteGATTCharacteristic::WebBluetoothRemoteGATTCharacteristic(
    const std::string& instance_id_in,
    const ::device::BluetoothUUID& uuid_in,
    uint32_t properties_in)
    : … { … }

WebBluetoothRemoteGATTCharacteristic::~WebBluetoothRemoteGATTCharacteristic() = default;

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

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

WebBluetoothAdvertisingEvent::WebBluetoothAdvertisingEvent(
    WebBluetoothDevicePtr device_in,
    const std::optional<std::string>& name_in,
    std::vector<::device::BluetoothUUID> uuids_in,
    bool appearance_is_set_in,
    uint16_t appearance_in,
    bool tx_power_is_set_in,
    uint8_t tx_power_in,
    bool rssi_is_set_in,
    uint8_t rssi_in,
    const base::flat_map<uint16_t, std::vector<uint8_t>>& manufacturer_data_in,
    const base::flat_map<::device::BluetoothUUID, std::vector<uint8_t>>& service_data_in)
    : … { … }

WebBluetoothAdvertisingEvent::~WebBluetoothAdvertisingEvent() = default;

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

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

WebBluetoothRemoteGATTDescriptor::WebBluetoothRemoteGATTDescriptor(
    const std::string& instance_id_in,
    const ::device::BluetoothUUID& uuid_in)
    : … { … }

WebBluetoothRemoteGATTDescriptor::~WebBluetoothRemoteGATTDescriptor() = default;

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t WebBluetoothService::GetAvailability_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RequestDevice_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::GetDevices_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::ForgetDevice_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteServerConnect_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteServerDisconnect_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteServerGetPrimaryServices_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteServiceGetCharacteristics_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteCharacteristicReadValue_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteCharacteristicWriteValue_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteCharacteristicStartNotifications_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteCharacteristicStopNotifications_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteCharacteristicGetDescriptors_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteDescriptorReadValue_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RemoteDescriptorWriteValue_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::RequestScanningStart_Sym::IPCStableHash() { … }
uint32_t WebBluetoothService::WatchAdvertisementsForDevice_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void WebBluetoothServiceProxy::GetAvailability(
    GetAvailabilityCallback callback) { … }

void WebBluetoothServiceProxy::RequestDevice(
    WebBluetoothRequestDeviceOptionsPtr in_options, RequestDeviceCallback callback) { … }

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

void WebBluetoothServiceProxy::ForgetDevice(
    const ::blink::WebBluetoothDeviceId& in_device_id, ForgetDeviceCallback callback) { … }

void WebBluetoothServiceProxy::RemoteServerConnect(
    const ::blink::WebBluetoothDeviceId& in_device_id, ::mojo::PendingAssociatedRemote<WebBluetoothServerClient> in_client, RemoteServerConnectCallback callback) { … }

void WebBluetoothServiceProxy::RemoteServerDisconnect(
    const ::blink::WebBluetoothDeviceId& in_device_id) { … }

void WebBluetoothServiceProxy::RemoteServerGetPrimaryServices(
    const ::blink::WebBluetoothDeviceId& in_device_id, WebBluetoothGATTQueryQuantity in_quantity, const std::optional<::device::BluetoothUUID>& in_services_uuid, RemoteServerGetPrimaryServicesCallback callback) { … }

void WebBluetoothServiceProxy::RemoteServiceGetCharacteristics(
    const std::string& in_service_instance_id, WebBluetoothGATTQueryQuantity in_quantity, const std::optional<::device::BluetoothUUID>& in_characteristics_uuid, RemoteServiceGetCharacteristicsCallback callback) { … }

void WebBluetoothServiceProxy::RemoteCharacteristicReadValue(
    const std::string& in_characteristic_instance_id, RemoteCharacteristicReadValueCallback callback) { … }

void WebBluetoothServiceProxy::RemoteCharacteristicWriteValue(
    const std::string& in_characteristic_instance_id, const std::vector<uint8_t>& in_value, WebBluetoothWriteType in_write_type, RemoteCharacteristicWriteValueCallback callback) { … }

void WebBluetoothServiceProxy::RemoteCharacteristicStartNotifications(
    const std::string& in_characteristic_instance_id, ::mojo::PendingAssociatedRemote<WebBluetoothCharacteristicClient> in_client, RemoteCharacteristicStartNotificationsCallback callback) { … }

void WebBluetoothServiceProxy::RemoteCharacteristicStopNotifications(
    const std::string& in_characteristic_instance_id, RemoteCharacteristicStopNotificationsCallback callback) { … }

void WebBluetoothServiceProxy::RemoteCharacteristicGetDescriptors(
    const std::string& in_characteristics_instance_id, WebBluetoothGATTQueryQuantity in_quantity, const std::optional<::device::BluetoothUUID>& in_descriptor_uuid, RemoteCharacteristicGetDescriptorsCallback callback) { … }

void WebBluetoothServiceProxy::RemoteDescriptorReadValue(
    const std::string& in_descriptor_instance_id, RemoteDescriptorReadValueCallback callback) { … }

void WebBluetoothServiceProxy::RemoteDescriptorWriteValue(
    const std::string& in_descriptor_instance_id, const std::vector<uint8_t>& in_value, RemoteDescriptorWriteValueCallback callback) { … }

void WebBluetoothServiceProxy::RequestScanningStart(
    ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> in_client, WebBluetoothRequestLEScanOptionsPtr in_options, RequestScanningStartCallback callback) { … }

void WebBluetoothServiceProxy::WatchAdvertisementsForDevice(
    const ::blink::WebBluetoothDeviceId& in_device_id, ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> in_client, WatchAdvertisementsForDeviceCallback callback) { … }
class WebBluetoothService_GetAvailability_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_GetAvailability_ProxyToResponder::Run(
    bool in_is_available) { … }
class WebBluetoothService_RequestDevice_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RequestDevice_ProxyToResponder::Run(
    WebBluetoothResult in_result, WebBluetoothDevicePtr in_device) { … }
class WebBluetoothService_GetDevices_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_GetDevices_ProxyToResponder::Run(
    std::vector<WebBluetoothDevicePtr> in_devices) { … }
class WebBluetoothService_ForgetDevice_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_ForgetDevice_ProxyToResponder::Run(
    ) { … }
class WebBluetoothService_RemoteServerConnect_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteServerConnect_ProxyToResponder::Run(
    WebBluetoothResult in_result) { … }
class WebBluetoothService_RemoteServerGetPrimaryServices_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteServerGetPrimaryServices_ProxyToResponder::Run(
    WebBluetoothResult in_result, std::optional<std::vector<WebBluetoothRemoteGATTServicePtr>> in_services) { … }
class WebBluetoothService_RemoteServiceGetCharacteristics_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteServiceGetCharacteristics_ProxyToResponder::Run(
    WebBluetoothResult in_result, std::optional<std::vector<WebBluetoothRemoteGATTCharacteristicPtr>> in_characteristics) { … }
class WebBluetoothService_RemoteCharacteristicReadValue_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteCharacteristicReadValue_ProxyToResponder::Run(
    WebBluetoothResult in_result, const std::optional<std::vector<uint8_t>>& in_value) { … }
class WebBluetoothService_RemoteCharacteristicWriteValue_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteCharacteristicWriteValue_ProxyToResponder::Run(
    WebBluetoothResult in_result) { … }
class WebBluetoothService_RemoteCharacteristicStartNotifications_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteCharacteristicStartNotifications_ProxyToResponder::Run(
    WebBluetoothResult in_result) { … }
class WebBluetoothService_RemoteCharacteristicStopNotifications_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteCharacteristicStopNotifications_ProxyToResponder::Run(
    ) { … }
class WebBluetoothService_RemoteCharacteristicGetDescriptors_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteCharacteristicGetDescriptors_ProxyToResponder::Run(
    WebBluetoothResult in_result, std::optional<std::vector<WebBluetoothRemoteGATTDescriptorPtr>> in_descriptors) { … }
class WebBluetoothService_RemoteDescriptorReadValue_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteDescriptorReadValue_ProxyToResponder::Run(
    WebBluetoothResult in_result, const std::optional<std::vector<uint8_t>>& in_value) { … }
class WebBluetoothService_RemoteDescriptorWriteValue_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RemoteDescriptorWriteValue_ProxyToResponder::Run(
    WebBluetoothResult in_result) { … }
class WebBluetoothService_RequestScanningStart_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_RequestScanningStart_ProxyToResponder::Run(
    WebBluetoothResult in_result) { … }
class WebBluetoothService_WatchAdvertisementsForDevice_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebBluetoothService_WatchAdvertisementsForDevice_ProxyToResponder::Run(
    WebBluetoothResult in_result) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t WebBluetoothServerClient::GATTServerDisconnected_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void WebBluetoothServerClientProxy::GATTServerDisconnected(
    ) { … }

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

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

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

const char WebBluetoothCharacteristicClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t WebBluetoothCharacteristicClient::RemoteCharacteristicValueChanged_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void WebBluetoothCharacteristicClientProxy::RemoteCharacteristicValueChanged(
    const std::vector<uint8_t>& in_value) { … }

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

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

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

const char WebBluetoothAdvertisementClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t WebBluetoothAdvertisementClient::AdvertisingEvent_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void WebBluetoothAdvertisementClientProxy::AdvertisingEvent(
    WebBluetoothAdvertisingEventPtr in_result) { … }

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

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

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



}  // blink::mojom


namespace mojo {


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


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


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


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


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


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


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


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


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


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


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

}  // namespace mojo


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


namespace blink::mojom {


void WebBluetoothServiceInterceptorForTesting::GetAvailability(GetAvailabilityCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RequestDevice(WebBluetoothRequestDeviceOptionsPtr options, RequestDeviceCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::GetDevices(GetDevicesCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::ForgetDevice(const ::blink::WebBluetoothDeviceId& device_id, ForgetDeviceCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteServerConnect(const ::blink::WebBluetoothDeviceId& device_id, ::mojo::PendingAssociatedRemote<WebBluetoothServerClient> client, RemoteServerConnectCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteServerDisconnect(const ::blink::WebBluetoothDeviceId& device_id) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteServerGetPrimaryServices(const ::blink::WebBluetoothDeviceId& device_id, WebBluetoothGATTQueryQuantity quantity, const std::optional<::device::BluetoothUUID>& services_uuid, RemoteServerGetPrimaryServicesCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteServiceGetCharacteristics(const std::string& service_instance_id, WebBluetoothGATTQueryQuantity quantity, const std::optional<::device::BluetoothUUID>& characteristics_uuid, RemoteServiceGetCharacteristicsCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteCharacteristicReadValue(const std::string& characteristic_instance_id, RemoteCharacteristicReadValueCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteCharacteristicWriteValue(const std::string& characteristic_instance_id, const std::vector<uint8_t>& value, WebBluetoothWriteType write_type, RemoteCharacteristicWriteValueCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteCharacteristicStartNotifications(const std::string& characteristic_instance_id, ::mojo::PendingAssociatedRemote<WebBluetoothCharacteristicClient> client, RemoteCharacteristicStartNotificationsCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteCharacteristicStopNotifications(const std::string& characteristic_instance_id, RemoteCharacteristicStopNotificationsCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteCharacteristicGetDescriptors(const std::string& characteristics_instance_id, WebBluetoothGATTQueryQuantity quantity, const std::optional<::device::BluetoothUUID>& descriptor_uuid, RemoteCharacteristicGetDescriptorsCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteDescriptorReadValue(const std::string& descriptor_instance_id, RemoteDescriptorReadValueCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RemoteDescriptorWriteValue(const std::string& descriptor_instance_id, const std::vector<uint8_t>& value, RemoteDescriptorWriteValueCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::RequestScanningStart(::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> client, WebBluetoothRequestLEScanOptionsPtr options, RequestScanningStartCallback callback) { … }
void WebBluetoothServiceInterceptorForTesting::WatchAdvertisementsForDevice(const ::blink::WebBluetoothDeviceId& device_id, ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> client, WatchAdvertisementsForDeviceCallback callback) { … }
WebBluetoothServiceAsyncWaiter::WebBluetoothServiceAsyncWaiter(
    WebBluetoothService* proxy) : … { … }

WebBluetoothServiceAsyncWaiter::~WebBluetoothServiceAsyncWaiter() = default;

void WebBluetoothServiceAsyncWaiter::GetAvailability(
    bool* out_is_available) { … }

bool WebBluetoothServiceAsyncWaiter::GetAvailability(
    ) { … }

void WebBluetoothServiceAsyncWaiter::RequestDevice(
    WebBluetoothRequestDeviceOptionsPtr options, WebBluetoothResult* out_result, WebBluetoothDevicePtr* out_device) { … }



void WebBluetoothServiceAsyncWaiter::GetDevices(
    std::vector<WebBluetoothDevicePtr>* out_devices) { … }

std::vector<WebBluetoothDevicePtr> WebBluetoothServiceAsyncWaiter::GetDevices(
    ) { … }

void WebBluetoothServiceAsyncWaiter::ForgetDevice(
    const ::blink::WebBluetoothDeviceId& device_id) { … }



void WebBluetoothServiceAsyncWaiter::RemoteServerConnect(
    const ::blink::WebBluetoothDeviceId& device_id, ::mojo::PendingAssociatedRemote<WebBluetoothServerClient> client, WebBluetoothResult* out_result) { … }

WebBluetoothResult WebBluetoothServiceAsyncWaiter::RemoteServerConnect(
    const ::blink::WebBluetoothDeviceId& device_id, ::mojo::PendingAssociatedRemote<WebBluetoothServerClient> client) { … }

void WebBluetoothServiceAsyncWaiter::RemoteServerGetPrimaryServices(
    const ::blink::WebBluetoothDeviceId& device_id, WebBluetoothGATTQueryQuantity quantity, const std::optional<::device::BluetoothUUID>& services_uuid, WebBluetoothResult* out_result, std::optional<std::vector<WebBluetoothRemoteGATTServicePtr>>* out_services) { … }



void WebBluetoothServiceAsyncWaiter::RemoteServiceGetCharacteristics(
    const std::string& service_instance_id, WebBluetoothGATTQueryQuantity quantity, const std::optional<::device::BluetoothUUID>& characteristics_uuid, WebBluetoothResult* out_result, std::optional<std::vector<WebBluetoothRemoteGATTCharacteristicPtr>>* out_characteristics) { … }



void WebBluetoothServiceAsyncWaiter::RemoteCharacteristicReadValue(
    const std::string& characteristic_instance_id, WebBluetoothResult* out_result, std::optional<std::vector<uint8_t>>* out_value) { … }



void WebBluetoothServiceAsyncWaiter::RemoteCharacteristicWriteValue(
    const std::string& characteristic_instance_id, const std::vector<uint8_t>& value, WebBluetoothWriteType write_type, WebBluetoothResult* out_result) { … }

WebBluetoothResult WebBluetoothServiceAsyncWaiter::RemoteCharacteristicWriteValue(
    const std::string& characteristic_instance_id, const std::vector<uint8_t>& value, WebBluetoothWriteType write_type) { … }

void WebBluetoothServiceAsyncWaiter::RemoteCharacteristicStartNotifications(
    const std::string& characteristic_instance_id, ::mojo::PendingAssociatedRemote<WebBluetoothCharacteristicClient> client, WebBluetoothResult* out_result) { … }

WebBluetoothResult WebBluetoothServiceAsyncWaiter::RemoteCharacteristicStartNotifications(
    const std::string& characteristic_instance_id, ::mojo::PendingAssociatedRemote<WebBluetoothCharacteristicClient> client) { … }

void WebBluetoothServiceAsyncWaiter::RemoteCharacteristicStopNotifications(
    const std::string& characteristic_instance_id) { … }



void WebBluetoothServiceAsyncWaiter::RemoteCharacteristicGetDescriptors(
    const std::string& characteristics_instance_id, WebBluetoothGATTQueryQuantity quantity, const std::optional<::device::BluetoothUUID>& descriptor_uuid, WebBluetoothResult* out_result, std::optional<std::vector<WebBluetoothRemoteGATTDescriptorPtr>>* out_descriptors) { … }



void WebBluetoothServiceAsyncWaiter::RemoteDescriptorReadValue(
    const std::string& descriptor_instance_id, WebBluetoothResult* out_result, std::optional<std::vector<uint8_t>>* out_value) { … }



void WebBluetoothServiceAsyncWaiter::RemoteDescriptorWriteValue(
    const std::string& descriptor_instance_id, const std::vector<uint8_t>& value, WebBluetoothResult* out_result) { … }

WebBluetoothResult WebBluetoothServiceAsyncWaiter::RemoteDescriptorWriteValue(
    const std::string& descriptor_instance_id, const std::vector<uint8_t>& value) { … }

void WebBluetoothServiceAsyncWaiter::RequestScanningStart(
    ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> client, WebBluetoothRequestLEScanOptionsPtr options, WebBluetoothResult* out_result) { … }

WebBluetoothResult WebBluetoothServiceAsyncWaiter::RequestScanningStart(
    ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> client, WebBluetoothRequestLEScanOptionsPtr options) { … }

void WebBluetoothServiceAsyncWaiter::WatchAdvertisementsForDevice(
    const ::blink::WebBluetoothDeviceId& device_id, ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> client, WebBluetoothResult* out_result) { … }

WebBluetoothResult WebBluetoothServiceAsyncWaiter::WatchAdvertisementsForDevice(
    const ::blink::WebBluetoothDeviceId& device_id, ::mojo::PendingAssociatedRemote<WebBluetoothAdvertisementClient> client) { … }




void WebBluetoothServerClientInterceptorForTesting::GATTServerDisconnected() { … }
WebBluetoothServerClientAsyncWaiter::WebBluetoothServerClientAsyncWaiter(
    WebBluetoothServerClient* proxy) : … { … }

WebBluetoothServerClientAsyncWaiter::~WebBluetoothServerClientAsyncWaiter() = default;




void WebBluetoothCharacteristicClientInterceptorForTesting::RemoteCharacteristicValueChanged(const std::vector<uint8_t>& value) { … }
WebBluetoothCharacteristicClientAsyncWaiter::WebBluetoothCharacteristicClientAsyncWaiter(
    WebBluetoothCharacteristicClient* proxy) : … { … }

WebBluetoothCharacteristicClientAsyncWaiter::~WebBluetoothCharacteristicClientAsyncWaiter() = default;




void WebBluetoothAdvertisementClientInterceptorForTesting::AdvertisingEvent(WebBluetoothAdvertisingEventPtr result) { … }
WebBluetoothAdvertisementClientAsyncWaiter::WebBluetoothAdvertisementClientAsyncWaiter(
    WebBluetoothAdvertisementClient* proxy) : … { … }

WebBluetoothAdvertisementClientAsyncWaiter::~WebBluetoothAdvertisementClientAsyncWaiter() = default;






}  // blink::mojom


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