| // mojo/public/interfaces/bindings/pipe_control_messages.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit |
| |
| // Copyright 2013 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef MOJO_PUBLIC_INTERFACES_BINDINGS_PIPE_CONTROL_MESSAGES_MOJOM_BLINK_H_ |
| #define MOJO_PUBLIC_INTERFACES_BINDINGS_PIPE_CONTROL_MESSAGES_MOJOM_BLINK_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <optional> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/types/cxx23_to_underlying.h" |
| #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 "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h" |
| |
| #include "mojo/public/interfaces/bindings/pipe_control_messages.mojom-features.h" |
| #include "mojo/public/interfaces/bindings/pipe_control_messages.mojom-shared.h" |
| #include "mojo/public/interfaces/bindings/pipe_control_messages.mojom-blink-forward.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 "base/component_export.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace mojo::pipe_control::blink { |
| |
| |
| |
| |
| |
| |
| // @generated_from: mojo.pipe_control.DisconnectReason |
| class COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) DisconnectReason { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<DisconnectReason, T>::value>; |
| using DataView = DisconnectReasonDataView; |
| using Data_ = internal::DisconnectReason_Data; |
| |
| template <typename... Args> |
| static DisconnectReasonPtr New(Args&&... args) { |
| return DisconnectReasonPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static DisconnectReasonPtr From(const U& u) { |
| return mojo::TypeConverter<DisconnectReasonPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, DisconnectReason>::Convert(*this); |
| } |
| |
| |
| DisconnectReason(); |
| |
| DisconnectReason( |
| uint32_t custom_reason, |
| const WTF::String& description); |
| |
| |
| ~DisconnectReason(); |
| |
| // 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 = DisconnectReasonPtr> |
| DisconnectReasonPtr 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, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool operator!=(const T& rhs) const { return !operator==(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| DisconnectReason::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| DisconnectReason::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::DisconnectReason_UnserializedMessageContext< |
| UserType, DisconnectReason::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<DisconnectReason::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return DisconnectReason::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::DisconnectReason_UnserializedMessageContext< |
| UserType, DisconnectReason::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<DisconnectReason::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.DisconnectReason.custom_reason |
| uint32_t custom_reason; |
| |
| // @generated_from: mojo.pipe_control.DisconnectReason.description |
| WTF::String description; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| 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, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput |
| class COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) RunOrClosePipeInput { |
| public: |
| using DataView = RunOrClosePipeInputDataView; |
| using Data_ = internal::RunOrClosePipeInput_Data; |
| using Tag = Data_::RunOrClosePipeInput_Tag; |
| |
| template <typename... Args> |
| static RunOrClosePipeInputPtr New(Args&&... args) { |
| static_assert( |
| sizeof...(args) < 0, |
| "Do not use Union::New(); to create a union of a given subtype, use " |
| "New<SubType>(), not New() followed by set_<sub_type>(). To represent " |
| "an empty union, mark the field or parameter as nullable in the mojom " |
| "definition."); |
| return nullptr; |
| } |
| // Construct an instance holding |peer_associated_endpoint_closed_event|. |
| static RunOrClosePipeInputPtr |
| NewPeerAssociatedEndpointClosedEvent( |
| PeerAssociatedEndpointClosedEventPtr value) { |
| auto result = RunOrClosePipeInputPtr(std::in_place); |
| result->set_peer_associated_endpoint_closed_event(std::move(value)); |
| return result; |
| } |
| // Construct an instance holding |pause_until_flush_completes|. |
| static RunOrClosePipeInputPtr |
| NewPauseUntilFlushCompletes( |
| PauseUntilFlushCompletesPtr value) { |
| auto result = RunOrClosePipeInputPtr(std::in_place); |
| result->set_pause_until_flush_completes(std::move(value)); |
| return result; |
| } |
| // Construct an instance holding |flush_async|. |
| static RunOrClosePipeInputPtr |
| NewFlushAsync( |
| FlushAsyncPtr value) { |
| auto result = RunOrClosePipeInputPtr(std::in_place); |
| result->set_flush_async(std::move(value)); |
| return result; |
| } |
| |
| template <typename U> |
| static RunOrClosePipeInputPtr From(const U& u) { |
| return mojo::TypeConverter<RunOrClosePipeInputPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, RunOrClosePipeInput>::Convert(*this); |
| } |
| |
| RunOrClosePipeInput(); |
| ~RunOrClosePipeInput(); |
| // Delete the copy constructor and copy assignment operators because `data_` |
| // contains raw pointers that must not be copied. |
| RunOrClosePipeInput(const RunOrClosePipeInput& other) = delete; |
| RunOrClosePipeInput& operator=(const RunOrClosePipeInput& other) = delete; |
| |
| // 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 UnionPtrType = RunOrClosePipeInputPtr> |
| RunOrClosePipeInputPtr 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, |
| typename std::enable_if<std::is_same< |
| T, RunOrClosePipeInput>::value>::type* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, RunOrClosePipeInput>::value>::type* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| Tag which() const { |
| return tag_; |
| } |
| |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.peer_associated_endpoint_closed_event |
| bool is_peer_associated_endpoint_closed_event() const { return tag_ == Tag::kPeerAssociatedEndpointClosedEvent; } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.peer_associated_endpoint_closed_event |
| PeerAssociatedEndpointClosedEventPtr& get_peer_associated_endpoint_closed_event() const { |
| CHECK(tag_ == Tag::kPeerAssociatedEndpointClosedEvent); |
| return *(data_.peer_associated_endpoint_closed_event); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.peer_associated_endpoint_closed_event |
| void set_peer_associated_endpoint_closed_event( |
| PeerAssociatedEndpointClosedEventPtr peer_associated_endpoint_closed_event); |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.pause_until_flush_completes |
| bool is_pause_until_flush_completes() const { return tag_ == Tag::kPauseUntilFlushCompletes; } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.pause_until_flush_completes |
| PauseUntilFlushCompletesPtr& get_pause_until_flush_completes() const { |
| CHECK(tag_ == Tag::kPauseUntilFlushCompletes); |
| return *(data_.pause_until_flush_completes); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.pause_until_flush_completes |
| void set_pause_until_flush_completes( |
| PauseUntilFlushCompletesPtr pause_until_flush_completes); |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.flush_async |
| bool is_flush_async() const { return tag_ == Tag::kFlushAsync; } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.flush_async |
| FlushAsyncPtr& get_flush_async() const { |
| CHECK(tag_ == Tag::kFlushAsync); |
| return *(data_.flush_async); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeInput.flush_async |
| void set_flush_async( |
| FlushAsyncPtr flush_async); |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| RunOrClosePipeInput::DataView>(input); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<RunOrClosePipeInput::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| private: |
| union Union_ { |
| Union_() = default; |
| ~Union_() = default; |
| PeerAssociatedEndpointClosedEventPtr* peer_associated_endpoint_closed_event; |
| PauseUntilFlushCompletesPtr* pause_until_flush_completes; |
| FlushAsyncPtr* flush_async; |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| void DestroyActive(); |
| Tag tag_; |
| Union_ data_; |
| }; |
| |
| |
| |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeMessageParams |
| class COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) RunOrClosePipeMessageParams { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<RunOrClosePipeMessageParams, T>::value>; |
| using DataView = RunOrClosePipeMessageParamsDataView; |
| using Data_ = internal::RunOrClosePipeMessageParams_Data; |
| |
| template <typename... Args> |
| static RunOrClosePipeMessageParamsPtr New(Args&&... args) { |
| return RunOrClosePipeMessageParamsPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static RunOrClosePipeMessageParamsPtr From(const U& u) { |
| return mojo::TypeConverter<RunOrClosePipeMessageParamsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, RunOrClosePipeMessageParams>::Convert(*this); |
| } |
| |
| |
| RunOrClosePipeMessageParams(); |
| |
| explicit RunOrClosePipeMessageParams( |
| RunOrClosePipeInputPtr input); |
| |
| RunOrClosePipeMessageParams(const RunOrClosePipeMessageParams&) = delete; |
| RunOrClosePipeMessageParams& operator=(const RunOrClosePipeMessageParams&) = delete; |
| |
| ~RunOrClosePipeMessageParams(); |
| |
| // 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 = RunOrClosePipeMessageParamsPtr> |
| RunOrClosePipeMessageParamsPtr 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, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool operator!=(const T& rhs) const { return !operator==(rhs); } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| RunOrClosePipeMessageParams::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::RunOrClosePipeMessageParams_UnserializedMessageContext< |
| UserType, RunOrClosePipeMessageParams::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<RunOrClosePipeMessageParams::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return RunOrClosePipeMessageParams::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::RunOrClosePipeMessageParams_UnserializedMessageContext< |
| UserType, RunOrClosePipeMessageParams::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<RunOrClosePipeMessageParams::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.RunOrClosePipeMessageParams.input |
| RunOrClosePipeInputPtr input; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| 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, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: mojo.pipe_control.PeerAssociatedEndpointClosedEvent |
| class COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) PeerAssociatedEndpointClosedEvent { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<PeerAssociatedEndpointClosedEvent, T>::value>; |
| using DataView = PeerAssociatedEndpointClosedEventDataView; |
| using Data_ = internal::PeerAssociatedEndpointClosedEvent_Data; |
| |
| template <typename... Args> |
| static PeerAssociatedEndpointClosedEventPtr New(Args&&... args) { |
| return PeerAssociatedEndpointClosedEventPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static PeerAssociatedEndpointClosedEventPtr From(const U& u) { |
| return mojo::TypeConverter<PeerAssociatedEndpointClosedEventPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, PeerAssociatedEndpointClosedEvent>::Convert(*this); |
| } |
| |
| |
| PeerAssociatedEndpointClosedEvent(); |
| |
| PeerAssociatedEndpointClosedEvent( |
| uint32_t id, |
| DisconnectReasonPtr disconnect_reason); |
| |
| PeerAssociatedEndpointClosedEvent(const PeerAssociatedEndpointClosedEvent&) = delete; |
| PeerAssociatedEndpointClosedEvent& operator=(const PeerAssociatedEndpointClosedEvent&) = delete; |
| |
| ~PeerAssociatedEndpointClosedEvent(); |
| |
| // 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 = PeerAssociatedEndpointClosedEventPtr> |
| PeerAssociatedEndpointClosedEventPtr 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, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool operator!=(const T& rhs) const { return !operator==(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| PeerAssociatedEndpointClosedEvent::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| PeerAssociatedEndpointClosedEvent::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::PeerAssociatedEndpointClosedEvent_UnserializedMessageContext< |
| UserType, PeerAssociatedEndpointClosedEvent::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<PeerAssociatedEndpointClosedEvent::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return PeerAssociatedEndpointClosedEvent::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::PeerAssociatedEndpointClosedEvent_UnserializedMessageContext< |
| UserType, PeerAssociatedEndpointClosedEvent::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<PeerAssociatedEndpointClosedEvent::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.PeerAssociatedEndpointClosedEvent.id |
| uint32_t id; |
| |
| // @generated_from: mojo.pipe_control.PeerAssociatedEndpointClosedEvent.disconnect_reason |
| DisconnectReasonPtr disconnect_reason; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| 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, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: mojo.pipe_control.PauseUntilFlushCompletes |
| class COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) PauseUntilFlushCompletes { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<PauseUntilFlushCompletes, T>::value>; |
| using DataView = PauseUntilFlushCompletesDataView; |
| using Data_ = internal::PauseUntilFlushCompletes_Data; |
| |
| template <typename... Args> |
| static PauseUntilFlushCompletesPtr New(Args&&... args) { |
| return PauseUntilFlushCompletesPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static PauseUntilFlushCompletesPtr From(const U& u) { |
| return mojo::TypeConverter<PauseUntilFlushCompletesPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, PauseUntilFlushCompletes>::Convert(*this); |
| } |
| |
| |
| PauseUntilFlushCompletes(); |
| |
| explicit PauseUntilFlushCompletes( |
| ::mojo::ScopedMessagePipeHandle flush_pipe); |
| |
| PauseUntilFlushCompletes(const PauseUntilFlushCompletes&) = delete; |
| PauseUntilFlushCompletes& operator=(const PauseUntilFlushCompletes&) = delete; |
| |
| ~PauseUntilFlushCompletes(); |
| |
| // 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 = PauseUntilFlushCompletesPtr> |
| PauseUntilFlushCompletesPtr 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, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool operator!=(const T& rhs) const { return !operator==(rhs); } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| PauseUntilFlushCompletes::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::PauseUntilFlushCompletes_UnserializedMessageContext< |
| UserType, PauseUntilFlushCompletes::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<PauseUntilFlushCompletes::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return PauseUntilFlushCompletes::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::PauseUntilFlushCompletes_UnserializedMessageContext< |
| UserType, PauseUntilFlushCompletes::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<PauseUntilFlushCompletes::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.PauseUntilFlushCompletes.flush_pipe |
| ::mojo::ScopedMessagePipeHandle flush_pipe; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| 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, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: mojo.pipe_control.FlushAsync |
| class COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) FlushAsync { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<FlushAsync, T>::value>; |
| using DataView = FlushAsyncDataView; |
| using Data_ = internal::FlushAsync_Data; |
| |
| template <typename... Args> |
| static FlushAsyncPtr New(Args&&... args) { |
| return FlushAsyncPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static FlushAsyncPtr From(const U& u) { |
| return mojo::TypeConverter<FlushAsyncPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, FlushAsync>::Convert(*this); |
| } |
| |
| |
| FlushAsync(); |
| |
| explicit FlushAsync( |
| ::mojo::ScopedMessagePipeHandle flusher_pipe); |
| |
| FlushAsync(const FlushAsync&) = delete; |
| FlushAsync& operator=(const FlushAsync&) = delete; |
| |
| ~FlushAsync(); |
| |
| // 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 = FlushAsyncPtr> |
| FlushAsyncPtr 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, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool operator!=(const T& rhs) const { return !operator==(rhs); } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| FlushAsync::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::FlushAsync_UnserializedMessageContext< |
| UserType, FlushAsync::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<FlushAsync::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return FlushAsync::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::FlushAsync_UnserializedMessageContext< |
| UserType, FlushAsync::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<FlushAsync::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: mojo.pipe_control.FlushAsync.flusher_pipe |
| ::mojo::ScopedMessagePipeHandle flusher_pipe; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| 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, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, FlushAsync::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename UnionPtrType> |
| RunOrClosePipeInputPtr RunOrClosePipeInput::Clone() const { |
| switch (tag_) { |
| case Tag::kPeerAssociatedEndpointClosedEvent: |
| return NewPeerAssociatedEndpointClosedEvent( |
| mojo::Clone(*data_.peer_associated_endpoint_closed_event)); |
| case Tag::kPauseUntilFlushCompletes: |
| return NewPauseUntilFlushCompletes( |
| mojo::Clone(*data_.pause_until_flush_completes)); |
| case Tag::kFlushAsync: |
| return NewFlushAsync( |
| mojo::Clone(*data_.flush_async)); |
| } |
| return nullptr; |
| } |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, RunOrClosePipeInput>::value>::type*> |
| bool RunOrClosePipeInput::Equals(const T& other) const { |
| if (tag_ != other.which()) |
| return false; |
| |
| switch (tag_) { |
| case Tag::kPeerAssociatedEndpointClosedEvent: |
| return mojo::Equals(*(data_.peer_associated_endpoint_closed_event), *(other.data_.peer_associated_endpoint_closed_event)); |
| case Tag::kPauseUntilFlushCompletes: |
| return mojo::Equals(*(data_.pause_until_flush_completes), *(other.data_.pause_until_flush_completes)); |
| case Tag::kFlushAsync: |
| return mojo::Equals(*(data_.flush_async), *(other.data_.flush_async)); |
| } |
| |
| return false; |
| } |
| template <typename StructPtrType> |
| RunOrClosePipeMessageParamsPtr RunOrClosePipeMessageParams::Clone() const { |
| return New( |
| mojo::Clone(input) |
| ); |
| } |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>*> |
| bool RunOrClosePipeMessageParams::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->input, other_struct.input)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, RunOrClosePipeMessageParams::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.input < rhs.input) |
| return true; |
| if (rhs.input < lhs.input) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| DisconnectReasonPtr DisconnectReason::Clone() const { |
| return New( |
| mojo::Clone(custom_reason), |
| mojo::Clone(description) |
| ); |
| } |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>*> |
| bool DisconnectReason::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->custom_reason, other_struct.custom_reason)) |
| return false; |
| if (!mojo::Equals(this->description, other_struct.description)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, DisconnectReason::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.custom_reason < rhs.custom_reason) |
| return true; |
| if (rhs.custom_reason < lhs.custom_reason) |
| return false; |
| if (lhs.description < rhs.description) |
| return true; |
| if (rhs.description < lhs.description) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| PeerAssociatedEndpointClosedEventPtr PeerAssociatedEndpointClosedEvent::Clone() const { |
| return New( |
| mojo::Clone(id), |
| mojo::Clone(disconnect_reason) |
| ); |
| } |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>*> |
| bool PeerAssociatedEndpointClosedEvent::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->id, other_struct.id)) |
| return false; |
| if (!mojo::Equals(this->disconnect_reason, other_struct.disconnect_reason)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, PeerAssociatedEndpointClosedEvent::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.id < rhs.id) |
| return true; |
| if (rhs.id < lhs.id) |
| return false; |
| if (lhs.disconnect_reason < rhs.disconnect_reason) |
| return true; |
| if (rhs.disconnect_reason < lhs.disconnect_reason) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| PauseUntilFlushCompletesPtr PauseUntilFlushCompletes::Clone() const { |
| return New( |
| mojo::Clone(flush_pipe) |
| ); |
| } |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>*> |
| bool PauseUntilFlushCompletes::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->flush_pipe, other_struct.flush_pipe)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, PauseUntilFlushCompletes::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.flush_pipe < rhs.flush_pipe) |
| return true; |
| if (rhs.flush_pipe < lhs.flush_pipe) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| FlushAsyncPtr FlushAsync::Clone() const { |
| return New( |
| mojo::Clone(flusher_pipe) |
| ); |
| } |
| |
| template <typename T, FlushAsync::EnableIfSame<T>*> |
| bool FlushAsync::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->flusher_pipe, other_struct.flusher_pipe)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, FlushAsync::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.flusher_pipe < rhs.flusher_pipe) |
| return true; |
| if (rhs.flusher_pipe < lhs.flusher_pipe) |
| return false; |
| return false; |
| } |
| |
| |
| } // mojo::pipe_control::blink |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) StructTraits<::mojo::pipe_control::blink::RunOrClosePipeMessageParams::DataView, |
| ::mojo::pipe_control::blink::RunOrClosePipeMessageParamsPtr> { |
| static bool IsNull(const ::mojo::pipe_control::blink::RunOrClosePipeMessageParamsPtr& input) { return !input; } |
| static void SetToNull(::mojo::pipe_control::blink::RunOrClosePipeMessageParamsPtr* output) { output->reset(); } |
| |
| static decltype(::mojo::pipe_control::blink::RunOrClosePipeMessageParams::input)& input( |
| ::mojo::pipe_control::blink::RunOrClosePipeMessageParamsPtr& input) { |
| return input->input; |
| } |
| |
| static bool Read(::mojo::pipe_control::blink::RunOrClosePipeMessageParams::DataView input, ::mojo::pipe_control::blink::RunOrClosePipeMessageParamsPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) StructTraits<::mojo::pipe_control::blink::DisconnectReason::DataView, |
| ::mojo::pipe_control::blink::DisconnectReasonPtr> { |
| static bool IsNull(const ::mojo::pipe_control::blink::DisconnectReasonPtr& input) { return !input; } |
| static void SetToNull(::mojo::pipe_control::blink::DisconnectReasonPtr* output) { output->reset(); } |
| |
| static decltype(::mojo::pipe_control::blink::DisconnectReason::custom_reason) custom_reason( |
| const ::mojo::pipe_control::blink::DisconnectReasonPtr& input) { |
| return input->custom_reason; |
| } |
| |
| static const decltype(::mojo::pipe_control::blink::DisconnectReason::description)& description( |
| const ::mojo::pipe_control::blink::DisconnectReasonPtr& input) { |
| return input->description; |
| } |
| |
| static bool Read(::mojo::pipe_control::blink::DisconnectReason::DataView input, ::mojo::pipe_control::blink::DisconnectReasonPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) StructTraits<::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEvent::DataView, |
| ::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr> { |
| static bool IsNull(const ::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr& input) { return !input; } |
| static void SetToNull(::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr* output) { output->reset(); } |
| |
| static decltype(::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEvent::id) id( |
| const ::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr& input) { |
| return input->id; |
| } |
| |
| static const decltype(::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEvent::disconnect_reason)& disconnect_reason( |
| const ::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr& input) { |
| return input->disconnect_reason; |
| } |
| |
| static bool Read(::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEvent::DataView input, ::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) StructTraits<::mojo::pipe_control::blink::PauseUntilFlushCompletes::DataView, |
| ::mojo::pipe_control::blink::PauseUntilFlushCompletesPtr> { |
| static bool IsNull(const ::mojo::pipe_control::blink::PauseUntilFlushCompletesPtr& input) { return !input; } |
| static void SetToNull(::mojo::pipe_control::blink::PauseUntilFlushCompletesPtr* output) { output->reset(); } |
| |
| static decltype(::mojo::pipe_control::blink::PauseUntilFlushCompletes::flush_pipe)& flush_pipe( |
| ::mojo::pipe_control::blink::PauseUntilFlushCompletesPtr& input) { |
| return input->flush_pipe; |
| } |
| |
| static bool Read(::mojo::pipe_control::blink::PauseUntilFlushCompletes::DataView input, ::mojo::pipe_control::blink::PauseUntilFlushCompletesPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) StructTraits<::mojo::pipe_control::blink::FlushAsync::DataView, |
| ::mojo::pipe_control::blink::FlushAsyncPtr> { |
| static bool IsNull(const ::mojo::pipe_control::blink::FlushAsyncPtr& input) { return !input; } |
| static void SetToNull(::mojo::pipe_control::blink::FlushAsyncPtr* output) { output->reset(); } |
| |
| static decltype(::mojo::pipe_control::blink::FlushAsync::flusher_pipe)& flusher_pipe( |
| ::mojo::pipe_control::blink::FlushAsyncPtr& input) { |
| return input->flusher_pipe; |
| } |
| |
| static bool Read(::mojo::pipe_control::blink::FlushAsync::DataView input, ::mojo::pipe_control::blink::FlushAsyncPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(MOJO_MOJOM_BINDINGS_BLINK) UnionTraits<::mojo::pipe_control::blink::RunOrClosePipeInput::DataView, |
| ::mojo::pipe_control::blink::RunOrClosePipeInputPtr> { |
| static bool IsNull(const ::mojo::pipe_control::blink::RunOrClosePipeInputPtr& input) { return !input; } |
| static void SetToNull(::mojo::pipe_control::blink::RunOrClosePipeInputPtr* output) { output->reset(); } |
| |
| static ::mojo::pipe_control::blink::RunOrClosePipeInput::Tag GetTag(const ::mojo::pipe_control::blink::RunOrClosePipeInputPtr& input) { |
| return input->which(); |
| } |
| |
| static const ::mojo::pipe_control::blink::PeerAssociatedEndpointClosedEventPtr& peer_associated_endpoint_closed_event(const ::mojo::pipe_control::blink::RunOrClosePipeInputPtr& input) { |
| return input->get_peer_associated_endpoint_closed_event(); |
| } |
| |
| static ::mojo::pipe_control::blink::PauseUntilFlushCompletesPtr& pause_until_flush_completes( ::mojo::pipe_control::blink::RunOrClosePipeInputPtr& input) { |
| return input->get_pause_until_flush_completes(); |
| } |
| |
| static ::mojo::pipe_control::blink::FlushAsyncPtr& flush_async( ::mojo::pipe_control::blink::RunOrClosePipeInputPtr& input) { |
| return input->get_flush_async(); |
| } |
| |
| static bool Read(::mojo::pipe_control::blink::RunOrClosePipeInput::DataView input, ::mojo::pipe_control::blink::RunOrClosePipeInputPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // MOJO_PUBLIC_INTERFACES_BINDINGS_PIPE_CONTROL_MESSAGES_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJ0eXBlIjogImt5dGhlMCIsICJtZXRhIjogW3sidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJi
|
| ZWdpbiI6IDE3NTAsICJlbmQiOiAxNzY2LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwg
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0v
|
| c3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5EaXNjb25uZWN0UmVh
|
| c29uIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgImJlZ2luIjogNTY3NiwgImVuZCI6IDU2ODksICJ2bmFtZSI6IHsibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNl
|
| YXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm1vam8ucGlwZV9jb250cm9s
|
| LkRpc2Nvbm5lY3RSZWFzb24uY3VzdG9tX3JlYXNvbiJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDU3NzUsICJl
|
| bmQiOiA1Nzg2LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNp
|
| Z25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5EaXNjb25uZWN0UmVhc29uLmRlc2NyaXB0aW9u
|
| In0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgImJlZ2luIjogNjg4MCwgImVuZCI6IDY4OTksICJ2bmFtZSI6IHsibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJj
|
| aC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm1vam8ucGlwZV9jb250cm9sLlJ1
|
| bk9yQ2xvc2VQaXBlSW5wdXQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxMDAyMiwgImVuZCI6IDEwMDYyLCAi
|
| dm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJt
|
| b2pvLnBpcGVfY29udHJvbC5SdW5PckNsb3NlUGlwZUlucHV0LnBlZXJfYXNzb2NpYXRlZF9lbmRw
|
| b2ludF9jbG9zZWRfZXZlbnQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxMDI3MSwgImVuZCI6IDEwMzEyLCAi
|
| dm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJt
|
| b2pvLnBpcGVfY29udHJvbC5SdW5PckNsb3NlUGlwZUlucHV0LnBlZXJfYXNzb2NpYXRlZF9lbmRw
|
| b2ludF9jbG9zZWRfZXZlbnQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxMDU1MywgImVuZCI6IDEwNTk0LCAi
|
| dm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJt
|
| b2pvLnBpcGVfY29udHJvbC5SdW5PckNsb3NlUGlwZUlucHV0LnBlZXJfYXNzb2NpYXRlZF9lbmRw
|
| b2ludF9jbG9zZWRfZXZlbnQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxMDc3NSwgImVuZCI6IDEwODA1LCAi
|
| dm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJt
|
| b2pvLnBpcGVfY29udHJvbC5SdW5PckNsb3NlUGlwZUlucHV0LnBhdXNlX3VudGlsX2ZsdXNoX2Nv
|
| bXBsZXRlcyJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDEwOTg2LCAiZW5kIjogMTEwMTcsICJ2bmFtZSI6IHsi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm1vam8ucGlwZV9j
|
| b250cm9sLlJ1bk9yQ2xvc2VQaXBlSW5wdXQucGF1c2VfdW50aWxfZmx1c2hfY29tcGxldGVzIn0s
|
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgImJlZ2luIjogMTEyMjksICJlbmQiOiAxMTI2MCwgInZuYW1lIjogeyJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNo
|
| L2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibW9qby5waXBlX2NvbnRyb2wuUnVu
|
| T3JDbG9zZVBpcGVJbnB1dC5wYXVzZV91bnRpbF9mbHVzaF9jb21wbGV0ZXMifSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVn
|
| aW4iOiAxMTQwNiwgImVuZCI6IDExNDIwLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwg
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0v
|
| c3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5SdW5PckNsb3NlUGlw
|
| ZUlucHV0LmZsdXNoX2FzeW5jIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwg
|
| eyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMTE1NTcsICJlbmQiOiAxMTU3Miwg
|
| InZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAi
|
| bW9qby5waXBlX2NvbnRyb2wuUnVuT3JDbG9zZVBpcGVJbnB1dC5mbHVzaF9hc3luYyJ9LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIs
|
| ICJiZWdpbiI6IDExNzM4LCAiZW5kIjogMTE3NTMsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJv
|
| bWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm1vam8ucGlwZV9jb250cm9sLlJ1bk9yQ2xv
|
| c2VQaXBlSW5wdXQuZmx1c2hfYXN5bmMifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxMjg0MywgImVuZCI6IDEy
|
| ODcwLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVy
|
| ZSI6ICJtb2pvLnBpcGVfY29udHJvbC5SdW5PckNsb3NlUGlwZU1lc3NhZ2VQYXJhbXMifSwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAiYmVnaW4iOiAxNjk2MSwgImVuZCI6IDE2OTY2LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1v
|
| am9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hy
|
| b21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5SdW5PckNs
|
| b3NlUGlwZU1lc3NhZ2VQYXJhbXMuaW5wdXQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxODExNiwgImVuZCI6
|
| IDE4MTQ5LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25h
|
| dHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5QZWVyQXNzb2NpYXRlZEVuZHBvaW50Q2xvc2VkRXZl
|
| bnQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9y
|
| X2RlZmluZXMiLCAiYmVnaW4iOiAyMjYzNSwgImVuZCI6IDIyNjM3LCAidm5hbWUiOiB7Imxhbmd1
|
| YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVz
|
| ZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJv
|
| bC5QZWVyQXNzb2NpYXRlZEVuZHBvaW50Q2xvc2VkRXZlbnQuaWQifSwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAy
|
| Mjc1NCwgImVuZCI6IDIyNzcxLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9t
|
| YWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5QZWVyQXNzb2NpYXRlZEVuZHBv
|
| aW50Q2xvc2VkRXZlbnQuZGlzY29ubmVjdF9yZWFzb24ifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdl
|
| L2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAyMzkzNSwg
|
| ImVuZCI6IDIzOTU5LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwg
|
| InNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5QYXVzZVVudGlsRmx1c2hDb21wbGV0ZXMi
|
| fSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAiYmVnaW4iOiAyNzk5MSwgImVuZCI6IDI4MDAxLCAidm5hbWUiOiB7Imxhbmd1YWdl
|
| IjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFy
|
| Y2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5Q
|
| YXVzZVVudGlsRmx1c2hDb21wbGV0ZXMuZmx1c2hfcGlwZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDI5MTE1
|
| LCAiZW5kIjogMjkxMjUsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4i
|
| LCAic2lnbmF0dXJlIjogIm1vam8ucGlwZV9jb250cm9sLkZsdXNoQXN5bmMifSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVn
|
| aW4iOiAzMjc1NSwgImVuZCI6IDMyNzY3LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwg
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0v
|
| c3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJtb2pvLnBpcGVfY29udHJvbC5GbHVzaEFzeW5jLmZs
|
| dXNoZXJfcGlwZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn1dfQ==
|
| */ |