| // 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 SERVICES_DEVICE_PUBLIC_MOJOM_SERIAL_MOJOM_BLINK_H_ |
| #define SERVICES_DEVICE_PUBLIC_MOJOM_SERIAL_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 "services/device/public/mojom/serial.mojom-shared.h" |
| #include "services/device/public/mojom/serial.mojom-blink-forward.h" |
| #include "mojo/public/mojom/base/file_path.mojom-blink.h" |
| #include "mojo/public/mojom/base/unguessable_token.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" |
| #include "third_party/blink/public/platform/web_common.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_SerialSendError_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::SerialSendError& value) { |
| using utype = std::underlying_type<::device::mojom::SerialSendError>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::SerialSendError& left, const ::device::mojom::SerialSendError& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::SerialSendError> |
| : public GenericHashTraits<::device::mojom::SerialSendError> { |
| 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 ::device::mojom::SerialSendError& value) { |
| return value == static_cast<::device::mojom::SerialSendError>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::SerialSendError& slot, bool) { |
| slot = static_cast<::device::mojom::SerialSendError>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::SerialSendError& value) { |
| return value == static_cast<::device::mojom::SerialSendError>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_SerialReceiveError_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::SerialReceiveError& value) { |
| using utype = std::underlying_type<::device::mojom::SerialReceiveError>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::SerialReceiveError& left, const ::device::mojom::SerialReceiveError& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::SerialReceiveError> |
| : public GenericHashTraits<::device::mojom::SerialReceiveError> { |
| 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 ::device::mojom::SerialReceiveError& value) { |
| return value == static_cast<::device::mojom::SerialReceiveError>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::SerialReceiveError& slot, bool) { |
| slot = static_cast<::device::mojom::SerialReceiveError>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::SerialReceiveError& value) { |
| return value == static_cast<::device::mojom::SerialReceiveError>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_SerialDataBits_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::SerialDataBits& value) { |
| using utype = std::underlying_type<::device::mojom::SerialDataBits>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::SerialDataBits& left, const ::device::mojom::SerialDataBits& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::SerialDataBits> |
| : public GenericHashTraits<::device::mojom::SerialDataBits> { |
| 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 ::device::mojom::SerialDataBits& value) { |
| return value == static_cast<::device::mojom::SerialDataBits>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::SerialDataBits& slot, bool) { |
| slot = static_cast<::device::mojom::SerialDataBits>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::SerialDataBits& value) { |
| return value == static_cast<::device::mojom::SerialDataBits>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_SerialParityBit_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::SerialParityBit& value) { |
| using utype = std::underlying_type<::device::mojom::SerialParityBit>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::SerialParityBit& left, const ::device::mojom::SerialParityBit& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::SerialParityBit> |
| : public GenericHashTraits<::device::mojom::SerialParityBit> { |
| 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 ::device::mojom::SerialParityBit& value) { |
| return value == static_cast<::device::mojom::SerialParityBit>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::SerialParityBit& slot, bool) { |
| slot = static_cast<::device::mojom::SerialParityBit>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::SerialParityBit& value) { |
| return value == static_cast<::device::mojom::SerialParityBit>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct device_mojom_internal_SerialStopBits_DataHashFn { |
| static unsigned GetHash(const ::device::mojom::SerialStopBits& value) { |
| using utype = std::underlying_type<::device::mojom::SerialStopBits>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::device::mojom::SerialStopBits& left, const ::device::mojom::SerialStopBits& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::device::mojom::SerialStopBits> |
| : public GenericHashTraits<::device::mojom::SerialStopBits> { |
| 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 ::device::mojom::SerialStopBits& value) { |
| return value == static_cast<::device::mojom::SerialStopBits>(-1000000); |
| } |
| static void ConstructDeletedValue(::device::mojom::SerialStopBits& slot, bool) { |
| slot = static_cast<::device::mojom::SerialStopBits>(-1000001); |
| } |
| static bool IsDeletedValue(const ::device::mojom::SerialStopBits& value) { |
| return value == static_cast<::device::mojom::SerialStopBits>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace device { |
| namespace mojom { |
| namespace blink { |
| |
| class SerialPortManagerProxy; |
| |
| template <typename ImplRefTraits> |
| class SerialPortManagerStub; |
| |
| class SerialPortManagerRequestValidator; |
| class SerialPortManagerResponseValidator; |
| |
| |
| // @generated_from: device.mojom.SerialPortManager |
| class BLINK_PLATFORM_EXPORT SerialPortManager |
| : public SerialPortManagerInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = SerialPortManagerInterfaceBase; |
| using Proxy_ = SerialPortManagerProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = SerialPortManagerStub<ImplRefTraits>; |
| |
| using RequestValidator_ = SerialPortManagerRequestValidator; |
| using ResponseValidator_ = SerialPortManagerResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kGetDevicesMinVersion = 0, |
| kGetPortMinVersion = 0, |
| }; |
| virtual ~SerialPortManager() {} |
| |
| |
| using GetDevicesCallback = base::OnceCallback<void(WTF::Vector<SerialPortInfoPtr>)>; |
| |
| // @generated_from: device.mojom.SerialPortManager.GetDevices |
| virtual void GetDevices(GetDevicesCallback callback) = 0; |
| |
| |
| // @generated_from: device.mojom.SerialPortManager.GetPort |
| virtual void GetPort(const base::UnguessableToken& token, SerialPortRequest port_request, SerialPortConnectionWatcherPtr watcher) = 0; |
| }; |
| |
| class SerialPortProxy; |
| |
| template <typename ImplRefTraits> |
| class SerialPortStub; |
| |
| class SerialPortRequestValidator; |
| class SerialPortResponseValidator; |
| |
| |
| // @generated_from: device.mojom.SerialPort |
| class BLINK_PLATFORM_EXPORT SerialPort |
| : public SerialPortInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = SerialPortInterfaceBase; |
| using Proxy_ = SerialPortProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = SerialPortStub<ImplRefTraits>; |
| |
| using RequestValidator_ = SerialPortRequestValidator; |
| using ResponseValidator_ = SerialPortResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kOpenMinVersion = 0, |
| kClearSendErrorMinVersion = 0, |
| kClearReadErrorMinVersion = 0, |
| kFlushMinVersion = 0, |
| kGetControlSignalsMinVersion = 0, |
| kSetControlSignalsMinVersion = 0, |
| kConfigurePortMinVersion = 0, |
| kGetPortInfoMinVersion = 0, |
| kSetBreakMinVersion = 0, |
| kClearBreakMinVersion = 0, |
| }; |
| virtual ~SerialPort() {} |
| |
| |
| using OpenCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: device.mojom.SerialPort.Open |
| virtual void Open(SerialConnectionOptionsPtr options, mojo::ScopedDataPipeConsumerHandle in_stream, mojo::ScopedDataPipeProducerHandle out_stream, SerialPortClientPtr client, OpenCallback callback) = 0; |
| |
| |
| // @generated_from: device.mojom.SerialPort.ClearSendError |
| virtual void ClearSendError(mojo::ScopedDataPipeConsumerHandle consumer) = 0; |
| |
| |
| // @generated_from: device.mojom.SerialPort.ClearReadError |
| virtual void ClearReadError(mojo::ScopedDataPipeProducerHandle producer) = 0; |
| |
| |
| using FlushCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: device.mojom.SerialPort.Flush |
| virtual void Flush(FlushCallback callback) = 0; |
| |
| |
| using GetControlSignalsCallback = base::OnceCallback<void(SerialPortControlSignalsPtr)>; |
| |
| // @generated_from: device.mojom.SerialPort.GetControlSignals |
| virtual void GetControlSignals(GetControlSignalsCallback callback) = 0; |
| |
| |
| using SetControlSignalsCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: device.mojom.SerialPort.SetControlSignals |
| virtual void SetControlSignals(SerialHostControlSignalsPtr signals, SetControlSignalsCallback callback) = 0; |
| |
| |
| using ConfigurePortCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: device.mojom.SerialPort.ConfigurePort |
| virtual void ConfigurePort(SerialConnectionOptionsPtr options, ConfigurePortCallback callback) = 0; |
| |
| |
| using GetPortInfoCallback = base::OnceCallback<void(SerialConnectionInfoPtr)>; |
| |
| // @generated_from: device.mojom.SerialPort.GetPortInfo |
| virtual void GetPortInfo(GetPortInfoCallback callback) = 0; |
| |
| |
| using SetBreakCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: device.mojom.SerialPort.SetBreak |
| virtual void SetBreak(SetBreakCallback callback) = 0; |
| |
| |
| using ClearBreakCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: device.mojom.SerialPort.ClearBreak |
| virtual void ClearBreak(ClearBreakCallback callback) = 0; |
| }; |
| |
| class SerialPortClientProxy; |
| |
| template <typename ImplRefTraits> |
| class SerialPortClientStub; |
| |
| class SerialPortClientRequestValidator; |
| |
| |
| // @generated_from: device.mojom.SerialPortClient |
| class BLINK_PLATFORM_EXPORT SerialPortClient |
| : public SerialPortClientInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = SerialPortClientInterfaceBase; |
| using Proxy_ = SerialPortClientProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = SerialPortClientStub<ImplRefTraits>; |
| |
| using RequestValidator_ = SerialPortClientRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kOnReadErrorMinVersion = 0, |
| kOnSendErrorMinVersion = 0, |
| }; |
| virtual ~SerialPortClient() {} |
| |
| |
| // @generated_from: device.mojom.SerialPortClient.OnReadError |
| virtual void OnReadError(SerialReceiveError error) = 0; |
| |
| |
| // @generated_from: device.mojom.SerialPortClient.OnSendError |
| virtual void OnSendError(SerialSendError error) = 0; |
| }; |
| |
| class SerialPortConnectionWatcherProxy; |
| |
| template <typename ImplRefTraits> |
| class SerialPortConnectionWatcherStub; |
| |
| class SerialPortConnectionWatcherRequestValidator; |
| |
| |
| // @generated_from: device.mojom.SerialPortConnectionWatcher |
| class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcher |
| : public SerialPortConnectionWatcherInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = SerialPortConnectionWatcherInterfaceBase; |
| using Proxy_ = SerialPortConnectionWatcherProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = SerialPortConnectionWatcherStub<ImplRefTraits>; |
| |
| using RequestValidator_ = SerialPortConnectionWatcherRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| }; |
| virtual ~SerialPortConnectionWatcher() {} |
| }; |
| |
| class BLINK_PLATFORM_EXPORT SerialPortManagerProxy |
| : public SerialPortManager { |
| public: |
| using InterfaceType = SerialPortManager; |
| |
| explicit SerialPortManagerProxy(mojo::MessageReceiverWithResponder* receiver); |
| void GetDevices(GetDevicesCallback callback) final; |
| void GetPort(const base::UnguessableToken& token, SerialPortRequest port_request, SerialPortConnectionWatcherPtr watcher) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT SerialPortProxy |
| : public SerialPort { |
| public: |
| using InterfaceType = SerialPort; |
| |
| explicit SerialPortProxy(mojo::MessageReceiverWithResponder* receiver); |
| void Open(SerialConnectionOptionsPtr options, mojo::ScopedDataPipeConsumerHandle in_stream, mojo::ScopedDataPipeProducerHandle out_stream, SerialPortClientPtr client, OpenCallback callback) final; |
| void ClearSendError(mojo::ScopedDataPipeConsumerHandle consumer) final; |
| void ClearReadError(mojo::ScopedDataPipeProducerHandle producer) final; |
| void Flush(FlushCallback callback) final; |
| void GetControlSignals(GetControlSignalsCallback callback) final; |
| void SetControlSignals(SerialHostControlSignalsPtr signals, SetControlSignalsCallback callback) final; |
| void ConfigurePort(SerialConnectionOptionsPtr options, ConfigurePortCallback callback) final; |
| void GetPortInfo(GetPortInfoCallback callback) final; |
| void SetBreak(SetBreakCallback callback) final; |
| void ClearBreak(ClearBreakCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT SerialPortClientProxy |
| : public SerialPortClient { |
| public: |
| using InterfaceType = SerialPortClient; |
| |
| explicit SerialPortClientProxy(mojo::MessageReceiverWithResponder* receiver); |
| void OnReadError(SerialReceiveError error) final; |
| void OnSendError(SerialSendError error) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcherProxy |
| : public SerialPortConnectionWatcher { |
| public: |
| using InterfaceType = SerialPortConnectionWatcher; |
| |
| explicit SerialPortConnectionWatcherProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortManagerStubDispatch { |
| public: |
| static bool Accept(SerialPortManager* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| SerialPortManager* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<SerialPortManager>> |
| class SerialPortManagerStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| SerialPortManagerStub() {} |
| ~SerialPortManagerStub() 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 SerialPortManagerStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return SerialPortManagerStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortStubDispatch { |
| public: |
| static bool Accept(SerialPort* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| SerialPort* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<SerialPort>> |
| class SerialPortStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| SerialPortStub() {} |
| ~SerialPortStub() 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 SerialPortStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return SerialPortStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortClientStubDispatch { |
| public: |
| static bool Accept(SerialPortClient* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| SerialPortClient* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<SerialPortClient>> |
| class SerialPortClientStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| SerialPortClientStub() {} |
| ~SerialPortClientStub() 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 SerialPortClientStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return SerialPortClientStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcherStubDispatch { |
| public: |
| static bool Accept(SerialPortConnectionWatcher* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| SerialPortConnectionWatcher* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<SerialPortConnectionWatcher>> |
| class SerialPortConnectionWatcherStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| SerialPortConnectionWatcherStub() {} |
| ~SerialPortConnectionWatcherStub() 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 SerialPortConnectionWatcherStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return SerialPortConnectionWatcherStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortManagerRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortClientRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortConnectionWatcherRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortManagerResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT SerialPortResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.SerialHostControlSignals |
| class BLINK_PLATFORM_EXPORT SerialHostControlSignals { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<SerialHostControlSignals, T>::value>; |
| using DataView = SerialHostControlSignalsDataView; |
| using Data_ = internal::SerialHostControlSignals_Data; |
| |
| template <typename... Args> |
| static SerialHostControlSignalsPtr New(Args&&... args) { |
| return SerialHostControlSignalsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static SerialHostControlSignalsPtr From(const U& u) { |
| return mojo::TypeConverter<SerialHostControlSignalsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, SerialHostControlSignals>::Convert(*this); |
| } |
| |
| |
| SerialHostControlSignals(); |
| |
| SerialHostControlSignals( |
| bool dtr, |
| bool has_dtr, |
| bool rts, |
| bool has_rts); |
| |
| ~SerialHostControlSignals(); |
| |
| // 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 = SerialHostControlSignalsPtr> |
| SerialHostControlSignalsPtr 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, SerialHostControlSignals::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< |
| SerialHostControlSignals::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| SerialHostControlSignals::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::SerialHostControlSignals_UnserializedMessageContext< |
| UserType, SerialHostControlSignals::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<SerialHostControlSignals::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 SerialHostControlSignals::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::SerialHostControlSignals_UnserializedMessageContext< |
| UserType, SerialHostControlSignals::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<SerialHostControlSignals::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.SerialHostControlSignals.dtr |
| bool dtr; |
| |
| // @generated_from: device.mojom.SerialHostControlSignals.has_dtr |
| bool has_dtr; |
| |
| // @generated_from: device.mojom.SerialHostControlSignals.rts |
| bool rts; |
| |
| // @generated_from: device.mojom.SerialHostControlSignals.has_rts |
| bool has_rts; |
| |
| 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, SerialHostControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, SerialHostControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.SerialPortControlSignals |
| class BLINK_PLATFORM_EXPORT SerialPortControlSignals { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<SerialPortControlSignals, T>::value>; |
| using DataView = SerialPortControlSignalsDataView; |
| using Data_ = internal::SerialPortControlSignals_Data; |
| |
| template <typename... Args> |
| static SerialPortControlSignalsPtr New(Args&&... args) { |
| return SerialPortControlSignalsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static SerialPortControlSignalsPtr From(const U& u) { |
| return mojo::TypeConverter<SerialPortControlSignalsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, SerialPortControlSignals>::Convert(*this); |
| } |
| |
| |
| SerialPortControlSignals(); |
| |
| SerialPortControlSignals( |
| bool dcd, |
| bool cts, |
| bool ri, |
| bool dsr); |
| |
| ~SerialPortControlSignals(); |
| |
| // 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 = SerialPortControlSignalsPtr> |
| SerialPortControlSignalsPtr 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, SerialPortControlSignals::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< |
| SerialPortControlSignals::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| SerialPortControlSignals::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::SerialPortControlSignals_UnserializedMessageContext< |
| UserType, SerialPortControlSignals::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<SerialPortControlSignals::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 SerialPortControlSignals::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::SerialPortControlSignals_UnserializedMessageContext< |
| UserType, SerialPortControlSignals::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<SerialPortControlSignals::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.SerialPortControlSignals.dcd |
| bool dcd; |
| |
| // @generated_from: device.mojom.SerialPortControlSignals.cts |
| bool cts; |
| |
| // @generated_from: device.mojom.SerialPortControlSignals.ri |
| bool ri; |
| |
| // @generated_from: device.mojom.SerialPortControlSignals.dsr |
| bool dsr; |
| |
| 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, SerialPortControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, SerialPortControlSignals::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.SerialPortInfo |
| class BLINK_PLATFORM_EXPORT SerialPortInfo { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<SerialPortInfo, T>::value>; |
| using DataView = SerialPortInfoDataView; |
| using Data_ = internal::SerialPortInfo_Data; |
| |
| template <typename... Args> |
| static SerialPortInfoPtr New(Args&&... args) { |
| return SerialPortInfoPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static SerialPortInfoPtr From(const U& u) { |
| return mojo::TypeConverter<SerialPortInfoPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, SerialPortInfo>::Convert(*this); |
| } |
| |
| |
| SerialPortInfo(); |
| |
| SerialPortInfo( |
| const base::UnguessableToken& token, |
| const base::FilePath& path, |
| uint16_t vendor_id, |
| bool has_vendor_id, |
| uint16_t product_id, |
| bool has_product_id, |
| const WTF::String& display_name); |
| |
| ~SerialPortInfo(); |
| |
| // 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 = SerialPortInfoPtr> |
| SerialPortInfoPtr 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, SerialPortInfo::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| SerialPortInfo::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| SerialPortInfo::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::SerialPortInfo_UnserializedMessageContext< |
| UserType, SerialPortInfo::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<SerialPortInfo::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 SerialPortInfo::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::SerialPortInfo_UnserializedMessageContext< |
| UserType, SerialPortInfo::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<SerialPortInfo::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.SerialPortInfo.token |
| base::UnguessableToken token; |
| |
| // @generated_from: device.mojom.SerialPortInfo.path |
| base::FilePath path; |
| |
| // @generated_from: device.mojom.SerialPortInfo.vendor_id |
| uint16_t vendor_id; |
| |
| // @generated_from: device.mojom.SerialPortInfo.has_vendor_id |
| bool has_vendor_id; |
| |
| // @generated_from: device.mojom.SerialPortInfo.product_id |
| uint16_t product_id; |
| |
| // @generated_from: device.mojom.SerialPortInfo.has_product_id |
| bool has_product_id; |
| |
| // @generated_from: device.mojom.SerialPortInfo.display_name |
| WTF::String display_name; |
| |
| 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, SerialPortInfo::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, SerialPortInfo::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.SerialConnectionOptions |
| class BLINK_PLATFORM_EXPORT SerialConnectionOptions { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<SerialConnectionOptions, T>::value>; |
| using DataView = SerialConnectionOptionsDataView; |
| using Data_ = internal::SerialConnectionOptions_Data; |
| |
| template <typename... Args> |
| static SerialConnectionOptionsPtr New(Args&&... args) { |
| return SerialConnectionOptionsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static SerialConnectionOptionsPtr From(const U& u) { |
| return mojo::TypeConverter<SerialConnectionOptionsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, SerialConnectionOptions>::Convert(*this); |
| } |
| |
| |
| SerialConnectionOptions(); |
| |
| SerialConnectionOptions( |
| uint32_t bitrate, |
| SerialDataBits data_bits, |
| SerialParityBit parity_bit, |
| SerialStopBits stop_bits, |
| bool cts_flow_control, |
| bool has_cts_flow_control); |
| |
| ~SerialConnectionOptions(); |
| |
| // 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 = SerialConnectionOptionsPtr> |
| SerialConnectionOptionsPtr 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, SerialConnectionOptions::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< |
| SerialConnectionOptions::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| SerialConnectionOptions::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::SerialConnectionOptions_UnserializedMessageContext< |
| UserType, SerialConnectionOptions::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<SerialConnectionOptions::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 SerialConnectionOptions::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::SerialConnectionOptions_UnserializedMessageContext< |
| UserType, SerialConnectionOptions::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<SerialConnectionOptions::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.SerialConnectionOptions.bitrate |
| uint32_t bitrate; |
| |
| // @generated_from: device.mojom.SerialConnectionOptions.data_bits |
| SerialDataBits data_bits; |
| |
| // @generated_from: device.mojom.SerialConnectionOptions.parity_bit |
| SerialParityBit parity_bit; |
| |
| // @generated_from: device.mojom.SerialConnectionOptions.stop_bits |
| SerialStopBits stop_bits; |
| |
| // @generated_from: device.mojom.SerialConnectionOptions.cts_flow_control |
| bool cts_flow_control; |
| |
| // @generated_from: device.mojom.SerialConnectionOptions.has_cts_flow_control |
| bool has_cts_flow_control; |
| |
| 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, SerialConnectionOptions::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, SerialConnectionOptions::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: device.mojom.SerialConnectionInfo |
| class BLINK_PLATFORM_EXPORT SerialConnectionInfo { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<SerialConnectionInfo, T>::value>; |
| using DataView = SerialConnectionInfoDataView; |
| using Data_ = internal::SerialConnectionInfo_Data; |
| |
| template <typename... Args> |
| static SerialConnectionInfoPtr New(Args&&... args) { |
| return SerialConnectionInfoPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static SerialConnectionInfoPtr From(const U& u) { |
| return mojo::TypeConverter<SerialConnectionInfoPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, SerialConnectionInfo>::Convert(*this); |
| } |
| |
| |
| SerialConnectionInfo(); |
| |
| SerialConnectionInfo( |
| uint32_t bitrate, |
| SerialDataBits data_bits, |
| SerialParityBit parity_bit, |
| SerialStopBits stop_bits, |
| bool cts_flow_control); |
| |
| ~SerialConnectionInfo(); |
| |
| // 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 = SerialConnectionInfoPtr> |
| SerialConnectionInfoPtr 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, SerialConnectionInfo::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< |
| SerialConnectionInfo::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| SerialConnectionInfo::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::SerialConnectionInfo_UnserializedMessageContext< |
| UserType, SerialConnectionInfo::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<SerialConnectionInfo::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 SerialConnectionInfo::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::SerialConnectionInfo_UnserializedMessageContext< |
| UserType, SerialConnectionInfo::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<SerialConnectionInfo::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: device.mojom.SerialConnectionInfo.bitrate |
| uint32_t bitrate; |
| |
| // @generated_from: device.mojom.SerialConnectionInfo.data_bits |
| SerialDataBits data_bits; |
| |
| // @generated_from: device.mojom.SerialConnectionInfo.parity_bit |
| SerialParityBit parity_bit; |
| |
| // @generated_from: device.mojom.SerialConnectionInfo.stop_bits |
| SerialStopBits stop_bits; |
| |
| // @generated_from: device.mojom.SerialConnectionInfo.cts_flow_control |
| bool cts_flow_control; |
| |
| 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, SerialConnectionInfo::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, SerialConnectionInfo::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| template <typename StructPtrType> |
| SerialPortInfoPtr SerialPortInfo::Clone() const { |
| return New( |
| mojo::Clone(token), |
| mojo::Clone(path), |
| mojo::Clone(vendor_id), |
| mojo::Clone(has_vendor_id), |
| mojo::Clone(product_id), |
| mojo::Clone(has_product_id), |
| mojo::Clone(display_name) |
| ); |
| } |
| |
| template <typename T, SerialPortInfo::EnableIfSame<T>*> |
| bool SerialPortInfo::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->token, other_struct.token)) |
| return false; |
| if (!mojo::Equals(this->path, other_struct.path)) |
| return false; |
| if (!mojo::Equals(this->vendor_id, other_struct.vendor_id)) |
| return false; |
| if (!mojo::Equals(this->has_vendor_id, other_struct.has_vendor_id)) |
| return false; |
| if (!mojo::Equals(this->product_id, other_struct.product_id)) |
| return false; |
| if (!mojo::Equals(this->has_product_id, other_struct.has_product_id)) |
| return false; |
| if (!mojo::Equals(this->display_name, other_struct.display_name)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, SerialPortInfo::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.token < rhs.token) |
| return true; |
| if (rhs.token < lhs.token) |
| return false; |
| if (lhs.path < rhs.path) |
| return true; |
| if (rhs.path < lhs.path) |
| return false; |
| if (lhs.vendor_id < rhs.vendor_id) |
| return true; |
| if (rhs.vendor_id < lhs.vendor_id) |
| return false; |
| if (lhs.has_vendor_id < rhs.has_vendor_id) |
| return true; |
| if (rhs.has_vendor_id < lhs.has_vendor_id) |
| return false; |
| if (lhs.product_id < rhs.product_id) |
| return true; |
| if (rhs.product_id < lhs.product_id) |
| return false; |
| if (lhs.has_product_id < rhs.has_product_id) |
| return true; |
| if (rhs.has_product_id < lhs.has_product_id) |
| return false; |
| if (lhs.display_name < rhs.display_name) |
| return true; |
| if (rhs.display_name < lhs.display_name) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| SerialConnectionOptionsPtr SerialConnectionOptions::Clone() const { |
| return New( |
| mojo::Clone(bitrate), |
| mojo::Clone(data_bits), |
| mojo::Clone(parity_bit), |
| mojo::Clone(stop_bits), |
| mojo::Clone(cts_flow_control), |
| mojo::Clone(has_cts_flow_control) |
| ); |
| } |
| |
| template <typename T, SerialConnectionOptions::EnableIfSame<T>*> |
| bool SerialConnectionOptions::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->bitrate, other_struct.bitrate)) |
| return false; |
| if (!mojo::Equals(this->data_bits, other_struct.data_bits)) |
| return false; |
| if (!mojo::Equals(this->parity_bit, other_struct.parity_bit)) |
| return false; |
| if (!mojo::Equals(this->stop_bits, other_struct.stop_bits)) |
| return false; |
| if (!mojo::Equals(this->cts_flow_control, other_struct.cts_flow_control)) |
| return false; |
| if (!mojo::Equals(this->has_cts_flow_control, other_struct.has_cts_flow_control)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, SerialConnectionOptions::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.bitrate < rhs.bitrate) |
| return true; |
| if (rhs.bitrate < lhs.bitrate) |
| return false; |
| if (lhs.data_bits < rhs.data_bits) |
| return true; |
| if (rhs.data_bits < lhs.data_bits) |
| return false; |
| if (lhs.parity_bit < rhs.parity_bit) |
| return true; |
| if (rhs.parity_bit < lhs.parity_bit) |
| return false; |
| if (lhs.stop_bits < rhs.stop_bits) |
| return true; |
| if (rhs.stop_bits < lhs.stop_bits) |
| return false; |
| if (lhs.cts_flow_control < rhs.cts_flow_control) |
| return true; |
| if (rhs.cts_flow_control < lhs.cts_flow_control) |
| return false; |
| if (lhs.has_cts_flow_control < rhs.has_cts_flow_control) |
| return true; |
| if (rhs.has_cts_flow_control < lhs.has_cts_flow_control) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| SerialConnectionInfoPtr SerialConnectionInfo::Clone() const { |
| return New( |
| mojo::Clone(bitrate), |
| mojo::Clone(data_bits), |
| mojo::Clone(parity_bit), |
| mojo::Clone(stop_bits), |
| mojo::Clone(cts_flow_control) |
| ); |
| } |
| |
| template <typename T, SerialConnectionInfo::EnableIfSame<T>*> |
| bool SerialConnectionInfo::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->bitrate, other_struct.bitrate)) |
| return false; |
| if (!mojo::Equals(this->data_bits, other_struct.data_bits)) |
| return false; |
| if (!mojo::Equals(this->parity_bit, other_struct.parity_bit)) |
| return false; |
| if (!mojo::Equals(this->stop_bits, other_struct.stop_bits)) |
| return false; |
| if (!mojo::Equals(this->cts_flow_control, other_struct.cts_flow_control)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, SerialConnectionInfo::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.bitrate < rhs.bitrate) |
| return true; |
| if (rhs.bitrate < lhs.bitrate) |
| return false; |
| if (lhs.data_bits < rhs.data_bits) |
| return true; |
| if (rhs.data_bits < lhs.data_bits) |
| return false; |
| if (lhs.parity_bit < rhs.parity_bit) |
| return true; |
| if (rhs.parity_bit < lhs.parity_bit) |
| return false; |
| if (lhs.stop_bits < rhs.stop_bits) |
| return true; |
| if (rhs.stop_bits < lhs.stop_bits) |
| return false; |
| if (lhs.cts_flow_control < rhs.cts_flow_control) |
| return true; |
| if (rhs.cts_flow_control < lhs.cts_flow_control) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| SerialHostControlSignalsPtr SerialHostControlSignals::Clone() const { |
| return New( |
| mojo::Clone(dtr), |
| mojo::Clone(has_dtr), |
| mojo::Clone(rts), |
| mojo::Clone(has_rts) |
| ); |
| } |
| |
| template <typename T, SerialHostControlSignals::EnableIfSame<T>*> |
| bool SerialHostControlSignals::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->dtr, other_struct.dtr)) |
| return false; |
| if (!mojo::Equals(this->has_dtr, other_struct.has_dtr)) |
| return false; |
| if (!mojo::Equals(this->rts, other_struct.rts)) |
| return false; |
| if (!mojo::Equals(this->has_rts, other_struct.has_rts)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, SerialHostControlSignals::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.dtr < rhs.dtr) |
| return true; |
| if (rhs.dtr < lhs.dtr) |
| return false; |
| if (lhs.has_dtr < rhs.has_dtr) |
| return true; |
| if (rhs.has_dtr < lhs.has_dtr) |
| return false; |
| if (lhs.rts < rhs.rts) |
| return true; |
| if (rhs.rts < lhs.rts) |
| return false; |
| if (lhs.has_rts < rhs.has_rts) |
| return true; |
| if (rhs.has_rts < lhs.has_rts) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| SerialPortControlSignalsPtr SerialPortControlSignals::Clone() const { |
| return New( |
| mojo::Clone(dcd), |
| mojo::Clone(cts), |
| mojo::Clone(ri), |
| mojo::Clone(dsr) |
| ); |
| } |
| |
| template <typename T, SerialPortControlSignals::EnableIfSame<T>*> |
| bool SerialPortControlSignals::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->dcd, other_struct.dcd)) |
| return false; |
| if (!mojo::Equals(this->cts, other_struct.cts)) |
| return false; |
| if (!mojo::Equals(this->ri, other_struct.ri)) |
| return false; |
| if (!mojo::Equals(this->dsr, other_struct.dsr)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, SerialPortControlSignals::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.dcd < rhs.dcd) |
| return true; |
| if (rhs.dcd < lhs.dcd) |
| return false; |
| if (lhs.cts < rhs.cts) |
| return true; |
| if (rhs.cts < lhs.cts) |
| return false; |
| if (lhs.ri < rhs.ri) |
| return true; |
| if (rhs.ri < lhs.ri) |
| return false; |
| if (lhs.dsr < rhs.dsr) |
| return true; |
| if (rhs.dsr < lhs.dsr) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace device |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialPortInfo::DataView, |
| ::device::mojom::blink::SerialPortInfoPtr> { |
| static bool IsNull(const ::device::mojom::blink::SerialPortInfoPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::SerialPortInfoPtr* output) { output->reset(); } |
| |
| static const decltype(::device::mojom::blink::SerialPortInfo::token)& token( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->token; |
| } |
| |
| static const decltype(::device::mojom::blink::SerialPortInfo::path)& path( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->path; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortInfo::vendor_id) vendor_id( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->vendor_id; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortInfo::has_vendor_id) has_vendor_id( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->has_vendor_id; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortInfo::product_id) product_id( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->product_id; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortInfo::has_product_id) has_product_id( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->has_product_id; |
| } |
| |
| static const decltype(::device::mojom::blink::SerialPortInfo::display_name)& display_name( |
| const ::device::mojom::blink::SerialPortInfoPtr& input) { |
| return input->display_name; |
| } |
| |
| static bool Read(::device::mojom::blink::SerialPortInfo::DataView input, ::device::mojom::blink::SerialPortInfoPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialConnectionOptions::DataView, |
| ::device::mojom::blink::SerialConnectionOptionsPtr> { |
| static bool IsNull(const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::SerialConnectionOptionsPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::SerialConnectionOptions::bitrate) bitrate( |
| const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { |
| return input->bitrate; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionOptions::data_bits) data_bits( |
| const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { |
| return input->data_bits; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionOptions::parity_bit) parity_bit( |
| const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { |
| return input->parity_bit; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionOptions::stop_bits) stop_bits( |
| const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { |
| return input->stop_bits; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionOptions::cts_flow_control) cts_flow_control( |
| const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { |
| return input->cts_flow_control; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionOptions::has_cts_flow_control) has_cts_flow_control( |
| const ::device::mojom::blink::SerialConnectionOptionsPtr& input) { |
| return input->has_cts_flow_control; |
| } |
| |
| static bool Read(::device::mojom::blink::SerialConnectionOptions::DataView input, ::device::mojom::blink::SerialConnectionOptionsPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialConnectionInfo::DataView, |
| ::device::mojom::blink::SerialConnectionInfoPtr> { |
| static bool IsNull(const ::device::mojom::blink::SerialConnectionInfoPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::SerialConnectionInfoPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::SerialConnectionInfo::bitrate) bitrate( |
| const ::device::mojom::blink::SerialConnectionInfoPtr& input) { |
| return input->bitrate; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionInfo::data_bits) data_bits( |
| const ::device::mojom::blink::SerialConnectionInfoPtr& input) { |
| return input->data_bits; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionInfo::parity_bit) parity_bit( |
| const ::device::mojom::blink::SerialConnectionInfoPtr& input) { |
| return input->parity_bit; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionInfo::stop_bits) stop_bits( |
| const ::device::mojom::blink::SerialConnectionInfoPtr& input) { |
| return input->stop_bits; |
| } |
| |
| static decltype(::device::mojom::blink::SerialConnectionInfo::cts_flow_control) cts_flow_control( |
| const ::device::mojom::blink::SerialConnectionInfoPtr& input) { |
| return input->cts_flow_control; |
| } |
| |
| static bool Read(::device::mojom::blink::SerialConnectionInfo::DataView input, ::device::mojom::blink::SerialConnectionInfoPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialHostControlSignals::DataView, |
| ::device::mojom::blink::SerialHostControlSignalsPtr> { |
| static bool IsNull(const ::device::mojom::blink::SerialHostControlSignalsPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::SerialHostControlSignalsPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::SerialHostControlSignals::dtr) dtr( |
| const ::device::mojom::blink::SerialHostControlSignalsPtr& input) { |
| return input->dtr; |
| } |
| |
| static decltype(::device::mojom::blink::SerialHostControlSignals::has_dtr) has_dtr( |
| const ::device::mojom::blink::SerialHostControlSignalsPtr& input) { |
| return input->has_dtr; |
| } |
| |
| static decltype(::device::mojom::blink::SerialHostControlSignals::rts) rts( |
| const ::device::mojom::blink::SerialHostControlSignalsPtr& input) { |
| return input->rts; |
| } |
| |
| static decltype(::device::mojom::blink::SerialHostControlSignals::has_rts) has_rts( |
| const ::device::mojom::blink::SerialHostControlSignalsPtr& input) { |
| return input->has_rts; |
| } |
| |
| static bool Read(::device::mojom::blink::SerialHostControlSignals::DataView input, ::device::mojom::blink::SerialHostControlSignalsPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::device::mojom::blink::SerialPortControlSignals::DataView, |
| ::device::mojom::blink::SerialPortControlSignalsPtr> { |
| static bool IsNull(const ::device::mojom::blink::SerialPortControlSignalsPtr& input) { return !input; } |
| static void SetToNull(::device::mojom::blink::SerialPortControlSignalsPtr* output) { output->reset(); } |
| |
| static decltype(::device::mojom::blink::SerialPortControlSignals::dcd) dcd( |
| const ::device::mojom::blink::SerialPortControlSignalsPtr& input) { |
| return input->dcd; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortControlSignals::cts) cts( |
| const ::device::mojom::blink::SerialPortControlSignalsPtr& input) { |
| return input->cts; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortControlSignals::ri) ri( |
| const ::device::mojom::blink::SerialPortControlSignalsPtr& input) { |
| return input->ri; |
| } |
| |
| static decltype(::device::mojom::blink::SerialPortControlSignals::dsr) dsr( |
| const ::device::mojom::blink::SerialPortControlSignalsPtr& input) { |
| return input->dsr; |
| } |
| |
| static bool Read(::device::mojom::blink::SerialPortControlSignals::DataView input, ::device::mojom::blink::SerialPortControlSignalsPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_DEVICE_PUBLIC_MOJOM_SERIAL_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogOTI5MywgImJlZ2luIjogOTI3NiwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0TWFuYWdlciJ9
|
| fSwgeyJlbmQiOiAxMDE1MCwgImJlZ2luIjogMTAxNDAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydE1hbmFnZXIuR2V0RGV2
|
| aWNlcyJ9fSwgeyJlbmQiOiAxMDI3MCwgImJlZ2luIjogMTAyNjMsICJlZGdlIjogIiUva3l0aGUv
|
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y
|
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl
|
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydE1hbmFnZXIu
|
| R2V0UG9ydCJ9fSwgeyJlbmQiOiAxMDYyMywgImJlZ2luIjogMTA2MTMsICJlZGdlIjogIiUva3l0
|
| aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsi
|
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1
|
| YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydCJ9fSwg
|
| eyJlbmQiOiAxMTY0NCwgImJlZ2luIjogMTE2NDAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydC5PcGVuIn19LCB7ImVuZCI6
|
| IDExOTIyLCAiYmVnaW4iOiAxMTkwOCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0LkNsZWFyU2VuZEVycm9yIn19LCB7ImVu
|
| ZCI6IDEyMDY1LCAiYmVnaW4iOiAxMjA1MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0LkNsZWFyUmVhZEVycm9yIn19LCB7
|
| ImVuZCI6IDEyMjQ3LCAiYmVnaW4iOiAxMjI0MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0LkZsdXNoIn19LCB7ImVuZCI6
|
| IDEyNDY3LCAiYmVnaW4iOiAxMjQ1MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0LkdldENvbnRyb2xTaWduYWxzIn19LCB7
|
| ImVuZCI6IDEyNjc2LCAiYmVnaW4iOiAxMjY1OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0LlNldENvbnRyb2xTaWduYWxz
|
| In19LCB7ImVuZCI6IDEyOTEwLCAiYmVnaW4iOiAxMjg5NywgImVkZ2UiOiAiJS9reXRoZS9lZGdl
|
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi
|
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi
|
| bW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0LkNvbmZpZ3VyZVBv
|
| cnQifX0sIHsiZW5kIjogMTMxNTIsICJiZWdpbiI6IDEzMTQxLCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbFBvcnQuR2V0UG9ydElu
|
| Zm8ifX0sIHsiZW5kIjogMTMzMjgsICJiZWdpbiI6IDEzMzIwLCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbFBvcnQuU2V0QnJlYWsi
|
| fX0sIHsiZW5kIjogMTM1MDcsICJiZWdpbiI6IDEzNDk3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6
|
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt
|
| b2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbFBvcnQuQ2xlYXJCcmVhayJ9
|
| fSwgeyJlbmQiOiAxMzc3NSwgImJlZ2luIjogMTM3NTksICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydENsaWVudCJ9fSwgeyJl
|
| bmQiOiAxNDUzMywgImJlZ2luIjogMTQ1MjIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydENsaWVudC5PblJlYWRFcnJvciJ9
|
| fSwgeyJlbmQiOiAxNDY1NywgImJlZ2luIjogMTQ2NDYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydENsaWVudC5PblNlbmRF
|
| cnJvciJ9fSwgeyJlbmQiOiAxNDk3NCwgImJlZ2luIjogMTQ5NDcsICJlZGdlIjogIiUva3l0aGUv
|
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y
|
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl
|
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydENvbm5lY3Rp
|
| b25XYXRjaGVyIn19LCB7ImVuZCI6IDI0MjkwLCAiYmVnaW4iOiAyNDI2NiwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog
|
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxIb3N0Q29u
|
| dHJvbFNpZ25hbHMifX0sIHsiZW5kIjogMjgxMDgsICJiZWdpbiI6IDI4MTA1LCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbEhvc3RD
|
| b250cm9sU2lnbmFscy5kdHIifX0sIHsiZW5kIjogMjgxOTMsICJiZWdpbiI6IDI4MTg2LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny
|
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlh
|
| bEhvc3RDb250cm9sU2lnbmFscy5oYXNfZHRyIn19LCB7ImVuZCI6IDI4MjcwLCAiYmVnaW4iOiAy
|
| ODI2NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5t
|
| b2pvbS5TZXJpYWxIb3N0Q29udHJvbFNpZ25hbHMucnRzIn19LCB7ImVuZCI6IDI4MzU1LCAiYmVn
|
| aW4iOiAyODM0OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu
|
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl
|
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRl
|
| dmljZS5tb2pvbS5TZXJpYWxIb3N0Q29udHJvbFNpZ25hbHMuaGFzX3J0cyJ9fSwgeyJlbmQiOiAy
|
| OTM3MSwgImJlZ2luIjogMjkzNDcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydENvbnRyb2xTaWduYWxzIn19LCB7ImVuZCI6
|
| IDMzMTgwLCAiYmVnaW4iOiAzMzE3NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0Q29udHJvbFNpZ25hbHMuZGNkIn19LCB7
|
| ImVuZCI6IDMzMjU3LCAiYmVnaW4iOiAzMzI1NCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0Q29udHJvbFNpZ25hbHMuY3Rz
|
| In19LCB7ImVuZCI6IDMzMzMyLCAiYmVnaW4iOiAzMzMzMCwgImVkZ2UiOiAiJS9reXRoZS9lZGdl
|
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi
|
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi
|
| bW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0Q29udHJvbFNpZ25h
|
| bHMucmkifX0sIHsiZW5kIjogMzM0MDksICJiZWdpbiI6IDMzNDA2LCAiZWRnZSI6ICIlL2t5dGhl
|
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv
|
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn
|
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbFBvcnRDb250cm9s
|
| U2lnbmFscy5kc3IifX0sIHsiZW5kIjogMzQ0MDcsICJiZWdpbiI6IDM0MzkzLCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbFBvcnRJ
|
| bmZvIn19LCB7ImVuZCI6IDM4MTIzLCAiYmVnaW4iOiAzODExOCwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0SW5mby50b2tl
|
| biJ9fSwgeyJlbmQiOiAzODIwMiwgImJlZ2luIjogMzgxOTgsICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz
|
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog
|
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydEluZm8ucGF0aCJ9
|
| fSwgeyJlbmQiOiAzODI4NSwgImJlZ2luIjogMzgyNzYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsUG9ydEluZm8udmVuZG9yX2lk
|
| In19LCB7ImVuZCI6IDM4MzcyLCAiYmVnaW4iOiAzODM1OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdl
|
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi
|
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi
|
| bW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0SW5mby5oYXNfdmVu
|
| ZG9yX2lkIn19LCB7ImVuZCI6IDM4NDU3LCAiYmVnaW4iOiAzODQ0NywgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0SW5mby5w
|
| cm9kdWN0X2lkIn19LCB7ImVuZCI6IDM4NTQ2LCAiYmVnaW4iOiAzODUzMiwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog
|
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxQb3J0SW5m
|
| by5oYXNfcHJvZHVjdF9pZCJ9fSwgeyJlbmQiOiAzODYzOCwgImJlZ2luIjogMzg2MjYsICJlZGdl
|
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2
|
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj
|
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFs
|
| UG9ydEluZm8uZGlzcGxheV9uYW1lIn19LCB7ImVuZCI6IDM5NjEyLCAiYmVnaW4iOiAzOTU4OSwg
|
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz
|
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1
|
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5T
|
| ZXJpYWxDb25uZWN0aW9uT3B0aW9ucyJ9fSwgeyJlbmQiOiA0MzUzMCwgImJlZ2luIjogNDM1MjMs
|
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l
|
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p
|
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20u
|
| U2VyaWFsQ29ubmVjdGlvbk9wdGlvbnMuYml0cmF0ZSJ9fSwgeyJlbmQiOiA0MzYyOCwgImJlZ2lu
|
| IjogNDM2MTksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJkZXZp
|
| Y2UubW9qb20uU2VyaWFsQ29ubmVjdGlvbk9wdGlvbnMuZGF0YV9iaXRzIn19LCB7ImVuZCI6IDQz
|
| NzI5LCAiYmVnaW4iOiA0MzcxOSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0
|
| eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29v
|
| Z2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0
|
| dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxDb25uZWN0aW9uT3B0aW9ucy5wYXJpdHlfYml0In19
|
| LCB7ImVuZCI6IDQzODI3LCAiYmVnaW4iOiA0MzgxOCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxDb25uZWN0aW9uT3B0aW9ucy5z
|
| dG9wX2JpdHMifX0sIHsiZW5kIjogNDM5MjksICJiZWdpbiI6IDQzOTEzLCAiZWRnZSI6ICIlL2t5
|
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNlcmlhbENvbm5lY3Rp
|
| b25PcHRpb25zLmN0c19mbG93X2NvbnRyb2wifX0sIHsiZW5kIjogNDQwMzksICJiZWdpbiI6IDQ0
|
| MDE5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1v
|
| am9tLlNlcmlhbENvbm5lY3Rpb25PcHRpb25zLmhhc19jdHNfZmxvd19jb250cm9sIn19LCB7ImVu
|
| ZCI6IDQ1MDQzLCAiYmVnaW4iOiA0NTAyMywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxDb25uZWN0aW9uSW5mbyJ9fSwgeyJlbmQi
|
| OiA0ODg1NiwgImJlZ2luIjogNDg4NDksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp
|
| Z25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsQ29ubmVjdGlvbkluZm8uYml0cmF0ZSJ9fSwg
|
| eyJlbmQiOiA0ODk1MSwgImJlZ2luIjogNDg5NDIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJkZXZpY2UubW9qb20uU2VyaWFsQ29ubmVjdGlvbkluZm8uZGF0YV9i
|
| aXRzIn19LCB7ImVuZCI6IDQ5MDQ5LCAiYmVnaW4iOiA0OTAzOSwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxDb25uZWN0aW9uSW5m
|
| by5wYXJpdHlfYml0In19LCB7ImVuZCI6IDQ5MTQ0LCAiYmVnaW4iOiA0OTEzNSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l
|
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImRldmljZS5tb2pvbS5TZXJpYWxDb25u
|
| ZWN0aW9uSW5mby5zdG9wX2JpdHMifX0sIHsiZW5kIjogNDkyNDMsICJiZWdpbiI6IDQ5MjI3LCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiZGV2aWNlLm1vam9tLlNl
|
| cmlhbENvbm5lY3Rpb25JbmZvLmN0c19mbG93X2NvbnRyb2wifX1dLCAidHlwZSI6ICJreXRoZTAi
|
| fQ==
|
| */ |