| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef DEVICE_BLUETOOTH_PUBLIC_MOJOM_TEST_FAKE_BLUETOOTH_MOJOM_BLINK_H_ |
| #define DEVICE_BLUETOOTH_PUBLIC_MOJOM_TEST_FAKE_BLUETOOTH_MOJOM_BLINK_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "base/optional.h" |
| |
| #include "mojo/public/cpp/bindings/mojo_buildflags.h" |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| #include "base/trace_event/trace_event.h" |
| #endif |
| #include "mojo/public/cpp/bindings/clone_traits.h" |
| #include "mojo/public/cpp/bindings/equals_traits.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/struct_ptr.h" |
| #include "mojo/public/cpp/bindings/struct_traits.h" |
| #include "mojo/public/cpp/bindings/union_traits.h" |
| #include "device/bluetooth/public/mojom/test/fake_bluetooth.mojom-shared.h" |
| #include "device/bluetooth/public/mojom/test/fake_bluetooth.mojom-blink-forward.h" |
| #include "device/bluetooth/public/mojom/uuid.mojom-blink.h" |
| |
| #include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h" |
| #include "mojo/public/cpp/bindings/lib/wtf_hash_util.h" |
| #include "third_party/blink/renderer/platform/wtf/hash_functions.h" |
| #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" |
| |
| #include "mojo/public/cpp/bindings/associated_interface_ptr.h" |
| #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h" |
| #include "mojo/public/cpp/bindings/associated_interface_request.h" |
| #include "mojo/public/cpp/bindings/interface_ptr.h" |
| #include "mojo/public/cpp/bindings/interface_request.h" |
| #include "mojo/public/cpp/bindings/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h" |
| |
| |
| #include "mojo/public/cpp/bindings/lib/native_enum_serialization.h" |
| #include "mojo/public/cpp/bindings/lib/native_struct_serialization.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace WTF { |
| struct bluetooth_mojom_internal_CentralState_DataHashFn { |
| static unsigned GetHash(const ::bluetooth::mojom::CentralState& value) { |
| using utype = std::underlying_type<::bluetooth::mojom::CentralState>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::bluetooth::mojom::CentralState& left, const ::bluetooth::mojom::CentralState& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::bluetooth::mojom::CentralState> |
| : public GenericHashTraits<::bluetooth::mojom::CentralState> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::bluetooth::mojom::CentralState& value) { |
| return value == static_cast<::bluetooth::mojom::CentralState>(-1000000); |
| } |
| static void ConstructDeletedValue(::bluetooth::mojom::CentralState& slot, bool) { |
| slot = static_cast<::bluetooth::mojom::CentralState>(-1000001); |
| } |
| static bool IsDeletedValue(const ::bluetooth::mojom::CentralState& value) { |
| return value == static_cast<::bluetooth::mojom::CentralState>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace bluetooth { |
| namespace mojom { |
| namespace blink { |
| |
| class FakeBluetoothProxy; |
| |
| template <typename ImplRefTraits> |
| class FakeBluetoothStub; |
| |
| class FakeBluetoothRequestValidator; |
| class FakeBluetoothResponseValidator; |
| |
| |
| // @generated_from: bluetooth.mojom.FakeBluetooth |
| class FakeBluetooth |
| : public FakeBluetoothInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = FakeBluetoothInterfaceBase; |
| using Proxy_ = FakeBluetoothProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = FakeBluetoothStub<ImplRefTraits>; |
| |
| using RequestValidator_ = FakeBluetoothRequestValidator; |
| using ResponseValidator_ = FakeBluetoothResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kSetLESupportedMinVersion = 0, |
| kSimulateCentralMinVersion = 0, |
| kAllResponsesConsumedMinVersion = 0, |
| }; |
| virtual ~FakeBluetooth() {} |
| |
| |
| using SetLESupportedCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: bluetooth.mojom.FakeBluetooth.SetLESupported |
| virtual void SetLESupported(bool available, SetLESupportedCallback callback) = 0; |
| |
| |
| using SimulateCentralCallback = base::OnceCallback<void(FakeCentralPtr)>; |
| |
| // @generated_from: bluetooth.mojom.FakeBluetooth.SimulateCentral |
| virtual void SimulateCentral(CentralState state, SimulateCentralCallback callback) = 0; |
| |
| |
| using AllResponsesConsumedCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeBluetooth.AllResponsesConsumed |
| virtual void AllResponsesConsumed(AllResponsesConsumedCallback callback) = 0; |
| }; |
| |
| class FakeCentralProxy; |
| |
| template <typename ImplRefTraits> |
| class FakeCentralStub; |
| |
| class FakeCentralRequestValidator; |
| class FakeCentralResponseValidator; |
| |
| |
| // @generated_from: bluetooth.mojom.FakeCentral |
| class FakeCentral |
| : public FakeCentralInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = FakeCentralInterfaceBase; |
| using Proxy_ = FakeCentralProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = FakeCentralStub<ImplRefTraits>; |
| |
| using RequestValidator_ = FakeCentralRequestValidator; |
| using ResponseValidator_ = FakeCentralResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kSimulatePreconnectedPeripheralMinVersion = 0, |
| kSimulateAdvertisementReceivedMinVersion = 0, |
| kSetNextGATTConnectionResponseMinVersion = 0, |
| kSetNextGATTDiscoveryResponseMinVersion = 0, |
| kSimulateGATTDisconnectionMinVersion = 0, |
| kSimulateGATTServicesChangedMinVersion = 0, |
| kAddFakeServiceMinVersion = 0, |
| kRemoveFakeServiceMinVersion = 0, |
| kAddFakeCharacteristicMinVersion = 0, |
| kRemoveFakeCharacteristicMinVersion = 0, |
| kAddFakeDescriptorMinVersion = 0, |
| kRemoveFakeDescriptorMinVersion = 0, |
| kSetNextReadCharacteristicResponseMinVersion = 0, |
| kSetNextWriteCharacteristicResponseMinVersion = 0, |
| kSetNextSubscribeToNotificationsResponseMinVersion = 0, |
| kSetNextUnsubscribeFromNotificationsResponseMinVersion = 0, |
| kIsNotifyingMinVersion = 0, |
| kGetLastWrittenCharacteristicValueMinVersion = 0, |
| kSetNextReadDescriptorResponseMinVersion = 0, |
| kSetNextWriteDescriptorResponseMinVersion = 0, |
| kGetLastWrittenDescriptorValueMinVersion = 0, |
| }; |
| virtual ~FakeCentral() {} |
| |
| |
| using SimulatePreconnectedPeripheralCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SimulatePreconnectedPeripheral |
| virtual void SimulatePreconnectedPeripheral(const WTF::String& address, const WTF::String& name, WTF::Vector<::bluetooth::mojom::blink::UUIDPtr> known_service_uuids, SimulatePreconnectedPeripheralCallback callback) = 0; |
| |
| |
| using SimulateAdvertisementReceivedCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SimulateAdvertisementReceived |
| virtual void SimulateAdvertisementReceived(ScanResultPtr result, SimulateAdvertisementReceivedCallback callback) = 0; |
| |
| |
| using SetNextGATTConnectionResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextGATTConnectionResponse |
| virtual void SetNextGATTConnectionResponse(const WTF::String& address, uint16_t code, SetNextGATTConnectionResponseCallback callback) = 0; |
| |
| |
| using SetNextGATTDiscoveryResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextGATTDiscoveryResponse |
| virtual void SetNextGATTDiscoveryResponse(const WTF::String& address, uint16_t code, SetNextGATTDiscoveryResponseCallback callback) = 0; |
| |
| |
| using SimulateGATTDisconnectionCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SimulateGATTDisconnection |
| virtual void SimulateGATTDisconnection(const WTF::String& address, SimulateGATTDisconnectionCallback callback) = 0; |
| |
| |
| using SimulateGATTServicesChangedCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SimulateGATTServicesChanged |
| virtual void SimulateGATTServicesChanged(const WTF::String& address, SimulateGATTServicesChangedCallback callback) = 0; |
| |
| |
| using AddFakeServiceCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.AddFakeService |
| virtual void AddFakeService(const WTF::String& peripheral_address, ::bluetooth::mojom::blink::UUIDPtr service_uuid, AddFakeServiceCallback callback) = 0; |
| |
| |
| using RemoveFakeServiceCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.RemoveFakeService |
| virtual void RemoveFakeService(const WTF::String& service_id, const WTF::String& peripheral_address, RemoveFakeServiceCallback callback) = 0; |
| |
| |
| using AddFakeCharacteristicCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.AddFakeCharacteristic |
| virtual void AddFakeCharacteristic(::bluetooth::mojom::blink::UUIDPtr characteristic_uuid, CharacteristicPropertiesPtr properties, const WTF::String& service_id, const WTF::String& peripheral_address, AddFakeCharacteristicCallback callback) = 0; |
| |
| |
| using RemoveFakeCharacteristicCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.RemoveFakeCharacteristic |
| virtual void RemoveFakeCharacteristic(const WTF::String& identifier, const WTF::String& service_id, const WTF::String& peripheral_address, RemoveFakeCharacteristicCallback callback) = 0; |
| |
| |
| using AddFakeDescriptorCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.AddFakeDescriptor |
| virtual void AddFakeDescriptor(::bluetooth::mojom::blink::UUIDPtr descriptor_uuid, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, AddFakeDescriptorCallback callback) = 0; |
| |
| |
| using RemoveFakeDescriptorCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.RemoveFakeDescriptor |
| virtual void RemoveFakeDescriptor(const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, RemoveFakeDescriptorCallback callback) = 0; |
| |
| |
| using SetNextReadCharacteristicResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextReadCharacteristicResponse |
| virtual void SetNextReadCharacteristicResponse(uint16_t gatt_code, const base::Optional<WTF::Vector<uint8_t>>& value, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextReadCharacteristicResponseCallback callback) = 0; |
| |
| |
| using SetNextWriteCharacteristicResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextWriteCharacteristicResponse |
| virtual void SetNextWriteCharacteristicResponse(uint16_t gatt_code, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextWriteCharacteristicResponseCallback callback) = 0; |
| |
| |
| using SetNextSubscribeToNotificationsResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextSubscribeToNotificationsResponse |
| virtual void SetNextSubscribeToNotificationsResponse(uint16_t gatt_code, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextSubscribeToNotificationsResponseCallback callback) = 0; |
| |
| |
| using SetNextUnsubscribeFromNotificationsResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextUnsubscribeFromNotificationsResponse |
| virtual void SetNextUnsubscribeFromNotificationsResponse(uint16_t gatt_code, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextUnsubscribeFromNotificationsResponseCallback callback) = 0; |
| |
| |
| using IsNotifyingCallback = base::OnceCallback<void(bool, bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.IsNotifying |
| virtual void IsNotifying(const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, IsNotifyingCallback callback) = 0; |
| |
| |
| using GetLastWrittenCharacteristicValueCallback = base::OnceCallback<void(bool, const base::Optional<WTF::Vector<uint8_t>>&)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.GetLastWrittenCharacteristicValue |
| virtual void GetLastWrittenCharacteristicValue(const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, GetLastWrittenCharacteristicValueCallback callback) = 0; |
| |
| |
| using SetNextReadDescriptorResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextReadDescriptorResponse |
| virtual void SetNextReadDescriptorResponse(uint16_t gatt_code, const base::Optional<WTF::Vector<uint8_t>>& value, const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextReadDescriptorResponseCallback callback) = 0; |
| |
| |
| using SetNextWriteDescriptorResponseCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.SetNextWriteDescriptorResponse |
| virtual void SetNextWriteDescriptorResponse(uint16_t gatt_code, const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextWriteDescriptorResponseCallback callback) = 0; |
| |
| |
| using GetLastWrittenDescriptorValueCallback = base::OnceCallback<void(bool, const base::Optional<WTF::Vector<uint8_t>>&)>; |
| |
| // @generated_from: bluetooth.mojom.FakeCentral.GetLastWrittenDescriptorValue |
| virtual void GetLastWrittenDescriptorValue(const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, GetLastWrittenDescriptorValueCallback callback) = 0; |
| }; |
| |
| class FakeBluetoothProxy |
| : public FakeBluetooth { |
| public: |
| using InterfaceType = FakeBluetooth; |
| |
| explicit FakeBluetoothProxy(mojo::MessageReceiverWithResponder* receiver); |
| void SetLESupported(bool available, SetLESupportedCallback callback) final; |
| void SimulateCentral(CentralState state, SimulateCentralCallback callback) final; |
| void AllResponsesConsumed(AllResponsesConsumedCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class FakeCentralProxy |
| : public FakeCentral { |
| public: |
| using InterfaceType = FakeCentral; |
| |
| explicit FakeCentralProxy(mojo::MessageReceiverWithResponder* receiver); |
| void SimulatePreconnectedPeripheral(const WTF::String& address, const WTF::String& name, WTF::Vector<::bluetooth::mojom::blink::UUIDPtr> known_service_uuids, SimulatePreconnectedPeripheralCallback callback) final; |
| void SimulateAdvertisementReceived(ScanResultPtr result, SimulateAdvertisementReceivedCallback callback) final; |
| void SetNextGATTConnectionResponse(const WTF::String& address, uint16_t code, SetNextGATTConnectionResponseCallback callback) final; |
| void SetNextGATTDiscoveryResponse(const WTF::String& address, uint16_t code, SetNextGATTDiscoveryResponseCallback callback) final; |
| void SimulateGATTDisconnection(const WTF::String& address, SimulateGATTDisconnectionCallback callback) final; |
| void SimulateGATTServicesChanged(const WTF::String& address, SimulateGATTServicesChangedCallback callback) final; |
| void AddFakeService(const WTF::String& peripheral_address, ::bluetooth::mojom::blink::UUIDPtr service_uuid, AddFakeServiceCallback callback) final; |
| void RemoveFakeService(const WTF::String& service_id, const WTF::String& peripheral_address, RemoveFakeServiceCallback callback) final; |
| void AddFakeCharacteristic(::bluetooth::mojom::blink::UUIDPtr characteristic_uuid, CharacteristicPropertiesPtr properties, const WTF::String& service_id, const WTF::String& peripheral_address, AddFakeCharacteristicCallback callback) final; |
| void RemoveFakeCharacteristic(const WTF::String& identifier, const WTF::String& service_id, const WTF::String& peripheral_address, RemoveFakeCharacteristicCallback callback) final; |
| void AddFakeDescriptor(::bluetooth::mojom::blink::UUIDPtr descriptor_uuid, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, AddFakeDescriptorCallback callback) final; |
| void RemoveFakeDescriptor(const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, RemoveFakeDescriptorCallback callback) final; |
| void SetNextReadCharacteristicResponse(uint16_t gatt_code, const base::Optional<WTF::Vector<uint8_t>>& value, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextReadCharacteristicResponseCallback callback) final; |
| void SetNextWriteCharacteristicResponse(uint16_t gatt_code, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextWriteCharacteristicResponseCallback callback) final; |
| void SetNextSubscribeToNotificationsResponse(uint16_t gatt_code, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextSubscribeToNotificationsResponseCallback callback) final; |
| void SetNextUnsubscribeFromNotificationsResponse(uint16_t gatt_code, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextUnsubscribeFromNotificationsResponseCallback callback) final; |
| void IsNotifying(const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, IsNotifyingCallback callback) final; |
| void GetLastWrittenCharacteristicValue(const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, GetLastWrittenCharacteristicValueCallback callback) final; |
| void SetNextReadDescriptorResponse(uint16_t gatt_code, const base::Optional<WTF::Vector<uint8_t>>& value, const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextReadDescriptorResponseCallback callback) final; |
| void SetNextWriteDescriptorResponse(uint16_t gatt_code, const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, SetNextWriteDescriptorResponseCallback callback) final; |
| void GetLastWrittenDescriptorValue(const WTF::String& descriptor_id, const WTF::String& characteristic_id, const WTF::String& service_id, const WTF::String& peripheral_address, GetLastWrittenDescriptorValueCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class FakeBluetoothStubDispatch { |
| public: |
| static bool Accept(FakeBluetooth* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| FakeBluetooth* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<FakeBluetooth>> |
| class FakeBluetoothStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| FakeBluetoothStub() {} |
| ~FakeBluetoothStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return FakeBluetoothStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return FakeBluetoothStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class FakeCentralStubDispatch { |
| public: |
| static bool Accept(FakeCentral* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| FakeCentral* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<FakeCentral>> |
| class FakeCentralStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| FakeCentralStub() {} |
| ~FakeCentralStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return FakeCentralStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return FakeCentralStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class FakeBluetoothRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class FakeCentralRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class FakeBluetoothResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class FakeCentralResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| // @generated_from: bluetooth.mojom.Appearance |
| class Appearance { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<Appearance, T>::value>; |
| using DataView = AppearanceDataView; |
| using Data_ = internal::Appearance_Data; |
| |
| template <typename... Args> |
| static AppearancePtr New(Args&&... args) { |
| return AppearancePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static AppearancePtr From(const U& u) { |
| return mojo::TypeConverter<AppearancePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, Appearance>::Convert(*this); |
| } |
| |
| |
| Appearance(); |
| |
| Appearance( |
| bool has_value, |
| int8_t value); |
| |
| ~Appearance(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = AppearancePtr> |
| AppearancePtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, Appearance::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| Appearance::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| Appearance::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::Appearance_UnserializedMessageContext< |
| UserType, Appearance::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<Appearance::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return Appearance::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::Appearance_UnserializedMessageContext< |
| UserType, Appearance::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<Appearance::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: bluetooth.mojom.Appearance.has_value |
| bool has_value; |
| |
| // @generated_from: bluetooth.mojom.Appearance.value |
| int8_t value; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, Appearance::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, Appearance::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, Appearance::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, Appearance::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: bluetooth.mojom.Power |
| class Power { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<Power, T>::value>; |
| using DataView = PowerDataView; |
| using Data_ = internal::Power_Data; |
| |
| template <typename... Args> |
| static PowerPtr New(Args&&... args) { |
| return PowerPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static PowerPtr From(const U& u) { |
| return mojo::TypeConverter<PowerPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, Power>::Convert(*this); |
| } |
| |
| |
| Power(); |
| |
| Power( |
| bool has_value, |
| int8_t value); |
| |
| ~Power(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = PowerPtr> |
| PowerPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, Power::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| Power::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| Power::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::Power_UnserializedMessageContext< |
| UserType, Power::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<Power::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return Power::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::Power_UnserializedMessageContext< |
| UserType, Power::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<Power::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: bluetooth.mojom.Power.has_value |
| bool has_value; |
| |
| // @generated_from: bluetooth.mojom.Power.value |
| int8_t value; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, Power::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, Power::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, Power::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, Power::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: bluetooth.mojom.ServiceDataMap |
| class ServiceDataMap { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ServiceDataMap, T>::value>; |
| using DataView = ServiceDataMapDataView; |
| using Data_ = internal::ServiceDataMap_Data; |
| |
| template <typename... Args> |
| static ServiceDataMapPtr New(Args&&... args) { |
| return ServiceDataMapPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ServiceDataMapPtr From(const U& u) { |
| return mojo::TypeConverter<ServiceDataMapPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ServiceDataMap>::Convert(*this); |
| } |
| |
| |
| ServiceDataMap(); |
| |
| explicit ServiceDataMap( |
| const WTF::HashMap<WTF::String, WTF::Vector<uint8_t>>& service_data); |
| |
| ~ServiceDataMap(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = ServiceDataMapPtr> |
| ServiceDataMapPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, ServiceDataMap::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| ServiceDataMap::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ServiceDataMap::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::ServiceDataMap_UnserializedMessageContext< |
| UserType, ServiceDataMap::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<ServiceDataMap::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ServiceDataMap::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::ServiceDataMap_UnserializedMessageContext< |
| UserType, ServiceDataMap::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ServiceDataMap::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: bluetooth.mojom.ServiceDataMap.service_data |
| WTF::HashMap<WTF::String, WTF::Vector<uint8_t>> service_data; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, ServiceDataMap::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ServiceDataMap::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ServiceDataMap::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ServiceDataMap::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: bluetooth.mojom.ScanRecord |
| class ScanRecord { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ScanRecord, T>::value>; |
| using DataView = ScanRecordDataView; |
| using Data_ = internal::ScanRecord_Data; |
| |
| template <typename... Args> |
| static ScanRecordPtr New(Args&&... args) { |
| return ScanRecordPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ScanRecordPtr From(const U& u) { |
| return mojo::TypeConverter<ScanRecordPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ScanRecord>::Convert(*this); |
| } |
| |
| |
| ScanRecord(); |
| |
| ScanRecord( |
| const WTF::String& name, |
| base::Optional<WTF::Vector<::bluetooth::mojom::blink::UUIDPtr>> uuids, |
| AppearancePtr appearance, |
| PowerPtr tx_power, |
| const base::Optional<WTF::HashMap<uint8_t, WTF::Vector<uint8_t>>>& manufacturer_data, |
| ServiceDataMapPtr service_data); |
| |
| ~ScanRecord(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = ScanRecordPtr> |
| ScanRecordPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, ScanRecord::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| ScanRecord::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ScanRecord::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::ScanRecord_UnserializedMessageContext< |
| UserType, ScanRecord::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<ScanRecord::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ScanRecord::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::ScanRecord_UnserializedMessageContext< |
| UserType, ScanRecord::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ScanRecord::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: bluetooth.mojom.ScanRecord.name |
| WTF::String name; |
| |
| // @generated_from: bluetooth.mojom.ScanRecord.uuids |
| base::Optional<WTF::Vector<::bluetooth::mojom::blink::UUIDPtr>> uuids; |
| |
| // @generated_from: bluetooth.mojom.ScanRecord.appearance |
| AppearancePtr appearance; |
| |
| // @generated_from: bluetooth.mojom.ScanRecord.tx_power |
| PowerPtr tx_power; |
| |
| // @generated_from: bluetooth.mojom.ScanRecord.manufacturer_data |
| base::Optional<WTF::HashMap<uint8_t, WTF::Vector<uint8_t>>> manufacturer_data; |
| |
| // @generated_from: bluetooth.mojom.ScanRecord.service_data |
| ServiceDataMapPtr service_data; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(ScanRecord); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, ScanRecord::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ScanRecord::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ScanRecord::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ScanRecord::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: bluetooth.mojom.ScanResult |
| class ScanResult { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ScanResult, T>::value>; |
| using DataView = ScanResultDataView; |
| using Data_ = internal::ScanResult_Data; |
| |
| template <typename... Args> |
| static ScanResultPtr New(Args&&... args) { |
| return ScanResultPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ScanResultPtr From(const U& u) { |
| return mojo::TypeConverter<ScanResultPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ScanResult>::Convert(*this); |
| } |
| |
| |
| ScanResult(); |
| |
| ScanResult( |
| const WTF::String& device_address, |
| int8_t rssi, |
| ScanRecordPtr scan_record); |
| |
| ~ScanResult(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = ScanResultPtr> |
| ScanResultPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, ScanResult::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| ScanResult::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ScanResult::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::ScanResult_UnserializedMessageContext< |
| UserType, ScanResult::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<ScanResult::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ScanResult::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::ScanResult_UnserializedMessageContext< |
| UserType, ScanResult::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ScanResult::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: bluetooth.mojom.ScanResult.device_address |
| WTF::String device_address; |
| |
| // @generated_from: bluetooth.mojom.ScanResult.rssi |
| int8_t rssi; |
| |
| // @generated_from: bluetooth.mojom.ScanResult.scan_record |
| ScanRecordPtr scan_record; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(ScanResult); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, ScanResult::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ScanResult::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ScanResult::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ScanResult::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties |
| class CharacteristicProperties { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CharacteristicProperties, T>::value>; |
| using DataView = CharacteristicPropertiesDataView; |
| using Data_ = internal::CharacteristicProperties_Data; |
| |
| template <typename... Args> |
| static CharacteristicPropertiesPtr New(Args&&... args) { |
| return CharacteristicPropertiesPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CharacteristicPropertiesPtr From(const U& u) { |
| return mojo::TypeConverter<CharacteristicPropertiesPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CharacteristicProperties>::Convert(*this); |
| } |
| |
| |
| CharacteristicProperties(); |
| |
| CharacteristicProperties( |
| bool broadcast, |
| bool read, |
| bool write_without_response, |
| bool write, |
| bool notify, |
| bool indicate, |
| bool authenticated_signed_writes, |
| bool extended_properties); |
| |
| ~CharacteristicProperties(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename StructPtrType = CharacteristicPropertiesPtr> |
| CharacteristicPropertiesPtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, CharacteristicProperties::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CharacteristicProperties::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CharacteristicProperties::DataView>(input); |
| } |
| |
| // The returned Message is serialized only if the message is moved |
| // cross-process or cross-language. Otherwise if the message is Deserialized |
| // as the same UserType |input| will just be moved to |output| in |
| // DeserializeFromMessage. |
| template <typename UserType> |
| static mojo::Message WrapAsMessage(UserType input) { |
| return mojo::Message(std::make_unique< |
| internal::CharacteristicProperties_UnserializedMessageContext< |
| UserType, CharacteristicProperties::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<CharacteristicProperties::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CharacteristicProperties::Deserialize( |
| input.size() == 0 ? nullptr : &input.front(), input.size(), output); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| auto context = input.TakeUnserializedContext< |
| internal::CharacteristicProperties_UnserializedMessageContext< |
| UserType, CharacteristicProperties::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CharacteristicProperties::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.broadcast |
| bool broadcast; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.read |
| bool read; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.write_without_response |
| bool write_without_response; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.write |
| bool write; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.notify |
| bool notify; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.indicate |
| bool indicate; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.authenticated_signed_writes |
| bool authenticated_signed_writes; |
| |
| // @generated_from: bluetooth.mojom.CharacteristicProperties.extended_properties |
| bool extended_properties; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CharacteristicProperties::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CharacteristicProperties::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CharacteristicProperties::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CharacteristicProperties::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| AppearancePtr Appearance::Clone() const { |
| return New( |
| mojo::Clone(has_value), |
| mojo::Clone(value) |
| ); |
| } |
| |
| template <typename T, Appearance::EnableIfSame<T>*> |
| bool Appearance::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->has_value, other_struct.has_value)) |
| return false; |
| if (!mojo::Equals(this->value, other_struct.value)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, Appearance::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.has_value < rhs.has_value) |
| return true; |
| if (rhs.has_value < lhs.has_value) |
| return false; |
| if (lhs.value < rhs.value) |
| return true; |
| if (rhs.value < lhs.value) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| PowerPtr Power::Clone() const { |
| return New( |
| mojo::Clone(has_value), |
| mojo::Clone(value) |
| ); |
| } |
| |
| template <typename T, Power::EnableIfSame<T>*> |
| bool Power::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->has_value, other_struct.has_value)) |
| return false; |
| if (!mojo::Equals(this->value, other_struct.value)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, Power::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.has_value < rhs.has_value) |
| return true; |
| if (rhs.has_value < lhs.has_value) |
| return false; |
| if (lhs.value < rhs.value) |
| return true; |
| if (rhs.value < lhs.value) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ServiceDataMapPtr ServiceDataMap::Clone() const { |
| return New( |
| mojo::Clone(service_data) |
| ); |
| } |
| |
| template <typename T, ServiceDataMap::EnableIfSame<T>*> |
| bool ServiceDataMap::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->service_data, other_struct.service_data)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ServiceDataMap::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.service_data < rhs.service_data) |
| return true; |
| if (rhs.service_data < lhs.service_data) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ScanRecordPtr ScanRecord::Clone() const { |
| return New( |
| mojo::Clone(name), |
| mojo::Clone(uuids), |
| mojo::Clone(appearance), |
| mojo::Clone(tx_power), |
| mojo::Clone(manufacturer_data), |
| mojo::Clone(service_data) |
| ); |
| } |
| |
| template <typename T, ScanRecord::EnableIfSame<T>*> |
| bool ScanRecord::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->name, other_struct.name)) |
| return false; |
| if (!mojo::Equals(this->uuids, other_struct.uuids)) |
| return false; |
| if (!mojo::Equals(this->appearance, other_struct.appearance)) |
| return false; |
| if (!mojo::Equals(this->tx_power, other_struct.tx_power)) |
| return false; |
| if (!mojo::Equals(this->manufacturer_data, other_struct.manufacturer_data)) |
| return false; |
| if (!mojo::Equals(this->service_data, other_struct.service_data)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ScanRecord::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.name < rhs.name) |
| return true; |
| if (rhs.name < lhs.name) |
| return false; |
| if (lhs.uuids < rhs.uuids) |
| return true; |
| if (rhs.uuids < lhs.uuids) |
| return false; |
| if (lhs.appearance < rhs.appearance) |
| return true; |
| if (rhs.appearance < lhs.appearance) |
| return false; |
| if (lhs.tx_power < rhs.tx_power) |
| return true; |
| if (rhs.tx_power < lhs.tx_power) |
| return false; |
| if (lhs.manufacturer_data < rhs.manufacturer_data) |
| return true; |
| if (rhs.manufacturer_data < lhs.manufacturer_data) |
| return false; |
| if (lhs.service_data < rhs.service_data) |
| return true; |
| if (rhs.service_data < lhs.service_data) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ScanResultPtr ScanResult::Clone() const { |
| return New( |
| mojo::Clone(device_address), |
| mojo::Clone(rssi), |
| mojo::Clone(scan_record) |
| ); |
| } |
| |
| template <typename T, ScanResult::EnableIfSame<T>*> |
| bool ScanResult::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->device_address, other_struct.device_address)) |
| return false; |
| if (!mojo::Equals(this->rssi, other_struct.rssi)) |
| return false; |
| if (!mojo::Equals(this->scan_record, other_struct.scan_record)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ScanResult::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.device_address < rhs.device_address) |
| return true; |
| if (rhs.device_address < lhs.device_address) |
| return false; |
| if (lhs.rssi < rhs.rssi) |
| return true; |
| if (rhs.rssi < lhs.rssi) |
| return false; |
| if (lhs.scan_record < rhs.scan_record) |
| return true; |
| if (rhs.scan_record < lhs.scan_record) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CharacteristicPropertiesPtr CharacteristicProperties::Clone() const { |
| return New( |
| mojo::Clone(broadcast), |
| mojo::Clone(read), |
| mojo::Clone(write_without_response), |
| mojo::Clone(write), |
| mojo::Clone(notify), |
| mojo::Clone(indicate), |
| mojo::Clone(authenticated_signed_writes), |
| mojo::Clone(extended_properties) |
| ); |
| } |
| |
| template <typename T, CharacteristicProperties::EnableIfSame<T>*> |
| bool CharacteristicProperties::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->broadcast, other_struct.broadcast)) |
| return false; |
| if (!mojo::Equals(this->read, other_struct.read)) |
| return false; |
| if (!mojo::Equals(this->write_without_response, other_struct.write_without_response)) |
| return false; |
| if (!mojo::Equals(this->write, other_struct.write)) |
| return false; |
| if (!mojo::Equals(this->notify, other_struct.notify)) |
| return false; |
| if (!mojo::Equals(this->indicate, other_struct.indicate)) |
| return false; |
| if (!mojo::Equals(this->authenticated_signed_writes, other_struct.authenticated_signed_writes)) |
| return false; |
| if (!mojo::Equals(this->extended_properties, other_struct.extended_properties)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CharacteristicProperties::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.broadcast < rhs.broadcast) |
| return true; |
| if (rhs.broadcast < lhs.broadcast) |
| return false; |
| if (lhs.read < rhs.read) |
| return true; |
| if (rhs.read < lhs.read) |
| return false; |
| if (lhs.write_without_response < rhs.write_without_response) |
| return true; |
| if (rhs.write_without_response < lhs.write_without_response) |
| return false; |
| if (lhs.write < rhs.write) |
| return true; |
| if (rhs.write < lhs.write) |
| return false; |
| if (lhs.notify < rhs.notify) |
| return true; |
| if (rhs.notify < lhs.notify) |
| return false; |
| if (lhs.indicate < rhs.indicate) |
| return true; |
| if (rhs.indicate < lhs.indicate) |
| return false; |
| if (lhs.authenticated_signed_writes < rhs.authenticated_signed_writes) |
| return true; |
| if (rhs.authenticated_signed_writes < lhs.authenticated_signed_writes) |
| return false; |
| if (lhs.extended_properties < rhs.extended_properties) |
| return true; |
| if (rhs.extended_properties < lhs.extended_properties) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace bluetooth |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct StructTraits<::bluetooth::mojom::blink::Appearance::DataView, |
| ::bluetooth::mojom::blink::AppearancePtr> { |
| static bool IsNull(const ::bluetooth::mojom::blink::AppearancePtr& input) { return !input; } |
| static void SetToNull(::bluetooth::mojom::blink::AppearancePtr* output) { output->reset(); } |
| |
| static decltype(::bluetooth::mojom::blink::Appearance::has_value) has_value( |
| const ::bluetooth::mojom::blink::AppearancePtr& input) { |
| return input->has_value; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::Appearance::value) value( |
| const ::bluetooth::mojom::blink::AppearancePtr& input) { |
| return input->value; |
| } |
| |
| static bool Read(::bluetooth::mojom::blink::Appearance::DataView input, ::bluetooth::mojom::blink::AppearancePtr* output); |
| }; |
| |
| |
| template <> |
| struct StructTraits<::bluetooth::mojom::blink::Power::DataView, |
| ::bluetooth::mojom::blink::PowerPtr> { |
| static bool IsNull(const ::bluetooth::mojom::blink::PowerPtr& input) { return !input; } |
| static void SetToNull(::bluetooth::mojom::blink::PowerPtr* output) { output->reset(); } |
| |
| static decltype(::bluetooth::mojom::blink::Power::has_value) has_value( |
| const ::bluetooth::mojom::blink::PowerPtr& input) { |
| return input->has_value; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::Power::value) value( |
| const ::bluetooth::mojom::blink::PowerPtr& input) { |
| return input->value; |
| } |
| |
| static bool Read(::bluetooth::mojom::blink::Power::DataView input, ::bluetooth::mojom::blink::PowerPtr* output); |
| }; |
| |
| |
| template <> |
| struct StructTraits<::bluetooth::mojom::blink::ServiceDataMap::DataView, |
| ::bluetooth::mojom::blink::ServiceDataMapPtr> { |
| static bool IsNull(const ::bluetooth::mojom::blink::ServiceDataMapPtr& input) { return !input; } |
| static void SetToNull(::bluetooth::mojom::blink::ServiceDataMapPtr* output) { output->reset(); } |
| |
| static const decltype(::bluetooth::mojom::blink::ServiceDataMap::service_data)& service_data( |
| const ::bluetooth::mojom::blink::ServiceDataMapPtr& input) { |
| return input->service_data; |
| } |
| |
| static bool Read(::bluetooth::mojom::blink::ServiceDataMap::DataView input, ::bluetooth::mojom::blink::ServiceDataMapPtr* output); |
| }; |
| |
| |
| template <> |
| struct StructTraits<::bluetooth::mojom::blink::ScanRecord::DataView, |
| ::bluetooth::mojom::blink::ScanRecordPtr> { |
| static bool IsNull(const ::bluetooth::mojom::blink::ScanRecordPtr& input) { return !input; } |
| static void SetToNull(::bluetooth::mojom::blink::ScanRecordPtr* output) { output->reset(); } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanRecord::name)& name( |
| const ::bluetooth::mojom::blink::ScanRecordPtr& input) { |
| return input->name; |
| } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanRecord::uuids)& uuids( |
| const ::bluetooth::mojom::blink::ScanRecordPtr& input) { |
| return input->uuids; |
| } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanRecord::appearance)& appearance( |
| const ::bluetooth::mojom::blink::ScanRecordPtr& input) { |
| return input->appearance; |
| } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanRecord::tx_power)& tx_power( |
| const ::bluetooth::mojom::blink::ScanRecordPtr& input) { |
| return input->tx_power; |
| } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanRecord::manufacturer_data)& manufacturer_data( |
| const ::bluetooth::mojom::blink::ScanRecordPtr& input) { |
| return input->manufacturer_data; |
| } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanRecord::service_data)& service_data( |
| const ::bluetooth::mojom::blink::ScanRecordPtr& input) { |
| return input->service_data; |
| } |
| |
| static bool Read(::bluetooth::mojom::blink::ScanRecord::DataView input, ::bluetooth::mojom::blink::ScanRecordPtr* output); |
| }; |
| |
| |
| template <> |
| struct StructTraits<::bluetooth::mojom::blink::ScanResult::DataView, |
| ::bluetooth::mojom::blink::ScanResultPtr> { |
| static bool IsNull(const ::bluetooth::mojom::blink::ScanResultPtr& input) { return !input; } |
| static void SetToNull(::bluetooth::mojom::blink::ScanResultPtr* output) { output->reset(); } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanResult::device_address)& device_address( |
| const ::bluetooth::mojom::blink::ScanResultPtr& input) { |
| return input->device_address; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::ScanResult::rssi) rssi( |
| const ::bluetooth::mojom::blink::ScanResultPtr& input) { |
| return input->rssi; |
| } |
| |
| static const decltype(::bluetooth::mojom::blink::ScanResult::scan_record)& scan_record( |
| const ::bluetooth::mojom::blink::ScanResultPtr& input) { |
| return input->scan_record; |
| } |
| |
| static bool Read(::bluetooth::mojom::blink::ScanResult::DataView input, ::bluetooth::mojom::blink::ScanResultPtr* output); |
| }; |
| |
| |
| template <> |
| struct StructTraits<::bluetooth::mojom::blink::CharacteristicProperties::DataView, |
| ::bluetooth::mojom::blink::CharacteristicPropertiesPtr> { |
| static bool IsNull(const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { return !input; } |
| static void SetToNull(::bluetooth::mojom::blink::CharacteristicPropertiesPtr* output) { output->reset(); } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::broadcast) broadcast( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->broadcast; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::read) read( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->read; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::write_without_response) write_without_response( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->write_without_response; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::write) write( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->write; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::notify) notify( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->notify; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::indicate) indicate( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->indicate; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::authenticated_signed_writes) authenticated_signed_writes( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->authenticated_signed_writes; |
| } |
| |
| static decltype(::bluetooth::mojom::blink::CharacteristicProperties::extended_properties) extended_properties( |
| const ::bluetooth::mojom::blink::CharacteristicPropertiesPtr& input) { |
| return input->extended_properties; |
| } |
| |
| static bool Read(::bluetooth::mojom::blink::CharacteristicProperties::DataView input, ::bluetooth::mojom::blink::CharacteristicPropertiesPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // DEVICE_BLUETOOTH_PUBLIC_MOJOM_TEST_FAKE_BLUETOOTH_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogMzc2NywgImJlZ2luIjogMzc1NCwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pvbS5GYWtlQmx1ZXRvb3RoIn19
|
| LCB7ImVuZCI6IDQ2MzAsICJiZWdpbiI6IDQ2MTYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUJsdWV0b290aC5TZXRMRVN1cHBv
|
| cnRlZCJ9fSwgeyJlbmQiOiA0ODYyLCAiYmVnaW4iOiA0ODQ3LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkZha2VCbHVldG9vdGguU2lt
|
| dWxhdGVDZW50cmFsIn19LCB7ImVuZCI6IDUxMDQsICJiZWdpbiI6IDUwODQsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUJsdWV0
|
| b290aC5BbGxSZXNwb25zZXNDb25zdW1lZCJ9fSwgeyJlbmQiOiA1Mzc1LCAiYmVnaW4iOiA1MzY0
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1v
|
| am9tLkZha2VDZW50cmFsIn19LCB7ImVuZCI6IDcxNjEsICJiZWdpbiI6IDcxMzEsICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt
|
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNl
|
| bnRyYWwuU2ltdWxhdGVQcmVjb25uZWN0ZWRQZXJpcGhlcmFsIn19LCB7ImVuZCI6IDc1NDEsICJi
|
| ZWdpbiI6IDc1MTIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj
|
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJi
|
| bHVldG9vdGgubW9qb20uRmFrZUNlbnRyYWwuU2ltdWxhdGVBZHZlcnRpc2VtZW50UmVjZWl2ZWQi
|
| fX0sIHsiZW5kIjogNzgyNCwgImJlZ2luIjogNzc5NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pvbS5GYWtlQ2VudHJhbC5TZXROZXh0R0FU
|
| VENvbm5lY3Rpb25SZXNwb25zZSJ9fSwgeyJlbmQiOiA4MTI1LCAiYmVnaW4iOiA4MDk3LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny
|
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkZh
|
| a2VDZW50cmFsLlNldE5leHRHQVRURGlzY292ZXJ5UmVzcG9uc2UifX0sIHsiZW5kIjogODQxNiwg
|
| ImJlZ2luIjogODM5MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog
|
| ImJsdWV0b290aC5tb2pvbS5GYWtlQ2VudHJhbC5TaW11bGF0ZUdBVFREaXNjb25uZWN0aW9uIn19
|
| LCB7ImVuZCI6IDg2OTUsICJiZWdpbiI6IDg2NjgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNlbnRyYWwuU2ltdWxhdGVHQVRU
|
| U2VydmljZXNDaGFuZ2VkIn19LCB7ImVuZCI6IDg5NTEsICJiZWdpbiI6IDg5MzcsICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt
|
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNl
|
| bnRyYWwuQWRkRmFrZVNlcnZpY2UifX0sIHsiZW5kIjogOTI0OSwgImJlZ2luIjogOTIzMiwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pvbS5G
|
| YWtlQ2VudHJhbC5SZW1vdmVGYWtlU2VydmljZSJ9fSwgeyJlbmQiOiA5NTU4LCAiYmVnaW4iOiA5
|
| NTM3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3Ro
|
| Lm1vam9tLkZha2VDZW50cmFsLkFkZEZha2VDaGFyYWN0ZXJpc3RpYyJ9fSwgeyJlbmQiOiA5OTYy
|
| LCAiYmVnaW4iOiA5OTM4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi
|
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi
|
| OiAiYmx1ZXRvb3RoLm1vam9tLkZha2VDZW50cmFsLlJlbW92ZUZha2VDaGFyYWN0ZXJpc3RpYyJ9
|
| fSwgeyJlbmQiOiAxMDI5NywgImJlZ2luIjogMTAyODAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNlbnRyYWwuQWRkRmFrZURl
|
| c2NyaXB0b3IifX0sIHsiZW5kIjogMTA2NzksICJiZWdpbiI6IDEwNjU5LCAiZWRnZSI6ICIlL2t5
|
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkZha2VDZW50cmFs
|
| LlJlbW92ZUZha2VEZXNjcmlwdG9yIn19LCB7ImVuZCI6IDExMDg1LCAiYmVnaW4iOiAxMTA1Miwg
|
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz
|
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1
|
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pv
|
| bS5GYWtlQ2VudHJhbC5TZXROZXh0UmVhZENoYXJhY3RlcmlzdGljUmVzcG9uc2UifX0sIHsiZW5k
|
| IjogMTE1NDQsICJiZWdpbiI6IDExNTEwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkZha2VDZW50cmFsLlNldE5leHRXcml0ZUNoYXJh
|
| Y3RlcmlzdGljUmVzcG9uc2UifX0sIHsiZW5kIjogMTE5NjgsICJiZWdpbiI6IDExOTI5LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny
|
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkZh
|
| a2VDZW50cmFsLlNldE5leHRTdWJzY3JpYmVUb05vdGlmaWNhdGlvbnNSZXNwb25zZSJ9fSwgeyJl
|
| bmQiOiAxMjQwOSwgImJlZ2luIjogMTIzNjYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNlbnRyYWwuU2V0TmV4dFVuc3Vic2Ny
|
| aWJlRnJvbU5vdGlmaWNhdGlvbnNSZXNwb25zZSJ9fSwgeyJlbmQiOiAxMjc2NCwgImJlZ2luIjog
|
| MTI3NTMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9v
|
| dGgubW9qb20uRmFrZUNlbnRyYWwuSXNOb3RpZnlpbmcifX0sIHsiZW5kIjogMTMxNzIsICJiZWdp
|
| biI6IDEzMTM5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j
|
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu
|
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1
|
| ZXRvb3RoLm1vam9tLkZha2VDZW50cmFsLkdldExhc3RXcml0dGVuQ2hhcmFjdGVyaXN0aWNWYWx1
|
| ZSJ9fSwgeyJlbmQiOiAxMzU0NSwgImJlZ2luIjogMTM1MTYsICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz
|
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog
|
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNlbnRyYWwuU2V0TmV4
|
| dFJlYWREZXNjcmlwdG9yUmVzcG9uc2UifX0sIHsiZW5kIjogMTQwMjIsICJiZWdpbiI6IDEzOTky
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1v
|
| am9tLkZha2VDZW50cmFsLlNldE5leHRXcml0ZURlc2NyaXB0b3JSZXNwb25zZSJ9fSwgeyJlbmQi
|
| OiAxNDQ5MSwgImJlZ2luIjogMTQ0NjIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp
|
| Z25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uRmFrZUNlbnRyYWwuR2V0TGFzdFdyaXR0ZW5EZXNj
|
| cmlwdG9yVmFsdWUifX0sIHsiZW5kIjogMjI2ODAsICJiZWdpbiI6IDIyNjcwLCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkFwcGVhcmFu
|
| Y2UifX0sIHsiZW5kIjogMjYxNDcsICJiZWdpbiI6IDI2MTM4LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkFwcGVhcmFuY2UuaGFzX3Zh
|
| bHVlIn19LCB7ImVuZCI6IDI2MjE5LCAiYmVnaW4iOiAyNjIxNCwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pvbS5BcHBlYXJhbmNlLnZhbHVl
|
| In19LCB7ImVuZCI6IDI3MTIzLCAiYmVnaW4iOiAyNzExOCwgImVkZ2UiOiAiJS9reXRoZS9lZGdl
|
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi
|
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi
|
| bW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pvbS5Qb3dlciJ9fSwgeyJlbmQiOiAz
|
| MDQ3MCwgImJlZ2luIjogMzA0NjEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJibHVldG9vdGgubW9qb20uUG93ZXIuaGFzX3ZhbHVlIn19LCB7ImVuZCI6IDMwNTM3
|
| LCAiYmVnaW4iOiAzMDUzMiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl
|
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl
|
| IjogImJsdWV0b290aC5tb2pvbS5Qb3dlci52YWx1ZSJ9fSwgeyJlbmQiOiAzMTQ0NywgImJlZ2lu
|
| IjogMzE0MzMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVl
|
| dG9vdGgubW9qb20uU2VydmljZURhdGFNYXAifX0sIHsiZW5kIjogMzUwNjcsICJiZWdpbiI6IDM1
|
| MDU1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3Ro
|
| Lm1vam9tLlNlcnZpY2VEYXRhTWFwLnNlcnZpY2VfZGF0YSJ9fSwgeyJlbmQiOiAzNTk5NywgImJl
|
| Z2luIjogMzU5ODcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj
|
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJi
|
| bHVldG9vdGgubW9qb20uU2NhblJlY29yZCJ9fSwgeyJlbmQiOiAzOTY4MCwgImJlZ2luIjogMzk2
|
| NzYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVm
|
| aW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hy
|
| b21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgu
|
| bW9qb20uU2NhblJlY29yZC5uYW1lIn19LCB7ImVuZCI6IDM5ODA5LCAiYmVnaW4iOiAzOTgwNCwg
|
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz
|
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1
|
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pv
|
| bS5TY2FuUmVjb3JkLnV1aWRzIn19LCB7ImVuZCI6IDM5ODg3LCAiYmVnaW4iOiAzOTg3NCwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5tb2pvbS5T
|
| Y2FuUmVjb3JkLmFwcGVhcmFuY2UifX0sIHsiZW5kIjogMzk5NzgsICJiZWdpbiI6IDM5OTcwLCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9t
|
| LlNjYW5SZWNvcmQudHhfcG93ZXIifX0sIHsiZW5kIjogNDAxMjcsICJiZWdpbiI6IDQwMTEwLCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9t
|
| LlNjYW5SZWNvcmQubWFudWZhY3R1cmVyX2RhdGEifX0sIHsiZW5kIjogNDAyMjQsICJiZWdpbiI6
|
| IDQwMjEyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y
|
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t
|
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRv
|
| b3RoLm1vam9tLlNjYW5SZWNvcmQuc2VydmljZV9kYXRhIn19LCB7ImVuZCI6IDQxMTc4LCAiYmVn
|
| aW4iOiA0MTE2OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu
|
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl
|
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJs
|
| dWV0b290aC5tb2pvbS5TY2FuUmVzdWx0In19LCB7ImVuZCI6IDQ0Njc5LCAiYmVnaW4iOiA0NDY2
|
| NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv
|
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0b290aC5t
|
| b2pvbS5TY2FuUmVzdWx0LmRldmljZV9hZGRyZXNzIn19LCB7ImVuZCI6IDQ0NzQ5LCAiYmVnaW4i
|
| OiA0NDc0NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0
|
| b290aC5tb2pvbS5TY2FuUmVzdWx0LnJzc2kifX0sIHsiZW5kIjogNDQ4NDAsICJiZWdpbiI6IDQ0
|
| ODI5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3Ro
|
| Lm1vam9tLlNjYW5SZXN1bHQuc2Nhbl9yZWNvcmQifX0sIHsiZW5kIjogNDU4MjIsICJiZWdpbiI6
|
| IDQ1Nzk4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y
|
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t
|
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRv
|
| b3RoLm1vam9tLkNoYXJhY3RlcmlzdGljUHJvcGVydGllcyJ9fSwgeyJlbmQiOiA0OTc4NywgImJl
|
| Z2luIjogNDk3NzgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj
|
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJi
|
| bHVldG9vdGgubW9qb20uQ2hhcmFjdGVyaXN0aWNQcm9wZXJ0aWVzLmJyb2FkY2FzdCJ9fSwgeyJl
|
| bmQiOiA0OTg2OSwgImJlZ2luIjogNDk4NjUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uQ2hhcmFjdGVyaXN0aWNQcm9wZXJ0aWVzLnJl
|
| YWQifX0sIHsiZW5kIjogNDk5ODcsICJiZWdpbiI6IDQ5OTY1LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkNoYXJhY3RlcmlzdGljUHJv
|
| cGVydGllcy53cml0ZV93aXRob3V0X3Jlc3BvbnNlIn19LCB7ImVuZCI6IDUwMDcxLCAiYmVnaW4i
|
| OiA1MDA2NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImJsdWV0
|
| b290aC5tb2pvbS5DaGFyYWN0ZXJpc3RpY1Byb3BlcnRpZXMud3JpdGUifX0sIHsiZW5kIjogNTAx
|
| NTcsICJiZWdpbiI6IDUwMTUxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5
|
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n
|
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1
|
| cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkNoYXJhY3RlcmlzdGljUHJvcGVydGllcy5ub3RpZnkifX0s
|
| IHsiZW5kIjogNTAyNDcsICJiZWdpbiI6IDUwMjM5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAiYmx1ZXRvb3RoLm1vam9tLkNoYXJhY3RlcmlzdGljUHJvcGVydGll
|
| cy5pbmRpY2F0ZSJ9fSwgeyJlbmQiOiA1MDM3NSwgImJlZ2luIjogNTAzNDgsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJibHVldG9vdGgubW9qb20uQ2hhcmFjdGVy
|
| aXN0aWNQcm9wZXJ0aWVzLmF1dGhlbnRpY2F0ZWRfc2lnbmVkX3dyaXRlcyJ9fSwgeyJlbmQiOiA1
|
| MDQ4NywgImJlZ2luIjogNTA0NjgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJibHVldG9vdGgubW9qb20uQ2hhcmFjdGVyaXN0aWNQcm9wZXJ0aWVzLmV4dGVuZGVk
|
| X3Byb3BlcnRpZXMifX1dLCAidHlwZSI6ICJreXRoZTAifQ==
|
| */ |
