| // 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_RENDERER_MOJOM_H_ |
| #define CONTENT_COMMON_RENDERER_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/renderer.mojom-shared.h" |
| #include "content/common/renderer.mojom-forward.h" |
| #include "content/common/document_scoped_interface_bundle.mojom.h" |
| #include "content/common/native_types.mojom.h" |
| #include "ipc/constants.mojom.h" |
| #include "mojo/public/mojom/base/time.mojom.h" |
| #include "mojo/public/mojom/base/unguessable_token.mojom.h" |
| #include "services/network/public/mojom/network_types.mojom.h" |
| #include "services/service_manager/public/mojom/service.mojom.h" |
| #include "third_party/blink/public/mojom/renderer_preferences.mojom.h" |
| #include "third_party/blink/public/mojom/service_worker/embedded_worker.mojom.h" |
| #include "third_party/blink/public/mojom/user_agent/user_agent_metadata.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 mojom { |
| |
| class RendererProxy; |
| |
| template <typename ImplRefTraits> |
| class RendererStub; |
| |
| class RendererRequestValidator; |
| |
| |
| // @generated_from: content.mojom.Renderer |
| class CONTENT_EXPORT Renderer |
| : public RendererInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = RendererInterfaceBase; |
| using Proxy_ = RendererProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = RendererStub<ImplRefTraits>; |
| |
| using RequestValidator_ = RendererRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kCreateEmbedderRendererServiceMinVersion = 0, |
| kCreateViewMinVersion = 0, |
| kCreateFrameMinVersion = 0, |
| kCreateFrameProxyMinVersion = 0, |
| kSetUpEmbeddedWorkerChannelForServiceWorkerMinVersion = 0, |
| kOnNetworkConnectionChangedMinVersion = 0, |
| kOnNetworkQualityChangedMinVersion = 0, |
| kSetWebKitSharedTimersSuspendedMinVersion = 0, |
| kSetUserAgentMinVersion = 0, |
| kSetUserAgentMetadataMinVersion = 0, |
| kUpdateScrollbarThemeMinVersion = 0, |
| kOnSystemColorsChangedMinVersion = 0, |
| kPurgePluginListCacheMinVersion = 0, |
| kSetProcessStateMinVersion = 0, |
| kSetSchedulerKeepActiveMinVersion = 0, |
| kSetIsLockedToSiteMinVersion = 0, |
| kEnableV8LowMemoryModeMinVersion = 0, |
| }; |
| virtual ~Renderer() {} |
| |
| |
| // @generated_from: content.mojom.Renderer.CreateEmbedderRendererService |
| virtual void CreateEmbedderRendererService(::service_manager::mojom::ServiceRequest service_request) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.CreateView |
| virtual void CreateView(CreateViewParamsPtr params) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.CreateFrame |
| virtual void CreateFrame(CreateFrameParamsPtr params) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.CreateFrameProxy |
| virtual void CreateFrameProxy(int32_t routing_id, int32_t render_view_routing_id, int32_t opener_routing_id, int32_t parent_routing_id, const content::FrameReplicationState& replication_state, const base::UnguessableToken& devtools_frame_token) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetUpEmbeddedWorkerChannelForServiceWorker |
| virtual void SetUpEmbeddedWorkerChannelForServiceWorker(::blink::mojom::EmbeddedWorkerInstanceClientRequest client_request) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.OnNetworkConnectionChanged |
| virtual void OnNetworkConnectionChanged(net::NetworkChangeNotifier::ConnectionType connection_type, double max_bandwidth_mbps) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.OnNetworkQualityChanged |
| virtual void OnNetworkQualityChanged(net::EffectiveConnectionType effective_connection_type, base::TimeDelta http_rtt, base::TimeDelta transport_rtt, double bandwidth_kbps) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetWebKitSharedTimersSuspended |
| virtual void SetWebKitSharedTimersSuspended(bool suspend) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetUserAgent |
| virtual void SetUserAgent(const std::string& user_agent) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetUserAgentMetadata |
| virtual void SetUserAgentMetadata(const blink::UserAgentMetadata& metadata) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.UpdateScrollbarTheme |
| virtual void UpdateScrollbarTheme(UpdateScrollbarThemeParamsPtr params) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.OnSystemColorsChanged |
| virtual void OnSystemColorsChanged(int32_t aqua_color_variant, const std::string& highlight_text_color, const std::string& highlight_color) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.PurgePluginListCache |
| virtual void PurgePluginListCache(bool reload_pages) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetProcessState |
| virtual void SetProcessState(RenderProcessState process_state) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetSchedulerKeepActive |
| virtual void SetSchedulerKeepActive(bool keep_active) = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.SetIsLockedToSite |
| virtual void SetIsLockedToSite() = 0; |
| |
| |
| // @generated_from: content.mojom.Renderer.EnableV8LowMemoryMode |
| virtual void EnableV8LowMemoryMode() = 0; |
| }; |
| |
| class CONTENT_EXPORT RendererProxy |
| : public Renderer { |
| public: |
| using InterfaceType = Renderer; |
| |
| explicit RendererProxy(mojo::MessageReceiverWithResponder* receiver); |
| void CreateEmbedderRendererService(::service_manager::mojom::ServiceRequest service_request) final; |
| void CreateView(CreateViewParamsPtr params) final; |
| void CreateFrame(CreateFrameParamsPtr params) final; |
| void CreateFrameProxy(int32_t routing_id, int32_t render_view_routing_id, int32_t opener_routing_id, int32_t parent_routing_id, const content::FrameReplicationState& replication_state, const base::UnguessableToken& devtools_frame_token) final; |
| void SetUpEmbeddedWorkerChannelForServiceWorker(::blink::mojom::EmbeddedWorkerInstanceClientRequest client_request) final; |
| void OnNetworkConnectionChanged(net::NetworkChangeNotifier::ConnectionType connection_type, double max_bandwidth_mbps) final; |
| void OnNetworkQualityChanged(net::EffectiveConnectionType effective_connection_type, base::TimeDelta http_rtt, base::TimeDelta transport_rtt, double bandwidth_kbps) final; |
| void SetWebKitSharedTimersSuspended(bool suspend) final; |
| void SetUserAgent(const std::string& user_agent) final; |
| void SetUserAgentMetadata(const blink::UserAgentMetadata& metadata) final; |
| void UpdateScrollbarTheme(UpdateScrollbarThemeParamsPtr params) final; |
| void OnSystemColorsChanged(int32_t aqua_color_variant, const std::string& highlight_text_color, const std::string& highlight_color) final; |
| void PurgePluginListCache(bool reload_pages) final; |
| void SetProcessState(RenderProcessState process_state) final; |
| void SetSchedulerKeepActive(bool keep_active) final; |
| void SetIsLockedToSite() final; |
| void EnableV8LowMemoryMode() final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class CONTENT_EXPORT RendererStubDispatch { |
| public: |
| static bool Accept(Renderer* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| Renderer* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<Renderer>> |
| class RendererStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| RendererStub() {} |
| ~RendererStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return RendererStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return RendererStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class CONTENT_EXPORT RendererRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| |
| // @generated_from: content.mojom.CreateFrameWidgetParams |
| class CONTENT_EXPORT CreateFrameWidgetParams { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CreateFrameWidgetParams, T>::value>; |
| using DataView = CreateFrameWidgetParamsDataView; |
| using Data_ = internal::CreateFrameWidgetParams_Data; |
| |
| template <typename... Args> |
| static CreateFrameWidgetParamsPtr New(Args&&... args) { |
| return CreateFrameWidgetParamsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CreateFrameWidgetParamsPtr From(const U& u) { |
| return mojo::TypeConverter<CreateFrameWidgetParamsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CreateFrameWidgetParams>::Convert(*this); |
| } |
| |
| |
| CreateFrameWidgetParams(); |
| |
| CreateFrameWidgetParams( |
| int32_t routing_id, |
| bool hidden); |
| |
| ~CreateFrameWidgetParams(); |
| |
| // 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 = CreateFrameWidgetParamsPtr> |
| CreateFrameWidgetParamsPtr 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, CreateFrameWidgetParams::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CreateFrameWidgetParams::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CreateFrameWidgetParams::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::CreateFrameWidgetParams_UnserializedMessageContext< |
| UserType, CreateFrameWidgetParams::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<CreateFrameWidgetParams::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 CreateFrameWidgetParams::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::CreateFrameWidgetParams_UnserializedMessageContext< |
| UserType, CreateFrameWidgetParams::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CreateFrameWidgetParams::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.mojom.CreateFrameWidgetParams.routing_id |
| int32_t routing_id; |
| |
| // @generated_from: content.mojom.CreateFrameWidgetParams.hidden |
| bool hidden; |
| |
| 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, CreateFrameWidgetParams::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CreateFrameWidgetParams::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CreateFrameWidgetParams::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CreateFrameWidgetParams::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: content.mojom.CreateViewParams |
| class CONTENT_EXPORT CreateViewParams { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CreateViewParams, T>::value>; |
| using DataView = CreateViewParamsDataView; |
| using Data_ = internal::CreateViewParams_Data; |
| |
| template <typename... Args> |
| static CreateViewParamsPtr New(Args&&... args) { |
| return CreateViewParamsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CreateViewParamsPtr From(const U& u) { |
| return mojo::TypeConverter<CreateViewParamsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CreateViewParams>::Convert(*this); |
| } |
| |
| |
| CreateViewParams(); |
| |
| CreateViewParams( |
| ::blink::mojom::RendererPreferencesPtr renderer_preferences, |
| const content::WebPreferences& web_preferences, |
| int32_t view_id, |
| int32_t main_frame_routing_id, |
| ::content::mojom::DocumentScopedInterfaceBundlePtr main_frame_interface_bundle, |
| int32_t main_frame_widget_routing_id, |
| const std::string& session_storage_namespace_id, |
| int32_t opener_frame_route_id, |
| const content::FrameReplicationState& replicated_frame_state, |
| const base::UnguessableToken& devtools_main_frame_token, |
| int32_t proxy_routing_id, |
| bool hidden, |
| bool never_visible, |
| bool window_was_created_with_opener, |
| bool has_committed_real_load, |
| const content::VisualProperties& visual_properties, |
| bool renderer_wide_named_frame_lookup, |
| bool inside_portal); |
| |
| ~CreateViewParams(); |
| |
| // 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 = CreateViewParamsPtr> |
| CreateViewParamsPtr 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, CreateViewParams::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CreateViewParams::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CreateViewParams::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::CreateViewParams_UnserializedMessageContext< |
| UserType, CreateViewParams::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<CreateViewParams::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 CreateViewParams::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::CreateViewParams_UnserializedMessageContext< |
| UserType, CreateViewParams::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CreateViewParams::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.mojom.CreateViewParams.renderer_preferences |
| ::blink::mojom::RendererPreferencesPtr renderer_preferences; |
| |
| // @generated_from: content.mojom.CreateViewParams.web_preferences |
| content::WebPreferences web_preferences; |
| |
| // @generated_from: content.mojom.CreateViewParams.view_id |
| int32_t view_id; |
| |
| // @generated_from: content.mojom.CreateViewParams.main_frame_routing_id |
| int32_t main_frame_routing_id; |
| |
| // @generated_from: content.mojom.CreateViewParams.main_frame_interface_bundle |
| ::content::mojom::DocumentScopedInterfaceBundlePtr main_frame_interface_bundle; |
| |
| // @generated_from: content.mojom.CreateViewParams.main_frame_widget_routing_id |
| int32_t main_frame_widget_routing_id; |
| |
| // @generated_from: content.mojom.CreateViewParams.session_storage_namespace_id |
| std::string session_storage_namespace_id; |
| |
| // @generated_from: content.mojom.CreateViewParams.opener_frame_route_id |
| int32_t opener_frame_route_id; |
| |
| // @generated_from: content.mojom.CreateViewParams.replicated_frame_state |
| content::FrameReplicationState replicated_frame_state; |
| |
| // @generated_from: content.mojom.CreateViewParams.devtools_main_frame_token |
| base::UnguessableToken devtools_main_frame_token; |
| |
| // @generated_from: content.mojom.CreateViewParams.proxy_routing_id |
| int32_t proxy_routing_id; |
| |
| // @generated_from: content.mojom.CreateViewParams.hidden |
| bool hidden; |
| |
| // @generated_from: content.mojom.CreateViewParams.never_visible |
| bool never_visible; |
| |
| // @generated_from: content.mojom.CreateViewParams.window_was_created_with_opener |
| bool window_was_created_with_opener; |
| |
| // @generated_from: content.mojom.CreateViewParams.has_committed_real_load |
| bool has_committed_real_load; |
| |
| // @generated_from: content.mojom.CreateViewParams.visual_properties |
| content::VisualProperties visual_properties; |
| |
| // @generated_from: content.mojom.CreateViewParams.renderer_wide_named_frame_lookup |
| bool renderer_wide_named_frame_lookup; |
| |
| // @generated_from: content.mojom.CreateViewParams.inside_portal |
| bool inside_portal; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(CreateViewParams); |
| }; |
| |
| // 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, CreateViewParams::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CreateViewParams::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CreateViewParams::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CreateViewParams::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: content.mojom.CreateFrameParams |
| class CONTENT_EXPORT CreateFrameParams { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CreateFrameParams, T>::value>; |
| using DataView = CreateFrameParamsDataView; |
| using Data_ = internal::CreateFrameParams_Data; |
| |
| template <typename... Args> |
| static CreateFrameParamsPtr New(Args&&... args) { |
| return CreateFrameParamsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CreateFrameParamsPtr From(const U& u) { |
| return mojo::TypeConverter<CreateFrameParamsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CreateFrameParams>::Convert(*this); |
| } |
| |
| |
| CreateFrameParams(); |
| |
| CreateFrameParams( |
| int32_t routing_id, |
| int32_t previous_routing_id, |
| int32_t opener_routing_id, |
| int32_t parent_routing_id, |
| int32_t previous_sibling_routing_id, |
| ::content::mojom::DocumentScopedInterfaceBundlePtr interface_bundle, |
| const content::FrameReplicationState& replication_state, |
| const base::UnguessableToken& devtools_frame_token, |
| const content::FrameOwnerProperties& frame_owner_properties, |
| CreateFrameWidgetParamsPtr widget_params, |
| bool has_committed_real_load); |
| |
| ~CreateFrameParams(); |
| |
| // 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 = CreateFrameParamsPtr> |
| CreateFrameParamsPtr 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, CreateFrameParams::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CreateFrameParams::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CreateFrameParams::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::CreateFrameParams_UnserializedMessageContext< |
| UserType, CreateFrameParams::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<CreateFrameParams::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 CreateFrameParams::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::CreateFrameParams_UnserializedMessageContext< |
| UserType, CreateFrameParams::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CreateFrameParams::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.mojom.CreateFrameParams.routing_id |
| int32_t routing_id; |
| |
| // @generated_from: content.mojom.CreateFrameParams.previous_routing_id |
| int32_t previous_routing_id; |
| |
| // @generated_from: content.mojom.CreateFrameParams.opener_routing_id |
| int32_t opener_routing_id; |
| |
| // @generated_from: content.mojom.CreateFrameParams.parent_routing_id |
| int32_t parent_routing_id; |
| |
| // @generated_from: content.mojom.CreateFrameParams.previous_sibling_routing_id |
| int32_t previous_sibling_routing_id; |
| |
| // @generated_from: content.mojom.CreateFrameParams.interface_bundle |
| ::content::mojom::DocumentScopedInterfaceBundlePtr interface_bundle; |
| |
| // @generated_from: content.mojom.CreateFrameParams.replication_state |
| content::FrameReplicationState replication_state; |
| |
| // @generated_from: content.mojom.CreateFrameParams.devtools_frame_token |
| base::UnguessableToken devtools_frame_token; |
| |
| // @generated_from: content.mojom.CreateFrameParams.frame_owner_properties |
| content::FrameOwnerProperties frame_owner_properties; |
| |
| // @generated_from: content.mojom.CreateFrameParams.widget_params |
| CreateFrameWidgetParamsPtr widget_params; |
| |
| // @generated_from: content.mojom.CreateFrameParams.has_committed_real_load |
| bool has_committed_real_load; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(CreateFrameParams); |
| }; |
| |
| // 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, CreateFrameParams::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CreateFrameParams::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CreateFrameParams::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CreateFrameParams::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams |
| class CONTENT_EXPORT UpdateScrollbarThemeParams { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<UpdateScrollbarThemeParams, T>::value>; |
| using DataView = UpdateScrollbarThemeParamsDataView; |
| using Data_ = internal::UpdateScrollbarThemeParams_Data; |
| |
| template <typename... Args> |
| static UpdateScrollbarThemeParamsPtr New(Args&&... args) { |
| return UpdateScrollbarThemeParamsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static UpdateScrollbarThemeParamsPtr From(const U& u) { |
| return mojo::TypeConverter<UpdateScrollbarThemeParamsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, UpdateScrollbarThemeParams>::Convert(*this); |
| } |
| |
| |
| UpdateScrollbarThemeParams(); |
| |
| UpdateScrollbarThemeParams( |
| float initial_button_delay, |
| float autoscroll_button_delay, |
| bool jump_on_track_click, |
| ::content::mojom::ScrollerStyle preferred_scroller_style, |
| bool redraw, |
| ::content::mojom::ScrollbarButtonsPlacement button_placement, |
| bool scroll_view_rubber_banding); |
| |
| ~UpdateScrollbarThemeParams(); |
| |
| // 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 = UpdateScrollbarThemeParamsPtr> |
| UpdateScrollbarThemeParamsPtr 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, UpdateScrollbarThemeParams::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| size_t Hash(size_t seed) const; |
| |
| template <typename UserType> |
| static std::vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| UpdateScrollbarThemeParams::DataView, std::vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| UpdateScrollbarThemeParams::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::UpdateScrollbarThemeParams_UnserializedMessageContext< |
| UserType, UpdateScrollbarThemeParams::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<UpdateScrollbarThemeParams::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 UpdateScrollbarThemeParams::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::UpdateScrollbarThemeParams_UnserializedMessageContext< |
| UserType, UpdateScrollbarThemeParams::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<UpdateScrollbarThemeParams::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.initial_button_delay |
| float initial_button_delay; |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.autoscroll_button_delay |
| float autoscroll_button_delay; |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.jump_on_track_click |
| bool jump_on_track_click; |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.preferred_scroller_style |
| ::content::mojom::ScrollerStyle preferred_scroller_style; |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.redraw |
| bool redraw; |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.button_placement |
| ::content::mojom::ScrollbarButtonsPlacement button_placement; |
| |
| // @generated_from: content.mojom.UpdateScrollbarThemeParams.scroll_view_rubber_banding |
| bool scroll_view_rubber_banding; |
| |
| 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, UpdateScrollbarThemeParams::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, UpdateScrollbarThemeParams::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, UpdateScrollbarThemeParams::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, UpdateScrollbarThemeParams::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| CreateViewParamsPtr CreateViewParams::Clone() const { |
| return New( |
| mojo::Clone(renderer_preferences), |
| mojo::Clone(web_preferences), |
| mojo::Clone(view_id), |
| mojo::Clone(main_frame_routing_id), |
| mojo::Clone(main_frame_interface_bundle), |
| mojo::Clone(main_frame_widget_routing_id), |
| mojo::Clone(session_storage_namespace_id), |
| mojo::Clone(opener_frame_route_id), |
| mojo::Clone(replicated_frame_state), |
| mojo::Clone(devtools_main_frame_token), |
| mojo::Clone(proxy_routing_id), |
| mojo::Clone(hidden), |
| mojo::Clone(never_visible), |
| mojo::Clone(window_was_created_with_opener), |
| mojo::Clone(has_committed_real_load), |
| mojo::Clone(visual_properties), |
| mojo::Clone(renderer_wide_named_frame_lookup), |
| mojo::Clone(inside_portal) |
| ); |
| } |
| |
| template <typename T, CreateViewParams::EnableIfSame<T>*> |
| bool CreateViewParams::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->renderer_preferences, other_struct.renderer_preferences)) |
| return false; |
| if (!mojo::Equals(this->web_preferences, other_struct.web_preferences)) |
| return false; |
| if (!mojo::Equals(this->view_id, other_struct.view_id)) |
| return false; |
| if (!mojo::Equals(this->main_frame_routing_id, other_struct.main_frame_routing_id)) |
| return false; |
| if (!mojo::Equals(this->main_frame_interface_bundle, other_struct.main_frame_interface_bundle)) |
| return false; |
| if (!mojo::Equals(this->main_frame_widget_routing_id, other_struct.main_frame_widget_routing_id)) |
| return false; |
| if (!mojo::Equals(this->session_storage_namespace_id, other_struct.session_storage_namespace_id)) |
| return false; |
| if (!mojo::Equals(this->opener_frame_route_id, other_struct.opener_frame_route_id)) |
| return false; |
| if (!mojo::Equals(this->replicated_frame_state, other_struct.replicated_frame_state)) |
| return false; |
| if (!mojo::Equals(this->devtools_main_frame_token, other_struct.devtools_main_frame_token)) |
| return false; |
| if (!mojo::Equals(this->proxy_routing_id, other_struct.proxy_routing_id)) |
| return false; |
| if (!mojo::Equals(this->hidden, other_struct.hidden)) |
| return false; |
| if (!mojo::Equals(this->never_visible, other_struct.never_visible)) |
| return false; |
| if (!mojo::Equals(this->window_was_created_with_opener, other_struct.window_was_created_with_opener)) |
| return false; |
| if (!mojo::Equals(this->has_committed_real_load, other_struct.has_committed_real_load)) |
| return false; |
| if (!mojo::Equals(this->visual_properties, other_struct.visual_properties)) |
| return false; |
| if (!mojo::Equals(this->renderer_wide_named_frame_lookup, other_struct.renderer_wide_named_frame_lookup)) |
| return false; |
| if (!mojo::Equals(this->inside_portal, other_struct.inside_portal)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CreateViewParams::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.renderer_preferences < rhs.renderer_preferences) |
| return true; |
| if (rhs.renderer_preferences < lhs.renderer_preferences) |
| return false; |
| if (lhs.web_preferences < rhs.web_preferences) |
| return true; |
| if (rhs.web_preferences < lhs.web_preferences) |
| return false; |
| if (lhs.view_id < rhs.view_id) |
| return true; |
| if (rhs.view_id < lhs.view_id) |
| return false; |
| if (lhs.main_frame_routing_id < rhs.main_frame_routing_id) |
| return true; |
| if (rhs.main_frame_routing_id < lhs.main_frame_routing_id) |
| return false; |
| if (lhs.main_frame_interface_bundle < rhs.main_frame_interface_bundle) |
| return true; |
| if (rhs.main_frame_interface_bundle < lhs.main_frame_interface_bundle) |
| return false; |
| if (lhs.main_frame_widget_routing_id < rhs.main_frame_widget_routing_id) |
| return true; |
| if (rhs.main_frame_widget_routing_id < lhs.main_frame_widget_routing_id) |
| return false; |
| if (lhs.session_storage_namespace_id < rhs.session_storage_namespace_id) |
| return true; |
| if (rhs.session_storage_namespace_id < lhs.session_storage_namespace_id) |
| return false; |
| if (lhs.opener_frame_route_id < rhs.opener_frame_route_id) |
| return true; |
| if (rhs.opener_frame_route_id < lhs.opener_frame_route_id) |
| return false; |
| if (lhs.replicated_frame_state < rhs.replicated_frame_state) |
| return true; |
| if (rhs.replicated_frame_state < lhs.replicated_frame_state) |
| return false; |
| if (lhs.devtools_main_frame_token < rhs.devtools_main_frame_token) |
| return true; |
| if (rhs.devtools_main_frame_token < lhs.devtools_main_frame_token) |
| return false; |
| if (lhs.proxy_routing_id < rhs.proxy_routing_id) |
| return true; |
| if (rhs.proxy_routing_id < lhs.proxy_routing_id) |
| return false; |
| if (lhs.hidden < rhs.hidden) |
| return true; |
| if (rhs.hidden < lhs.hidden) |
| return false; |
| if (lhs.never_visible < rhs.never_visible) |
| return true; |
| if (rhs.never_visible < lhs.never_visible) |
| return false; |
| if (lhs.window_was_created_with_opener < rhs.window_was_created_with_opener) |
| return true; |
| if (rhs.window_was_created_with_opener < lhs.window_was_created_with_opener) |
| return false; |
| if (lhs.has_committed_real_load < rhs.has_committed_real_load) |
| return true; |
| if (rhs.has_committed_real_load < lhs.has_committed_real_load) |
| return false; |
| if (lhs.visual_properties < rhs.visual_properties) |
| return true; |
| if (rhs.visual_properties < lhs.visual_properties) |
| return false; |
| if (lhs.renderer_wide_named_frame_lookup < rhs.renderer_wide_named_frame_lookup) |
| return true; |
| if (rhs.renderer_wide_named_frame_lookup < lhs.renderer_wide_named_frame_lookup) |
| return false; |
| if (lhs.inside_portal < rhs.inside_portal) |
| return true; |
| if (rhs.inside_portal < lhs.inside_portal) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CreateFrameWidgetParamsPtr CreateFrameWidgetParams::Clone() const { |
| return New( |
| mojo::Clone(routing_id), |
| mojo::Clone(hidden) |
| ); |
| } |
| |
| template <typename T, CreateFrameWidgetParams::EnableIfSame<T>*> |
| bool CreateFrameWidgetParams::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->routing_id, other_struct.routing_id)) |
| return false; |
| if (!mojo::Equals(this->hidden, other_struct.hidden)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CreateFrameWidgetParams::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.routing_id < rhs.routing_id) |
| return true; |
| if (rhs.routing_id < lhs.routing_id) |
| return false; |
| if (lhs.hidden < rhs.hidden) |
| return true; |
| if (rhs.hidden < lhs.hidden) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CreateFrameParamsPtr CreateFrameParams::Clone() const { |
| return New( |
| mojo::Clone(routing_id), |
| mojo::Clone(previous_routing_id), |
| mojo::Clone(opener_routing_id), |
| mojo::Clone(parent_routing_id), |
| mojo::Clone(previous_sibling_routing_id), |
| mojo::Clone(interface_bundle), |
| mojo::Clone(replication_state), |
| mojo::Clone(devtools_frame_token), |
| mojo::Clone(frame_owner_properties), |
| mojo::Clone(widget_params), |
| mojo::Clone(has_committed_real_load) |
| ); |
| } |
| |
| template <typename T, CreateFrameParams::EnableIfSame<T>*> |
| bool CreateFrameParams::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->routing_id, other_struct.routing_id)) |
| return false; |
| if (!mojo::Equals(this->previous_routing_id, other_struct.previous_routing_id)) |
| return false; |
| if (!mojo::Equals(this->opener_routing_id, other_struct.opener_routing_id)) |
| return false; |
| if (!mojo::Equals(this->parent_routing_id, other_struct.parent_routing_id)) |
| return false; |
| if (!mojo::Equals(this->previous_sibling_routing_id, other_struct.previous_sibling_routing_id)) |
| return false; |
| if (!mojo::Equals(this->interface_bundle, other_struct.interface_bundle)) |
| return false; |
| if (!mojo::Equals(this->replication_state, other_struct.replication_state)) |
| return false; |
| if (!mojo::Equals(this->devtools_frame_token, other_struct.devtools_frame_token)) |
| return false; |
| if (!mojo::Equals(this->frame_owner_properties, other_struct.frame_owner_properties)) |
| return false; |
| if (!mojo::Equals(this->widget_params, other_struct.widget_params)) |
| return false; |
| if (!mojo::Equals(this->has_committed_real_load, other_struct.has_committed_real_load)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CreateFrameParams::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.routing_id < rhs.routing_id) |
| return true; |
| if (rhs.routing_id < lhs.routing_id) |
| return false; |
| if (lhs.previous_routing_id < rhs.previous_routing_id) |
| return true; |
| if (rhs.previous_routing_id < lhs.previous_routing_id) |
| return false; |
| if (lhs.opener_routing_id < rhs.opener_routing_id) |
| return true; |
| if (rhs.opener_routing_id < lhs.opener_routing_id) |
| return false; |
| if (lhs.parent_routing_id < rhs.parent_routing_id) |
| return true; |
| if (rhs.parent_routing_id < lhs.parent_routing_id) |
| return false; |
| if (lhs.previous_sibling_routing_id < rhs.previous_sibling_routing_id) |
| return true; |
| if (rhs.previous_sibling_routing_id < lhs.previous_sibling_routing_id) |
| return false; |
| if (lhs.interface_bundle < rhs.interface_bundle) |
| return true; |
| if (rhs.interface_bundle < lhs.interface_bundle) |
| return false; |
| if (lhs.replication_state < rhs.replication_state) |
| return true; |
| if (rhs.replication_state < lhs.replication_state) |
| return false; |
| if (lhs.devtools_frame_token < rhs.devtools_frame_token) |
| return true; |
| if (rhs.devtools_frame_token < lhs.devtools_frame_token) |
| return false; |
| if (lhs.frame_owner_properties < rhs.frame_owner_properties) |
| return true; |
| if (rhs.frame_owner_properties < lhs.frame_owner_properties) |
| return false; |
| if (lhs.widget_params < rhs.widget_params) |
| return true; |
| if (rhs.widget_params < lhs.widget_params) |
| return false; |
| if (lhs.has_committed_real_load < rhs.has_committed_real_load) |
| return true; |
| if (rhs.has_committed_real_load < lhs.has_committed_real_load) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| UpdateScrollbarThemeParamsPtr UpdateScrollbarThemeParams::Clone() const { |
| return New( |
| mojo::Clone(initial_button_delay), |
| mojo::Clone(autoscroll_button_delay), |
| mojo::Clone(jump_on_track_click), |
| mojo::Clone(preferred_scroller_style), |
| mojo::Clone(redraw), |
| mojo::Clone(button_placement), |
| mojo::Clone(scroll_view_rubber_banding) |
| ); |
| } |
| |
| template <typename T, UpdateScrollbarThemeParams::EnableIfSame<T>*> |
| bool UpdateScrollbarThemeParams::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->initial_button_delay, other_struct.initial_button_delay)) |
| return false; |
| if (!mojo::Equals(this->autoscroll_button_delay, other_struct.autoscroll_button_delay)) |
| return false; |
| if (!mojo::Equals(this->jump_on_track_click, other_struct.jump_on_track_click)) |
| return false; |
| if (!mojo::Equals(this->preferred_scroller_style, other_struct.preferred_scroller_style)) |
| return false; |
| if (!mojo::Equals(this->redraw, other_struct.redraw)) |
| return false; |
| if (!mojo::Equals(this->button_placement, other_struct.button_placement)) |
| return false; |
| if (!mojo::Equals(this->scroll_view_rubber_banding, other_struct.scroll_view_rubber_banding)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, UpdateScrollbarThemeParams::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.initial_button_delay < rhs.initial_button_delay) |
| return true; |
| if (rhs.initial_button_delay < lhs.initial_button_delay) |
| return false; |
| if (lhs.autoscroll_button_delay < rhs.autoscroll_button_delay) |
| return true; |
| if (rhs.autoscroll_button_delay < lhs.autoscroll_button_delay) |
| return false; |
| if (lhs.jump_on_track_click < rhs.jump_on_track_click) |
| return true; |
| if (rhs.jump_on_track_click < lhs.jump_on_track_click) |
| return false; |
| if (lhs.preferred_scroller_style < rhs.preferred_scroller_style) |
| return true; |
| if (rhs.preferred_scroller_style < lhs.preferred_scroller_style) |
| return false; |
| if (lhs.redraw < rhs.redraw) |
| return true; |
| if (rhs.redraw < lhs.redraw) |
| return false; |
| if (lhs.button_placement < rhs.button_placement) |
| return true; |
| if (rhs.button_placement < lhs.button_placement) |
| return false; |
| if (lhs.scroll_view_rubber_banding < rhs.scroll_view_rubber_banding) |
| return true; |
| if (rhs.scroll_view_rubber_banding < lhs.scroll_view_rubber_banding) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace mojom |
| } // namespace content |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::mojom::CreateViewParams::DataView, |
| ::content::mojom::CreateViewParamsPtr> { |
| static bool IsNull(const ::content::mojom::CreateViewParamsPtr& input) { return !input; } |
| static void SetToNull(::content::mojom::CreateViewParamsPtr* output) { output->reset(); } |
| |
| static const decltype(::content::mojom::CreateViewParams::renderer_preferences)& renderer_preferences( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->renderer_preferences; |
| } |
| |
| static const decltype(::content::mojom::CreateViewParams::web_preferences)& web_preferences( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->web_preferences; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::view_id) view_id( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->view_id; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::main_frame_routing_id) main_frame_routing_id( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->main_frame_routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::main_frame_interface_bundle)& main_frame_interface_bundle( |
| ::content::mojom::CreateViewParamsPtr& input) { |
| return input->main_frame_interface_bundle; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::main_frame_widget_routing_id) main_frame_widget_routing_id( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->main_frame_widget_routing_id; |
| } |
| |
| static const decltype(::content::mojom::CreateViewParams::session_storage_namespace_id)& session_storage_namespace_id( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->session_storage_namespace_id; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::opener_frame_route_id) opener_frame_route_id( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->opener_frame_route_id; |
| } |
| |
| static const decltype(::content::mojom::CreateViewParams::replicated_frame_state)& replicated_frame_state( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->replicated_frame_state; |
| } |
| |
| static const decltype(::content::mojom::CreateViewParams::devtools_main_frame_token)& devtools_main_frame_token( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->devtools_main_frame_token; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::proxy_routing_id) proxy_routing_id( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->proxy_routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::hidden) hidden( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->hidden; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::never_visible) never_visible( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->never_visible; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::window_was_created_with_opener) window_was_created_with_opener( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->window_was_created_with_opener; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::has_committed_real_load) has_committed_real_load( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->has_committed_real_load; |
| } |
| |
| static const decltype(::content::mojom::CreateViewParams::visual_properties)& visual_properties( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->visual_properties; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::renderer_wide_named_frame_lookup) renderer_wide_named_frame_lookup( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->renderer_wide_named_frame_lookup; |
| } |
| |
| static decltype(::content::mojom::CreateViewParams::inside_portal) inside_portal( |
| const ::content::mojom::CreateViewParamsPtr& input) { |
| return input->inside_portal; |
| } |
| |
| static bool Read(::content::mojom::CreateViewParams::DataView input, ::content::mojom::CreateViewParamsPtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::mojom::CreateFrameWidgetParams::DataView, |
| ::content::mojom::CreateFrameWidgetParamsPtr> { |
| static bool IsNull(const ::content::mojom::CreateFrameWidgetParamsPtr& input) { return !input; } |
| static void SetToNull(::content::mojom::CreateFrameWidgetParamsPtr* output) { output->reset(); } |
| |
| static decltype(::content::mojom::CreateFrameWidgetParams::routing_id) routing_id( |
| const ::content::mojom::CreateFrameWidgetParamsPtr& input) { |
| return input->routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateFrameWidgetParams::hidden) hidden( |
| const ::content::mojom::CreateFrameWidgetParamsPtr& input) { |
| return input->hidden; |
| } |
| |
| static bool Read(::content::mojom::CreateFrameWidgetParams::DataView input, ::content::mojom::CreateFrameWidgetParamsPtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::mojom::CreateFrameParams::DataView, |
| ::content::mojom::CreateFrameParamsPtr> { |
| static bool IsNull(const ::content::mojom::CreateFrameParamsPtr& input) { return !input; } |
| static void SetToNull(::content::mojom::CreateFrameParamsPtr* output) { output->reset(); } |
| |
| static decltype(::content::mojom::CreateFrameParams::routing_id) routing_id( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateFrameParams::previous_routing_id) previous_routing_id( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->previous_routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateFrameParams::opener_routing_id) opener_routing_id( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->opener_routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateFrameParams::parent_routing_id) parent_routing_id( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->parent_routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateFrameParams::previous_sibling_routing_id) previous_sibling_routing_id( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->previous_sibling_routing_id; |
| } |
| |
| static decltype(::content::mojom::CreateFrameParams::interface_bundle)& interface_bundle( |
| ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->interface_bundle; |
| } |
| |
| static const decltype(::content::mojom::CreateFrameParams::replication_state)& replication_state( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->replication_state; |
| } |
| |
| static const decltype(::content::mojom::CreateFrameParams::devtools_frame_token)& devtools_frame_token( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->devtools_frame_token; |
| } |
| |
| static const decltype(::content::mojom::CreateFrameParams::frame_owner_properties)& frame_owner_properties( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->frame_owner_properties; |
| } |
| |
| static const decltype(::content::mojom::CreateFrameParams::widget_params)& widget_params( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->widget_params; |
| } |
| |
| static decltype(::content::mojom::CreateFrameParams::has_committed_real_load) has_committed_real_load( |
| const ::content::mojom::CreateFrameParamsPtr& input) { |
| return input->has_committed_real_load; |
| } |
| |
| static bool Read(::content::mojom::CreateFrameParams::DataView input, ::content::mojom::CreateFrameParamsPtr* output); |
| }; |
| |
| |
| template <> |
| struct CONTENT_EXPORT StructTraits<::content::mojom::UpdateScrollbarThemeParams::DataView, |
| ::content::mojom::UpdateScrollbarThemeParamsPtr> { |
| static bool IsNull(const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { return !input; } |
| static void SetToNull(::content::mojom::UpdateScrollbarThemeParamsPtr* output) { output->reset(); } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::initial_button_delay) initial_button_delay( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->initial_button_delay; |
| } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::autoscroll_button_delay) autoscroll_button_delay( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->autoscroll_button_delay; |
| } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::jump_on_track_click) jump_on_track_click( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->jump_on_track_click; |
| } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::preferred_scroller_style) preferred_scroller_style( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->preferred_scroller_style; |
| } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::redraw) redraw( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->redraw; |
| } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::button_placement) button_placement( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->button_placement; |
| } |
| |
| static decltype(::content::mojom::UpdateScrollbarThemeParams::scroll_view_rubber_banding) scroll_view_rubber_banding( |
| const ::content::mojom::UpdateScrollbarThemeParamsPtr& input) { |
| return input->scroll_view_rubber_banding; |
| } |
| |
| static bool Read(::content::mojom::UpdateScrollbarThemeParams::DataView input, ::content::mojom::UpdateScrollbarThemeParamsPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // CONTENT_COMMON_RENDERER_MOJOM_H_
|
|
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogMjY0NywgImJlZ2luIjogMjYzOSwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uUmVuZGVyZXIifX0sIHsiZW5k
|
| IjogNDAzNCwgImJlZ2luIjogNDAwNSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogImNvbnRlbnQubW9qb20uUmVuZGVyZXIuQ3JlYXRlRW1iZWRkZXJSZW5kZXJlclNl
|
| cnZpY2UifX0sIHsiZW5kIjogNDE4MSwgImJlZ2luIjogNDE3MSwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uUmVuZGVyZXIuQ3JlYXRlVmll
|
| dyJ9fSwgeyJlbmQiOiA0MzAwLCAiYmVnaW4iOiA0Mjg5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6
|
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt
|
| b2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5SZW5kZXJlci5DcmVhdGVGcmFtZSJ9
|
| fSwgeyJlbmQiOiA0NDMwLCAiYmVnaW4iOiA0NDE0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5SZW5kZXJlci5DcmVhdGVGcmFtZVByb3h5
|
| In19LCB7ImVuZCI6IDQ3OTgsICJiZWdpbiI6IDQ3NTYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n
|
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog
|
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v
|
| am9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLlJlbmRlcmVyLlNldFVwRW1iZWRkZWRX
|
| b3JrZXJDaGFubmVsRm9yU2VydmljZVdvcmtlciJ9fSwgeyJlbmQiOiA0OTg3LCAiYmVnaW4iOiA0
|
| OTYxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5t
|
| b2pvbS5SZW5kZXJlci5Pbk5ldHdvcmtDb25uZWN0aW9uQ2hhbmdlZCJ9fSwgeyJlbmQiOiA1MTg5
|
| LCAiYmVnaW4iOiA1MTY2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi
|
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi
|
| OiAiY29udGVudC5tb2pvbS5SZW5kZXJlci5Pbk5ldHdvcmtRdWFsaXR5Q2hhbmdlZCJ9fSwgeyJl
|
| bmQiOiA1NDU0LCAiYmVnaW4iOiA1NDI0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5SZW5kZXJlci5TZXRXZWJLaXRTaGFyZWRUaW1lcnNT
|
| dXNwZW5kZWQifX0sIHsiZW5kIjogNTU2MSwgImJlZ2luIjogNTU0OSwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uUmVuZGVyZXIuU2V0VXNl
|
| ckFnZW50In19LCB7ImVuZCI6IDU3MDEsICJiZWdpbiI6IDU2ODEsICJlZGdlIjogIiUva3l0aGUv
|
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y
|
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl
|
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLlJlbmRlcmVyLlNldFVzZXJB
|
| Z2VudE1ldGFkYXRhIn19LCB7ImVuZCI6IDU4NTIsICJiZWdpbiI6IDU4MzIsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLlJlbmRlcmVyLlVw
|
| ZGF0ZVNjcm9sbGJhclRoZW1lIn19LCB7ImVuZCI6IDYwMDEsICJiZWdpbiI6IDU5ODAsICJlZGdl
|
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2
|
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj
|
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLlJlbmRl
|
| cmVyLk9uU3lzdGVtQ29sb3JzQ2hhbmdlZCJ9fSwgeyJlbmQiOiA2MjE1LCAiYmVnaW4iOiA2MTk1
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pv
|
| bS5SZW5kZXJlci5QdXJnZVBsdWdpbkxpc3RDYWNoZSJ9fSwgeyJlbmQiOiA2MzMzLCAiYmVnaW4i
|
| OiA2MzE4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y
|
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t
|
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVu
|
| dC5tb2pvbS5SZW5kZXJlci5TZXRQcm9jZXNzU3RhdGUifX0sIHsiZW5kIjogNjQ4MCwgImJlZ2lu
|
| IjogNjQ1OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRl
|
| bnQubW9qb20uUmVuZGVyZXIuU2V0U2NoZWR1bGVyS2VlcEFjdGl2ZSJ9fSwgeyJlbmQiOiA2NjAx
|
| LCAiYmVnaW4iOiA2NTg0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi
|
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi
|
| OiAiY29udGVudC5tb2pvbS5SZW5kZXJlci5TZXRJc0xvY2tlZFRvU2l0ZSJ9fSwgeyJlbmQiOiA2
|
| NzE0LCAiYmVnaW4iOiA2NjkzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5
|
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n
|
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1
|
| cmUiOiAiY29udGVudC5tb2pvbS5SZW5kZXJlci5FbmFibGVWOExvd01lbW9yeU1vZGUifX0sIHsi
|
| ZW5kIjogOTk5NCwgImJlZ2luIjogOTk3MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uQ3JlYXRlRnJhbWVXaWRnZXRQYXJhbXMifX0sIHsi
|
| ZW5kIjogMTM3NzksICJiZWdpbiI6IDEzNzY5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh
|
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVGcmFtZVdpZGdldFBhcmFtcy5yb3V0
|
| aW5nX2lkIn19LCB7ImVuZCI6IDEzODYyLCAiYmVnaW4iOiAxMzg1NiwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uQ3JlYXRlRnJhbWVXaWRn
|
| ZXRQYXJhbXMuaGlkZGVuIn19LCB7ImVuZCI6IDE0ODU2LCAiYmVnaW4iOiAxNDg0MCwgImVkZ2Ui
|
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu
|
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi
|
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uQ3JlYXRl
|
| Vmlld1BhcmFtcyJ9fSwgeyJlbmQiOiAxOTI2NCwgImJlZ2luIjogMTkyNDQsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZVZpZXdQ
|
| YXJhbXMucmVuZGVyZXJfcHJlZmVyZW5jZXMifX0sIHsiZW5kIjogMTkzNzcsICJiZWdpbiI6IDE5
|
| MzYyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5t
|
| b2pvbS5DcmVhdGVWaWV3UGFyYW1zLndlYl9wcmVmZXJlbmNlcyJ9fSwgeyJlbmQiOiAxOTQ1OCwg
|
| ImJlZ2luIjogMTk0NTEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6
|
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv
|
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6
|
| ICJjb250ZW50Lm1vam9tLkNyZWF0ZVZpZXdQYXJhbXMudmlld19pZCJ9fSwgeyJlbmQiOiAxOTU2
|
| NywgImJlZ2luIjogMTk1NDYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw
|
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds
|
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy
|
| ZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZVZpZXdQYXJhbXMubWFpbl9mcmFtZV9yb3V0aW5nX2lk
|
| In19LCB7ImVuZCI6IDE5NzMxLCAiYmVnaW4iOiAxOTcwNCwgImVkZ2UiOiAiJS9reXRoZS9lZGdl
|
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi
|
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi
|
| bW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uQ3JlYXRlVmlld1BhcmFtcy5tYWlu
|
| X2ZyYW1lX2ludGVyZmFjZV9idW5kbGUifX0sIHsiZW5kIjogMTk4NTQsICJiZWdpbiI6IDE5ODI2
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pv
|
| bS5DcmVhdGVWaWV3UGFyYW1zLm1haW5fZnJhbWVfd2lkZ2V0X3JvdXRpbmdfaWQifX0sIHsiZW5k
|
| IjogMTk5ODEsICJiZWdpbiI6IDE5OTUzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVWaWV3UGFyYW1zLnNlc3Npb25fc3RvcmFn
|
| ZV9uYW1lc3BhY2VfaWQifX0sIHsiZW5kIjogMjAwOTAsICJiZWdpbiI6IDIwMDY5LCAiZWRnZSI6
|
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5h
|
| bWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIs
|
| ICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVW
|
| aWV3UGFyYW1zLm9wZW5lcl9mcmFtZV9yb3V0ZV9pZCJ9fSwgeyJlbmQiOiAyMDIyNCwgImJlZ2lu
|
| IjogMjAyMDIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250
|
| ZW50Lm1vam9tLkNyZWF0ZVZpZXdQYXJhbXMucmVwbGljYXRlZF9mcmFtZV9zdGF0ZSJ9fSwgeyJl
|
| bmQiOiAyMDM1NiwgImJlZ2luIjogMjAzMzEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZVZpZXdQYXJhbXMuZGV2dG9vbHNfbWFp
|
| bl9mcmFtZV90b2tlbiJ9fSwgeyJlbmQiOiAyMDQ1NSwgImJlZ2luIjogMjA0MzksICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt
|
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZVZp
|
| ZXdQYXJhbXMucHJveHlfcm91dGluZ19pZCJ9fSwgeyJlbmQiOiAyMDUzMSwgImJlZ2luIjogMjA1
|
| MjUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVm
|
| aW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hy
|
| b21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1v
|
| am9tLkNyZWF0ZVZpZXdQYXJhbXMuaGlkZGVuIn19LCB7ImVuZCI6IDIwNjIxLCAiYmVnaW4iOiAy
|
| MDYwOCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQu
|
| bW9qb20uQ3JlYXRlVmlld1BhcmFtcy5uZXZlcl92aXNpYmxlIn19LCB7ImVuZCI6IDIwNzQ1LCAi
|
| YmVnaW4iOiAyMDcxNSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog
|
| ImNvbnRlbnQubW9qb20uQ3JlYXRlVmlld1BhcmFtcy53aW5kb3dfd2FzX2NyZWF0ZWRfd2l0aF9v
|
| cGVuZXIifX0sIHsiZW5kIjogMjA4NTUsICJiZWdpbiI6IDIwODMyLCAiZWRnZSI6ICIlL2t5dGhl
|
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv
|
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn
|
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVWaWV3UGFyYW1z
|
| Lmhhc19jb21taXR0ZWRfcmVhbF9sb2FkIn19LCB7ImVuZCI6IDIwOTc0LCAiYmVnaW4iOiAyMDk1
|
| NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv
|
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9q
|
| b20uQ3JlYXRlVmlld1BhcmFtcy52aXN1YWxfcHJvcGVydGllcyJ9fSwgeyJlbmQiOiAyMTEwMiwg
|
| ImJlZ2luIjogMjEwNzAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6
|
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv
|
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6
|
| ICJjb250ZW50Lm1vam9tLkNyZWF0ZVZpZXdQYXJhbXMucmVuZGVyZXJfd2lkZV9uYW1lZF9mcmFt
|
| ZV9sb29rdXAifX0sIHsiZW5kIjogMjExOTIsICJiZWdpbiI6IDIxMTc5LCAiZWRnZSI6ICIlL2t5
|
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7
|
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n
|
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVWaWV3UGFy
|
| YW1zLmluc2lkZV9wb3J0YWwifX0sIHsiZW5kIjogMjIyMDMsICJiZWdpbiI6IDIyMTg2LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny
|
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVh
|
| dGVGcmFtZVBhcmFtcyJ9fSwgeyJlbmQiOiAyNjI4MiwgImJlZ2luIjogMjYyNzIsICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt
|
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZUZy
|
| YW1lUGFyYW1zLnJvdXRpbmdfaWQifX0sIHsiZW5kIjogMjYzODgsICJiZWdpbiI6IDI2MzY5LCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5D
|
| cmVhdGVGcmFtZVBhcmFtcy5wcmV2aW91c19yb3V0aW5nX2lkIn19LCB7ImVuZCI6IDI2NDkwLCAi
|
| YmVnaW4iOiAyNjQ3MywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog
|
| ImNvbnRlbnQubW9qb20uQ3JlYXRlRnJhbWVQYXJhbXMub3BlbmVyX3JvdXRpbmdfaWQifX0sIHsi
|
| ZW5kIjogMjY1OTIsICJiZWdpbiI6IDI2NTc1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh
|
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVGcmFtZVBhcmFtcy5wYXJlbnRfcm91
|
| dGluZ19pZCJ9fSwgeyJlbmQiOiAyNjcxNCwgImJlZ2luIjogMjY2ODcsICJlZGdlIjogIiUva3l0
|
| aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsi
|
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1
|
| YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZUZyYW1lUGFy
|
| YW1zLnByZXZpb3VzX3NpYmxpbmdfcm91dGluZ19pZCJ9fSwgeyJlbmQiOiAyNjg1NywgImJlZ2lu
|
| IjogMjY4NDEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250
|
| ZW50Lm1vam9tLkNyZWF0ZUZyYW1lUGFyYW1zLmludGVyZmFjZV9idW5kbGUifX0sIHsiZW5kIjog
|
| MjY5ODIsICJiZWdpbiI6IDI2OTY1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVGcmFtZVBhcmFtcy5yZXBsaWNhdGlvbl9zdGF0
|
| ZSJ9fSwgeyJlbmQiOiAyNzEwNSwgImJlZ2luIjogMjcwODUsICJlZGdlIjogIiUva3l0aGUvZWRn
|
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz
|
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog
|
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLkNyZWF0ZUZyYW1lUGFyYW1zLmRl
|
| dnRvb2xzX2ZyYW1lX3Rva2VuIn19LCB7ImVuZCI6IDI3MjM5LCAiYmVnaW4iOiAyNzIxNywgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uQ3Jl
|
| YXRlRnJhbWVQYXJhbXMuZnJhbWVfb3duZXJfcHJvcGVydGllcyJ9fSwgeyJlbmQiOiAyNzM1Miwg
|
| ImJlZ2luIjogMjczMzksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6
|
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv
|
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6
|
| ICJjb250ZW50Lm1vam9tLkNyZWF0ZUZyYW1lUGFyYW1zLndpZGdldF9wYXJhbXMifX0sIHsiZW5k
|
| IjogMjc0NjMsICJiZWdpbiI6IDI3NDQwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5DcmVhdGVGcmFtZVBhcmFtcy5oYXNfY29tbWl0dGVk
|
| X3JlYWxfbG9hZCJ9fSwgeyJlbmQiOiAyODQ5NiwgImJlZ2luIjogMjg0NzAsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLlVwZGF0ZVNjcm9s
|
| bGJhclRoZW1lUGFyYW1zIn19LCB7ImVuZCI6IDMyNjE5LCAiYmVnaW4iOiAzMjU5OSwgImVkZ2Ui
|
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu
|
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi
|
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogImNvbnRlbnQubW9qb20uVXBkYXRl
|
| U2Nyb2xsYmFyVGhlbWVQYXJhbXMuaW5pdGlhbF9idXR0b25fZGVsYXkifX0sIHsiZW5kIjogMzI3
|
| NDAsICJiZWdpbiI6IDMyNzE3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5
|
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n
|
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1
|
| cmUiOiAiY29udGVudC5tb2pvbS5VcGRhdGVTY3JvbGxiYXJUaGVtZVBhcmFtcy5hdXRvc2Nyb2xs
|
| X2J1dHRvbl9kZWxheSJ9fSwgeyJlbmQiOiAzMjg1MiwgImJlZ2luIjogMzI4MzMsICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt
|
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJjb250ZW50Lm1vam9tLlVwZGF0ZVNj
|
| cm9sbGJhclRoZW1lUGFyYW1zLmp1bXBfb25fdHJhY2tfY2xpY2sifX0sIHsiZW5kIjogMzMwMDEs
|
| ICJiZWdpbiI6IDMyOTc3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi
|
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz
|
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi
|
| OiAiY29udGVudC5tb2pvbS5VcGRhdGVTY3JvbGxiYXJUaGVtZVBhcmFtcy5wcmVmZXJyZWRfc2Ny
|
| b2xsZXJfc3R5bGUifX0sIHsiZW5kIjogMzMwODcsICJiZWdpbiI6IDMzMDgxLCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pvbS5VcGRhdGVTY3Jv
|
| bGxiYXJUaGVtZVBhcmFtcy5yZWRyYXcifX0sIHsiZW5kIjogMzMyMzIsICJiZWdpbiI6IDMzMjE2
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAiY29udGVudC5tb2pv
|
| bS5VcGRhdGVTY3JvbGxiYXJUaGVtZVBhcmFtcy5idXR0b25fcGxhY2VtZW50In19LCB7ImVuZCI6
|
| IDMzMzU4LCAiYmVnaW4iOiAzMzMzMiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogImNvbnRlbnQubW9qb20uVXBkYXRlU2Nyb2xsYmFyVGhlbWVQYXJhbXMuc2Nyb2xs
|
| X3ZpZXdfcnViYmVyX2JhbmRpbmcifX1dLCAidHlwZSI6ICJreXRoZTAifQ==
|
| */ |
