| // services/network/public/mojom/content_security_policy.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 SERVICES_NETWORK_PUBLIC_MOJOM_CONTENT_SECURITY_POLICY_MOJOM_BLINK_H_ |
| #define SERVICES_NETWORK_PUBLIC_MOJOM_CONTENT_SECURITY_POLICY_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 "services/network/public/mojom/content_security_policy.mojom-features.h" |
| #include "services/network/public/mojom/content_security_policy.mojom-shared.h" |
| #include "services/network/public/mojom/content_security_policy.mojom-blink-forward.h" |
| #include "url/mojom/origin.mojom-blink.h" |
| #include "url/mojom/url.mojom-blink.h" |
| #include "services/network/public/mojom/source_location.mojom-blink.h" |
| #include "services/network/public/mojom/web_sandbox_flags.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 "third_party/blink/public/platform/web_common.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace network::mojom::blink { |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.ContentSecurityPolicyHeader |
| class BLINK_PLATFORM_EXPORT ContentSecurityPolicyHeader { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ContentSecurityPolicyHeader, T>::value>; |
| using DataView = ContentSecurityPolicyHeaderDataView; |
| using Data_ = internal::ContentSecurityPolicyHeader_Data; |
| |
| template <typename... Args> |
| static ContentSecurityPolicyHeaderPtr New(Args&&... args) { |
| return ContentSecurityPolicyHeaderPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ContentSecurityPolicyHeaderPtr From(const U& u) { |
| return mojo::TypeConverter<ContentSecurityPolicyHeaderPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ContentSecurityPolicyHeader>::Convert(*this); |
| } |
| |
| |
| ContentSecurityPolicyHeader(); |
| |
| ContentSecurityPolicyHeader( |
| const WTF::String& header_value, |
| ContentSecurityPolicyType type, |
| ContentSecurityPolicySource source); |
| |
| |
| ~ContentSecurityPolicyHeader(); |
| |
| // 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 = ContentSecurityPolicyHeaderPtr> |
| ContentSecurityPolicyHeaderPtr 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, ContentSecurityPolicyHeader::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, ContentSecurityPolicyHeader::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, ContentSecurityPolicyHeader::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< |
| ContentSecurityPolicyHeader::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ContentSecurityPolicyHeader::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::ContentSecurityPolicyHeader_UnserializedMessageContext< |
| UserType, ContentSecurityPolicyHeader::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<ContentSecurityPolicyHeader::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ContentSecurityPolicyHeader::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::ContentSecurityPolicyHeader_UnserializedMessageContext< |
| UserType, ContentSecurityPolicyHeader::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ContentSecurityPolicyHeader::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.ContentSecurityPolicyHeader.header_value |
| WTF::String header_value; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicyHeader.type |
| ContentSecurityPolicyType type; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicyHeader.source |
| ContentSecurityPolicySource source; |
| |
| // 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, ContentSecurityPolicyHeader::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ContentSecurityPolicyHeader::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ContentSecurityPolicyHeader::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ContentSecurityPolicyHeader::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue |
| class BLINK_PLATFORM_EXPORT AllowCSPFromHeaderValue { |
| public: |
| using DataView = AllowCSPFromHeaderValueDataView; |
| using Data_ = internal::AllowCSPFromHeaderValue_Data; |
| using Tag = Data_::AllowCSPFromHeaderValue_Tag; |
| |
| template <typename... Args> |
| static AllowCSPFromHeaderValuePtr 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 |allow_star|. |
| static AllowCSPFromHeaderValuePtr |
| NewAllowStar( |
| bool value) { |
| auto result = AllowCSPFromHeaderValuePtr(std::in_place); |
| result->set_allow_star(std::move(value)); |
| return result; |
| } |
| // Construct an instance holding |origin|. |
| static AllowCSPFromHeaderValuePtr |
| NewOrigin( |
| const ::scoped_refptr<const ::blink::SecurityOrigin>& value) { |
| auto result = AllowCSPFromHeaderValuePtr(std::in_place); |
| result->set_origin(std::move(value)); |
| return result; |
| } |
| // Construct an instance holding |error_message|. |
| static AllowCSPFromHeaderValuePtr |
| NewErrorMessage( |
| const WTF::String& value) { |
| auto result = AllowCSPFromHeaderValuePtr(std::in_place); |
| result->set_error_message(std::move(value)); |
| return result; |
| } |
| |
| template <typename U> |
| static AllowCSPFromHeaderValuePtr From(const U& u) { |
| return mojo::TypeConverter<AllowCSPFromHeaderValuePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, AllowCSPFromHeaderValue>::Convert(*this); |
| } |
| |
| AllowCSPFromHeaderValue(); |
| ~AllowCSPFromHeaderValue(); |
| // Delete the copy constructor and copy assignment operators because `data_` |
| // contains raw pointers that must not be copied. |
| AllowCSPFromHeaderValue(const AllowCSPFromHeaderValue& other) = delete; |
| AllowCSPFromHeaderValue& operator=(const AllowCSPFromHeaderValue& 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 = AllowCSPFromHeaderValuePtr> |
| AllowCSPFromHeaderValuePtr 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, AllowCSPFromHeaderValue>::value>::type* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, AllowCSPFromHeaderValue>::value>::type* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| Tag which() const { |
| return tag_; |
| } |
| |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.allow_star |
| bool is_allow_star() const { return tag_ == Tag::kAllowStar; } |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.allow_star |
| bool get_allow_star() const { |
| CHECK(tag_ == Tag::kAllowStar); |
| return data_.allow_star; |
| } |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.allow_star |
| void set_allow_star( |
| bool allow_star); |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.origin |
| bool is_origin() const { return tag_ == Tag::kOrigin; } |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.origin |
| ::scoped_refptr<const ::blink::SecurityOrigin>& get_origin() const { |
| CHECK(tag_ == Tag::kOrigin); |
| return *(data_.origin); |
| } |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.origin |
| void set_origin( |
| const ::scoped_refptr<const ::blink::SecurityOrigin>& origin); |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.error_message |
| bool is_error_message() const { return tag_ == Tag::kErrorMessage; } |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.error_message |
| WTF::String& get_error_message() const { |
| CHECK(tag_ == Tag::kErrorMessage); |
| return *(data_.error_message); |
| } |
| |
| |
| // @generated_from: network.mojom.AllowCSPFromHeaderValue.error_message |
| void set_error_message( |
| const WTF::String& error_message); |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| AllowCSPFromHeaderValue::DataView>(input); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<AllowCSPFromHeaderValue::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| private: |
| union Union_ { |
| Union_() = default; |
| ~Union_() = default; |
| bool allow_star; |
| ::scoped_refptr<const ::blink::SecurityOrigin>* origin; |
| WTF::String* error_message; |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| void DestroyActive(); |
| Tag tag_; |
| Union_ data_; |
| }; |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CSPSource |
| class BLINK_PLATFORM_EXPORT CSPSource { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CSPSource, T>::value>; |
| using DataView = CSPSourceDataView; |
| using Data_ = internal::CSPSource_Data; |
| |
| template <typename... Args> |
| static CSPSourcePtr New(Args&&... args) { |
| return CSPSourcePtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CSPSourcePtr From(const U& u) { |
| return mojo::TypeConverter<CSPSourcePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CSPSource>::Convert(*this); |
| } |
| |
| |
| CSPSource(); |
| |
| CSPSource( |
| const WTF::String& scheme, |
| const WTF::String& host, |
| int32_t port, |
| const WTF::String& path, |
| bool is_host_wildcard, |
| bool is_port_wildcard); |
| |
| |
| ~CSPSource(); |
| |
| // 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 = CSPSourcePtr> |
| CSPSourcePtr 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, CSPSource::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CSPSource::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, CSPSource::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< |
| CSPSource::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CSPSource::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::CSPSource_UnserializedMessageContext< |
| UserType, CSPSource::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<CSPSource::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CSPSource::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::CSPSource_UnserializedMessageContext< |
| UserType, CSPSource::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CSPSource::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CSPSource.scheme |
| WTF::String scheme; |
| |
| // @generated_from: network.mojom.CSPSource.host |
| WTF::String host; |
| |
| // @generated_from: network.mojom.CSPSource.port |
| int32_t port; |
| |
| // @generated_from: network.mojom.CSPSource.path |
| WTF::String path; |
| |
| // @generated_from: network.mojom.CSPSource.is_host_wildcard |
| bool is_host_wildcard; |
| |
| // @generated_from: network.mojom.CSPSource.is_port_wildcard |
| bool is_port_wildcard; |
| |
| // 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, CSPSource::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CSPSource::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CSPSource::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CSPSource::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CSPHashSource |
| class BLINK_PLATFORM_EXPORT CSPHashSource { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CSPHashSource, T>::value>; |
| using DataView = CSPHashSourceDataView; |
| using Data_ = internal::CSPHashSource_Data; |
| |
| template <typename... Args> |
| static CSPHashSourcePtr New(Args&&... args) { |
| return CSPHashSourcePtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CSPHashSourcePtr From(const U& u) { |
| return mojo::TypeConverter<CSPHashSourcePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CSPHashSource>::Convert(*this); |
| } |
| |
| |
| CSPHashSource(); |
| |
| CSPHashSource( |
| CSPHashAlgorithm algorithm, |
| WTF::Vector<uint8_t> value); |
| |
| |
| ~CSPHashSource(); |
| |
| // 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 = CSPHashSourcePtr> |
| CSPHashSourcePtr 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, CSPHashSource::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CSPHashSource::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, CSPHashSource::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< |
| CSPHashSource::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CSPHashSource::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::CSPHashSource_UnserializedMessageContext< |
| UserType, CSPHashSource::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<CSPHashSource::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CSPHashSource::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::CSPHashSource_UnserializedMessageContext< |
| UserType, CSPHashSource::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CSPHashSource::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CSPHashSource.algorithm |
| CSPHashAlgorithm algorithm; |
| |
| // @generated_from: network.mojom.CSPHashSource.value |
| WTF::Vector<uint8_t> value; |
| |
| // 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, CSPHashSource::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CSPHashSource::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CSPHashSource::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CSPHashSource::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CSPSourceList |
| class BLINK_PLATFORM_EXPORT CSPSourceList { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CSPSourceList, T>::value>; |
| using DataView = CSPSourceListDataView; |
| using Data_ = internal::CSPSourceList_Data; |
| |
| template <typename... Args> |
| static CSPSourceListPtr New(Args&&... args) { |
| return CSPSourceListPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CSPSourceListPtr From(const U& u) { |
| return mojo::TypeConverter<CSPSourceListPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CSPSourceList>::Convert(*this); |
| } |
| |
| |
| CSPSourceList(); |
| |
| CSPSourceList( |
| WTF::Vector<CSPSourcePtr> sources, |
| WTF::Vector<WTF::String> nonces, |
| WTF::Vector<CSPHashSourcePtr> hashes, |
| bool allow_self, |
| bool allow_star, |
| bool allow_response_redirects, |
| bool allow_inline, |
| bool allow_inline_speculation_rules, |
| bool allow_eval, |
| bool allow_wasm_eval, |
| bool allow_wasm_unsafe_eval, |
| bool allow_dynamic, |
| bool allow_unsafe_hashes, |
| bool report_sample); |
| |
| CSPSourceList(const CSPSourceList&) = delete; |
| CSPSourceList& operator=(const CSPSourceList&) = delete; |
| |
| ~CSPSourceList(); |
| |
| // 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 = CSPSourceListPtr> |
| CSPSourceListPtr 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, CSPSourceList::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CSPSourceList::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, CSPSourceList::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< |
| CSPSourceList::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CSPSourceList::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::CSPSourceList_UnserializedMessageContext< |
| UserType, CSPSourceList::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<CSPSourceList::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CSPSourceList::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::CSPSourceList_UnserializedMessageContext< |
| UserType, CSPSourceList::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CSPSourceList::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CSPSourceList.sources |
| WTF::Vector<CSPSourcePtr> sources; |
| |
| // @generated_from: network.mojom.CSPSourceList.nonces |
| WTF::Vector<WTF::String> nonces; |
| |
| // @generated_from: network.mojom.CSPSourceList.hashes |
| WTF::Vector<CSPHashSourcePtr> hashes; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_self |
| bool allow_self; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_star |
| bool allow_star; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_response_redirects |
| bool allow_response_redirects; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_inline |
| bool allow_inline; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_inline_speculation_rules |
| bool allow_inline_speculation_rules; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_eval |
| bool allow_eval; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_wasm_eval |
| bool allow_wasm_eval; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_wasm_unsafe_eval |
| bool allow_wasm_unsafe_eval; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_dynamic |
| bool allow_dynamic; |
| |
| // @generated_from: network.mojom.CSPSourceList.allow_unsafe_hashes |
| bool allow_unsafe_hashes; |
| |
| // @generated_from: network.mojom.CSPSourceList.report_sample |
| bool report_sample; |
| |
| // 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, CSPSourceList::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CSPSourceList::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CSPSourceList::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CSPSourceList::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CSPTrustedTypes |
| class BLINK_PLATFORM_EXPORT CSPTrustedTypes { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CSPTrustedTypes, T>::value>; |
| using DataView = CSPTrustedTypesDataView; |
| using Data_ = internal::CSPTrustedTypes_Data; |
| |
| template <typename... Args> |
| static CSPTrustedTypesPtr New(Args&&... args) { |
| return CSPTrustedTypesPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CSPTrustedTypesPtr From(const U& u) { |
| return mojo::TypeConverter<CSPTrustedTypesPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CSPTrustedTypes>::Convert(*this); |
| } |
| |
| |
| CSPTrustedTypes(); |
| |
| CSPTrustedTypes( |
| WTF::Vector<WTF::String> list, |
| bool allow_any, |
| bool allow_duplicates); |
| |
| |
| ~CSPTrustedTypes(); |
| |
| // 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 = CSPTrustedTypesPtr> |
| CSPTrustedTypesPtr 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, CSPTrustedTypes::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CSPTrustedTypes::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, CSPTrustedTypes::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< |
| CSPTrustedTypes::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CSPTrustedTypes::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::CSPTrustedTypes_UnserializedMessageContext< |
| UserType, CSPTrustedTypes::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<CSPTrustedTypes::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CSPTrustedTypes::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::CSPTrustedTypes_UnserializedMessageContext< |
| UserType, CSPTrustedTypes::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CSPTrustedTypes::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CSPTrustedTypes.list |
| WTF::Vector<WTF::String> list; |
| |
| // @generated_from: network.mojom.CSPTrustedTypes.allow_any |
| bool allow_any; |
| |
| // @generated_from: network.mojom.CSPTrustedTypes.allow_duplicates |
| bool allow_duplicates; |
| |
| // 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, CSPTrustedTypes::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CSPTrustedTypes::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CSPTrustedTypes::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CSPTrustedTypes::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy |
| class BLINK_PLATFORM_EXPORT ContentSecurityPolicy { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ContentSecurityPolicy, T>::value>; |
| using DataView = ContentSecurityPolicyDataView; |
| using Data_ = internal::ContentSecurityPolicy_Data; |
| |
| template <typename... Args> |
| static ContentSecurityPolicyPtr New(Args&&... args) { |
| return ContentSecurityPolicyPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ContentSecurityPolicyPtr From(const U& u) { |
| return mojo::TypeConverter<ContentSecurityPolicyPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ContentSecurityPolicy>::Convert(*this); |
| } |
| |
| |
| ContentSecurityPolicy(); |
| |
| ContentSecurityPolicy( |
| CSPSourcePtr self_origin, |
| const WTF::HashMap<CSPDirectiveName, WTF::String>& raw_directives, |
| WTF::HashMap<CSPDirectiveName, CSPSourceListPtr> directives, |
| bool upgrade_insecure_requests, |
| bool treat_as_public_address, |
| bool block_all_mixed_content, |
| ::network::mojom::blink::WebSandboxFlags sandbox, |
| ContentSecurityPolicyHeaderPtr header, |
| bool use_reporting_api, |
| WTF::Vector<WTF::String> report_endpoints, |
| CSPRequireTrustedTypesFor require_trusted_types_for, |
| CSPTrustedTypesPtr trusted_types, |
| WTF::Vector<WTF::String> parsing_errors); |
| |
| ContentSecurityPolicy(const ContentSecurityPolicy&) = delete; |
| ContentSecurityPolicy& operator=(const ContentSecurityPolicy&) = delete; |
| |
| ~ContentSecurityPolicy(); |
| |
| // 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 = ContentSecurityPolicyPtr> |
| ContentSecurityPolicyPtr 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, ContentSecurityPolicy::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, ContentSecurityPolicy::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, ContentSecurityPolicy::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< |
| ContentSecurityPolicy::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ContentSecurityPolicy::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::ContentSecurityPolicy_UnserializedMessageContext< |
| UserType, ContentSecurityPolicy::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<ContentSecurityPolicy::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ContentSecurityPolicy::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::ContentSecurityPolicy_UnserializedMessageContext< |
| UserType, ContentSecurityPolicy::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ContentSecurityPolicy::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.self_origin |
| CSPSourcePtr self_origin; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.raw_directives |
| WTF::HashMap<CSPDirectiveName, WTF::String> raw_directives; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.directives |
| WTF::HashMap<CSPDirectiveName, CSPSourceListPtr> directives; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.upgrade_insecure_requests |
| bool upgrade_insecure_requests; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.treat_as_public_address |
| bool treat_as_public_address; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.block_all_mixed_content |
| bool block_all_mixed_content; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.sandbox |
| ::network::mojom::blink::WebSandboxFlags sandbox; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.header |
| ContentSecurityPolicyHeaderPtr header; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.use_reporting_api |
| bool use_reporting_api; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.report_endpoints |
| WTF::Vector<WTF::String> report_endpoints; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.require_trusted_types_for |
| CSPRequireTrustedTypesFor require_trusted_types_for; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.trusted_types |
| CSPTrustedTypesPtr trusted_types; |
| |
| // @generated_from: network.mojom.ContentSecurityPolicy.parsing_errors |
| WTF::Vector<WTF::String> parsing_errors; |
| |
| // 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, ContentSecurityPolicy::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ContentSecurityPolicy::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ContentSecurityPolicy::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ContentSecurityPolicy::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CSPViolation |
| class BLINK_PLATFORM_EXPORT CSPViolation { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CSPViolation, T>::value>; |
| using DataView = CSPViolationDataView; |
| using Data_ = internal::CSPViolation_Data; |
| |
| template <typename... Args> |
| static CSPViolationPtr New(Args&&... args) { |
| return CSPViolationPtr( |
| std::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CSPViolationPtr From(const U& u) { |
| return mojo::TypeConverter<CSPViolationPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CSPViolation>::Convert(*this); |
| } |
| |
| |
| CSPViolation(); |
| |
| CSPViolation( |
| const WTF::String& directive, |
| const WTF::String& effective_directive, |
| const WTF::String& console_message, |
| const ::blink::KURL& blocked_url, |
| WTF::Vector<WTF::String> report_endpoints, |
| bool use_reporting_api, |
| const WTF::String& header, |
| ContentSecurityPolicyType type, |
| ::network::mojom::blink::SourceLocationPtr source_location); |
| |
| CSPViolation(const CSPViolation&) = delete; |
| CSPViolation& operator=(const CSPViolation&) = delete; |
| |
| ~CSPViolation(); |
| |
| // 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 = CSPViolationPtr> |
| CSPViolationPtr 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, CSPViolation::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CSPViolation::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| template <typename T, CSPViolation::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< |
| CSPViolation::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CSPViolation::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::CSPViolation_UnserializedMessageContext< |
| UserType, CSPViolation::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<CSPViolation::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CSPViolation::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::CSPViolation_UnserializedMessageContext< |
| UserType, CSPViolation::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CSPViolation::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CSPViolation.directive |
| WTF::String directive; |
| |
| // @generated_from: network.mojom.CSPViolation.effective_directive |
| WTF::String effective_directive; |
| |
| // @generated_from: network.mojom.CSPViolation.console_message |
| WTF::String console_message; |
| |
| // @generated_from: network.mojom.CSPViolation.blocked_url |
| ::blink::KURL blocked_url; |
| |
| // @generated_from: network.mojom.CSPViolation.report_endpoints |
| WTF::Vector<WTF::String> report_endpoints; |
| |
| // @generated_from: network.mojom.CSPViolation.use_reporting_api |
| bool use_reporting_api; |
| |
| // @generated_from: network.mojom.CSPViolation.header |
| WTF::String header; |
| |
| // @generated_from: network.mojom.CSPViolation.type |
| ContentSecurityPolicyType type; |
| |
| // @generated_from: network.mojom.CSPViolation.source_location |
| ::network::mojom::blink::SourceLocationPtr source_location; |
| |
| // 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, CSPViolation::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CSPViolation::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CSPViolation::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CSPViolation::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename UnionPtrType> |
| AllowCSPFromHeaderValuePtr AllowCSPFromHeaderValue::Clone() const { |
| switch (tag_) { |
| case Tag::kAllowStar: |
| return NewAllowStar( |
| mojo::Clone(data_.allow_star)); |
| case Tag::kOrigin: |
| return NewOrigin( |
| mojo::Clone(*data_.origin)); |
| case Tag::kErrorMessage: |
| return NewErrorMessage( |
| mojo::Clone(*data_.error_message)); |
| } |
| return nullptr; |
| } |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, AllowCSPFromHeaderValue>::value>::type*> |
| bool AllowCSPFromHeaderValue::Equals(const T& other) const { |
| if (tag_ != other.which()) |
| return false; |
| |
| switch (tag_) { |
| case Tag::kAllowStar: |
| return mojo::Equals(data_.allow_star, other.data_.allow_star); |
| case Tag::kOrigin: |
| return mojo::Equals(*(data_.origin), *(other.data_.origin)); |
| case Tag::kErrorMessage: |
| return mojo::Equals(*(data_.error_message), *(other.data_.error_message)); |
| } |
| |
| return false; |
| } |
| template <typename StructPtrType> |
| ContentSecurityPolicyHeaderPtr ContentSecurityPolicyHeader::Clone() const { |
| return New( |
| mojo::Clone(header_value), |
| mojo::Clone(type), |
| mojo::Clone(source) |
| ); |
| } |
| |
| template <typename T, ContentSecurityPolicyHeader::EnableIfSame<T>*> |
| bool ContentSecurityPolicyHeader::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->header_value, other_struct.header_value)) |
| return false; |
| if (!mojo::Equals(this->type, other_struct.type)) |
| return false; |
| if (!mojo::Equals(this->source, other_struct.source)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ContentSecurityPolicyHeader::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.header_value < rhs.header_value) |
| return true; |
| if (rhs.header_value < lhs.header_value) |
| return false; |
| if (lhs.type < rhs.type) |
| return true; |
| if (rhs.type < lhs.type) |
| return false; |
| if (lhs.source < rhs.source) |
| return true; |
| if (rhs.source < lhs.source) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CSPSourcePtr CSPSource::Clone() const { |
| return New( |
| mojo::Clone(scheme), |
| mojo::Clone(host), |
| mojo::Clone(port), |
| mojo::Clone(path), |
| mojo::Clone(is_host_wildcard), |
| mojo::Clone(is_port_wildcard) |
| ); |
| } |
| |
| template <typename T, CSPSource::EnableIfSame<T>*> |
| bool CSPSource::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->scheme, other_struct.scheme)) |
| return false; |
| if (!mojo::Equals(this->host, other_struct.host)) |
| return false; |
| if (!mojo::Equals(this->port, other_struct.port)) |
| return false; |
| if (!mojo::Equals(this->path, other_struct.path)) |
| return false; |
| if (!mojo::Equals(this->is_host_wildcard, other_struct.is_host_wildcard)) |
| return false; |
| if (!mojo::Equals(this->is_port_wildcard, other_struct.is_port_wildcard)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CSPSource::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.scheme < rhs.scheme) |
| return true; |
| if (rhs.scheme < lhs.scheme) |
| return false; |
| if (lhs.host < rhs.host) |
| return true; |
| if (rhs.host < lhs.host) |
| return false; |
| if (lhs.port < rhs.port) |
| return true; |
| if (rhs.port < lhs.port) |
| return false; |
| if (lhs.path < rhs.path) |
| return true; |
| if (rhs.path < lhs.path) |
| return false; |
| if (lhs.is_host_wildcard < rhs.is_host_wildcard) |
| return true; |
| if (rhs.is_host_wildcard < lhs.is_host_wildcard) |
| return false; |
| if (lhs.is_port_wildcard < rhs.is_port_wildcard) |
| return true; |
| if (rhs.is_port_wildcard < lhs.is_port_wildcard) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CSPHashSourcePtr CSPHashSource::Clone() const { |
| return New( |
| mojo::Clone(algorithm), |
| mojo::Clone(value) |
| ); |
| } |
| |
| template <typename T, CSPHashSource::EnableIfSame<T>*> |
| bool CSPHashSource::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->algorithm, other_struct.algorithm)) |
| return false; |
| if (!mojo::Equals(this->value, other_struct.value)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CSPHashSource::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.algorithm < rhs.algorithm) |
| return true; |
| if (rhs.algorithm < lhs.algorithm) |
| return false; |
| if (lhs.value < rhs.value) |
| return true; |
| if (rhs.value < lhs.value) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CSPSourceListPtr CSPSourceList::Clone() const { |
| return New( |
| mojo::Clone(sources), |
| mojo::Clone(nonces), |
| mojo::Clone(hashes), |
| mojo::Clone(allow_self), |
| mojo::Clone(allow_star), |
| mojo::Clone(allow_response_redirects), |
| mojo::Clone(allow_inline), |
| mojo::Clone(allow_inline_speculation_rules), |
| mojo::Clone(allow_eval), |
| mojo::Clone(allow_wasm_eval), |
| mojo::Clone(allow_wasm_unsafe_eval), |
| mojo::Clone(allow_dynamic), |
| mojo::Clone(allow_unsafe_hashes), |
| mojo::Clone(report_sample) |
| ); |
| } |
| |
| template <typename T, CSPSourceList::EnableIfSame<T>*> |
| bool CSPSourceList::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->sources, other_struct.sources)) |
| return false; |
| if (!mojo::Equals(this->nonces, other_struct.nonces)) |
| return false; |
| if (!mojo::Equals(this->hashes, other_struct.hashes)) |
| return false; |
| if (!mojo::Equals(this->allow_self, other_struct.allow_self)) |
| return false; |
| if (!mojo::Equals(this->allow_star, other_struct.allow_star)) |
| return false; |
| if (!mojo::Equals(this->allow_response_redirects, other_struct.allow_response_redirects)) |
| return false; |
| if (!mojo::Equals(this->allow_inline, other_struct.allow_inline)) |
| return false; |
| if (!mojo::Equals(this->allow_inline_speculation_rules, other_struct.allow_inline_speculation_rules)) |
| return false; |
| if (!mojo::Equals(this->allow_eval, other_struct.allow_eval)) |
| return false; |
| if (!mojo::Equals(this->allow_wasm_eval, other_struct.allow_wasm_eval)) |
| return false; |
| if (!mojo::Equals(this->allow_wasm_unsafe_eval, other_struct.allow_wasm_unsafe_eval)) |
| return false; |
| if (!mojo::Equals(this->allow_dynamic, other_struct.allow_dynamic)) |
| return false; |
| if (!mojo::Equals(this->allow_unsafe_hashes, other_struct.allow_unsafe_hashes)) |
| return false; |
| if (!mojo::Equals(this->report_sample, other_struct.report_sample)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CSPSourceList::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.sources < rhs.sources) |
| return true; |
| if (rhs.sources < lhs.sources) |
| return false; |
| if (lhs.nonces < rhs.nonces) |
| return true; |
| if (rhs.nonces < lhs.nonces) |
| return false; |
| if (lhs.hashes < rhs.hashes) |
| return true; |
| if (rhs.hashes < lhs.hashes) |
| return false; |
| if (lhs.allow_self < rhs.allow_self) |
| return true; |
| if (rhs.allow_self < lhs.allow_self) |
| return false; |
| if (lhs.allow_star < rhs.allow_star) |
| return true; |
| if (rhs.allow_star < lhs.allow_star) |
| return false; |
| if (lhs.allow_response_redirects < rhs.allow_response_redirects) |
| return true; |
| if (rhs.allow_response_redirects < lhs.allow_response_redirects) |
| return false; |
| if (lhs.allow_inline < rhs.allow_inline) |
| return true; |
| if (rhs.allow_inline < lhs.allow_inline) |
| return false; |
| if (lhs.allow_inline_speculation_rules < rhs.allow_inline_speculation_rules) |
| return true; |
| if (rhs.allow_inline_speculation_rules < lhs.allow_inline_speculation_rules) |
| return false; |
| if (lhs.allow_eval < rhs.allow_eval) |
| return true; |
| if (rhs.allow_eval < lhs.allow_eval) |
| return false; |
| if (lhs.allow_wasm_eval < rhs.allow_wasm_eval) |
| return true; |
| if (rhs.allow_wasm_eval < lhs.allow_wasm_eval) |
| return false; |
| if (lhs.allow_wasm_unsafe_eval < rhs.allow_wasm_unsafe_eval) |
| return true; |
| if (rhs.allow_wasm_unsafe_eval < lhs.allow_wasm_unsafe_eval) |
| return false; |
| if (lhs.allow_dynamic < rhs.allow_dynamic) |
| return true; |
| if (rhs.allow_dynamic < lhs.allow_dynamic) |
| return false; |
| if (lhs.allow_unsafe_hashes < rhs.allow_unsafe_hashes) |
| return true; |
| if (rhs.allow_unsafe_hashes < lhs.allow_unsafe_hashes) |
| return false; |
| if (lhs.report_sample < rhs.report_sample) |
| return true; |
| if (rhs.report_sample < lhs.report_sample) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CSPTrustedTypesPtr CSPTrustedTypes::Clone() const { |
| return New( |
| mojo::Clone(list), |
| mojo::Clone(allow_any), |
| mojo::Clone(allow_duplicates) |
| ); |
| } |
| |
| template <typename T, CSPTrustedTypes::EnableIfSame<T>*> |
| bool CSPTrustedTypes::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->list, other_struct.list)) |
| return false; |
| if (!mojo::Equals(this->allow_any, other_struct.allow_any)) |
| return false; |
| if (!mojo::Equals(this->allow_duplicates, other_struct.allow_duplicates)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CSPTrustedTypes::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.list < rhs.list) |
| return true; |
| if (rhs.list < lhs.list) |
| return false; |
| if (lhs.allow_any < rhs.allow_any) |
| return true; |
| if (rhs.allow_any < lhs.allow_any) |
| return false; |
| if (lhs.allow_duplicates < rhs.allow_duplicates) |
| return true; |
| if (rhs.allow_duplicates < lhs.allow_duplicates) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ContentSecurityPolicyPtr ContentSecurityPolicy::Clone() const { |
| return New( |
| mojo::Clone(self_origin), |
| mojo::Clone(raw_directives), |
| mojo::Clone(directives), |
| mojo::Clone(upgrade_insecure_requests), |
| mojo::Clone(treat_as_public_address), |
| mojo::Clone(block_all_mixed_content), |
| mojo::Clone(sandbox), |
| mojo::Clone(header), |
| mojo::Clone(use_reporting_api), |
| mojo::Clone(report_endpoints), |
| mojo::Clone(require_trusted_types_for), |
| mojo::Clone(trusted_types), |
| mojo::Clone(parsing_errors) |
| ); |
| } |
| |
| template <typename T, ContentSecurityPolicy::EnableIfSame<T>*> |
| bool ContentSecurityPolicy::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->self_origin, other_struct.self_origin)) |
| return false; |
| if (!mojo::Equals(this->raw_directives, other_struct.raw_directives)) |
| return false; |
| if (!mojo::Equals(this->directives, other_struct.directives)) |
| return false; |
| if (!mojo::Equals(this->upgrade_insecure_requests, other_struct.upgrade_insecure_requests)) |
| return false; |
| if (!mojo::Equals(this->treat_as_public_address, other_struct.treat_as_public_address)) |
| return false; |
| if (!mojo::Equals(this->block_all_mixed_content, other_struct.block_all_mixed_content)) |
| return false; |
| if (!mojo::Equals(this->sandbox, other_struct.sandbox)) |
| return false; |
| if (!mojo::Equals(this->header, other_struct.header)) |
| return false; |
| if (!mojo::Equals(this->use_reporting_api, other_struct.use_reporting_api)) |
| return false; |
| if (!mojo::Equals(this->report_endpoints, other_struct.report_endpoints)) |
| return false; |
| if (!mojo::Equals(this->require_trusted_types_for, other_struct.require_trusted_types_for)) |
| return false; |
| if (!mojo::Equals(this->trusted_types, other_struct.trusted_types)) |
| return false; |
| if (!mojo::Equals(this->parsing_errors, other_struct.parsing_errors)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ContentSecurityPolicy::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.self_origin < rhs.self_origin) |
| return true; |
| if (rhs.self_origin < lhs.self_origin) |
| return false; |
| if (lhs.raw_directives < rhs.raw_directives) |
| return true; |
| if (rhs.raw_directives < lhs.raw_directives) |
| return false; |
| if (lhs.directives < rhs.directives) |
| return true; |
| if (rhs.directives < lhs.directives) |
| return false; |
| if (lhs.upgrade_insecure_requests < rhs.upgrade_insecure_requests) |
| return true; |
| if (rhs.upgrade_insecure_requests < lhs.upgrade_insecure_requests) |
| return false; |
| if (lhs.treat_as_public_address < rhs.treat_as_public_address) |
| return true; |
| if (rhs.treat_as_public_address < lhs.treat_as_public_address) |
| return false; |
| if (lhs.block_all_mixed_content < rhs.block_all_mixed_content) |
| return true; |
| if (rhs.block_all_mixed_content < lhs.block_all_mixed_content) |
| return false; |
| if (lhs.sandbox < rhs.sandbox) |
| return true; |
| if (rhs.sandbox < lhs.sandbox) |
| return false; |
| if (lhs.header < rhs.header) |
| return true; |
| if (rhs.header < lhs.header) |
| return false; |
| if (lhs.use_reporting_api < rhs.use_reporting_api) |
| return true; |
| if (rhs.use_reporting_api < lhs.use_reporting_api) |
| return false; |
| if (lhs.report_endpoints < rhs.report_endpoints) |
| return true; |
| if (rhs.report_endpoints < lhs.report_endpoints) |
| return false; |
| if (lhs.require_trusted_types_for < rhs.require_trusted_types_for) |
| return true; |
| if (rhs.require_trusted_types_for < lhs.require_trusted_types_for) |
| return false; |
| if (lhs.trusted_types < rhs.trusted_types) |
| return true; |
| if (rhs.trusted_types < lhs.trusted_types) |
| return false; |
| if (lhs.parsing_errors < rhs.parsing_errors) |
| return true; |
| if (rhs.parsing_errors < lhs.parsing_errors) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CSPViolationPtr CSPViolation::Clone() const { |
| return New( |
| mojo::Clone(directive), |
| mojo::Clone(effective_directive), |
| mojo::Clone(console_message), |
| mojo::Clone(blocked_url), |
| mojo::Clone(report_endpoints), |
| mojo::Clone(use_reporting_api), |
| mojo::Clone(header), |
| mojo::Clone(type), |
| mojo::Clone(source_location) |
| ); |
| } |
| |
| template <typename T, CSPViolation::EnableIfSame<T>*> |
| bool CSPViolation::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->directive, other_struct.directive)) |
| return false; |
| if (!mojo::Equals(this->effective_directive, other_struct.effective_directive)) |
| return false; |
| if (!mojo::Equals(this->console_message, other_struct.console_message)) |
| return false; |
| if (!mojo::Equals(this->blocked_url, other_struct.blocked_url)) |
| return false; |
| if (!mojo::Equals(this->report_endpoints, other_struct.report_endpoints)) |
| return false; |
| if (!mojo::Equals(this->use_reporting_api, other_struct.use_reporting_api)) |
| return false; |
| if (!mojo::Equals(this->header, other_struct.header)) |
| return false; |
| if (!mojo::Equals(this->type, other_struct.type)) |
| return false; |
| if (!mojo::Equals(this->source_location, other_struct.source_location)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CSPViolation::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.directive < rhs.directive) |
| return true; |
| if (rhs.directive < lhs.directive) |
| return false; |
| if (lhs.effective_directive < rhs.effective_directive) |
| return true; |
| if (rhs.effective_directive < lhs.effective_directive) |
| return false; |
| if (lhs.console_message < rhs.console_message) |
| return true; |
| if (rhs.console_message < lhs.console_message) |
| return false; |
| if (lhs.blocked_url < rhs.blocked_url) |
| return true; |
| if (rhs.blocked_url < lhs.blocked_url) |
| return false; |
| if (lhs.report_endpoints < rhs.report_endpoints) |
| return true; |
| if (rhs.report_endpoints < lhs.report_endpoints) |
| return false; |
| if (lhs.use_reporting_api < rhs.use_reporting_api) |
| return true; |
| if (rhs.use_reporting_api < lhs.use_reporting_api) |
| return false; |
| if (lhs.header < rhs.header) |
| return true; |
| if (rhs.header < lhs.header) |
| return false; |
| if (lhs.type < rhs.type) |
| return true; |
| if (rhs.type < lhs.type) |
| return false; |
| if (lhs.source_location < rhs.source_location) |
| return true; |
| if (rhs.source_location < lhs.source_location) |
| return false; |
| return false; |
| } |
| |
| |
| } // network::mojom::blink |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::ContentSecurityPolicyHeader::DataView, |
| ::network::mojom::blink::ContentSecurityPolicyHeaderPtr> { |
| static bool IsNull(const ::network::mojom::blink::ContentSecurityPolicyHeaderPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::ContentSecurityPolicyHeaderPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicyHeader::header_value)& header_value( |
| const ::network::mojom::blink::ContentSecurityPolicyHeaderPtr& input) { |
| return input->header_value; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicyHeader::type) type( |
| const ::network::mojom::blink::ContentSecurityPolicyHeaderPtr& input) { |
| return input->type; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicyHeader::source) source( |
| const ::network::mojom::blink::ContentSecurityPolicyHeaderPtr& input) { |
| return input->source; |
| } |
| |
| static bool Read(::network::mojom::blink::ContentSecurityPolicyHeader::DataView input, ::network::mojom::blink::ContentSecurityPolicyHeaderPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CSPSource::DataView, |
| ::network::mojom::blink::CSPSourcePtr> { |
| static bool IsNull(const ::network::mojom::blink::CSPSourcePtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CSPSourcePtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CSPSource::scheme)& scheme( |
| const ::network::mojom::blink::CSPSourcePtr& input) { |
| return input->scheme; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPSource::host)& host( |
| const ::network::mojom::blink::CSPSourcePtr& input) { |
| return input->host; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSource::port) port( |
| const ::network::mojom::blink::CSPSourcePtr& input) { |
| return input->port; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPSource::path)& path( |
| const ::network::mojom::blink::CSPSourcePtr& input) { |
| return input->path; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSource::is_host_wildcard) is_host_wildcard( |
| const ::network::mojom::blink::CSPSourcePtr& input) { |
| return input->is_host_wildcard; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSource::is_port_wildcard) is_port_wildcard( |
| const ::network::mojom::blink::CSPSourcePtr& input) { |
| return input->is_port_wildcard; |
| } |
| |
| static bool Read(::network::mojom::blink::CSPSource::DataView input, ::network::mojom::blink::CSPSourcePtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CSPHashSource::DataView, |
| ::network::mojom::blink::CSPHashSourcePtr> { |
| static bool IsNull(const ::network::mojom::blink::CSPHashSourcePtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CSPHashSourcePtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CSPHashSource::algorithm) algorithm( |
| const ::network::mojom::blink::CSPHashSourcePtr& input) { |
| return input->algorithm; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPHashSource::value)& value( |
| const ::network::mojom::blink::CSPHashSourcePtr& input) { |
| return input->value; |
| } |
| |
| static bool Read(::network::mojom::blink::CSPHashSource::DataView input, ::network::mojom::blink::CSPHashSourcePtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CSPSourceList::DataView, |
| ::network::mojom::blink::CSPSourceListPtr> { |
| static bool IsNull(const ::network::mojom::blink::CSPSourceListPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CSPSourceListPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CSPSourceList::sources)& sources( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->sources; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPSourceList::nonces)& nonces( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->nonces; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPSourceList::hashes)& hashes( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->hashes; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_self) allow_self( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_self; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_star) allow_star( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_star; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_response_redirects) allow_response_redirects( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_response_redirects; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_inline) allow_inline( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_inline; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_inline_speculation_rules) allow_inline_speculation_rules( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_inline_speculation_rules; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_eval) allow_eval( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_eval; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_wasm_eval) allow_wasm_eval( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_wasm_eval; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_wasm_unsafe_eval) allow_wasm_unsafe_eval( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_wasm_unsafe_eval; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_dynamic) allow_dynamic( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_dynamic; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::allow_unsafe_hashes) allow_unsafe_hashes( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->allow_unsafe_hashes; |
| } |
| |
| static decltype(::network::mojom::blink::CSPSourceList::report_sample) report_sample( |
| const ::network::mojom::blink::CSPSourceListPtr& input) { |
| return input->report_sample; |
| } |
| |
| static bool Read(::network::mojom::blink::CSPSourceList::DataView input, ::network::mojom::blink::CSPSourceListPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CSPTrustedTypes::DataView, |
| ::network::mojom::blink::CSPTrustedTypesPtr> { |
| static bool IsNull(const ::network::mojom::blink::CSPTrustedTypesPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CSPTrustedTypesPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CSPTrustedTypes::list)& list( |
| const ::network::mojom::blink::CSPTrustedTypesPtr& input) { |
| return input->list; |
| } |
| |
| static decltype(::network::mojom::blink::CSPTrustedTypes::allow_any) allow_any( |
| const ::network::mojom::blink::CSPTrustedTypesPtr& input) { |
| return input->allow_any; |
| } |
| |
| static decltype(::network::mojom::blink::CSPTrustedTypes::allow_duplicates) allow_duplicates( |
| const ::network::mojom::blink::CSPTrustedTypesPtr& input) { |
| return input->allow_duplicates; |
| } |
| |
| static bool Read(::network::mojom::blink::CSPTrustedTypes::DataView input, ::network::mojom::blink::CSPTrustedTypesPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::ContentSecurityPolicy::DataView, |
| ::network::mojom::blink::ContentSecurityPolicyPtr> { |
| static bool IsNull(const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::ContentSecurityPolicyPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::self_origin)& self_origin( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->self_origin; |
| } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::raw_directives)& raw_directives( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->raw_directives; |
| } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::directives)& directives( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->directives; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicy::upgrade_insecure_requests) upgrade_insecure_requests( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->upgrade_insecure_requests; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicy::treat_as_public_address) treat_as_public_address( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->treat_as_public_address; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicy::block_all_mixed_content) block_all_mixed_content( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->block_all_mixed_content; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicy::sandbox) sandbox( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->sandbox; |
| } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::header)& header( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->header; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicy::use_reporting_api) use_reporting_api( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->use_reporting_api; |
| } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::report_endpoints)& report_endpoints( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->report_endpoints; |
| } |
| |
| static decltype(::network::mojom::blink::ContentSecurityPolicy::require_trusted_types_for) require_trusted_types_for( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->require_trusted_types_for; |
| } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::trusted_types)& trusted_types( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->trusted_types; |
| } |
| |
| static const decltype(::network::mojom::blink::ContentSecurityPolicy::parsing_errors)& parsing_errors( |
| const ::network::mojom::blink::ContentSecurityPolicyPtr& input) { |
| return input->parsing_errors; |
| } |
| |
| static bool Read(::network::mojom::blink::ContentSecurityPolicy::DataView input, ::network::mojom::blink::ContentSecurityPolicyPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CSPViolation::DataView, |
| ::network::mojom::blink::CSPViolationPtr> { |
| static bool IsNull(const ::network::mojom::blink::CSPViolationPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CSPViolationPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::directive)& directive( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->directive; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::effective_directive)& effective_directive( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->effective_directive; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::console_message)& console_message( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->console_message; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::blocked_url)& blocked_url( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->blocked_url; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::report_endpoints)& report_endpoints( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->report_endpoints; |
| } |
| |
| static decltype(::network::mojom::blink::CSPViolation::use_reporting_api) use_reporting_api( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->use_reporting_api; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::header)& header( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->header; |
| } |
| |
| static decltype(::network::mojom::blink::CSPViolation::type) type( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->type; |
| } |
| |
| static const decltype(::network::mojom::blink::CSPViolation::source_location)& source_location( |
| const ::network::mojom::blink::CSPViolationPtr& input) { |
| return input->source_location; |
| } |
| |
| static bool Read(::network::mojom::blink::CSPViolation::DataView input, ::network::mojom::blink::CSPViolationPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT UnionTraits<::network::mojom::blink::AllowCSPFromHeaderValue::DataView, |
| ::network::mojom::blink::AllowCSPFromHeaderValuePtr> { |
| static bool IsNull(const ::network::mojom::blink::AllowCSPFromHeaderValuePtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::AllowCSPFromHeaderValuePtr* output) { output->reset(); } |
| |
| static ::network::mojom::blink::AllowCSPFromHeaderValue::Tag GetTag(const ::network::mojom::blink::AllowCSPFromHeaderValuePtr& input) { |
| return input->which(); |
| } |
| |
| static bool allow_star(const ::network::mojom::blink::AllowCSPFromHeaderValuePtr& input) { |
| return input->get_allow_star(); |
| } |
| |
| static const ::scoped_refptr<const ::blink::SecurityOrigin>& origin(const ::network::mojom::blink::AllowCSPFromHeaderValuePtr& input) { |
| return input->get_origin(); |
| } |
| |
| static const WTF::String& error_message(const ::network::mojom::blink::AllowCSPFromHeaderValuePtr& input) { |
| return input->get_error_message(); |
| } |
| |
| static bool Read(::network::mojom::blink::AllowCSPFromHeaderValue::DataView input, ::network::mojom::blink::AllowCSPFromHeaderValuePtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_NETWORK_PUBLIC_MOJOM_CONTENT_SECURITY_POLICY_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJ0eXBlIjogImt5dGhlMCIsICJtZXRhIjogW3sidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJi
|
| ZWdpbiI6IDE5ODYsICJlbmQiOiAyMDEzLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwg
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0v
|
| c3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvbnRlbnRTZWN1cml0eVBv
|
| bGljeUhlYWRlciJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6
|
| ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDYyNTgsICJlbmQiOiA2MjcwLCAidm5hbWUiOiB7
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t
|
| L2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1v
|
| am9tLkNvbnRlbnRTZWN1cml0eVBvbGljeUhlYWRlci5oZWFkZXJfdmFsdWUifSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVn
|
| aW4iOiA2MzcwLCAiZW5kIjogNjM3NCwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3Ny
|
| Yy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db250ZW50U2VjdXJpdHlQb2xp
|
| Y3lIZWFkZXIudHlwZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlw
|
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDY0NzgsICJlbmQiOiA2NDg0LCAidm5hbWUi
|
| OiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu
|
| Y29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3Jr
|
| Lm1vam9tLkNvbnRlbnRTZWN1cml0eVBvbGljeUhlYWRlci5zb3VyY2UifSwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4i
|
| OiA3NjAzLCAiZW5kIjogNzYyNiwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8v
|
| bWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5BbGxvd0NTUEZyb21IZWFkZXJWYWx1
|
| ZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJiZWdpbiI6IDEwNjgxLCAiZW5kIjogMTA2OTQsICJ2bmFtZSI6IHsibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNl
|
| YXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQWxs
|
| b3dDU1BGcm9tSGVhZGVyVmFsdWUuYWxsb3dfc3RhciJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDEwODE5LCAi
|
| ZW5kIjogMTA4MzMsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAi
|
| c2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQWxsb3dDU1BGcm9tSGVhZGVyVmFsdWUuYWxsb3df
|
| c3RhciJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJiZWdpbiI6IDEwOTkzLCAiZW5kIjogMTEwMDcsICJ2bmFtZSI6IHsibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29k
|
| ZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u
|
| QWxsb3dDU1BGcm9tSGVhZGVyVmFsdWUuYWxsb3dfc3RhciJ9LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDExMTA4
|
| LCAiZW5kIjogMTExMTcsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4i
|
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQWxsb3dDU1BGcm9tSGVhZGVyVmFsdWUub3Jp
|
| Z2luIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgImJlZ2luIjogMTEyNzgsICJlbmQiOiAxMTI4OCwgInZuYW1lIjogeyJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rl
|
| c2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5B
|
| bGxvd0NTUEZyb21IZWFkZXJWYWx1ZS5vcmlnaW4ifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxMTQ0MCwgImVu
|
| ZCI6IDExNDUwLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNp
|
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkFsbG93Q1NQRnJvbUhlYWRlclZhbHVlLm9yaWdpbiJ9
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVm
|
| aW5lcyIsICJiZWdpbiI6IDExNjAzLCAiZW5kIjogMTE2MTksICJ2bmFtZSI6IHsibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJj
|
| aC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQWxsb3dD
|
| U1BGcm9tSGVhZGVyVmFsdWUuZXJyb3JfbWVzc2FnZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDExNzU4LCAi
|
| ZW5kIjogMTE3NzUsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAi
|
| c2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQWxsb3dDU1BGcm9tSGVhZGVyVmFsdWUuZXJyb3Jf
|
| bWVzc2FnZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDExOTQ3LCAiZW5kIjogMTE5NjQsICJ2bmFtZSI6IHsi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9q
|
| b20uQWxsb3dDU1BGcm9tSGVhZGVyVmFsdWUuZXJyb3JfbWVzc2FnZSJ9LCAiZWRnZSI6ICIlL2t5
|
| dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6
|
| IDEyOTY0LCAiZW5kIjogMTI5NzMsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29y
|
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMv
|
| L21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQU291cmNlIn0sICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJl
|
| Z2luIjogMTY3OTgsICJlbmQiOiAxNjgwNCwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVt
|
| L3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BTb3VyY2Uuc2NoZW1l
|
| In0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgImJlZ2luIjogMTY4NzIsICJlbmQiOiAxNjg3NiwgInZuYW1lIjogeyJsYW5ndWFn
|
| ZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2Vh
|
| cmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BT
|
| b3VyY2UuaG9zdCJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6
|
| ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDE2OTQwLCAiZW5kIjogMTY5NDQsICJ2bmFtZSI6
|
| IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsu
|
| bW9qb20uQ1NQU291cmNlLnBvcnQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9
|
| LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxNzAxMiwgImVuZCI6IDE3MDE2
|
| LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n
|
| bGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6
|
| ICJuZXR3b3JrLm1vam9tLkNTUFNvdXJjZS5wYXRoIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMTcwODksICJl
|
| bmQiOiAxNzEwNSwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJz
|
| aWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BTb3VyY2UuaXNfaG9zdF93aWxkY2FyZCJ9LCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5l
|
| cyIsICJiZWdpbiI6IDE3MTc4LCAiZW5kIjogMTcxOTQsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAi
|
| bW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9j
|
| aHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQU291cmNl
|
| LmlzX3BvcnRfd2lsZGNhcmQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAxODIyNSwgImVuZCI6IDE4MjM4LCAi
|
| dm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJu
|
| ZXR3b3JrLm1vam9tLkNTUEhhc2hTb3VyY2UifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAyMjAzNiwgImVuZCI6
|
| IDIyMDQ1LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25h
|
| dHVyZSI6ICJuZXR3b3JrLm1vam9tLkNTUEhhc2hTb3VyY2UuYWxnb3JpdGhtIn0sICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJl
|
| Z2luIjogMjIxMjcsICJlbmQiOiAyMjEzMiwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVt
|
| L3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BIYXNoU291cmNlLnZh
|
| bHVlIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgImJlZ2luIjogMjMxNzksICJlbmQiOiAyMzE5MiwgInZuYW1lIjogeyJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rl
|
| c2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D
|
| U1BTb3VyY2VMaXN0In0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBl
|
| IjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMjc0NzcsICJlbmQiOiAyNzQ4NCwgInZuYW1l
|
| IjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl
|
| LmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29y
|
| ay5tb2pvbS5DU1BTb3VyY2VMaXN0LnNvdXJjZXMifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAyNzU3MSwgImVu
|
| ZCI6IDI3NTc3LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNp
|
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNTUFNvdXJjZUxpc3Qubm9uY2VzIn0sICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJl
|
| Z2luIjogMjc2NjksICJlbmQiOiAyNzY3NSwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVt
|
| L3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BTb3VyY2VMaXN0Lmhh
|
| c2hlcyJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJiZWdpbiI6IDI3NzQ2LCAiZW5kIjogMjc3NTYsICJ2bmFtZSI6IHsibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29k
|
| ZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u
|
| Q1NQU291cmNlTGlzdC5hbGxvd19zZWxmIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMjc4MjcsICJlbmQiOiAy
|
| NzgzNywgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1
|
| cmUiOiAibmV0d29yay5tb2pvbS5DU1BTb3VyY2VMaXN0LmFsbG93X3N0YXIifSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVn
|
| aW4iOiAyNzkyMiwgImVuZCI6IDI3OTQ2LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwg
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0v
|
| c3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNTUFNvdXJjZUxpc3QuYWxs
|
| b3dfcmVzcG9uc2VfcmVkaXJlY3RzIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| fSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMjgwMTksICJlbmQiOiAyODAz
|
| MSwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29v
|
| Z2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUi
|
| OiAibmV0d29yay5tb2pvbS5DU1BTb3VyY2VMaXN0LmFsbG93X2lubGluZSJ9LCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdp
|
| biI6IDI4MTIyLCAiZW5kIjogMjgxNTIsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9z
|
| cmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQU291cmNlTGlzdC5hbGxv
|
| d19pbmxpbmVfc3BlY3VsYXRpb25fcnVsZXMifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAyODIyMywgImVuZCI6
|
| IDI4MjMzLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25h
|
| dHVyZSI6ICJuZXR3b3JrLm1vam9tLkNTUFNvdXJjZUxpc3QuYWxsb3dfZXZhbCJ9LCAiZWRnZSI6
|
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJi
|
| ZWdpbiI6IDI4MzA5LCAiZW5kIjogMjgzMjQsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1
|
| bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQU291cmNlTGlzdC5h
|
| bGxvd193YXNtX2V2YWwifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5
|
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAyODQwNywgImVuZCI6IDI4NDI5LCAidm5h
|
| bWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy
|
| Y2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3
|
| b3JrLm1vam9tLkNTUFNvdXJjZUxpc3QuYWxsb3dfd2FzbV91bnNhZmVfZXZhbCJ9LCAiZWRnZSI6
|
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJi
|
| ZWdpbiI6IDI4NTAzLCAiZW5kIjogMjg1MTYsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1
|
| bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQU291cmNlTGlzdC5h
|
| bGxvd19keW5hbWljIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBl
|
| IjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMjg1OTYsICJlbmQiOiAyODYxNSwgInZuYW1l
|
| IjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl
|
| LmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29y
|
| ay5tb2pvbS5DU1BTb3VyY2VMaXN0LmFsbG93X3Vuc2FmZV9oYXNoZXMifSwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4i
|
| OiAyODY4OSwgImVuZCI6IDI4NzAyLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNv
|
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3Jj
|
| Ly9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNTUFNvdXJjZUxpc3QucmVwb3J0
|
| X3NhbXBsZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDI5NzUxLCAiZW5kIjogMjk3NjYsICJ2bmFtZSI6IHsi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9q
|
| b20uQ1NQVHJ1c3RlZFR5cGVzIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwg
|
| eyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMzM2MzksICJlbmQiOiAzMzY0Mywg
|
| InZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAi
|
| bmV0d29yay5tb2pvbS5DU1BUcnVzdGVkVHlwZXMubGlzdCJ9LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDMzNzE1
|
| LCAiZW5kIjogMzM3MjQsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4i
|
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQVHJ1c3RlZFR5cGVzLmFsbG93X2FueSJ9
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVm
|
| aW5lcyIsICJiZWdpbiI6IDMzODAzLCAiZW5kIjogMzM4MTksICJ2bmFtZSI6IHsibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJj
|
| aC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQVHJ1
|
| c3RlZFR5cGVzLmFsbG93X2R1cGxpY2F0ZXMifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiAzNDg4MiwgImVuZCI6
|
| IDM0OTAzLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25h
|
| dHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvbnRlbnRTZWN1cml0eVBvbGljeSJ9LCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdp
|
| biI6IDM5NTgyLCAiZW5kIjogMzk1OTMsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9z
|
| cmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29udGVudFNlY3VyaXR5UG9s
|
| aWN5LnNlbGZfb3JpZ2luIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0
|
| eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMzk3MTUsICJlbmQiOiAzOTcyOSwgInZu
|
| YW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0
|
| d29yay5tb2pvbS5Db250ZW50U2VjdXJpdHlQb2xpY3kucmF3X2RpcmVjdGl2ZXMifSwgImVkZ2Ui
|
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| YmVnaW4iOiAzOTg1MiwgImVuZCI6IDM5ODYyLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9t
|
| IiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21p
|
| dW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvbnRlbnRTZWN1cml0
|
| eVBvbGljeS5kaXJlY3RpdmVzIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwg
|
| eyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogMzk5NTYsICJlbmQiOiAzOTk4MSwg
|
| InZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAi
|
| bmV0d29yay5tb2pvbS5Db250ZW50U2VjdXJpdHlQb2xpY3kudXBncmFkZV9pbnNlY3VyZV9yZXF1
|
| ZXN0cyJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJiZWdpbiI6IDQwMDczLCAiZW5kIjogNDAwOTYsICJ2bmFtZSI6IHsibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29k
|
| ZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u
|
| Q29udGVudFNlY3VyaXR5UG9saWN5LnRyZWF0X2FzX3B1YmxpY19hZGRyZXNzIn0sICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJl
|
| Z2luIjogNDAxODgsICJlbmQiOiA0MDIxMSwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVt
|
| L3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db250ZW50U2VjdXJpdHlQ
|
| b2xpY3kuYmxvY2tfYWxsX21peGVkX2NvbnRlbnQifSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAiYmVnaW4iOiA0MDMyMywgImVu
|
| ZCI6IDQwMzMwLCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNp
|
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvbnRlbnRTZWN1cml0eVBvbGljeS5zYW5kYm94In0s
|
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgImJlZ2luIjogNDA0MDAsICJlbmQiOiA0MDQzMCwgInZuYW1lIjogeyJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNo
|
| L2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db250ZW50
|
| U2VjdXJpdHlQb2xpY3kuaGVhZGVyIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| fSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogNDA1MjMsICJlbmQiOiA0MDU0
|
| MCwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29v
|
| Z2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUi
|
| OiAibmV0d29yay5tb2pvbS5Db250ZW50U2VjdXJpdHlQb2xpY3kudXNlX3JlcG9ydGluZ19hcGki
|
| fSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAiYmVnaW4iOiA0MDY0NSwgImVuZCI6IDQwNjYxLCAidm5hbWUiOiB7Imxhbmd1YWdl
|
| IjogIm1vam9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFy
|
| Y2gvY2hyb21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvbnRl
|
| bnRTZWN1cml0eVBvbGljeS5yZXBvcnRfZW5kcG9pbnRzIn0sICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogNDA3NzYs
|
| ICJlbmQiOiA0MDgwMSwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIs
|
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db250ZW50U2VjdXJpdHlQb2xpY3kucmVxdWly
|
| ZV90cnVzdGVkX3R5cGVzX2ZvciJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0s
|
| IHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDQwODk3LCAiZW5kIjogNDA5MTAs
|
| ICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdvb2ds
|
| ZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjog
|
| Im5ldHdvcmsubW9qb20uQ29udGVudFNlY3VyaXR5UG9saWN5LnRydXN0ZWRfdHlwZXMifSwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyJ9LCB7InR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAiYmVnaW4iOiA0MTAxMywgImVuZCI6IDQxMDI3LCAidm5hbWUiOiB7Imxhbmd1YWdlIjogIm1v
|
| am9tIiwgImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2NvZGVzZWFyY2gvY2hy
|
| b21pdW0vc3JjLy9tYWluIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvbnRlbnRTZWN1
|
| cml0eVBvbGljeS5wYXJzaW5nX2Vycm9ycyJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh
|
| dGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDQyMTA1LCAiZW5kIjog
|
| NDIxMTcsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0
|
| dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQVmlvbGF0aW9uIn0sICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogNDYyOTUs
|
| ICJlbmQiOiA0NjMwNCwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIs
|
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BWaW9sYXRpb24uZGlyZWN0aXZlIn0sICJl
|
| ZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hvcl9kZWZpbmVz
|
| IiwgImJlZ2luIjogNDYzOTAsICJlbmQiOiA0NjQwOSwgInZuYW1lIjogeyJsYW5ndWFnZSI6ICJt
|
| b2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rlc2VhcmNoL2No
|
| cm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DU1BWaW9sYXRp
|
| b24uZWZmZWN0aXZlX2RpcmVjdGl2ZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| In0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDQ2NDkxLCAiZW5kIjogNDY1
|
| MDYsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAic2lnbmF0dXJl
|
| IjogIm5ldHdvcmsubW9qb20uQ1NQVmlvbGF0aW9uLmNvbnNvbGVfbWVzc2FnZSJ9LCAiZWRnZSI6
|
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJi
|
| ZWdpbiI6IDQ2NTg2LCAiZW5kIjogNDY1OTcsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1
|
| bS9zcmMvL21haW4iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQVmlvbGF0aW9uLmJs
|
| b2NrZWRfdXJsIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogNDY2OTMsICJlbmQiOiA0NjcwOSwgInZuYW1lIjog
|
| eyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5t
|
| b2pvbS5DU1BWaW9sYXRpb24ucmVwb3J0X2VuZHBvaW50cyJ9LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDQ2Nzg2
|
| LCAiZW5kIjogNDY4MDMsICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4i
|
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQVmlvbGF0aW9uLnVzZV9yZXBvcnRpbmdf
|
| YXBpIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwgeyJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgImJlZ2luIjogNDY4NzYsICJlbmQiOiA0Njg4MiwgInZuYW1lIjogeyJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jb2Rl
|
| c2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D
|
| U1BWaW9sYXRpb24uaGVhZGVyIn0sICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMifSwg
|
| eyJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgImJlZ2luIjogNDY5NjcsICJlbmQiOiA0Njk3MSwg
|
| InZuYW1lIjogeyJsYW5ndWFnZSI6ICJtb2pvbSIsICJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jb2Rlc2VhcmNoL2Nocm9taXVtL3NyYy8vbWFpbiIsICJzaWduYXR1cmUiOiAi
|
| bmV0d29yay5tb2pvbS5DU1BWaW9sYXRpb24udHlwZSJ9LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIn0sIHsidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJiZWdpbiI6IDQ3MDg0LCAi
|
| ZW5kIjogNDcwOTksICJ2bmFtZSI6IHsibGFuZ3VhZ2UiOiAibW9qb20iLCAiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY29kZXNlYXJjaC9jaHJvbWl1bS9zcmMvL21haW4iLCAi
|
| c2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ1NQVmlvbGF0aW9uLnNvdXJjZV9sb2NhdGlvbiJ9
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIn1dfQ==
|
| */ |
