| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef CONTENT_COMMON_PAGE_STATE_MOJOM_H_ |
| #define CONTENT_COMMON_PAGE_STATE_MOJOM_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "base/optional.h" |
| |
| #include "mojo/public/cpp/bindings/mojo_buildflags.h" |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| #include "base/trace_event/trace_event.h" |
| #endif |
| #include "mojo/public/cpp/bindings/clone_traits.h" |
| #include "mojo/public/cpp/bindings/equals_traits.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/struct_ptr.h" |
| #include "mojo/public/cpp/bindings/struct_traits.h" |
| #include "mojo/public/cpp/bindings/union_traits.h" |
| #include "content/common/page_state.mojom-shared.h" |
| #include "content/common/page_state.mojom-forward.h" |
| #include "mojo/public/mojom/base/string16.mojom.h" |
| #include "mojo/public/mojom/base/time.mojom.h" |
| #include "services/network/public/mojom/referrer_policy.mojom.h" |
| #include "url/mojom/url.mojom.h" |
| #include "ui/gfx/geometry/mojo/geometry.mojom.h" |
| #include <string> |
| #include <vector> |
| |
| #include "mojo/public/cpp/bindings/associated_interface_ptr.h" |
| #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h" |
| #include "mojo/public/cpp/bindings/associated_interface_request.h" |
| #include "mojo/public/cpp/bindings/interface_ptr.h" |
| #include "mojo/public/cpp/bindings/interface_request.h" |
| #include "mojo/public/cpp/bindings/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h" |
| |
| |
| #include "mojo/public/cpp/bindings/lib/native_enum_serialization.h" |
| #include "mojo/public/cpp/bindings/lib/native_struct_serialization.h" |
| #include "content/common/content_export.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace content { |
| namespace history { |
| namespace mojom { |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.Element |
| class CONTENT_EXPORT Element { |
| public: |
| using DataView = ElementDataView; |
| using Data_ = internal::Element_Data; |
| using Tag = Data_::Element_Tag; |
| |
| static ElementPtr New() { |
| return ElementPtr(base::in_place); |
| } |
| // Construct an instance holding |blob_uuid|. |
| static ElementPtr |
| NewBlobUuid( |
| const std::string& blob_uuid) { |
| auto result = ElementPtr(base::in_place); |
| result->set_blob_uuid(std::move(blob_uuid)); |
| return result; |
| } |
| // Construct an instance holding |bytes|. |
| static ElementPtr |
| NewBytes( |
| const std::vector<uint8_t>& bytes) { |
| auto result = ElementPtr(base::in_place); |
| result->set_bytes(std::move(bytes)); |
| return result; |
| } |
| // Construct an instance holding |file|. |
| static ElementPtr |
| NewFile( |
| FilePtr file) { |
| auto result = ElementPtr(base::in_place); |
| result->set_file(std::move(file)); |
| return result; |
| } |
| // Construct an instance holding |DEPRECATED_file_system_file|. |
| static ElementPtr |
| NewDEPRECATEDFileSystemFile( |
| DEPRECATED_FileSystemFilePtr DEPRECATED_file_system_file) { |
| auto result = ElementPtr(base::in_place); |
| result->set_DEPRECATED_file_system_file(std::move(DEPRECATED_file_system_file)); |
| return result; |
| } |
| |
| template <typename U> |
| static ElementPtr From(const U& u) { |
| return mojo::TypeConverter<ElementPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, Element>::Convert(*this); |
| } |
| |
| Element(); |
| ~Element(); |
| |
| // 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 = ElementPtr> |
| ElementPtr 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, Element>::value>::type* = nullptr> |
| bool Equals(const T& other) const; |
| |
| Tag which() const { |
| return tag_; |
| } |
| |
| |
| |
| // @generated_from: content.history.mojom.Element.blob_uuid |
| bool is_blob_uuid() const { return tag_ == Tag::BLOB_UUID; } |
| |
| |
| // @generated_from: content.history.mojom.Element.blob_uuid |
| std::string& get_blob_uuid() const { |
| DCHECK(tag_ == Tag::BLOB_UUID); |
| return *(data_.blob_uuid); |
| } |
| |
| |
| // @generated_from: content.history.mojom.Element.blob_uuid |
| void set_blob_uuid( |
| const std::string& blob_uuid); |
| |
| // @generated_from: content.history.mojom.Element.bytes |
| bool is_bytes() const { return tag_ == Tag::BYTES; } |
| |
| |
| // @generated_from: content.history.mojom.Element.bytes |
| std::vector<uint8_t>& get_bytes() const { |
| DCHECK(tag_ == Tag::BYTES); |
| return *(data_.bytes); |
| } |
| |
| |
| // @generated_from: content.history.mojom.Element.bytes |
| void set_bytes( |
| const std::vector<uint8_t>& bytes); |
| |
| // @generated_from: content.history.mojom.Element.file |
| bool is_file() const { return tag_ == Tag::FILE; } |
| |
| |
| // @generated_from: content.history.mojom.Element.file |
| FilePtr& get_file() const { |
| DCHECK(tag_ == Tag::FILE); |
| return *(data_.file); |
| } |
| |
| |
| // @generated_from: content.history.mojom.Element.file |
| void set_file( |
| FilePtr file); |
| |
| // @generated_from: content.history.mojom.Element.DEPRECATED_file_system_file |
| bool is_DEPRECATED_file_system_file() const { return tag_ == Tag::DEPRECATED_FILE_SYSTEM_FILE; } |
| |
| |
| // @generated_from: content.history.mojom.Element.DEPRECATED_file_system_file |
| DEPRECATED_FileSystemFilePtr& get_DEPRECATED_file_system_file() const { |
| DCHECK(tag_ == Tag::DEPRECATED_FILE_SYSTEM_FILE); |
| return *(data_.DEPRECATED_file_system_file); |
| } |
| |
| |
| // @generated_from: content.history.mojom.Element.DEPRECATED_file_system_file |
| void set_DEPRECATED_file_system_file( |
| DEPRECATED_FileSystemFilePtr DEPRECATED_file_system_file); |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| Element::DataView>(input); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<Element::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| private: |
| union Union_ { |
| Union_() {} |
| ~Union_() {} |
| std::string* blob_uuid; |
| std::vector<uint8_t>* bytes; |
| FilePtr* file; |
| DEPRECATED_FileSystemFilePtr* DEPRECATED_file_system_file; |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| void DestroyActive(); |
| Tag tag_; |
| Union_ data_; |
| }; |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.DEPRECATED_FileSystemFile |
| class CONTENT_EXPORT DEPRECATED_FileSystemFile { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<DEPRECATED_FileSystemFile, T>::value>; |
| using DataView = DEPRECATED_FileSystemFileDataView; |
| using Data_ = internal::DEPRECATED_FileSystemFile_Data; |
| |
| template <typename... Args> |
| static DEPRECATED_FileSystemFilePtr New(Args&&... args) { |
| return DEPRECATED_FileSystemFilePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static DEPRECATED_FileSystemFilePtr From(const U& u) { |
| return mojo::TypeConverter<DEPRECATED_FileSystemFilePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, DEPRECATED_FileSystemFile>::Convert(*this); |
| } |
| |
| |
| DEPRECATED_FileSystemFile(); |
| |
| DEPRECATED_FileSystemFile( |
| const GURL& filesystem_url, |
| uint64_t offset, |
| uint64_t length, |
| base::Time modification_time); |
| |
| ~DEPRECATED_FileSystemFile(); |
| |
| // 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 = DEPRECATED_FileSystemFilePtr> |
| DEPRECATED_FileSystemFilePtr 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, DEPRECATED_FileSystemFile::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| DEPRECATED_FileSystemFile::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| DEPRECATED_FileSystemFile::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::DEPRECATED_FileSystemFile_UnserializedMessageContext< |
| UserType, DEPRECATED_FileSystemFile::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<DEPRECATED_FileSystemFile::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return DEPRECATED_FileSystemFile::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::DEPRECATED_FileSystemFile_UnserializedMessageContext< |
| UserType, DEPRECATED_FileSystemFile::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<DEPRECATED_FileSystemFile::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.DEPRECATED_FileSystemFile.filesystem_url |
| GURL filesystem_url; |
| |
| // @generated_from: content.history.mojom.DEPRECATED_FileSystemFile.offset |
| uint64_t offset; |
| |
| // @generated_from: content.history.mojom.DEPRECATED_FileSystemFile.length |
| uint64_t length; |
| |
| // @generated_from: content.history.mojom.DEPRECATED_FileSystemFile.modification_time |
| base::Time modification_time; |
| |
| 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, DEPRECATED_FileSystemFile::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, DEPRECATED_FileSystemFile::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, DEPRECATED_FileSystemFile::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, DEPRECATED_FileSystemFile::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.File |
| class CONTENT_EXPORT File { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<File, T>::value>; |
| using DataView = FileDataView; |
| using Data_ = internal::File_Data; |
| |
| template <typename... Args> |
| static FilePtr New(Args&&... args) { |
| return FilePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static FilePtr From(const U& u) { |
| return mojo::TypeConverter<FilePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, File>::Convert(*this); |
| } |
| |
| |
| File(); |
| |
| File( |
| const base::string16& path, |
| uint64_t offset, |
| uint64_t length, |
| base::Time modification_time); |
| |
| ~File(); |
| |
| // 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 = FilePtr> |
| FilePtr 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, File::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| File::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| File::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::File_UnserializedMessageContext< |
| UserType, File::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<File::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return File::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::File_UnserializedMessageContext< |
| UserType, File::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<File::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.File.path |
| base::string16 path; |
| |
| // @generated_from: content.history.mojom.File.offset |
| uint64_t offset; |
| |
| // @generated_from: content.history.mojom.File.length |
| uint64_t length; |
| |
| // @generated_from: content.history.mojom.File.modification_time |
| base::Time modification_time; |
| |
| 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, File::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, File::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, File::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, File::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.RequestBody |
| class CONTENT_EXPORT RequestBody { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<RequestBody, T>::value>; |
| using DataView = RequestBodyDataView; |
| using Data_ = internal::RequestBody_Data; |
| |
| template <typename... Args> |
| static RequestBodyPtr New(Args&&... args) { |
| return RequestBodyPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static RequestBodyPtr From(const U& u) { |
| return mojo::TypeConverter<RequestBodyPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, RequestBody>::Convert(*this); |
| } |
| |
| |
| RequestBody(); |
| |
| RequestBody( |
| std::vector<ElementPtr> elements, |
| int64_t identifier, |
| bool contains_sensitive_info); |
| |
| ~RequestBody(); |
| |
| // 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 = RequestBodyPtr> |
| RequestBodyPtr 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, RequestBody::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| RequestBody::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| RequestBody::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::RequestBody_UnserializedMessageContext< |
| UserType, RequestBody::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<RequestBody::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return RequestBody::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::RequestBody_UnserializedMessageContext< |
| UserType, RequestBody::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<RequestBody::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.RequestBody.elements |
| std::vector<ElementPtr> elements; |
| |
| // @generated_from: content.history.mojom.RequestBody.identifier |
| int64_t identifier; |
| |
| // @generated_from: content.history.mojom.RequestBody.contains_sensitive_info |
| bool contains_sensitive_info; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(RequestBody); |
| }; |
| |
| // 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, RequestBody::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, RequestBody::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, RequestBody::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, RequestBody::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.HttpBody |
| class CONTENT_EXPORT HttpBody { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<HttpBody, T>::value>; |
| using DataView = HttpBodyDataView; |
| using Data_ = internal::HttpBody_Data; |
| |
| template <typename... Args> |
| static HttpBodyPtr New(Args&&... args) { |
| return HttpBodyPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static HttpBodyPtr From(const U& u) { |
| return mojo::TypeConverter<HttpBodyPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, HttpBody>::Convert(*this); |
| } |
| |
| |
| HttpBody(); |
| |
| HttpBody( |
| const base::Optional<base::string16>& http_content_type, |
| RequestBodyPtr request_body, |
| bool contains_passwords); |
| |
| ~HttpBody(); |
| |
| // 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 = HttpBodyPtr> |
| HttpBodyPtr 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, HttpBody::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| HttpBody::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| HttpBody::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::HttpBody_UnserializedMessageContext< |
| UserType, HttpBody::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<HttpBody::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return HttpBody::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::HttpBody_UnserializedMessageContext< |
| UserType, HttpBody::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<HttpBody::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.HttpBody.http_content_type |
| base::Optional<base::string16> http_content_type; |
| |
| // @generated_from: content.history.mojom.HttpBody.request_body |
| RequestBodyPtr request_body; |
| |
| // @generated_from: content.history.mojom.HttpBody.contains_passwords |
| bool contains_passwords; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(HttpBody); |
| }; |
| |
| // 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, HttpBody::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, HttpBody::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, HttpBody::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, HttpBody::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.ViewState |
| class CONTENT_EXPORT ViewState { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ViewState, T>::value>; |
| using DataView = ViewStateDataView; |
| using Data_ = internal::ViewState_Data; |
| |
| template <typename... Args> |
| static ViewStatePtr New(Args&&... args) { |
| return ViewStatePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ViewStatePtr From(const U& u) { |
| return mojo::TypeConverter<ViewStatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ViewState>::Convert(*this); |
| } |
| |
| |
| ViewState(); |
| |
| ViewState( |
| const gfx::PointF& visual_viewport_scroll_offset, |
| const gfx::Point& scroll_offset, |
| double page_scale_factor); |
| |
| ViewState( |
| const gfx::PointF& visual_viewport_scroll_offset, |
| const gfx::Point& scroll_offset, |
| double page_scale_factor, |
| const base::Optional<base::string16>& scroll_anchor_selector, |
| const base::Optional<gfx::PointF>& scroll_anchor_offset, |
| uint64_t scroll_anchor_simhash); |
| |
| ~ViewState(); |
| |
| // 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 = ViewStatePtr> |
| ViewStatePtr 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, ViewState::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| ViewState::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ViewState::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::ViewState_UnserializedMessageContext< |
| UserType, ViewState::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<ViewState::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return ViewState::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::ViewState_UnserializedMessageContext< |
| UserType, ViewState::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ViewState::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.ViewState.visual_viewport_scroll_offset |
| gfx::PointF visual_viewport_scroll_offset; |
| |
| // @generated_from: content.history.mojom.ViewState.scroll_offset |
| gfx::Point scroll_offset; |
| |
| // @generated_from: content.history.mojom.ViewState.page_scale_factor |
| double page_scale_factor; |
| |
| // @generated_from: content.history.mojom.ViewState.scroll_anchor_selector |
| base::Optional<base::string16> scroll_anchor_selector; |
| |
| // @generated_from: content.history.mojom.ViewState.scroll_anchor_offset |
| base::Optional<gfx::PointF> scroll_anchor_offset; |
| |
| // @generated_from: content.history.mojom.ViewState.scroll_anchor_simhash |
| uint64_t scroll_anchor_simhash; |
| |
| 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, ViewState::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ViewState::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ViewState::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ViewState::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.FrameState |
| class CONTENT_EXPORT FrameState { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<FrameState, T>::value>; |
| using DataView = FrameStateDataView; |
| using Data_ = internal::FrameState_Data; |
| |
| template <typename... Args> |
| static FrameStatePtr New(Args&&... args) { |
| return FrameStatePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static FrameStatePtr From(const U& u) { |
| return mojo::TypeConverter<FrameStatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, FrameState>::Convert(*this); |
| } |
| |
| |
| FrameState(); |
| |
| FrameState( |
| const base::Optional<base::string16>& url_string, |
| const base::Optional<base::string16>& referrer, |
| const base::Optional<base::string16>& target, |
| const base::Optional<base::string16>& state_object, |
| const std::vector<base::Optional<base::string16>>& document_state, |
| ScrollRestorationType scroll_restoration_type, |
| ViewStatePtr view_state, |
| int64_t item_sequence_number, |
| int64_t document_sequence_number, |
| ::network::mojom::ReferrerPolicy referrer_policy, |
| HttpBodyPtr http_body, |
| std::vector<FrameStatePtr> children); |
| |
| ~FrameState(); |
| |
| // 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 = FrameStatePtr> |
| FrameStatePtr 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, FrameState::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| FrameState::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| FrameState::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::FrameState_UnserializedMessageContext< |
| UserType, FrameState::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<FrameState::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return FrameState::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::FrameState_UnserializedMessageContext< |
| UserType, FrameState::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<FrameState::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.FrameState.url_string |
| base::Optional<base::string16> url_string; |
| |
| // @generated_from: content.history.mojom.FrameState.referrer |
| base::Optional<base::string16> referrer; |
| |
| // @generated_from: content.history.mojom.FrameState.target |
| base::Optional<base::string16> target; |
| |
| // @generated_from: content.history.mojom.FrameState.state_object |
| base::Optional<base::string16> state_object; |
| |
| // @generated_from: content.history.mojom.FrameState.document_state |
| std::vector<base::Optional<base::string16>> document_state; |
| |
| // @generated_from: content.history.mojom.FrameState.scroll_restoration_type |
| ScrollRestorationType scroll_restoration_type; |
| |
| // @generated_from: content.history.mojom.FrameState.view_state |
| ViewStatePtr view_state; |
| |
| // @generated_from: content.history.mojom.FrameState.item_sequence_number |
| int64_t item_sequence_number; |
| |
| // @generated_from: content.history.mojom.FrameState.document_sequence_number |
| int64_t document_sequence_number; |
| |
| // @generated_from: content.history.mojom.FrameState.referrer_policy |
| ::network::mojom::ReferrerPolicy referrer_policy; |
| |
| // @generated_from: content.history.mojom.FrameState.http_body |
| HttpBodyPtr http_body; |
| |
| // @generated_from: content.history.mojom.FrameState.children |
| std::vector<FrameStatePtr> children; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(FrameState); |
| }; |
| |
| // 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, FrameState::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, FrameState::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, FrameState::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, FrameState::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.history.mojom.PageState |
| class CONTENT_EXPORT PageState { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<PageState, T>::value>; |
| using DataView = PageStateDataView; |
| using Data_ = internal::PageState_Data; |
| |
| template <typename... Args> |
| static PageStatePtr New(Args&&... args) { |
| return PageStatePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static PageStatePtr From(const U& u) { |
| return mojo::TypeConverter<PageStatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, PageState>::Convert(*this); |
| } |
| |
| |
| PageState(); |
| |
| PageState( |
| const std::vector<base::Optional<base::string16>>& referenced_files, |
| FrameStatePtr top); |
| |
| ~PageState(); |
| |
| // 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 = PageStatePtr> |
| PageStatePtr 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, PageState::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| PageState::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| PageState::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::PageState_UnserializedMessageContext< |
| UserType, PageState::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<PageState::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const std::vector<uint8_t>& input, |
| UserType* output) { |
| return PageState::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::PageState_UnserializedMessageContext< |
| UserType, PageState::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<PageState::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.history.mojom.PageState.referenced_files |
| std::vector<base::Optional<base::string16>> referenced_files; |
| |
| // @generated_from: content.history.mojom.PageState.top |
| FrameStatePtr top; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(PageState); |
| }; |
| |
| // 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, PageState::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, PageState::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, PageState::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, PageState::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename UnionPtrType> |
| ElementPtr Element::Clone() const { |
| // Use UnionPtrType to prevent the compiler from trying to compile this |
| // without being asked. |
| UnionPtrType rv(New()); |
| switch (tag_) { |
| case Tag::BLOB_UUID: |
| rv->set_blob_uuid(mojo::Clone(*data_.blob_uuid)); |
| break; |
| case Tag::BYTES: |
| rv->set_bytes(mojo::Clone(*data_.bytes)); |
| break; |
| case Tag::FILE: |
| rv->set_file(mojo::Clone(*data_.file)); |
| break; |
| case Tag::DEPRECATED_FILE_SYSTEM_FILE: |
| rv->set_DEPRECATED_file_system_file(mojo::Clone(*data_.DEPRECATED_file_system_file)); |
| break; |
| } |
| return rv; |
| } |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, Element>::value>::type*> |
| bool Element::Equals(const T& other) const { |
| if (tag_ != other.which()) |
| return false; |
| |
| switch (tag_) { |
| case Tag::BLOB_UUID: |
| return mojo::Equals(*(data_.blob_uuid), *(other.data_.blob_uuid)); |
| case Tag::BYTES: |
| return mojo::Equals(*(data_.bytes), *(other.data_.bytes)); |
| case Tag::FILE: |
| return mojo::Equals(*(data_.file), *(other.data_.file)); |
| case Tag::DEPRECATED_FILE_SYSTEM_FILE: |
| return mojo::Equals(*(data_.DEPRECATED_file_system_file), *(other.data_.DEPRECATED_file_system_file)); |
| } |
| |
| return false; |
| } |
| template <typename StructPtrType> |
| DEPRECATED_FileSystemFilePtr DEPRECATED_FileSystemFile::Clone() const { |
| return New( |
| mojo::Clone(filesystem_url), |
| mojo::Clone(offset), |
| mojo::Clone(length), |
| mojo::Clone(modification_time) |
| ); |
| } |
| |
| template <typename T, DEPRECATED_FileSystemFile::EnableIfSame<T>*> |
| bool DEPRECATED_FileSystemFile::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->filesystem_url, other_struct.filesystem_url)) |
| return false; |
| if (!mojo::Equals(this->offset, other_struct.offset)) |
| return false; |
| if (!mojo::Equals(this->length, other_struct.length)) |
| return false; |
| if (!mojo::Equals(this->modification_time, other_struct.modification_time)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, DEPRECATED_FileSystemFile::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.filesystem_url < rhs.filesystem_url) |
| return true; |
| if (rhs.filesystem_url < lhs.filesystem_url) |
| return false; |
| if (lhs.offset < rhs.offset) |
| return true; |
| if (rhs.offset < lhs.offset) |
| return false; |
| if (lhs.length < rhs.length) |
| return true; |
| if (rhs.length < lhs.length) |
| return false; |
| if (lhs.modification_time < rhs.modification_time) |
| return true; |
| if (rhs.modification_time < lhs.modification_time) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| FilePtr File::Clone() const { |
| return New( |
| mojo::Clone(path), |
| mojo::Clone(offset), |
| mojo::Clone(length), |
| mojo::Clone(modification_time) |
| ); |
| } |
| |
| template <typename T, File::EnableIfSame<T>*> |
| bool File::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->path, other_struct.path)) |
| return false; |
| if (!mojo::Equals(this->offset, other_struct.offset)) |
| return false; |
| if (!mojo::Equals(this->length, other_struct.length)) |
| return false; |
| if (!mojo::Equals(this->modification_time, other_struct.modification_time)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, File::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.path < rhs.path) |
| return true; |
| if (rhs.path < lhs.path) |
| return false; |
| if (lhs.offset < rhs.offset) |
| return true; |
| if (rhs.offset < lhs.offset) |
| return false; |
| if (lhs.length < rhs.length) |
| return true; |
| if (rhs.length < lhs.length) |
| return false; |
| if (lhs.modification_time < rhs.modification_time) |
| return true; |
| if (rhs.modification_time < lhs.modification_time) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| RequestBodyPtr RequestBody::Clone() const { |
| return New( |
| mojo::Clone(elements), |
| mojo::Clone(identifier), |
| mojo::Clone(contains_sensitive_info) |
| ); |
| } |
| |
| template <typename T, RequestBody::EnableIfSame<T>*> |
| bool RequestBody::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->elements, other_struct.elements)) |
| return false; |
| if (!mojo::Equals(this->identifier, other_struct.identifier)) |
| return false; |
| if (!mojo::Equals(this->contains_sensitive_info, other_struct.contains_sensitive_info)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, RequestBody::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.elements < rhs.elements) |
| return true; |
| if (rhs.elements < lhs.elements) |
| return false; |
| if (lhs.identifier < rhs.identifier) |
| return true; |
| if (rhs.identifier < lhs.identifier) |
| return false; |
| if (lhs.contains_sensitive_info < rhs.contains_sensitive_info) |
| return true; |
| if (rhs.contains_sensitive_info < lhs.contains_sensitive_info) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| HttpBodyPtr HttpBody::Clone() const { |
| return New( |
| mojo::Clone(http_content_type), |
| mojo::Clone(request_body), |
| mojo::Clone(contains_passwords) |
| ); |
| } |
| |
| template <typename T, HttpBody::EnableIfSame<T>*> |
| bool HttpBody::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->http_content_type, other_struct.http_content_type)) |
| return false; |
| if (!mojo::Equals(this->request_body, other_struct.request_body)) |
| return false; |
| if (!mojo::Equals(this->contains_passwords, other_struct.contains_passwords)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, HttpBody::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.http_content_type < rhs.http_content_type) |
| return true; |
| if (rhs.http_content_type < lhs.http_content_type) |
| return false; |
| if (lhs.request_body < rhs.request_body) |
| return true; |
| if (rhs.request_body < lhs.request_body) |
| return false; |
| if (lhs.contains_passwords < rhs.contains_passwords) |
| return true; |
| if (rhs.contains_passwords < lhs.contains_passwords) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ViewStatePtr ViewState::Clone() const { |
| return New( |
| mojo::Clone(visual_viewport_scroll_offset), |
| mojo::Clone(scroll_offset), |
| mojo::Clone(page_scale_factor), |
| mojo::Clone(scroll_anchor_selector), |
| mojo::Clone(scroll_anchor_offset), |
| mojo::Clone(scroll_anchor_simhash) |
| ); |
| } |
| |
| template <typename T, ViewState::EnableIfSame<T>*> |
| bool ViewState::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->visual_viewport_scroll_offset, other_struct.visual_viewport_scroll_offset)) |
| return false; |
| if (!mojo::Equals(this->scroll_offset, other_struct.scroll_offset)) |
| return false; |
| if (!mojo::Equals(this->page_scale_factor, other_struct.page_scale_factor)) |
| return false; |
| if (!mojo::Equals(this->scroll_anchor_selector, other_struct.scroll_anchor_selector)) |
| return false; |
| if (!mojo::Equals(this->scroll_anchor_offset, other_struct.scroll_anchor_offset)) |
| return false; |
| if (!mojo::Equals(this->scroll_anchor_simhash, other_struct.scroll_anchor_simhash)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ViewState::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.visual_viewport_scroll_offset < rhs.visual_viewport_scroll_offset) |
| return true; |
| if (rhs.visual_viewport_scroll_offset < lhs.visual_viewport_scroll_offset) |
| return false; |
| if (lhs.scroll_offset < rhs.scroll_offset) |
| return true; |
| if (rhs.scroll_offset < lhs.scroll_offset) |
| return false; |
| if (lhs.page_scale_factor < rhs.page_scale_factor) |
| return true; |
| if (rhs.page_scale_factor < lhs.page_scale_factor) |
| return false; |
| if (lhs.scroll_anchor_selector < rhs.scroll_anchor_selector) |
| return true; |
| if (rhs.scroll_anchor_selector < lhs.scroll_anchor_selector) |
| return false; |
| if (lhs.scroll_anchor_offset < rhs.scroll_anchor_offset) |
| return true; |
| if (rhs.scroll_anchor_offset < lhs.scroll_anchor_offset) |
| return false; |
| if (lhs.scroll_anchor_simhash < rhs.scroll_anchor_simhash) |
| return true; |
| if (rhs.scroll_anchor_simhash < lhs.scroll_anchor_simhash) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| FrameStatePtr FrameState::Clone() const { |
| return New( |
| mojo::Clone(url_string), |
| mojo::Clone(referrer), |
| mojo::Clone(target), |
| mojo::Clone(state_object), |
| mojo::Clone(document_state), |
| mojo::Clone(scroll_restoration_type), |
| mojo::Clone(view_state), |
| mojo::Clone(item_sequence_number), |
| mojo::Clone(document_sequence_number), |
| mojo::Clone(referrer_policy), |
| mojo::Clone(http_body), |
| mojo::Clone(children) |
| ); |
| } |
| |
| template <typename T, FrameState::EnableIfSame<T>*> |
| bool FrameState::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->url_string, other_struct.url_string)) |
| return false; |
| if (!mojo::Equals(this->referrer, other_struct.referrer)) |
| return false; |
| if (!mojo::Equals(this->target, other_struct.target)) |
| return false; |
| if (!mojo::Equals(this->state_object, other_struct.state_object)) |
| return false; |
| if (!mojo::Equals(this->document_state, other_struct.document_state)) |
| return false; |
| if (!mojo::Equals(this->scroll_restoration_type, other_struct.scroll_restoration_type)) |
| return false; |
| if (!mojo::Equals(this->view_state, other_struct.view_state)) |
| return false; |
| if (!mojo::Equals(this->item_sequence_number, other_struct.item_sequence_number)) |
| return false; |
| if (!mojo::Equals(this->document_sequence_number, other_struct.document_sequence_number)) |
| return false; |
| if (!mojo::Equals(this->referrer_policy, other_struct.referrer_policy)) |
| return false; |
| if (!mojo::Equals(this->http_body, other_struct.http_body)) |
| return false; |
| if (!mojo::Equals(this->children, other_struct.children)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, FrameState::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.url_string < rhs.url_string) |
| return true; |
| if (rhs.url_string < lhs.url_string) |
| return false; |
| if (lhs.referrer < rhs.referrer) |
| return true; |
| if (rhs.referrer < lhs.referrer) |
| return false; |
| if (lhs.target < rhs.target) |
| return true; |
| if (rhs.target < lhs.target) |
| return false; |
| if (lhs.state_object < rhs.state_object) |
| return true; |
| if (rhs.state_object < lhs.state_object) |
| return false; |
| if (lhs.document_state < rhs.document_state) |
| return true; |
| if (rhs.document_state < lhs.document_state) |
| return false; |
| if (lhs.scroll_restoration_type < rhs.scroll_restoration_type) |
| return true; |
| if (rhs.scroll_restoration_type < lhs.scroll_restoration_type) |
| return false; |
| if (lhs.view_state < rhs.view_state) |
| return true; |
| if (rhs.view_state < lhs.view_state) |
| return false; |
| if (lhs.item_sequence_number < rhs.item_sequence_number) |
| return true; |
| if (rhs.item_sequence_number < lhs.item_sequence_number) |
| return false; |
| if (lhs.document_sequence_number < rhs.document_sequence_number) |
| return true; |
| if (rhs.document_sequence_number < lhs.document_sequence_number) |
| return false; |
| if (lhs.referrer_policy < rhs.referrer_policy) |
| return true; |
| if (rhs.referrer_policy < lhs.referrer_policy) |
| return false; |
| if (lhs.http_body < rhs.http_body) |
| return true; |
| if (rhs.http_body < lhs.http_body) |
| return false; |
| if (lhs.children < rhs.children) |
| return true; |
| if (rhs.children < lhs.children) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| PageStatePtr PageState::Clone() const { |
| return New( |
| mojo::Clone(referenced_files), |
| mojo::Clone(top) |
| ); |
| } |
| |
| template <typename T, PageState::EnableIfSame<T>*> |
| bool PageState::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->referenced_files, other_struct.referenced_files)) |
| return false; |
| if (!mojo::Equals(this->top, other_struct.top)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, PageState::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.referenced_files < rhs.referenced_files) |
| return true; |
| if (rhs.referenced_files < lhs.referenced_files) |
| return false; |
| if (lhs.top < rhs.top) |
| return true; |
| if (rhs.top < lhs.top) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace mojom |
| } // namespace history |
| } // namespace content |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::DEPRECATED_FileSystemFile::DataView, |
| ::content::history::mojom::DEPRECATED_FileSystemFilePtr> { |
| static bool IsNull(const ::content::history::mojom::DEPRECATED_FileSystemFilePtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::DEPRECATED_FileSystemFilePtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::DEPRECATED_FileSystemFile::filesystem_url)& filesystem_url( |
| const ::content::history::mojom::DEPRECATED_FileSystemFilePtr& input) { |
| return input->filesystem_url; |
| } |
| |
| static decltype(::content::history::mojom::DEPRECATED_FileSystemFile::offset) offset( |
| const ::content::history::mojom::DEPRECATED_FileSystemFilePtr& input) { |
| return input->offset; |
| } |
| |
| static decltype(::content::history::mojom::DEPRECATED_FileSystemFile::length) length( |
| const ::content::history::mojom::DEPRECATED_FileSystemFilePtr& input) { |
| return input->length; |
| } |
| |
| static const decltype(::content::history::mojom::DEPRECATED_FileSystemFile::modification_time)& modification_time( |
| const ::content::history::mojom::DEPRECATED_FileSystemFilePtr& input) { |
| return input->modification_time; |
| } |
| |
| static bool Read(::content::history::mojom::DEPRECATED_FileSystemFile::DataView input, ::content::history::mojom::DEPRECATED_FileSystemFilePtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::File::DataView, |
| ::content::history::mojom::FilePtr> { |
| static bool IsNull(const ::content::history::mojom::FilePtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::FilePtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::File::path)& path( |
| const ::content::history::mojom::FilePtr& input) { |
| return input->path; |
| } |
| |
| static decltype(::content::history::mojom::File::offset) offset( |
| const ::content::history::mojom::FilePtr& input) { |
| return input->offset; |
| } |
| |
| static decltype(::content::history::mojom::File::length) length( |
| const ::content::history::mojom::FilePtr& input) { |
| return input->length; |
| } |
| |
| static const decltype(::content::history::mojom::File::modification_time)& modification_time( |
| const ::content::history::mojom::FilePtr& input) { |
| return input->modification_time; |
| } |
| |
| static bool Read(::content::history::mojom::File::DataView input, ::content::history::mojom::FilePtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::RequestBody::DataView, |
| ::content::history::mojom::RequestBodyPtr> { |
| static bool IsNull(const ::content::history::mojom::RequestBodyPtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::RequestBodyPtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::RequestBody::elements)& elements( |
| const ::content::history::mojom::RequestBodyPtr& input) { |
| return input->elements; |
| } |
| |
| static decltype(::content::history::mojom::RequestBody::identifier) identifier( |
| const ::content::history::mojom::RequestBodyPtr& input) { |
| return input->identifier; |
| } |
| |
| static decltype(::content::history::mojom::RequestBody::contains_sensitive_info) contains_sensitive_info( |
| const ::content::history::mojom::RequestBodyPtr& input) { |
| return input->contains_sensitive_info; |
| } |
| |
| static bool Read(::content::history::mojom::RequestBody::DataView input, ::content::history::mojom::RequestBodyPtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::HttpBody::DataView, |
| ::content::history::mojom::HttpBodyPtr> { |
| static bool IsNull(const ::content::history::mojom::HttpBodyPtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::HttpBodyPtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::HttpBody::http_content_type)& http_content_type( |
| const ::content::history::mojom::HttpBodyPtr& input) { |
| return input->http_content_type; |
| } |
| |
| static const decltype(::content::history::mojom::HttpBody::request_body)& request_body( |
| const ::content::history::mojom::HttpBodyPtr& input) { |
| return input->request_body; |
| } |
| |
| static decltype(::content::history::mojom::HttpBody::contains_passwords) contains_passwords( |
| const ::content::history::mojom::HttpBodyPtr& input) { |
| return input->contains_passwords; |
| } |
| |
| static bool Read(::content::history::mojom::HttpBody::DataView input, ::content::history::mojom::HttpBodyPtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::ViewState::DataView, |
| ::content::history::mojom::ViewStatePtr> { |
| static bool IsNull(const ::content::history::mojom::ViewStatePtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::ViewStatePtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::ViewState::visual_viewport_scroll_offset)& visual_viewport_scroll_offset( |
| const ::content::history::mojom::ViewStatePtr& input) { |
| return input->visual_viewport_scroll_offset; |
| } |
| |
| static const decltype(::content::history::mojom::ViewState::scroll_offset)& scroll_offset( |
| const ::content::history::mojom::ViewStatePtr& input) { |
| return input->scroll_offset; |
| } |
| |
| static decltype(::content::history::mojom::ViewState::page_scale_factor) page_scale_factor( |
| const ::content::history::mojom::ViewStatePtr& input) { |
| return input->page_scale_factor; |
| } |
| |
| static const decltype(::content::history::mojom::ViewState::scroll_anchor_selector)& scroll_anchor_selector( |
| const ::content::history::mojom::ViewStatePtr& input) { |
| return input->scroll_anchor_selector; |
| } |
| |
| static const decltype(::content::history::mojom::ViewState::scroll_anchor_offset)& scroll_anchor_offset( |
| const ::content::history::mojom::ViewStatePtr& input) { |
| return input->scroll_anchor_offset; |
| } |
| |
| static decltype(::content::history::mojom::ViewState::scroll_anchor_simhash) scroll_anchor_simhash( |
| const ::content::history::mojom::ViewStatePtr& input) { |
| return input->scroll_anchor_simhash; |
| } |
| |
| static bool Read(::content::history::mojom::ViewState::DataView input, ::content::history::mojom::ViewStatePtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::FrameState::DataView, |
| ::content::history::mojom::FrameStatePtr> { |
| static bool IsNull(const ::content::history::mojom::FrameStatePtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::FrameStatePtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::FrameState::url_string)& url_string( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->url_string; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::referrer)& referrer( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->referrer; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::target)& target( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->target; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::state_object)& state_object( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->state_object; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::document_state)& document_state( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->document_state; |
| } |
| |
| static decltype(::content::history::mojom::FrameState::scroll_restoration_type) scroll_restoration_type( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->scroll_restoration_type; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::view_state)& view_state( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->view_state; |
| } |
| |
| static decltype(::content::history::mojom::FrameState::item_sequence_number) item_sequence_number( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->item_sequence_number; |
| } |
| |
| static decltype(::content::history::mojom::FrameState::document_sequence_number) document_sequence_number( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->document_sequence_number; |
| } |
| |
| static decltype(::content::history::mojom::FrameState::referrer_policy) referrer_policy( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->referrer_policy; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::http_body)& http_body( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->http_body; |
| } |
| |
| static const decltype(::content::history::mojom::FrameState::children)& children( |
| const ::content::history::mojom::FrameStatePtr& input) { |
| return input->children; |
| } |
| |
| static bool Read(::content::history::mojom::FrameState::DataView input, ::content::history::mojom::FrameStatePtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::history::mojom::PageState::DataView, |
| ::content::history::mojom::PageStatePtr> { |
| static bool IsNull(const ::content::history::mojom::PageStatePtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::PageStatePtr* output) { output->reset(); } |
| |
| static const decltype(::content::history::mojom::PageState::referenced_files)& referenced_files( |
| const ::content::history::mojom::PageStatePtr& input) { |
| return input->referenced_files; |
| } |
| |
| static const decltype(::content::history::mojom::PageState::top)& top( |
| const ::content::history::mojom::PageStatePtr& input) { |
| return input->top; |
| } |
| |
| static bool Read(::content::history::mojom::PageState::DataView input, ::content::history::mojom::PageStatePtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT UnionTraits<::content::history::mojom::Element::DataView, |
| ::content::history::mojom::ElementPtr> { |
| static bool IsNull(const ::content::history::mojom::ElementPtr& input) { return !input; } |
| static void SetToNull(::content::history::mojom::ElementPtr* output) { output->reset(); } |
| |
| static ::content::history::mojom::Element::Tag GetTag(const ::content::history::mojom::ElementPtr& input) { |
| return input->which(); |
| } |
| |
| static const std::string& blob_uuid(const ::content::history::mojom::ElementPtr& input) { |
| return input->get_blob_uuid(); |
| } |
| |
| static const std::vector<uint8_t>& bytes(const ::content::history::mojom::ElementPtr& input) { |
| return input->get_bytes(); |
| } |
| |
| static const ::content::history::mojom::FilePtr& file(const ::content::history::mojom::ElementPtr& input) { |
| return input->get_file(); |
| } |
| |
| static const ::content::history::mojom::DEPRECATED_FileSystemFilePtr& DEPRECATED_file_system_file(const ::content::history::mojom::ElementPtr& input) { |
| return input->get_DEPRECATED_file_system_file(); |
| } |
| |
| static bool Read(::content::history::mojom::Element::DataView input, ::content::history::mojom::ElementPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // CONTENT_COMMON_PAGE_STATE_MOJOM_H_
|
|
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogMjE2MiwgImJlZ2luIjogMjE1NSwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5FbGVtZW50In19
|
| LCB7ImVuZCI6IDQzOTEsICJiZWdpbiI6IDQzNzksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRWxlbWVudC5ibG9iX3V1aWQi
|
| fX0sIHsiZW5kIjogNDUyNywgImJlZ2luIjogNDUxNCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5FbGVtZW50LmJsb2JfdXVp
|
| ZCJ9fSwgeyJlbmQiOiA0NjkzLCAiYmVnaW4iOiA0NjgwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6
|
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt
|
| b2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkVsZW1lbnQuYmxvYl91
|
| dWlkIn19LCB7ImVuZCI6IDQ4MDYsICJiZWdpbiI6IDQ3OTgsICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz
|
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog
|
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRWxlbWVudC5ieXRl
|
| cyJ9fSwgeyJlbmQiOiA0OTM5LCAiYmVnaW4iOiA0OTMwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6
|
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt
|
| b2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkVsZW1lbnQuYnl0ZXMi
|
| fX0sIHsiZW5kIjogNTA4OSwgImJlZ2luIjogNTA4MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5FbGVtZW50LmJ5dGVzIn19
|
| LCB7ImVuZCI6IDUyMDUsICJiZWdpbiI6IDUxOTgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l
|
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo
|
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t
|
| IiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRWxlbWVudC5maWxlIn19LCB7
|
| ImVuZCI6IDUzMTIsICJiZWdpbiI6IDUzMDUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRWxlbWVudC5maWxlIn19LCB7ImVu
|
| ZCI6IDU0NjgsICJiZWdpbiI6IDU0NjAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp
|
| Z25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRWxlbWVudC5maWxlIn19LCB7ImVuZCI6
|
| IDU2MDksICJiZWdpbiI6IDU1NzksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRWxlbWVudC5ERVBSRUNBVEVEX2ZpbGVfc3lz
|
| dGVtX2ZpbGUifX0sIHsiZW5kIjogNTgxNiwgImJlZ2luIjogNTc4NSwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5FbGVtZW50
|
| LkRFUFJFQ0FURURfZmlsZV9zeXN0ZW1fZmlsZSJ9fSwgeyJlbmQiOiA2MDU0LCAiYmVnaW4iOiA2
|
| MDIzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5o
|
| aXN0b3J5Lm1vam9tLkVsZW1lbnQuREVQUkVDQVRFRF9maWxlX3N5c3RlbV9maWxlIn19LCB7ImVu
|
| ZCI6IDcxMzksICJiZWdpbiI6IDcxMTQsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp
|
| Z25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uREVQUkVDQVRFRF9GaWxlU3lzdGVtRmls
|
| ZSJ9fSwgeyJlbmQiOiAxMTAyMiwgImJlZ2luIjogMTEwMDgsICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz
|
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog
|
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uREVQUkVDQVRFRF9G
|
| aWxlU3lzdGVtRmlsZS5maWxlc3lzdGVtX3VybCJ9fSwgeyJlbmQiOiAxMTExOSwgImJlZ2luIjog
|
| MTExMTMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50
|
| Lmhpc3RvcnkubW9qb20uREVQUkVDQVRFRF9GaWxlU3lzdGVtRmlsZS5vZmZzZXQifX0sIHsiZW5k
|
| IjogMTEyMTYsICJiZWdpbiI6IDExMjEwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkRFUFJFQ0FURURfRmlsZVN5c3RlbUZp
|
| bGUubGVuZ3RoIn19LCB7ImVuZCI6IDExMzM3LCAiYmVnaW4iOiAxMTMyMCwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog
|
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5ERVBS
|
| RUNBVEVEX0ZpbGVTeXN0ZW1GaWxlLm1vZGlmaWNhdGlvbl90aW1lIn19LCB7ImVuZCI6IDEyMzE5
|
| LCAiYmVnaW4iOiAxMjMxNSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl
|
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl
|
| IjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5GaWxlIn19LCB7ImVuZCI6IDE1Njg4LCAiYmVnaW4i
|
| OiAxNTY4NCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRl
|
| bnQuaGlzdG9yeS5tb2pvbS5GaWxlLnBhdGgifX0sIHsiZW5kIjogMTU3NjQsICJiZWdpbiI6IDE1
|
| NzU4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5o
|
| aXN0b3J5Lm1vam9tLkZpbGUub2Zmc2V0In19LCB7ImVuZCI6IDE1ODQwLCAiYmVnaW4iOiAxNTgz
|
| NCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv
|
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlz
|
| dG9yeS5tb2pvbS5GaWxlLmxlbmd0aCJ9fSwgeyJlbmQiOiAxNTk0MCwgImJlZ2luIjogMTU5MjMs
|
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l
|
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p
|
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3Rv
|
| cnkubW9qb20uRmlsZS5tb2RpZmljYXRpb25fdGltZSJ9fSwgeyJlbmQiOiAxNjg1MiwgImJlZ2lu
|
| IjogMTY4NDEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250
|
| ZW50Lmhpc3RvcnkubW9qb20uUmVxdWVzdEJvZHkifX0sIHsiZW5kIjogMjAzOTIsICJiZWdpbiI6
|
| IDIwMzg0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y
|
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t
|
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVu
|
| dC5oaXN0b3J5Lm1vam9tLlJlcXVlc3RCb2R5LmVsZW1lbnRzIn19LCB7ImVuZCI6IDIwNDgyLCAi
|
| YmVnaW4iOiAyMDQ3MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog
|
| ImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5SZXF1ZXN0Qm9keS5pZGVudGlmaWVyIn19LCB7ImVuZCI6
|
| IDIwNTk1LCAiYmVnaW4iOiAyMDU3MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5SZXF1ZXN0Qm9keS5jb250YWluc19zZW5z
|
| aXRpdmVfaW5mbyJ9fSwgeyJlbmQiOiAyMTU3MCwgImJlZ2luIjogMjE1NjIsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uSHR0
|
| cEJvZHkifX0sIHsiZW5kIjogMjUwOTAsICJiZWdpbiI6IDI1MDczLCAiZWRnZSI6ICIlL2t5dGhl
|
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv
|
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn
|
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkh0dHBCb2R5
|
| Lmh0dHBfY29udGVudF90eXBlIn19LCB7ImVuZCI6IDI1MTg4LCAiYmVnaW4iOiAyNTE3NiwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5t
|
| b2pvbS5IdHRwQm9keS5yZXF1ZXN0X2JvZHkifX0sIHsiZW5kIjogMjUyODgsICJiZWdpbiI6IDI1
|
| MjcwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5o
|
| aXN0b3J5Lm1vam9tLkh0dHBCb2R5LmNvbnRhaW5zX3Bhc3N3b3JkcyJ9fSwgeyJlbmQiOiAyNjI1
|
| MCwgImJlZ2luIjogMjYyNDEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw
|
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds
|
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy
|
| ZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uVmlld1N0YXRlIn19LCB7ImVuZCI6IDMwMTA4LCAi
|
| YmVnaW4iOiAzMDA3OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog
|
| ImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5WaWV3U3RhdGUudmlzdWFsX3ZpZXdwb3J0X3Njcm9sbF9v
|
| ZmZzZXQifX0sIHsiZW5kIjogMzAyMDUsICJiZWdpbiI6IDMwMTkyLCAiZWRnZSI6ICIlL2t5dGhl
|
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv
|
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn
|
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLlZpZXdTdGF0
|
| ZS5zY3JvbGxfb2Zmc2V0In19LCB7ImVuZCI6IDMwMzA2LCAiYmVnaW4iOiAzMDI4OSwgImVkZ2Ui
|
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu
|
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi
|
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pv
|
| bS5WaWV3U3RhdGUucGFnZV9zY2FsZV9mYWN0b3IifX0sIHsiZW5kIjogMzA0NDEsICJiZWdpbiI6
|
| IDMwNDE5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y
|
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t
|
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVu
|
| dC5oaXN0b3J5Lm1vam9tLlZpZXdTdGF0ZS5zY3JvbGxfYW5jaG9yX3NlbGVjdG9yIn19LCB7ImVu
|
| ZCI6IDMwNTY5LCAiYmVnaW4iOiAzMDU0OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5WaWV3U3RhdGUuc2Nyb2xsX2FuY2hv
|
| cl9vZmZzZXQifX0sIHsiZW5kIjogMzA2ODAsICJiZWdpbiI6IDMwNjU5LCAiZWRnZSI6ICIlL2t5
|
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLlZpZXdT
|
| dGF0ZS5zY3JvbGxfYW5jaG9yX3NpbWhhc2gifX0sIHsiZW5kIjogMzE2MTAsICJiZWdpbiI6IDMx
|
| NjAwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5o
|
| aXN0b3J5Lm1vam9tLkZyYW1lU3RhdGUifX0sIHsiZW5kIjogMzU2MTYsICJiZWdpbiI6IDM1NjA2
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0
|
| b3J5Lm1vam9tLkZyYW1lU3RhdGUudXJsX3N0cmluZyJ9fSwgeyJlbmQiOiAzNTcyNCwgImJlZ2lu
|
| IjogMzU3MTYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250
|
| ZW50Lmhpc3RvcnkubW9qb20uRnJhbWVTdGF0ZS5yZWZlcnJlciJ9fSwgeyJlbmQiOiAzNTgyOCwg
|
| ImJlZ2luIjogMzU4MjIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6
|
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv
|
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6
|
| ICJjb250ZW50Lmhpc3RvcnkubW9qb20uRnJhbWVTdGF0ZS50YXJnZXQifX0sIHsiZW5kIjogMzU5
|
| NDQsICJiZWdpbiI6IDM1OTMyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5
|
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n
|
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1
|
| cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkZyYW1lU3RhdGUuc3RhdGVfb2JqZWN0In19LCB7
|
| ImVuZCI6IDM2MDc3LCAiYmVnaW4iOiAzNjA2MywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5GcmFtZVN0YXRlLmRvY3VtZW50
|
| X3N0YXRlIn19LCB7ImVuZCI6IDM2MjA2LCAiYmVnaW4iOiAzNjE4MywgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5tb2pvbS5GcmFtZVN0
|
| YXRlLnNjcm9sbF9yZXN0b3JhdGlvbl90eXBlIn19LCB7ImVuZCI6IDM2MzAwLCAiYmVnaW4iOiAz
|
| NjI5MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQu
|
| aGlzdG9yeS5tb2pvbS5GcmFtZVN0YXRlLnZpZXdfc3RhdGUifX0sIHsiZW5kIjogMzY0MDksICJi
|
| ZWdpbiI6IDM2Mzg5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi
|
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy
|
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi
|
| Y29udGVudC5oaXN0b3J5Lm1vam9tLkZyYW1lU3RhdGUuaXRlbV9zZXF1ZW5jZV9udW1iZXIifX0s
|
| IHsiZW5kIjogMzY1MjYsICJiZWdpbiI6IDM2NTAyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkZyYW1lU3RhdGUuZG9jdW1l
|
| bnRfc2VxdWVuY2VfbnVtYmVyIn19LCB7ImVuZCI6IDM2NjUwLCAiYmVnaW4iOiAzNjYzNSwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQuaGlzdG9yeS5t
|
| b2pvbS5GcmFtZVN0YXRlLnJlZmVycmVyX3BvbGljeSJ9fSwgeyJlbmQiOiAzNjc0MSwgImJlZ2lu
|
| IjogMzY3MzIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250
|
| ZW50Lmhpc3RvcnkubW9qb20uRnJhbWVTdGF0ZS5odHRwX2JvZHkifX0sIHsiZW5kIjogMzY4NDUs
|
| ICJiZWdpbiI6IDM2ODM3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi
|
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi
|
| OiAiY29udGVudC5oaXN0b3J5Lm1vam9tLkZyYW1lU3RhdGUuY2hpbGRyZW4ifX0sIHsiZW5kIjog
|
| Mzc4MTcsICJiZWdpbiI6IDM3ODA4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLlBhZ2VTdGF0ZSJ9fSwgeyJlbmQiOiA0MTM0
|
| MywgImJlZ2luIjogNDEzMjcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw
|
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds
|
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy
|
| ZSI6ICJjb250ZW50Lmhpc3RvcnkubW9qb20uUGFnZVN0YXRlLnJlZmVyZW5jZWRfZmlsZXMifX0s
|
| IHsiZW5kIjogNDE0MjMsICJiZWdpbiI6IDQxNDIwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAiY29udGVudC5oaXN0b3J5Lm1vam9tLlBhZ2VTdGF0ZS50b3AifX1d
|
| LCAidHlwZSI6ICJreXRoZTAifQ==
|
| */ |