chromium/out/Default/gen/third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom.cc

// 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