| // Copyright 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef SERVICES_NETWORK_PUBLIC_MOJOM_COOKIE_MANAGER_MOJOM_BLINK_H_ |
| #define SERVICES_NETWORK_PUBLIC_MOJOM_COOKIE_MANAGER_MOJOM_BLINK_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "base/optional.h" |
| |
| #include "mojo/public/cpp/bindings/mojo_buildflags.h" |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| #include "base/trace_event/trace_event.h" |
| #endif |
| #include "mojo/public/cpp/bindings/clone_traits.h" |
| #include "mojo/public/cpp/bindings/equals_traits.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/struct_ptr.h" |
| #include "mojo/public/cpp/bindings/struct_traits.h" |
| #include "mojo/public/cpp/bindings/union_traits.h" |
| #include "services/network/public/mojom/cookie_manager.mojom-shared.h" |
| #include "services/network/public/mojom/cookie_manager.mojom-blink-forward.h" |
| #include "components/content_settings/core/common/content_settings.mojom-blink.h" |
| #include "mojo/public/mojom/base/time.mojom-blink.h" |
| #include "url/mojom/url.mojom-blink.h" |
| |
| #include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h" |
| #include "mojo/public/cpp/bindings/lib/wtf_hash_util.h" |
| #include "third_party/blink/renderer/platform/wtf/hash_functions.h" |
| #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" |
| |
| #include "mojo/public/cpp/bindings/associated_interface_ptr.h" |
| #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h" |
| #include "mojo/public/cpp/bindings/associated_interface_request.h" |
| #include "mojo/public/cpp/bindings/interface_ptr.h" |
| #include "mojo/public/cpp/bindings/interface_request.h" |
| #include "mojo/public/cpp/bindings/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h" |
| |
| |
| #include "mojo/public/cpp/bindings/lib/native_enum_serialization.h" |
| #include "mojo/public/cpp/bindings/lib/native_struct_serialization.h" |
| #include "third_party/blink/public/platform/web_canonical_cookie.h" |
| #include "third_party/blink/public/platform/web_common.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookiePriority_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookiePriority& value) { |
| using utype = std::underlying_type<::network::mojom::CookiePriority>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookiePriority& left, const ::network::mojom::CookiePriority& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookiePriority> |
| : public GenericHashTraits<::network::mojom::CookiePriority> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::network::mojom::CookiePriority& value) { |
| return value == static_cast<::network::mojom::CookiePriority>(-1000000); |
| } |
| static void ConstructDeletedValue(::network::mojom::CookiePriority& slot, bool) { |
| slot = static_cast<::network::mojom::CookiePriority>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookiePriority& value) { |
| return value == static_cast<::network::mojom::CookiePriority>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieSameSite_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieSameSite& value) { |
| using utype = std::underlying_type<::network::mojom::CookieSameSite>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieSameSite& left, const ::network::mojom::CookieSameSite& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieSameSite> |
| : public GenericHashTraits<::network::mojom::CookieSameSite> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::network::mojom::CookieSameSite& value) { |
| return value == static_cast<::network::mojom::CookieSameSite>(-1000000); |
| } |
| static void ConstructDeletedValue(::network::mojom::CookieSameSite& slot, bool) { |
| slot = static_cast<::network::mojom::CookieSameSite>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieSameSite& value) { |
| return value == static_cast<::network::mojom::CookieSameSite>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieSameSiteContext_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieSameSiteContext& value) { |
| using utype = std::underlying_type<::network::mojom::CookieSameSiteContext>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieSameSiteContext& left, const ::network::mojom::CookieSameSiteContext& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieSameSiteContext> |
| : public GenericHashTraits<::network::mojom::CookieSameSiteContext> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::network::mojom::CookieSameSiteContext& value) { |
| return value == static_cast<::network::mojom::CookieSameSiteContext>(-1000000); |
| } |
| static void ConstructDeletedValue(::network::mojom::CookieSameSiteContext& slot, bool) { |
| slot = static_cast<::network::mojom::CookieSameSiteContext>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieSameSiteContext& value) { |
| return value == static_cast<::network::mojom::CookieSameSiteContext>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieInclusionStatus_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieInclusionStatus& value) { |
| using utype = std::underlying_type<::network::mojom::CookieInclusionStatus>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieInclusionStatus& left, const ::network::mojom::CookieInclusionStatus& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieInclusionStatus> |
| : public GenericHashTraits<::network::mojom::CookieInclusionStatus> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::network::mojom::CookieInclusionStatus& value) { |
| return value == static_cast<::network::mojom::CookieInclusionStatus>(-1000000); |
| } |
| static void ConstructDeletedValue(::network::mojom::CookieInclusionStatus& slot, bool) { |
| slot = static_cast<::network::mojom::CookieInclusionStatus>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieInclusionStatus& value) { |
| return value == static_cast<::network::mojom::CookieInclusionStatus>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieChangeCause_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieChangeCause& value) { |
| using utype = std::underlying_type<::network::mojom::CookieChangeCause>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieChangeCause& left, const ::network::mojom::CookieChangeCause& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieChangeCause> |
| : public GenericHashTraits<::network::mojom::CookieChangeCause> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::network::mojom::CookieChangeCause& value) { |
| return value == static_cast<::network::mojom::CookieChangeCause>(-1000000); |
| } |
| static void ConstructDeletedValue(::network::mojom::CookieChangeCause& slot, bool) { |
| slot = static_cast<::network::mojom::CookieChangeCause>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieChangeCause& value) { |
| return value == static_cast<::network::mojom::CookieChangeCause>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieDeletionSessionControl_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieDeletionSessionControl& value) { |
| using utype = std::underlying_type<::network::mojom::CookieDeletionSessionControl>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieDeletionSessionControl& left, const ::network::mojom::CookieDeletionSessionControl& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieDeletionSessionControl> |
| : public GenericHashTraits<::network::mojom::CookieDeletionSessionControl> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool hasIsEmptyValueFunction = true; |
| static bool IsEmptyValue(const ::network::mojom::CookieDeletionSessionControl& value) { |
| return value == static_cast<::network::mojom::CookieDeletionSessionControl>(-1000000); |
| } |
| static void ConstructDeletedValue(::network::mojom::CookieDeletionSessionControl& slot, bool) { |
| slot = static_cast<::network::mojom::CookieDeletionSessionControl>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieDeletionSessionControl& value) { |
| return value == static_cast<::network::mojom::CookieDeletionSessionControl>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace network { |
| namespace mojom { |
| namespace blink { |
| |
| class CookieChangeListenerProxy; |
| |
| template <typename ImplRefTraits> |
| class CookieChangeListenerStub; |
| |
| class CookieChangeListenerRequestValidator; |
| |
| |
| // @generated_from: network.mojom.CookieChangeListener |
| class BLINK_PLATFORM_EXPORT CookieChangeListener |
| : public CookieChangeListenerInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = CookieChangeListenerInterfaceBase; |
| using Proxy_ = CookieChangeListenerProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = CookieChangeListenerStub<ImplRefTraits>; |
| |
| using RequestValidator_ = CookieChangeListenerRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kOnCookieChangeMinVersion = 0, |
| }; |
| virtual ~CookieChangeListener() {} |
| |
| |
| // @generated_from: network.mojom.CookieChangeListener.OnCookieChange |
| virtual void OnCookieChange(const ::blink::WebCanonicalCookie& cookie, CookieChangeCause cause) = 0; |
| }; |
| |
| class CookieManagerProxy; |
| |
| template <typename ImplRefTraits> |
| class CookieManagerStub; |
| |
| class CookieManagerRequestValidator; |
| class CookieManagerResponseValidator; |
| |
| |
| // @generated_from: network.mojom.CookieManager |
| class BLINK_PLATFORM_EXPORT CookieManager |
| : public CookieManagerInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = CookieManagerInterfaceBase; |
| using Proxy_ = CookieManagerProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = CookieManagerStub<ImplRefTraits>; |
| |
| using RequestValidator_ = CookieManagerRequestValidator; |
| using ResponseValidator_ = CookieManagerResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kGetAllCookiesMinVersion = 0, |
| kGetCookieListMinVersion = 0, |
| kSetCanonicalCookieMinVersion = 0, |
| kDeleteCanonicalCookieMinVersion = 0, |
| kDeleteCookiesMinVersion = 0, |
| kAddCookieChangeListenerMinVersion = 0, |
| kAddGlobalChangeListenerMinVersion = 0, |
| kCloneInterfaceMinVersion = 0, |
| kFlushCookieStoreMinVersion = 0, |
| kAllowFileSchemeCookiesMinVersion = 0, |
| kSetContentSettingsMinVersion = 0, |
| kSetForceKeepSessionStateMinVersion = 0, |
| kBlockThirdPartyCookiesMinVersion = 0, |
| }; |
| virtual ~CookieManager() {} |
| |
| |
| using GetAllCookiesCallback = base::OnceCallback<void(const WTF::Vector<::blink::WebCanonicalCookie>&)>; |
| |
| // @generated_from: network.mojom.CookieManager.GetAllCookies |
| virtual void GetAllCookies(GetAllCookiesCallback callback) = 0; |
| |
| |
| using GetCookieListCallback = base::OnceCallback<void(const WTF::Vector<::blink::WebCanonicalCookie>&, WTF::Vector<CookieWithStatusPtr>)>; |
| |
| // @generated_from: network.mojom.CookieManager.GetCookieList |
| virtual void GetCookieList(const ::blink::KURL& url, CookieOptionsPtr cookie_options, GetCookieListCallback callback) = 0; |
| |
| |
| using SetCanonicalCookieCallback = base::OnceCallback<void(CookieInclusionStatus)>; |
| |
| // @generated_from: network.mojom.CookieManager.SetCanonicalCookie |
| virtual void SetCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, const WTF::String& source_scheme, CookieOptionsPtr cookie_options, SetCanonicalCookieCallback callback) = 0; |
| |
| |
| using DeleteCanonicalCookieCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteCanonicalCookie |
| virtual void DeleteCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, DeleteCanonicalCookieCallback callback) = 0; |
| |
| |
| using DeleteCookiesCallback = base::OnceCallback<void(uint32_t)>; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteCookies |
| virtual void DeleteCookies(CookieDeletionFilterPtr filter, DeleteCookiesCallback callback) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.AddCookieChangeListener |
| virtual void AddCookieChangeListener(const ::blink::KURL& url, const WTF::String& name, CookieChangeListenerPtr listener) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.AddGlobalChangeListener |
| virtual void AddGlobalChangeListener(CookieChangeListenerPtr notification_pointer) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.CloneInterface |
| virtual void CloneInterface(CookieManagerRequest new_interface) = 0; |
| |
| |
| using FlushCookieStoreCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: network.mojom.CookieManager.FlushCookieStore |
| virtual void FlushCookieStore(FlushCookieStoreCallback callback) = 0; |
| |
| |
| using AllowFileSchemeCookiesCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: network.mojom.CookieManager.AllowFileSchemeCookies |
| virtual void AllowFileSchemeCookies(bool allow, AllowFileSchemeCookiesCallback callback) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.SetContentSettings |
| virtual void SetContentSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.SetForceKeepSessionState |
| virtual void SetForceKeepSessionState() = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.BlockThirdPartyCookies |
| virtual void BlockThirdPartyCookies(bool block) = 0; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT CookieChangeListenerProxy |
| : public CookieChangeListener { |
| public: |
| using InterfaceType = CookieChangeListener; |
| |
| explicit CookieChangeListenerProxy(mojo::MessageReceiverWithResponder* receiver); |
| void OnCookieChange(const ::blink::WebCanonicalCookie& cookie, CookieChangeCause cause) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class BLINK_PLATFORM_EXPORT CookieManagerProxy |
| : public CookieManager { |
| public: |
| using InterfaceType = CookieManager; |
| |
| explicit CookieManagerProxy(mojo::MessageReceiverWithResponder* receiver); |
| void GetAllCookies(GetAllCookiesCallback callback) final; |
| void GetCookieList(const ::blink::KURL& url, CookieOptionsPtr cookie_options, GetCookieListCallback callback) final; |
| void SetCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, const WTF::String& source_scheme, CookieOptionsPtr cookie_options, SetCanonicalCookieCallback callback) final; |
| void DeleteCanonicalCookie(const ::blink::WebCanonicalCookie& cookie, DeleteCanonicalCookieCallback callback) final; |
| void DeleteCookies(CookieDeletionFilterPtr filter, DeleteCookiesCallback callback) final; |
| void AddCookieChangeListener(const ::blink::KURL& url, const WTF::String& name, CookieChangeListenerPtr listener) final; |
| void AddGlobalChangeListener(CookieChangeListenerPtr notification_pointer) final; |
| void CloneInterface(CookieManagerRequest new_interface) final; |
| void FlushCookieStore(FlushCookieStoreCallback callback) final; |
| void AllowFileSchemeCookies(bool allow, AllowFileSchemeCookiesCallback callback) final; |
| void SetContentSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) final; |
| void SetForceKeepSessionState() final; |
| void BlockThirdPartyCookies(bool block) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class BLINK_PLATFORM_EXPORT CookieChangeListenerStubDispatch { |
| public: |
| static bool Accept(CookieChangeListener* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| CookieChangeListener* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<CookieChangeListener>> |
| class CookieChangeListenerStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| CookieChangeListenerStub() {} |
| ~CookieChangeListenerStub() 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 CookieChangeListenerStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return CookieChangeListenerStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT CookieManagerStubDispatch { |
| public: |
| static bool Accept(CookieManager* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| CookieManager* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<CookieManager>> |
| class CookieManagerStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| CookieManagerStub() {} |
| ~CookieManagerStub() 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 CookieManagerStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return CookieManagerStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BLINK_PLATFORM_EXPORT CookieChangeListenerRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT CookieManagerRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BLINK_PLATFORM_EXPORT CookieManagerResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieManagerParams |
| class BLINK_PLATFORM_EXPORT CookieManagerParams { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieManagerParams, T>::value>; |
| using DataView = CookieManagerParamsDataView; |
| using Data_ = internal::CookieManagerParams_Data; |
| |
| template <typename... Args> |
| static CookieManagerParamsPtr New(Args&&... args) { |
| return CookieManagerParamsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieManagerParamsPtr From(const U& u) { |
| return mojo::TypeConverter<CookieManagerParamsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieManagerParams>::Convert(*this); |
| } |
| |
| |
| CookieManagerParams(); |
| |
| CookieManagerParams( |
| bool block_third_party_cookies, |
| WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings, |
| const WTF::Vector<WTF::String>& secure_origin_cookies_allowed_schemes, |
| const WTF::Vector<WTF::String>& matching_scheme_cookies_allowed_schemes, |
| const WTF::Vector<WTF::String>& third_party_cookies_allowed_schemes, |
| bool allow_file_scheme_cookies); |
| |
| ~CookieManagerParams(); |
| |
| // 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 = CookieManagerParamsPtr> |
| CookieManagerParamsPtr 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, CookieManagerParams::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieManagerParams::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieManagerParams::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::CookieManagerParams_UnserializedMessageContext< |
| UserType, CookieManagerParams::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<CookieManagerParams::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieManagerParams::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::CookieManagerParams_UnserializedMessageContext< |
| UserType, CookieManagerParams::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieManagerParams::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieManagerParams.block_third_party_cookies |
| bool block_third_party_cookies; |
| |
| // @generated_from: network.mojom.CookieManagerParams.settings |
| WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings; |
| |
| // @generated_from: network.mojom.CookieManagerParams.secure_origin_cookies_allowed_schemes |
| WTF::Vector<WTF::String> secure_origin_cookies_allowed_schemes; |
| |
| // @generated_from: network.mojom.CookieManagerParams.matching_scheme_cookies_allowed_schemes |
| WTF::Vector<WTF::String> matching_scheme_cookies_allowed_schemes; |
| |
| // @generated_from: network.mojom.CookieManagerParams.third_party_cookies_allowed_schemes |
| WTF::Vector<WTF::String> third_party_cookies_allowed_schemes; |
| |
| // @generated_from: network.mojom.CookieManagerParams.allow_file_scheme_cookies |
| bool allow_file_scheme_cookies; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(CookieManagerParams); |
| }; |
| |
| // 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, CookieManagerParams::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieManagerParams::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieManagerParams::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieManagerParams::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieOptions |
| class BLINK_PLATFORM_EXPORT CookieOptions { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieOptions, T>::value>; |
| using DataView = CookieOptionsDataView; |
| using Data_ = internal::CookieOptions_Data; |
| |
| template <typename... Args> |
| static CookieOptionsPtr New(Args&&... args) { |
| return CookieOptionsPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieOptionsPtr From(const U& u) { |
| return mojo::TypeConverter<CookieOptionsPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieOptions>::Convert(*this); |
| } |
| |
| |
| CookieOptions(); |
| |
| CookieOptions( |
| bool exclude_httponly, |
| CookieSameSiteContext same_site_cookie_context, |
| bool update_access_time, |
| base::Optional<base::Time> server_time, |
| bool return_excluded_cookies); |
| |
| ~CookieOptions(); |
| |
| // 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 = CookieOptionsPtr> |
| CookieOptionsPtr 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, CookieOptions::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieOptions::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieOptions::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::CookieOptions_UnserializedMessageContext< |
| UserType, CookieOptions::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<CookieOptions::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieOptions::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::CookieOptions_UnserializedMessageContext< |
| UserType, CookieOptions::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieOptions::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieOptions.exclude_httponly |
| bool exclude_httponly; |
| |
| // @generated_from: network.mojom.CookieOptions.same_site_cookie_context |
| CookieSameSiteContext same_site_cookie_context; |
| |
| // @generated_from: network.mojom.CookieOptions.update_access_time |
| bool update_access_time; |
| |
| // @generated_from: network.mojom.CookieOptions.server_time |
| base::Optional<base::Time> server_time; |
| |
| // @generated_from: network.mojom.CookieOptions.return_excluded_cookies |
| bool return_excluded_cookies; |
| |
| 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, CookieOptions::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieOptions::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieOptions::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieOptions::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CanonicalCookie |
| class BLINK_PLATFORM_EXPORT CanonicalCookie { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CanonicalCookie, T>::value>; |
| using DataView = CanonicalCookieDataView; |
| using Data_ = internal::CanonicalCookie_Data; |
| |
| template <typename... Args> |
| static CanonicalCookiePtr New(Args&&... args) { |
| return CanonicalCookiePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CanonicalCookiePtr From(const U& u) { |
| return mojo::TypeConverter<CanonicalCookiePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CanonicalCookie>::Convert(*this); |
| } |
| |
| |
| CanonicalCookie(); |
| |
| CanonicalCookie( |
| const WTF::String& name, |
| const WTF::String& value, |
| const WTF::String& domain, |
| const WTF::String& path, |
| base::Time creation, |
| base::Time expiry, |
| base::Time last_access, |
| bool secure, |
| bool httponly, |
| CookieSameSite site_restrictions, |
| CookiePriority priority); |
| |
| ~CanonicalCookie(); |
| |
| // 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 = CanonicalCookiePtr> |
| CanonicalCookiePtr 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, CanonicalCookie::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CanonicalCookie::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CanonicalCookie::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::CanonicalCookie_UnserializedMessageContext< |
| UserType, CanonicalCookie::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<CanonicalCookie::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CanonicalCookie::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::CanonicalCookie_UnserializedMessageContext< |
| UserType, CanonicalCookie::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CanonicalCookie::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CanonicalCookie.name |
| WTF::String name; |
| |
| // @generated_from: network.mojom.CanonicalCookie.value |
| WTF::String value; |
| |
| // @generated_from: network.mojom.CanonicalCookie.domain |
| WTF::String domain; |
| |
| // @generated_from: network.mojom.CanonicalCookie.path |
| WTF::String path; |
| |
| // @generated_from: network.mojom.CanonicalCookie.creation |
| base::Time creation; |
| |
| // @generated_from: network.mojom.CanonicalCookie.expiry |
| base::Time expiry; |
| |
| // @generated_from: network.mojom.CanonicalCookie.last_access |
| base::Time last_access; |
| |
| // @generated_from: network.mojom.CanonicalCookie.secure |
| bool secure; |
| |
| // @generated_from: network.mojom.CanonicalCookie.httponly |
| bool httponly; |
| |
| // @generated_from: network.mojom.CanonicalCookie.site_restrictions |
| CookieSameSite site_restrictions; |
| |
| // @generated_from: network.mojom.CanonicalCookie.priority |
| CookiePriority priority; |
| |
| 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, CanonicalCookie::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CanonicalCookie::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CanonicalCookie::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CanonicalCookie::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieWithStatus |
| class BLINK_PLATFORM_EXPORT CookieWithStatus { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieWithStatus, T>::value>; |
| using DataView = CookieWithStatusDataView; |
| using Data_ = internal::CookieWithStatus_Data; |
| |
| template <typename... Args> |
| static CookieWithStatusPtr New(Args&&... args) { |
| return CookieWithStatusPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieWithStatusPtr From(const U& u) { |
| return mojo::TypeConverter<CookieWithStatusPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieWithStatus>::Convert(*this); |
| } |
| |
| |
| CookieWithStatus(); |
| |
| CookieWithStatus( |
| const ::blink::WebCanonicalCookie& cookie, |
| CookieInclusionStatus status); |
| |
| ~CookieWithStatus(); |
| |
| // 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 = CookieWithStatusPtr> |
| CookieWithStatusPtr 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, CookieWithStatus::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieWithStatus::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieWithStatus::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::CookieWithStatus_UnserializedMessageContext< |
| UserType, CookieWithStatus::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<CookieWithStatus::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieWithStatus::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::CookieWithStatus_UnserializedMessageContext< |
| UserType, CookieWithStatus::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieWithStatus::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieWithStatus.cookie |
| ::blink::WebCanonicalCookie cookie; |
| |
| // @generated_from: network.mojom.CookieWithStatus.status |
| CookieInclusionStatus status; |
| |
| 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, CookieWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieAndLineWithStatus |
| class BLINK_PLATFORM_EXPORT CookieAndLineWithStatus { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieAndLineWithStatus, T>::value>; |
| using DataView = CookieAndLineWithStatusDataView; |
| using Data_ = internal::CookieAndLineWithStatus_Data; |
| |
| template <typename... Args> |
| static CookieAndLineWithStatusPtr New(Args&&... args) { |
| return CookieAndLineWithStatusPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieAndLineWithStatusPtr From(const U& u) { |
| return mojo::TypeConverter<CookieAndLineWithStatusPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieAndLineWithStatus>::Convert(*this); |
| } |
| |
| |
| CookieAndLineWithStatus(); |
| |
| CookieAndLineWithStatus( |
| const base::Optional<::blink::WebCanonicalCookie>& cookie, |
| const WTF::String& cookie_string, |
| CookieInclusionStatus status); |
| |
| ~CookieAndLineWithStatus(); |
| |
| // 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 = CookieAndLineWithStatusPtr> |
| CookieAndLineWithStatusPtr 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, CookieAndLineWithStatus::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieAndLineWithStatus::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieAndLineWithStatus::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::CookieAndLineWithStatus_UnserializedMessageContext< |
| UserType, CookieAndLineWithStatus::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<CookieAndLineWithStatus::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieAndLineWithStatus::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::CookieAndLineWithStatus_UnserializedMessageContext< |
| UserType, CookieAndLineWithStatus::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieAndLineWithStatus::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieAndLineWithStatus.cookie |
| base::Optional<::blink::WebCanonicalCookie> cookie; |
| |
| // @generated_from: network.mojom.CookieAndLineWithStatus.cookie_string |
| WTF::String cookie_string; |
| |
| // @generated_from: network.mojom.CookieAndLineWithStatus.status |
| CookieInclusionStatus status; |
| |
| 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, CookieAndLineWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieAndLineWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieAndLineWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieAndLineWithStatus::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieDeletionFilter |
| class BLINK_PLATFORM_EXPORT CookieDeletionFilter { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieDeletionFilter, T>::value>; |
| using DataView = CookieDeletionFilterDataView; |
| using Data_ = internal::CookieDeletionFilter_Data; |
| |
| template <typename... Args> |
| static CookieDeletionFilterPtr New(Args&&... args) { |
| return CookieDeletionFilterPtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieDeletionFilterPtr From(const U& u) { |
| return mojo::TypeConverter<CookieDeletionFilterPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieDeletionFilter>::Convert(*this); |
| } |
| |
| |
| CookieDeletionFilter(); |
| |
| CookieDeletionFilter( |
| base::Optional<base::Time> created_after_time, |
| base::Optional<base::Time> created_before_time, |
| const base::Optional<WTF::Vector<WTF::String>>& excluding_domains, |
| const base::Optional<WTF::Vector<WTF::String>>& including_domains, |
| const WTF::String& cookie_name, |
| const WTF::String& host_name, |
| const base::Optional<::blink::KURL>& url, |
| CookieDeletionSessionControl session_control); |
| |
| ~CookieDeletionFilter(); |
| |
| // 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 = CookieDeletionFilterPtr> |
| CookieDeletionFilterPtr 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, CookieDeletionFilter::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieDeletionFilter::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieDeletionFilter::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::CookieDeletionFilter_UnserializedMessageContext< |
| UserType, CookieDeletionFilter::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<CookieDeletionFilter::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieDeletionFilter::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::CookieDeletionFilter_UnserializedMessageContext< |
| UserType, CookieDeletionFilter::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieDeletionFilter::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.created_after_time |
| base::Optional<base::Time> created_after_time; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.created_before_time |
| base::Optional<base::Time> created_before_time; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.excluding_domains |
| base::Optional<WTF::Vector<WTF::String>> excluding_domains; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.including_domains |
| base::Optional<WTF::Vector<WTF::String>> including_domains; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.cookie_name |
| WTF::String cookie_name; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.host_name |
| WTF::String host_name; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.url |
| base::Optional<::blink::KURL> url; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.session_control |
| CookieDeletionSessionControl session_control; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieDeletionFilter::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieDeletionFilter::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieDeletionFilter::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieDeletionFilter::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| CookieManagerParamsPtr CookieManagerParams::Clone() const { |
| return New( |
| mojo::Clone(block_third_party_cookies), |
| mojo::Clone(settings), |
| mojo::Clone(secure_origin_cookies_allowed_schemes), |
| mojo::Clone(matching_scheme_cookies_allowed_schemes), |
| mojo::Clone(third_party_cookies_allowed_schemes), |
| mojo::Clone(allow_file_scheme_cookies) |
| ); |
| } |
| |
| template <typename T, CookieManagerParams::EnableIfSame<T>*> |
| bool CookieManagerParams::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->block_third_party_cookies, other_struct.block_third_party_cookies)) |
| return false; |
| if (!mojo::Equals(this->settings, other_struct.settings)) |
| return false; |
| if (!mojo::Equals(this->secure_origin_cookies_allowed_schemes, other_struct.secure_origin_cookies_allowed_schemes)) |
| return false; |
| if (!mojo::Equals(this->matching_scheme_cookies_allowed_schemes, other_struct.matching_scheme_cookies_allowed_schemes)) |
| return false; |
| if (!mojo::Equals(this->third_party_cookies_allowed_schemes, other_struct.third_party_cookies_allowed_schemes)) |
| return false; |
| if (!mojo::Equals(this->allow_file_scheme_cookies, other_struct.allow_file_scheme_cookies)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieManagerParams::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.block_third_party_cookies < rhs.block_third_party_cookies) |
| return true; |
| if (rhs.block_third_party_cookies < lhs.block_third_party_cookies) |
| return false; |
| if (lhs.settings < rhs.settings) |
| return true; |
| if (rhs.settings < lhs.settings) |
| return false; |
| if (lhs.secure_origin_cookies_allowed_schemes < rhs.secure_origin_cookies_allowed_schemes) |
| return true; |
| if (rhs.secure_origin_cookies_allowed_schemes < lhs.secure_origin_cookies_allowed_schemes) |
| return false; |
| if (lhs.matching_scheme_cookies_allowed_schemes < rhs.matching_scheme_cookies_allowed_schemes) |
| return true; |
| if (rhs.matching_scheme_cookies_allowed_schemes < lhs.matching_scheme_cookies_allowed_schemes) |
| return false; |
| if (lhs.third_party_cookies_allowed_schemes < rhs.third_party_cookies_allowed_schemes) |
| return true; |
| if (rhs.third_party_cookies_allowed_schemes < lhs.third_party_cookies_allowed_schemes) |
| return false; |
| if (lhs.allow_file_scheme_cookies < rhs.allow_file_scheme_cookies) |
| return true; |
| if (rhs.allow_file_scheme_cookies < lhs.allow_file_scheme_cookies) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieOptionsPtr CookieOptions::Clone() const { |
| return New( |
| mojo::Clone(exclude_httponly), |
| mojo::Clone(same_site_cookie_context), |
| mojo::Clone(update_access_time), |
| mojo::Clone(server_time), |
| mojo::Clone(return_excluded_cookies) |
| ); |
| } |
| |
| template <typename T, CookieOptions::EnableIfSame<T>*> |
| bool CookieOptions::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->exclude_httponly, other_struct.exclude_httponly)) |
| return false; |
| if (!mojo::Equals(this->same_site_cookie_context, other_struct.same_site_cookie_context)) |
| return false; |
| if (!mojo::Equals(this->update_access_time, other_struct.update_access_time)) |
| return false; |
| if (!mojo::Equals(this->server_time, other_struct.server_time)) |
| return false; |
| if (!mojo::Equals(this->return_excluded_cookies, other_struct.return_excluded_cookies)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieOptions::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.exclude_httponly < rhs.exclude_httponly) |
| return true; |
| if (rhs.exclude_httponly < lhs.exclude_httponly) |
| return false; |
| if (lhs.same_site_cookie_context < rhs.same_site_cookie_context) |
| return true; |
| if (rhs.same_site_cookie_context < lhs.same_site_cookie_context) |
| return false; |
| if (lhs.update_access_time < rhs.update_access_time) |
| return true; |
| if (rhs.update_access_time < lhs.update_access_time) |
| return false; |
| if (lhs.server_time < rhs.server_time) |
| return true; |
| if (rhs.server_time < lhs.server_time) |
| return false; |
| if (lhs.return_excluded_cookies < rhs.return_excluded_cookies) |
| return true; |
| if (rhs.return_excluded_cookies < lhs.return_excluded_cookies) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CanonicalCookiePtr CanonicalCookie::Clone() const { |
| return New( |
| mojo::Clone(name), |
| mojo::Clone(value), |
| mojo::Clone(domain), |
| mojo::Clone(path), |
| mojo::Clone(creation), |
| mojo::Clone(expiry), |
| mojo::Clone(last_access), |
| mojo::Clone(secure), |
| mojo::Clone(httponly), |
| mojo::Clone(site_restrictions), |
| mojo::Clone(priority) |
| ); |
| } |
| |
| template <typename T, CanonicalCookie::EnableIfSame<T>*> |
| bool CanonicalCookie::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->name, other_struct.name)) |
| return false; |
| if (!mojo::Equals(this->value, other_struct.value)) |
| return false; |
| if (!mojo::Equals(this->domain, other_struct.domain)) |
| return false; |
| if (!mojo::Equals(this->path, other_struct.path)) |
| return false; |
| if (!mojo::Equals(this->creation, other_struct.creation)) |
| return false; |
| if (!mojo::Equals(this->expiry, other_struct.expiry)) |
| return false; |
| if (!mojo::Equals(this->last_access, other_struct.last_access)) |
| return false; |
| if (!mojo::Equals(this->secure, other_struct.secure)) |
| return false; |
| if (!mojo::Equals(this->httponly, other_struct.httponly)) |
| return false; |
| if (!mojo::Equals(this->site_restrictions, other_struct.site_restrictions)) |
| return false; |
| if (!mojo::Equals(this->priority, other_struct.priority)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CanonicalCookie::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.name < rhs.name) |
| return true; |
| if (rhs.name < lhs.name) |
| return false; |
| if (lhs.value < rhs.value) |
| return true; |
| if (rhs.value < lhs.value) |
| return false; |
| if (lhs.domain < rhs.domain) |
| return true; |
| if (rhs.domain < lhs.domain) |
| return false; |
| if (lhs.path < rhs.path) |
| return true; |
| if (rhs.path < lhs.path) |
| return false; |
| if (lhs.creation < rhs.creation) |
| return true; |
| if (rhs.creation < lhs.creation) |
| return false; |
| if (lhs.expiry < rhs.expiry) |
| return true; |
| if (rhs.expiry < lhs.expiry) |
| return false; |
| if (lhs.last_access < rhs.last_access) |
| return true; |
| if (rhs.last_access < lhs.last_access) |
| return false; |
| if (lhs.secure < rhs.secure) |
| return true; |
| if (rhs.secure < lhs.secure) |
| return false; |
| if (lhs.httponly < rhs.httponly) |
| return true; |
| if (rhs.httponly < lhs.httponly) |
| return false; |
| if (lhs.site_restrictions < rhs.site_restrictions) |
| return true; |
| if (rhs.site_restrictions < lhs.site_restrictions) |
| return false; |
| if (lhs.priority < rhs.priority) |
| return true; |
| if (rhs.priority < lhs.priority) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieWithStatusPtr CookieWithStatus::Clone() const { |
| return New( |
| mojo::Clone(cookie), |
| mojo::Clone(status) |
| ); |
| } |
| |
| template <typename T, CookieWithStatus::EnableIfSame<T>*> |
| bool CookieWithStatus::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->cookie, other_struct.cookie)) |
| return false; |
| if (!mojo::Equals(this->status, other_struct.status)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieWithStatus::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.cookie < rhs.cookie) |
| return true; |
| if (rhs.cookie < lhs.cookie) |
| return false; |
| if (lhs.status < rhs.status) |
| return true; |
| if (rhs.status < lhs.status) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieAndLineWithStatusPtr CookieAndLineWithStatus::Clone() const { |
| return New( |
| mojo::Clone(cookie), |
| mojo::Clone(cookie_string), |
| mojo::Clone(status) |
| ); |
| } |
| |
| template <typename T, CookieAndLineWithStatus::EnableIfSame<T>*> |
| bool CookieAndLineWithStatus::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->cookie, other_struct.cookie)) |
| return false; |
| if (!mojo::Equals(this->cookie_string, other_struct.cookie_string)) |
| return false; |
| if (!mojo::Equals(this->status, other_struct.status)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieAndLineWithStatus::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.cookie < rhs.cookie) |
| return true; |
| if (rhs.cookie < lhs.cookie) |
| return false; |
| if (lhs.cookie_string < rhs.cookie_string) |
| return true; |
| if (rhs.cookie_string < lhs.cookie_string) |
| return false; |
| if (lhs.status < rhs.status) |
| return true; |
| if (rhs.status < lhs.status) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieDeletionFilterPtr CookieDeletionFilter::Clone() const { |
| return New( |
| mojo::Clone(created_after_time), |
| mojo::Clone(created_before_time), |
| mojo::Clone(excluding_domains), |
| mojo::Clone(including_domains), |
| mojo::Clone(cookie_name), |
| mojo::Clone(host_name), |
| mojo::Clone(url), |
| mojo::Clone(session_control) |
| ); |
| } |
| |
| template <typename T, CookieDeletionFilter::EnableIfSame<T>*> |
| bool CookieDeletionFilter::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->created_after_time, other_struct.created_after_time)) |
| return false; |
| if (!mojo::Equals(this->created_before_time, other_struct.created_before_time)) |
| return false; |
| if (!mojo::Equals(this->excluding_domains, other_struct.excluding_domains)) |
| return false; |
| if (!mojo::Equals(this->including_domains, other_struct.including_domains)) |
| return false; |
| if (!mojo::Equals(this->cookie_name, other_struct.cookie_name)) |
| return false; |
| if (!mojo::Equals(this->host_name, other_struct.host_name)) |
| return false; |
| if (!mojo::Equals(this->url, other_struct.url)) |
| return false; |
| if (!mojo::Equals(this->session_control, other_struct.session_control)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieDeletionFilter::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.created_after_time < rhs.created_after_time) |
| return true; |
| if (rhs.created_after_time < lhs.created_after_time) |
| return false; |
| if (lhs.created_before_time < rhs.created_before_time) |
| return true; |
| if (rhs.created_before_time < lhs.created_before_time) |
| return false; |
| if (lhs.excluding_domains < rhs.excluding_domains) |
| return true; |
| if (rhs.excluding_domains < lhs.excluding_domains) |
| return false; |
| if (lhs.including_domains < rhs.including_domains) |
| return true; |
| if (rhs.including_domains < lhs.including_domains) |
| return false; |
| if (lhs.cookie_name < rhs.cookie_name) |
| return true; |
| if (rhs.cookie_name < lhs.cookie_name) |
| return false; |
| if (lhs.host_name < rhs.host_name) |
| return true; |
| if (rhs.host_name < lhs.host_name) |
| return false; |
| if (lhs.url < rhs.url) |
| return true; |
| if (rhs.url < lhs.url) |
| return false; |
| if (lhs.session_control < rhs.session_control) |
| return true; |
| if (rhs.session_control < lhs.session_control) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace network |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieManagerParams::DataView, |
| ::network::mojom::blink::CookieManagerParamsPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieManagerParamsPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieManagerParamsPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CookieManagerParams::block_third_party_cookies) block_third_party_cookies( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->block_third_party_cookies; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieManagerParams::settings)& settings( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->settings; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieManagerParams::secure_origin_cookies_allowed_schemes)& secure_origin_cookies_allowed_schemes( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->secure_origin_cookies_allowed_schemes; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieManagerParams::matching_scheme_cookies_allowed_schemes)& matching_scheme_cookies_allowed_schemes( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->matching_scheme_cookies_allowed_schemes; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieManagerParams::third_party_cookies_allowed_schemes)& third_party_cookies_allowed_schemes( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->third_party_cookies_allowed_schemes; |
| } |
| |
| static decltype(::network::mojom::blink::CookieManagerParams::allow_file_scheme_cookies) allow_file_scheme_cookies( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->allow_file_scheme_cookies; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieManagerParams::DataView input, ::network::mojom::blink::CookieManagerParamsPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieOptions::DataView, |
| ::network::mojom::blink::CookieOptionsPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieOptionsPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieOptionsPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CookieOptions::exclude_httponly) exclude_httponly( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->exclude_httponly; |
| } |
| |
| static decltype(::network::mojom::blink::CookieOptions::same_site_cookie_context) same_site_cookie_context( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->same_site_cookie_context; |
| } |
| |
| static decltype(::network::mojom::blink::CookieOptions::update_access_time) update_access_time( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->update_access_time; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieOptions::server_time)& server_time( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->server_time; |
| } |
| |
| static decltype(::network::mojom::blink::CookieOptions::return_excluded_cookies) return_excluded_cookies( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->return_excluded_cookies; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieOptions::DataView input, ::network::mojom::blink::CookieOptionsPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CanonicalCookie::DataView, |
| ::network::mojom::blink::CanonicalCookiePtr> { |
| static bool IsNull(const ::network::mojom::blink::CanonicalCookiePtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CanonicalCookiePtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::name)& name( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->name; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::value)& value( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->value; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::domain)& domain( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->domain; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::path)& path( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->path; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::creation)& creation( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->creation; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::expiry)& expiry( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->expiry; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::last_access)& last_access( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->last_access; |
| } |
| |
| static decltype(::network::mojom::blink::CanonicalCookie::secure) secure( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->secure; |
| } |
| |
| static decltype(::network::mojom::blink::CanonicalCookie::httponly) httponly( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->httponly; |
| } |
| |
| static decltype(::network::mojom::blink::CanonicalCookie::site_restrictions) site_restrictions( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->site_restrictions; |
| } |
| |
| static decltype(::network::mojom::blink::CanonicalCookie::priority) priority( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->priority; |
| } |
| |
| static bool Read(::network::mojom::blink::CanonicalCookie::DataView input, ::network::mojom::blink::CanonicalCookiePtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieWithStatus::DataView, |
| ::network::mojom::blink::CookieWithStatusPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieWithStatusPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieWithStatusPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieWithStatus::cookie)& cookie( |
| const ::network::mojom::blink::CookieWithStatusPtr& input) { |
| return input->cookie; |
| } |
| |
| static decltype(::network::mojom::blink::CookieWithStatus::status) status( |
| const ::network::mojom::blink::CookieWithStatusPtr& input) { |
| return input->status; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieWithStatus::DataView input, ::network::mojom::blink::CookieWithStatusPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieAndLineWithStatus::DataView, |
| ::network::mojom::blink::CookieAndLineWithStatusPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieAndLineWithStatusPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieAndLineWithStatus::cookie)& cookie( |
| const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) { |
| return input->cookie; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieAndLineWithStatus::cookie_string)& cookie_string( |
| const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) { |
| return input->cookie_string; |
| } |
| |
| static decltype(::network::mojom::blink::CookieAndLineWithStatus::status) status( |
| const ::network::mojom::blink::CookieAndLineWithStatusPtr& input) { |
| return input->status; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieAndLineWithStatus::DataView input, ::network::mojom::blink::CookieAndLineWithStatusPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieDeletionFilter::DataView, |
| ::network::mojom::blink::CookieDeletionFilterPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieDeletionFilterPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieDeletionFilterPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::created_after_time)& created_after_time( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->created_after_time; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::created_before_time)& created_before_time( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->created_before_time; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::excluding_domains)& excluding_domains( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->excluding_domains; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::including_domains)& including_domains( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->including_domains; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::cookie_name)& cookie_name( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->cookie_name; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::host_name)& host_name( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->host_name; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieDeletionFilter::url)& url( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->url; |
| } |
| |
| static decltype(::network::mojom::blink::CookieDeletionFilter::session_control) session_control( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->session_control; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieDeletionFilter::DataView input, ::network::mojom::blink::CookieDeletionFilterPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_NETWORK_PUBLIC_MOJOM_COOKIE_MANAGER_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogMTExNjQsICJiZWdpbiI6IDExMTQ0LCAiZWRnZSI6ICIlL2t5dGhl
|
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv
|
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn
|
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVDaGFuZ2VMaXN0
|
| ZW5lciJ9fSwgeyJlbmQiOiAxMTkyOCwgImJlZ2luIjogMTE5MTQsICJlZGdlIjogIiUva3l0aGUv
|
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y
|
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl
|
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZUNoYW5nZUxpc3Rl
|
| bmVyLk9uQ29va2llQ2hhbmdlIn19LCB7ImVuZCI6IDEyMjU5LCAiYmVnaW4iOiAxMjI0NiwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29v
|
| a2llTWFuYWdlciJ9fSwgeyJlbmQiOiAxMzU2NSwgImJlZ2luIjogMTM1NTIsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFn
|
| ZXIuR2V0QWxsQ29va2llcyJ9fSwgeyJlbmQiOiAxMzgzOSwgImJlZ2luIjogMTM4MjYsICJlZGdl
|
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2
|
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj
|
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tp
|
| ZU1hbmFnZXIuR2V0Q29va2llTGlzdCJ9fSwgeyJlbmQiOiAxNDEyNywgImJlZ2luIjogMTQxMDks
|
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l
|
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p
|
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9t
|
| LkNvb2tpZU1hbmFnZXIuU2V0Q2Fub25pY2FsQ29va2llIn19LCB7ImVuZCI6IDE0NDYzLCAiYmVn
|
| aW4iOiAxNDQ0MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu
|
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl
|
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5l
|
| dHdvcmsubW9qb20uQ29va2llTWFuYWdlci5EZWxldGVDYW5vbmljYWxDb29raWUifX0sIHsiZW5k
|
| IjogMTQ3MTUsICJiZWdpbiI6IDE0NzAyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLkRlbGV0ZUNvb2tpZXMifX0s
|
| IHsiZW5kIjogMTQ4OTksICJiZWdpbiI6IDE0ODc2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLkFkZENvb2tpZUNo
|
| YW5nZUxpc3RlbmVyIn19LCB7ImVuZCI6IDE1MTA0LCAiYmVnaW4iOiAxNTA4MSwgImVkZ2UiOiAi
|
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l
|
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi
|
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFu
|
| YWdlci5BZGRHbG9iYWxDaGFuZ2VMaXN0ZW5lciJ9fSwgeyJlbmQiOiAxNTI1MiwgImJlZ2luIjog
|
| MTUyMzgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3Jr
|
| Lm1vam9tLkNvb2tpZU1hbmFnZXIuQ2xvbmVJbnRlcmZhY2UifX0sIHsiZW5kIjogMTU0NTgsICJi
|
| ZWdpbiI6IDE1NDQyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi
|
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy
|
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi
|
| bmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLkZsdXNoQ29va2llU3RvcmUifX0sIHsiZW5kIjog
|
| MTU2ODUsICJiZWdpbiI6IDE1NjYzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLkFsbG93RmlsZVNjaGVtZUNvb2tp
|
| ZXMifX0sIHsiZW5kIjogMTU4NDgsICJiZWdpbiI6IDE1ODMwLCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLlNldENv
|
| bnRlbnRTZXR0aW5ncyJ9fSwgeyJlbmQiOiAxNjA1OCwgImJlZ2luIjogMTYwMzQsICJlZGdlIjog
|
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt
|
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg
|
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1h
|
| bmFnZXIuU2V0Rm9yY2VLZWVwU2Vzc2lvblN0YXRlIn19LCB7ImVuZCI6IDE2MTc4LCAiYmVnaW4i
|
| OiAxNjE1NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdv
|
| cmsubW9qb20uQ29va2llTWFuYWdlci5CbG9ja1RoaXJkUGFydHlDb29raWVzIn19LCB7ImVuZCI6
|
| IDIxMzAxLCAiYmVnaW4iOiAyMTI4MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs
|
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u
|
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln
|
| bmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlclBhcmFtcyJ9fSwgeyJlbmQiOiAy
|
| NTMzOSwgImJlZ2luIjogMjUzMTQsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi
|
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv
|
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h
|
| dHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXJQYXJhbXMuYmxvY2tfdGhpcmRfcGFy
|
| dHlfY29va2llcyJ9fSwgeyJlbmQiOiAyNTQ5NSwgImJlZ2luIjogMjU0ODcsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFn
|
| ZXJQYXJhbXMuc2V0dGluZ3MifX0sIHsiZW5kIjogMjU2NTYsICJiZWdpbiI6IDI1NjE5LCAiZWRn
|
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi
|
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny
|
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29r
|
| aWVNYW5hZ2VyUGFyYW1zLnNlY3VyZV9vcmlnaW5fY29va2llc19hbGxvd2VkX3NjaGVtZXMifX0s
|
| IHsiZW5kIjogMjU4MjEsICJiZWdpbiI6IDI1NzgyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyUGFyYW1zLm1hdGNo
|
| aW5nX3NjaGVtZV9jb29raWVzX2FsbG93ZWRfc2NoZW1lcyJ9fSwgeyJlbmQiOiAyNTk3OCwgImJl
|
| Z2luIjogMjU5NDMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj
|
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJu
|
| ZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXJQYXJhbXMudGhpcmRfcGFydHlfY29va2llc19hbGxv
|
| d2VkX3NjaGVtZXMifX0sIHsiZW5kIjogMjYwOTUsICJiZWdpbiI6IDI2MDcwLCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5h
|
| Z2VyUGFyYW1zLmFsbG93X2ZpbGVfc2NoZW1lX2Nvb2tpZXMifX0sIHsiZW5kIjogMjcxMTksICJi
|
| ZWdpbiI6IDI3MTA2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi
|
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy
|
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi
|
| bmV0d29yay5tb2pvbS5Db29raWVPcHRpb25zIn19LCB7ImVuZCI6IDMwNzkwLCAiYmVnaW4iOiAz
|
| MDc3NCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsu
|
| bW9qb20uQ29va2llT3B0aW9ucy5leGNsdWRlX2h0dHBvbmx5In19LCB7ImVuZCI6IDMwOTE2LCAi
|
| YmVnaW4iOiAzMDg5MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog
|
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291
|
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog
|
| Im5ldHdvcmsubW9qb20uQ29va2llT3B0aW9ucy5zYW1lX3NpdGVfY29va2llX2NvbnRleHQifX0s
|
| IHsiZW5kIjogMzEwMTMsICJiZWdpbiI6IDMwOTk1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu
|
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj
|
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv
|
| bSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVPcHRpb25zLnVwZGF0ZV9hY2Nl
|
| c3NfdGltZSJ9fSwgeyJlbmQiOiAzMTExOCwgImJlZ2luIjogMzExMDcsICJlZGdlIjogIiUva3l0
|
| aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsi
|
| Y29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1
|
| YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU9wdGlvbnMu
|
| c2VydmVyX3RpbWUifX0sIHsiZW5kIjogMzEyMjUsICJiZWdpbiI6IDMxMjAyLCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVPcHRp
|
| b25zLnJldHVybl9leGNsdWRlZF9jb29raWVzIn19LCB7ImVuZCI6IDMyMTgwLCAiYmVnaW4iOiAz
|
| MjE2NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsu
|
| bW9qb20uQ2Fub25pY2FsQ29va2llIn19LCB7ImVuZCI6IDM2MDA2LCAiYmVnaW4iOiAzNjAwMiwg
|
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz
|
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1
|
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u
|
| Q2Fub25pY2FsQ29va2llLm5hbWUifX0sIHsiZW5kIjogMzYwODYsICJiZWdpbiI6IDM2MDgxLCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D
|
| YW5vbmljYWxDb29raWUudmFsdWUifX0sIHsiZW5kIjogMzYxNjgsICJiZWdpbiI6IDM2MTYyLCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D
|
| YW5vbmljYWxDb29raWUuZG9tYWluIn19LCB7ImVuZCI6IDM2MjQ2LCAiYmVnaW4iOiAzNjI0Miwg
|
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz
|
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1
|
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u
|
| Q2Fub25pY2FsQ29va2llLnBhdGgifX0sIHsiZW5kIjogMzYzMzEsICJiZWdpbiI6IDM2MzIzLCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D
|
| YW5vbmljYWxDb29raWUuY3JlYXRpb24ifX0sIHsiZW5kIjogMzY0MTIsICJiZWdpbiI6IDM2NDA2
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pv
|
| bS5DYW5vbmljYWxDb29raWUuZXhwaXJ5In19LCB7ImVuZCI6IDM2NTAzLCAiYmVnaW4iOiAzNjQ5
|
| MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv
|
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9q
|
| b20uQ2Fub25pY2FsQ29va2llLmxhc3RfYWNjZXNzIn19LCB7ImVuZCI6IDM2NTc4LCAiYmVnaW4i
|
| OiAzNjU3MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdv
|
| cmsubW9qb20uQ2Fub25pY2FsQ29va2llLnNlY3VyZSJ9fSwgeyJlbmQiOiAzNjY1NywgImJlZ2lu
|
| IjogMzY2NDksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNo
|
| b3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5j
|
| b20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3
|
| b3JrLm1vam9tLkNhbm9uaWNhbENvb2tpZS5odHRwb25seSJ9fSwgeyJlbmQiOiAzNjc2NCwgImJl
|
| Z2luIjogMzY3NDcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh
|
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj
|
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJu
|
| ZXR3b3JrLm1vam9tLkNhbm9uaWNhbENvb2tpZS5zaXRlX3Jlc3RyaWN0aW9ucyJ9fSwgeyJlbmQi
|
| OiAzNjg1MywgImJlZ2luIjogMzY4NDUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp
|
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNhbm9uaWNhbENvb2tpZS5wcmlvcml0eSJ9fSwgeyJl
|
| bmQiOiAzNzgxOCwgImJlZ2luIjogMzc4MDIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0
|
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t
|
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg
|
| InNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZVdpdGhTdGF0dXMifX0sIHsiZW5kIjog
|
| NDE0NTMsICJiZWdpbiI6IDQxNDQ3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVXaXRoU3RhdHVzLmNvb2tpZSJ9fSwgeyJlbmQi
|
| OiA0MTU0NiwgImJlZ2luIjogNDE1NDAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi
|
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt
|
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp
|
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZVdpdGhTdGF0dXMuc3RhdHVzIn19LCB7ImVu
|
| ZCI6IDQyNTI5LCAiYmVnaW4iOiA0MjUwNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llQW5kTGluZVdpdGhTdGF0dXMifX0sIHsi
|
| ZW5kIjogNDY0MDQsICJiZWdpbiI6IDQ2Mzk4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh
|
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVBbmRMaW5lV2l0aFN0YXR1cy5jb29r
|
| aWUifX0sIHsiZW5kIjogNDY1MDgsICJiZWdpbiI6IDQ2NDk1LCAiZWRnZSI6ICIlL2t5dGhlL2Vk
|
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1
|
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6
|
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVBbmRMaW5lV2l0aFN0
|
| YXR1cy5jb29raWVfc3RyaW5nIn19LCB7ImVuZCI6IDQ2NjA4LCAiYmVnaW4iOiA0NjYwMiwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29v
|
| a2llQW5kTGluZVdpdGhTdGF0dXMuc3RhdHVzIn19LCB7ImVuZCI6IDQ3NjEzLCAiYmVnaW4iOiA0
|
| NzU5MywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsu
|
| bW9qb20uQ29va2llRGVsZXRpb25GaWx0ZXIifX0sIHsiZW5kIjogNTE3MDksICJiZWdpbiI6IDUx
|
| NjkxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl
|
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No
|
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5t
|
| b2pvbS5Db29raWVEZWxldGlvbkZpbHRlci5jcmVhdGVkX2FmdGVyX3RpbWUifX0sIHsiZW5kIjog
|
| NTE4MzcsICJiZWdpbiI6IDUxODE4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg
|
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n
|
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu
|
| YXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVEZWxldGlvbkZpbHRlci5jcmVhdGVkX2JlZm9y
|
| ZV90aW1lIn19LCB7ImVuZCI6IDUxOTc1LCAiYmVnaW4iOiA1MTk1OCwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25G
|
| aWx0ZXIuZXhjbHVkaW5nX2RvbWFpbnMifX0sIHsiZW5kIjogNTIxMTMsICJiZWdpbiI6IDUyMDk2
|
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu
|
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t
|
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pv
|
| bS5Db29raWVEZWxldGlvbkZpbHRlci5pbmNsdWRpbmdfZG9tYWlucyJ9fSwgeyJlbmQiOiA1MjIx
|
| MCwgImJlZ2luIjogNTIxOTksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw
|
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds
|
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy
|
| ZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZURlbGV0aW9uRmlsdGVyLmNvb2tpZV9uYW1lIn19LCB7
|
| ImVuZCI6IDUyMzAzLCAiYmVnaW4iOiA1MjI5NCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy
|
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy
|
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i
|
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25GaWx0ZXIuaG9zdF9u
|
| YW1lIn19LCB7ImVuZCI6IDUyNDAyLCAiYmVnaW4iOiA1MjM5OSwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25GaWx0
|
| ZXIudXJsIn19LCB7ImVuZCI6IDUyNTI0LCAiYmVnaW4iOiA1MjUwOSwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25G
|
| aWx0ZXIuc2Vzc2lvbl9jb250cm9sIn19XSwgInR5cGUiOiAia3l0aGUwIn0=
|
| */ |