| // services/network/public/mojom/cookie_manager.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit |
| |
| // 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 "third_party/abseil-cpp/absl/types/optional.h" |
| #include "mojo/public/cpp/bindings/clone_traits.h" |
| #include "mojo/public/cpp/bindings/equals_traits.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/struct_ptr.h" |
| #include "mojo/public/cpp/bindings/struct_traits.h" |
| #include "mojo/public/cpp/bindings/union_traits.h" |
| |
| #include "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h" |
| |
| #include "services/network/public/mojom/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 "services/network/public/mojom/cookie_partition_key.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/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| |
| |
| #include "services/network/public/cpp/cookie_manager_mojom_traits.h" |
| #include "services/network/public/cpp/cookie_manager_shared_mojom_traits.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_CookieAccessDelegateType_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieAccessDelegateType& value) { |
| using utype = std::underlying_type<::network::mojom::CookieAccessDelegateType>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieAccessDelegateType& left, const ::network::mojom::CookieAccessDelegateType& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieAccessDelegateType> |
| : public GenericHashTraits<::network::mojom::CookieAccessDelegateType> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::CookieAccessDelegateType EmptyValue() { return static_cast<::network::mojom::CookieAccessDelegateType>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::CookieAccessDelegateType& slot, bool) { |
| slot = static_cast<::network::mojom::CookieAccessDelegateType>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieAccessDelegateType& value) { |
| return value == static_cast<::network::mojom::CookieAccessDelegateType>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| 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 kEmptyValueIsZero = false; |
| static ::network::mojom::CookiePriority EmptyValue() { return 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_CookieSourceScheme_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieSourceScheme& value) { |
| using utype = std::underlying_type<::network::mojom::CookieSourceScheme>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieSourceScheme& left, const ::network::mojom::CookieSourceScheme& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieSourceScheme> |
| : public GenericHashTraits<::network::mojom::CookieSourceScheme> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::CookieSourceScheme EmptyValue() { return static_cast<::network::mojom::CookieSourceScheme>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::CookieSourceScheme& slot, bool) { |
| slot = static_cast<::network::mojom::CookieSourceScheme>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieSourceScheme& value) { |
| return value == static_cast<::network::mojom::CookieSourceScheme>(-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 kEmptyValueIsZero = false; |
| static ::network::mojom::CookieSameSite EmptyValue() { return 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_CookieEffectiveSameSite_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieEffectiveSameSite& value) { |
| using utype = std::underlying_type<::network::mojom::CookieEffectiveSameSite>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieEffectiveSameSite& left, const ::network::mojom::CookieEffectiveSameSite& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieEffectiveSameSite> |
| : public GenericHashTraits<::network::mojom::CookieEffectiveSameSite> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::CookieEffectiveSameSite EmptyValue() { return static_cast<::network::mojom::CookieEffectiveSameSite>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::CookieEffectiveSameSite& slot, bool) { |
| slot = static_cast<::network::mojom::CookieEffectiveSameSite>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieEffectiveSameSite& value) { |
| return value == static_cast<::network::mojom::CookieEffectiveSameSite>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_ContextType_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::ContextType& value) { |
| using utype = std::underlying_type<::network::mojom::ContextType>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::ContextType& left, const ::network::mojom::ContextType& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::ContextType> |
| : public GenericHashTraits<::network::mojom::ContextType> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::ContextType EmptyValue() { return static_cast<::network::mojom::ContextType>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::ContextType& slot, bool) { |
| slot = static_cast<::network::mojom::ContextType>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::ContextType& value) { |
| return value == static_cast<::network::mojom::ContextType>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieSameSiteContextMetadataDowngradeType_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieSameSiteContextMetadataDowngradeType& value) { |
| using utype = std::underlying_type<::network::mojom::CookieSameSiteContextMetadataDowngradeType>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieSameSiteContextMetadataDowngradeType& left, const ::network::mojom::CookieSameSiteContextMetadataDowngradeType& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieSameSiteContextMetadataDowngradeType> |
| : public GenericHashTraits<::network::mojom::CookieSameSiteContextMetadataDowngradeType> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::CookieSameSiteContextMetadataDowngradeType EmptyValue() { return static_cast<::network::mojom::CookieSameSiteContextMetadataDowngradeType>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::CookieSameSiteContextMetadataDowngradeType& slot, bool) { |
| slot = static_cast<::network::mojom::CookieSameSiteContextMetadataDowngradeType>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieSameSiteContextMetadataDowngradeType& value) { |
| return value == static_cast<::network::mojom::CookieSameSiteContextMetadataDowngradeType>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_ContextRedirectTypeBug1221316_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::ContextRedirectTypeBug1221316& value) { |
| using utype = std::underlying_type<::network::mojom::ContextRedirectTypeBug1221316>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::ContextRedirectTypeBug1221316& left, const ::network::mojom::ContextRedirectTypeBug1221316& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::ContextRedirectTypeBug1221316> |
| : public GenericHashTraits<::network::mojom::ContextRedirectTypeBug1221316> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::ContextRedirectTypeBug1221316 EmptyValue() { return static_cast<::network::mojom::ContextRedirectTypeBug1221316>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::ContextRedirectTypeBug1221316& slot, bool) { |
| slot = static_cast<::network::mojom::ContextRedirectTypeBug1221316>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::ContextRedirectTypeBug1221316& value) { |
| return value == static_cast<::network::mojom::ContextRedirectTypeBug1221316>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_SamePartyCookieContextType_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::SamePartyCookieContextType& value) { |
| using utype = std::underlying_type<::network::mojom::SamePartyCookieContextType>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::SamePartyCookieContextType& left, const ::network::mojom::SamePartyCookieContextType& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::SamePartyCookieContextType> |
| : public GenericHashTraits<::network::mojom::SamePartyCookieContextType> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::SamePartyCookieContextType EmptyValue() { return static_cast<::network::mojom::SamePartyCookieContextType>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::SamePartyCookieContextType& slot, bool) { |
| slot = static_cast<::network::mojom::SamePartyCookieContextType>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::SamePartyCookieContextType& value) { |
| return value == static_cast<::network::mojom::SamePartyCookieContextType>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct network_mojom_internal_CookieAccessSemantics_DataHashFn { |
| static unsigned GetHash(const ::network::mojom::CookieAccessSemantics& value) { |
| using utype = std::underlying_type<::network::mojom::CookieAccessSemantics>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::network::mojom::CookieAccessSemantics& left, const ::network::mojom::CookieAccessSemantics& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::network::mojom::CookieAccessSemantics> |
| : public GenericHashTraits<::network::mojom::CookieAccessSemantics> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::network::mojom::CookieAccessSemantics EmptyValue() { return static_cast<::network::mojom::CookieAccessSemantics>(-1000000); } |
| static void ConstructDeletedValue(::network::mojom::CookieAccessSemantics& slot, bool) { |
| slot = static_cast<::network::mojom::CookieAccessSemantics>(-1000001); |
| } |
| static bool IsDeletedValue(const ::network::mojom::CookieAccessSemantics& value) { |
| return value == static_cast<::network::mojom::CookieAccessSemantics>(-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 kEmptyValueIsZero = false; |
| static ::network::mojom::CookieChangeCause EmptyValue() { return 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 kEmptyValueIsZero = false; |
| static ::network::mojom::CookieDeletionSessionControl EmptyValue() { return 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 uint32_t MessageToStableIPCHash_(mojo::Message& message); |
| static const char* MessageToMethodName_(mojo::Message& message); |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| static constexpr bool HasUninterruptableMethods_ = 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() = default; |
| |
| |
| // @generated_from: network.mojom.CookieChangeListener.OnCookieChange |
| virtual void OnCookieChange(CookieChangeInfoPtr change) = 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 uint32_t MessageToStableIPCHash_(mojo::Message& message); |
| static const char* MessageToMethodName_(mojo::Message& message); |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| static constexpr bool HasUninterruptableMethods_ = 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, |
| kGetAllCookiesWithAccessSemanticsMinVersion = 0, |
| kGetCookieListMinVersion = 0, |
| kSetCanonicalCookieMinVersion = 0, |
| kDeleteCanonicalCookieMinVersion = 0, |
| kDeleteCookiesMinVersion = 0, |
| kDeleteSessionOnlyCookiesMinVersion = 0, |
| kAddCookieChangeListenerMinVersion = 0, |
| kAddGlobalChangeListenerMinVersion = 0, |
| kCloneInterfaceMinVersion = 0, |
| kFlushCookieStoreMinVersion = 0, |
| kAllowFileSchemeCookiesMinVersion = 0, |
| kSetContentSettingsMinVersion = 0, |
| kSetForceKeepSessionStateMinVersion = 0, |
| kBlockThirdPartyCookiesMinVersion = 0, |
| kSetContentSettingsForLegacyCookieAccessMinVersion = 0, |
| kSetStorageAccessGrantSettingsMinVersion = 0, |
| kConvertPartitionedCookiesToUnpartitionedMinVersion = 0, |
| }; |
| virtual ~CookieManager() = default; |
| |
| |
| using GetAllCookiesCallback = base::OnceCallback<void(const WTF::Vector<::net::CanonicalCookie>&)>; |
| |
| // @generated_from: network.mojom.CookieManager.GetAllCookies |
| virtual void GetAllCookies(GetAllCookiesCallback callback) = 0; |
| |
| |
| using GetAllCookiesWithAccessSemanticsCallback = base::OnceCallback<void(const WTF::Vector<::net::CanonicalCookie>&, const WTF::Vector<CookieAccessSemantics>&)>; |
| |
| // @generated_from: network.mojom.CookieManager.GetAllCookiesWithAccessSemantics |
| virtual void GetAllCookiesWithAccessSemantics(GetAllCookiesWithAccessSemanticsCallback callback) = 0; |
| |
| |
| using GetCookieListCallback = base::OnceCallback<void(WTF::Vector<CookieWithAccessResultPtr>, WTF::Vector<CookieWithAccessResultPtr>)>; |
| |
| // @generated_from: network.mojom.CookieManager.GetCookieList |
| virtual void GetCookieList(const ::blink::KURL& url, CookieOptionsPtr cookie_options, ::network::mojom::blink::CookiePartitionKeyCollectionPtr cookie_partition_key_collection, GetCookieListCallback callback) = 0; |
| |
| |
| using SetCanonicalCookieCallback = base::OnceCallback<void(CookieAccessResultPtr)>; |
| |
| // @generated_from: network.mojom.CookieManager.SetCanonicalCookie |
| virtual void SetCanonicalCookie(const ::net::CanonicalCookie& cookie, const ::blink::KURL& source_url, CookieOptionsPtr cookie_options, SetCanonicalCookieCallback callback) = 0; |
| |
| |
| using DeleteCanonicalCookieCallback = base::OnceCallback<void(bool)>; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteCanonicalCookie |
| virtual void DeleteCanonicalCookie(const ::net::CanonicalCookie& 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; |
| |
| |
| using DeleteSessionOnlyCookiesCallback = base::OnceCallback<void(uint32_t)>; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteSessionOnlyCookies |
| virtual void DeleteSessionOnlyCookies(DeleteSessionOnlyCookiesCallback callback) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.AddCookieChangeListener |
| virtual void AddCookieChangeListener(const ::blink::KURL& url, const WTF::String& name, ::mojo::PendingRemote<CookieChangeListener> listener) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.AddGlobalChangeListener |
| virtual void AddGlobalChangeListener(::mojo::PendingRemote<CookieChangeListener> notification_pointer) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.CloneInterface |
| virtual void CloneInterface(::mojo::PendingReceiver<CookieManager> 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; |
| |
| |
| // @generated_from: network.mojom.CookieManager.SetContentSettingsForLegacyCookieAccess |
| virtual void SetContentSettingsForLegacyCookieAccess(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) = 0; |
| |
| |
| using SetStorageAccessGrantSettingsCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: network.mojom.CookieManager.SetStorageAccessGrantSettings |
| virtual void SetStorageAccessGrantSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings, SetStorageAccessGrantSettingsCallback callback) = 0; |
| |
| |
| // @generated_from: network.mojom.CookieManager.ConvertPartitionedCookiesToUnpartitioned |
| virtual void ConvertPartitionedCookiesToUnpartitioned(const ::blink::KURL& url) = 0; |
| }; |
| |
| |
| |
| // @generated_from: network.mojom.CookieChangeListener |
| class BLINK_PLATFORM_EXPORT CookieChangeListenerProxy |
| : public CookieChangeListener { |
| public: |
| using InterfaceType = CookieChangeListener; |
| |
| explicit CookieChangeListenerProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: network.mojom.CookieChangeListener.OnCookieChange |
| void OnCookieChange(CookieChangeInfoPtr change) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| |
| |
| // @generated_from: network.mojom.CookieManager |
| class BLINK_PLATFORM_EXPORT CookieManagerProxy |
| : public CookieManager { |
| public: |
| using InterfaceType = CookieManager; |
| |
| explicit CookieManagerProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: network.mojom.CookieManager.GetAllCookies |
| void GetAllCookies(GetAllCookiesCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.GetAllCookiesWithAccessSemantics |
| void GetAllCookiesWithAccessSemantics(GetAllCookiesWithAccessSemanticsCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.GetCookieList |
| void GetCookieList(const ::blink::KURL& url, CookieOptionsPtr cookie_options, ::network::mojom::blink::CookiePartitionKeyCollectionPtr cookie_partition_key_collection, GetCookieListCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.SetCanonicalCookie |
| void SetCanonicalCookie(const ::net::CanonicalCookie& cookie, const ::blink::KURL& source_url, CookieOptionsPtr cookie_options, SetCanonicalCookieCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteCanonicalCookie |
| void DeleteCanonicalCookie(const ::net::CanonicalCookie& cookie, DeleteCanonicalCookieCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteCookies |
| void DeleteCookies(CookieDeletionFilterPtr filter, DeleteCookiesCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.DeleteSessionOnlyCookies |
| void DeleteSessionOnlyCookies(DeleteSessionOnlyCookiesCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.AddCookieChangeListener |
| void AddCookieChangeListener(const ::blink::KURL& url, const WTF::String& name, ::mojo::PendingRemote<CookieChangeListener> listener) final; |
| |
| // @generated_from: network.mojom.CookieManager.AddGlobalChangeListener |
| void AddGlobalChangeListener(::mojo::PendingRemote<CookieChangeListener> notification_pointer) final; |
| |
| // @generated_from: network.mojom.CookieManager.CloneInterface |
| void CloneInterface(::mojo::PendingReceiver<CookieManager> new_interface) final; |
| |
| // @generated_from: network.mojom.CookieManager.FlushCookieStore |
| void FlushCookieStore(FlushCookieStoreCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.AllowFileSchemeCookies |
| void AllowFileSchemeCookies(bool allow, AllowFileSchemeCookiesCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.SetContentSettings |
| void SetContentSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) final; |
| |
| // @generated_from: network.mojom.CookieManager.SetForceKeepSessionState |
| void SetForceKeepSessionState() final; |
| |
| // @generated_from: network.mojom.CookieManager.BlockThirdPartyCookies |
| void BlockThirdPartyCookies(bool block) final; |
| |
| // @generated_from: network.mojom.CookieManager.SetContentSettingsForLegacyCookieAccess |
| void SetContentSettingsForLegacyCookieAccess(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings) final; |
| |
| // @generated_from: network.mojom.CookieManager.SetStorageAccessGrantSettings |
| void SetStorageAccessGrantSettings(WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings, SetStorageAccessGrantSettingsCallback callback) final; |
| |
| // @generated_from: network.mojom.CookieManager.ConvertPartitionedCookiesToUnpartitioned |
| void ConvertPartitionedCookiesToUnpartitioned(const ::blink::KURL& url) 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() = default; |
| ~CookieChangeListenerStub() override = default; |
| |
| 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() = default; |
| ~CookieManagerStub() override = default; |
| |
| 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.CookieSameSiteContextMetadata |
| class BLINK_PLATFORM_EXPORT CookieSameSiteContextMetadata { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieSameSiteContextMetadata, T>::value>; |
| using DataView = CookieSameSiteContextMetadataDataView; |
| using Data_ = internal::CookieSameSiteContextMetadata_Data; |
| |
| template <typename... Args> |
| static CookieSameSiteContextMetadataPtr New(Args&&... args) { |
| return CookieSameSiteContextMetadataPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieSameSiteContextMetadataPtr From(const U& u) { |
| return mojo::TypeConverter<CookieSameSiteContextMetadataPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieSameSiteContextMetadata>::Convert(*this); |
| } |
| |
| |
| CookieSameSiteContextMetadata(); |
| |
| CookieSameSiteContextMetadata( |
| CookieSameSiteContextMetadataDowngradeType cross_site_redirect_downgrade, |
| ContextRedirectTypeBug1221316 redirect_type_bug_1221316); |
| |
| |
| ~CookieSameSiteContextMetadata(); |
| |
| // 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 = CookieSameSiteContextMetadataPtr> |
| CookieSameSiteContextMetadataPtr 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, CookieSameSiteContextMetadata::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieSameSiteContextMetadata::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieSameSiteContextMetadata::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::CookieSameSiteContextMetadata_UnserializedMessageContext< |
| UserType, CookieSameSiteContextMetadata::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieSameSiteContextMetadata::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieSameSiteContextMetadata::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::CookieSameSiteContextMetadata_UnserializedMessageContext< |
| UserType, CookieSameSiteContextMetadata::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieSameSiteContextMetadata::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieSameSiteContextMetadata.cross_site_redirect_downgrade |
| CookieSameSiteContextMetadataDowngradeType cross_site_redirect_downgrade; |
| |
| // @generated_from: network.mojom.CookieSameSiteContextMetadata.redirect_type_bug_1221316 |
| ContextRedirectTypeBug1221316 redirect_type_bug_1221316; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieInclusionStatus |
| class BLINK_PLATFORM_EXPORT CookieInclusionStatus { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieInclusionStatus, T>::value>; |
| using DataView = CookieInclusionStatusDataView; |
| using Data_ = internal::CookieInclusionStatus_Data; |
| |
| template <typename... Args> |
| static CookieInclusionStatusPtr New(Args&&... args) { |
| return CookieInclusionStatusPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieInclusionStatusPtr From(const U& u) { |
| return mojo::TypeConverter<CookieInclusionStatusPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieInclusionStatus>::Convert(*this); |
| } |
| |
| |
| CookieInclusionStatus(); |
| |
| CookieInclusionStatus( |
| uint32_t exclusion_reasons, |
| uint32_t warning_reasons); |
| |
| |
| ~CookieInclusionStatus(); |
| |
| // 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 = CookieInclusionStatusPtr> |
| CookieInclusionStatusPtr 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, CookieInclusionStatus::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieInclusionStatus::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieInclusionStatus::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::CookieInclusionStatus_UnserializedMessageContext< |
| UserType, CookieInclusionStatus::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieInclusionStatus::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieInclusionStatus::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::CookieInclusionStatus_UnserializedMessageContext< |
| UserType, CookieInclusionStatus::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieInclusionStatus::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieInclusionStatus.exclusion_reasons |
| uint32_t exclusion_reasons; |
| |
| // @generated_from: network.mojom.CookieInclusionStatus.warning_reasons |
| uint32_t warning_reasons; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.SamePartyContext |
| class BLINK_PLATFORM_EXPORT SamePartyContext { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<SamePartyContext, T>::value>; |
| using DataView = SamePartyContextDataView; |
| using Data_ = internal::SamePartyContext_Data; |
| |
| template <typename... Args> |
| static SamePartyContextPtr New(Args&&... args) { |
| return SamePartyContextPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static SamePartyContextPtr From(const U& u) { |
| return mojo::TypeConverter<SamePartyContextPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, SamePartyContext>::Convert(*this); |
| } |
| |
| |
| SamePartyContext(); |
| |
| SamePartyContext( |
| SamePartyCookieContextType context_type, |
| SamePartyCookieContextType ancestors_for_metrics_only, |
| SamePartyCookieContextType top_resource_for_metrics_only); |
| |
| |
| ~SamePartyContext(); |
| |
| // 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 = SamePartyContextPtr> |
| SamePartyContextPtr 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, SamePartyContext::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, SamePartyContext::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| SamePartyContext::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| SamePartyContext::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::SamePartyContext_UnserializedMessageContext< |
| UserType, SamePartyContext::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<SamePartyContext::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return SamePartyContext::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::SamePartyContext_UnserializedMessageContext< |
| UserType, SamePartyContext::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<SamePartyContext::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.SamePartyContext.context_type |
| SamePartyCookieContextType context_type; |
| |
| // @generated_from: network.mojom.SamePartyContext.ancestors_for_metrics_only |
| SamePartyCookieContextType ancestors_for_metrics_only; |
| |
| // @generated_from: network.mojom.SamePartyContext.top_resource_for_metrics_only |
| SamePartyCookieContextType top_resource_for_metrics_only; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, SamePartyContext::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, SamePartyContext::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, SamePartyContext::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, SamePartyContext::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieOrLine |
| class BLINK_PLATFORM_EXPORT CookieOrLine { |
| public: |
| using DataView = CookieOrLineDataView; |
| using Data_ = internal::CookieOrLine_Data; |
| using Tag = Data_::CookieOrLine_Tag; |
| |
| template <typename... Args> |
| static CookieOrLinePtr New(Args&&... args) { |
| static_assert( |
| sizeof...(args) < 0, |
| "Do not use Union::New(); to create a union of a given subtype, use " |
| "New<SubType>(), not New() followed by set_<sub_type>(). To represent " |
| "an empty union, mark the field or parameter as nullable in the mojom " |
| "definition."); |
| } |
| // Construct an instance holding |cookie|. |
| static CookieOrLinePtr |
| NewCookie( |
| const ::net::CanonicalCookie& cookie) { |
| auto result = CookieOrLinePtr(absl::in_place); |
| result->set_cookie(std::move(cookie)); |
| return result; |
| } |
| // Construct an instance holding |cookie_string|. |
| static CookieOrLinePtr |
| NewCookieString( |
| const WTF::String& cookie_string) { |
| auto result = CookieOrLinePtr(absl::in_place); |
| result->set_cookie_string(std::move(cookie_string)); |
| return result; |
| } |
| |
| template <typename U> |
| static CookieOrLinePtr From(const U& u) { |
| return mojo::TypeConverter<CookieOrLinePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieOrLine>::Convert(*this); |
| } |
| |
| CookieOrLine(); |
| ~CookieOrLine(); |
| |
| // Clone() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Clone() or copy |
| // constructor/assignment are available for members. |
| template <typename UnionPtrType = CookieOrLinePtr> |
| CookieOrLinePtr Clone() const; |
| |
| // Equals() is a template so it is only instantiated if it is used. Thus, the |
| // bindings generator does not need to know whether Equals() or == operator |
| // are available for members. |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, CookieOrLine>::value>::type* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, CookieOrLine>::value>::type* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| |
| Tag which() const { |
| return tag_; |
| } |
| |
| |
| |
| // @generated_from: network.mojom.CookieOrLine.cookie |
| bool is_cookie() const { return tag_ == Tag::kCookie; } |
| |
| |
| // @generated_from: network.mojom.CookieOrLine.cookie |
| ::net::CanonicalCookie& get_cookie() const { |
| CHECK(tag_ == Tag::kCookie); |
| return *(data_.cookie); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieOrLine.cookie |
| void set_cookie( |
| const ::net::CanonicalCookie& cookie); |
| |
| // @generated_from: network.mojom.CookieOrLine.cookie_string |
| bool is_cookie_string() const { return tag_ == Tag::kCookieString; } |
| |
| |
| // @generated_from: network.mojom.CookieOrLine.cookie_string |
| WTF::String& get_cookie_string() const { |
| CHECK(tag_ == Tag::kCookieString); |
| return *(data_.cookie_string); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieOrLine.cookie_string |
| void set_cookie_string( |
| const WTF::String& cookie_string); |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieOrLine::DataView>(input); |
| } |
| |
| template <typename UserType> |
| static bool DeserializeFromMessage(mojo::Message input, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<CookieOrLine::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| private: |
| union Union_ { |
| Union_() = default; |
| ~Union_() = default; |
| ::net::CanonicalCookie* cookie; |
| WTF::String* cookie_string; |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| void DestroyActive(); |
| Tag tag_; |
| Union_ data_; |
| }; |
| |
| |
| |
| |
| |
| // @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( |
| absl::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, |
| WTF::Vector<WTF::String> secure_origin_cookies_allowed_schemes, |
| WTF::Vector<WTF::String> matching_scheme_cookies_allowed_schemes, |
| WTF::Vector<WTF::String> third_party_cookies_allowed_schemes, |
| bool allow_file_scheme_cookies, |
| WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings_for_legacy_cookie_access, |
| WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings_for_storage_access, |
| CookieAccessDelegateType cookie_access_delegate_type); |
| |
| CookieManagerParams(const CookieManagerParams&) = delete; |
| CookieManagerParams& operator=(const CookieManagerParams&) = delete; |
| |
| ~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 T, CookieManagerParams::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| 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)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieManagerParams::DataView>( |
| message, data, data_num_bytes, 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, input.payload(), input.payload_num_bytes(), 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; |
| |
| // @generated_from: network.mojom.CookieManagerParams.settings_for_legacy_cookie_access |
| WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings_for_legacy_cookie_access; |
| |
| // @generated_from: network.mojom.CookieManagerParams.settings_for_storage_access |
| WTF::Vector<::content_settings::mojom::blink::ContentSettingPatternSourcePtr> settings_for_storage_access; |
| |
| // @generated_from: network.mojom.CookieManagerParams.cookie_access_delegate_type |
| CookieAccessDelegateType cookie_access_delegate_type; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, 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.CookieSameSiteContext |
| class BLINK_PLATFORM_EXPORT CookieSameSiteContext { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieSameSiteContext, T>::value>; |
| using DataView = CookieSameSiteContextDataView; |
| using Data_ = internal::CookieSameSiteContext_Data; |
| |
| template <typename... Args> |
| static CookieSameSiteContextPtr New(Args&&... args) { |
| return CookieSameSiteContextPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieSameSiteContextPtr From(const U& u) { |
| return mojo::TypeConverter<CookieSameSiteContextPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieSameSiteContext>::Convert(*this); |
| } |
| |
| |
| CookieSameSiteContext(); |
| |
| CookieSameSiteContext( |
| ContextType context, |
| ContextType schemeful_context, |
| CookieSameSiteContextMetadataPtr metadata, |
| CookieSameSiteContextMetadataPtr schemeful_metadata); |
| |
| CookieSameSiteContext(const CookieSameSiteContext&) = delete; |
| CookieSameSiteContext& operator=(const CookieSameSiteContext&) = delete; |
| |
| ~CookieSameSiteContext(); |
| |
| // 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 = CookieSameSiteContextPtr> |
| CookieSameSiteContextPtr 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, CookieSameSiteContext::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieSameSiteContext::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) const; |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieSameSiteContext::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieSameSiteContext::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::CookieSameSiteContext_UnserializedMessageContext< |
| UserType, CookieSameSiteContext::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieSameSiteContext::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieSameSiteContext::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::CookieSameSiteContext_UnserializedMessageContext< |
| UserType, CookieSameSiteContext::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieSameSiteContext::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieSameSiteContext.context |
| ContextType context; |
| |
| // @generated_from: network.mojom.CookieSameSiteContext.schemeful_context |
| ContextType schemeful_context; |
| |
| // @generated_from: network.mojom.CookieSameSiteContext.metadata |
| CookieSameSiteContextMetadataPtr metadata; |
| |
| // @generated_from: network.mojom.CookieSameSiteContext.schemeful_metadata |
| CookieSameSiteContextMetadataPtr schemeful_metadata; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieSameSiteContext::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieSameSiteContext::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieSameSiteContext::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieSameSiteContext::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( |
| absl::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, |
| CookieSameSiteContextPtr same_site_cookie_context, |
| bool update_access_time, |
| bool return_excluded_cookies, |
| SamePartyContextPtr same_party_context, |
| uint32_t full_party_context_size, |
| bool is_in_nontrivial_first_party_set); |
| |
| CookieOptions(const CookieOptions&) = delete; |
| CookieOptions& operator=(const CookieOptions&) = delete; |
| |
| ~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 T, CookieOptions::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| size_t Hash(size_t seed) 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)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieOptions::DataView>( |
| message, data, data_num_bytes, 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, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieOptions.exclude_httponly |
| bool exclude_httponly; |
| |
| // @generated_from: network.mojom.CookieOptions.same_site_cookie_context |
| CookieSameSiteContextPtr same_site_cookie_context; |
| |
| // @generated_from: network.mojom.CookieOptions.update_access_time |
| bool update_access_time; |
| |
| // @generated_from: network.mojom.CookieOptions.return_excluded_cookies |
| bool return_excluded_cookies; |
| |
| // @generated_from: network.mojom.CookieOptions.same_party_context |
| SamePartyContextPtr same_party_context; |
| |
| // @generated_from: network.mojom.CookieOptions.full_party_context_size |
| uint32_t full_party_context_size; |
| |
| // @generated_from: network.mojom.CookieOptions.is_in_nontrivial_first_party_set |
| bool is_in_nontrivial_first_party_set; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, 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( |
| absl::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, |
| ::base::Time last_update, |
| bool secure, |
| bool httponly, |
| CookieSameSite site_restrictions, |
| CookiePriority priority, |
| CookieSourceScheme source_scheme, |
| bool same_party, |
| ::network::mojom::blink::CookiePartitionKeyPtr partition_key, |
| int32_t source_port); |
| |
| CanonicalCookie(const CanonicalCookie&) = delete; |
| CanonicalCookie& operator=(const CanonicalCookie&) = delete; |
| |
| ~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 T, CanonicalCookie::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| 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)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CanonicalCookie::DataView>( |
| message, data, data_num_bytes, 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, input.payload(), input.payload_num_bytes(), 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.last_update |
| ::base::Time last_update; |
| |
| // @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; |
| |
| // @generated_from: network.mojom.CanonicalCookie.source_scheme |
| CookieSourceScheme source_scheme; |
| |
| // @generated_from: network.mojom.CanonicalCookie.same_party |
| bool same_party; |
| |
| // @generated_from: network.mojom.CanonicalCookie.partition_key |
| ::network::mojom::blink::CookiePartitionKeyPtr partition_key; |
| |
| // @generated_from: network.mojom.CanonicalCookie.source_port |
| int32_t source_port; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, 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.CookieAndLineWithAccessResult |
| class BLINK_PLATFORM_EXPORT CookieAndLineWithAccessResult { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieAndLineWithAccessResult, T>::value>; |
| using DataView = CookieAndLineWithAccessResultDataView; |
| using Data_ = internal::CookieAndLineWithAccessResult_Data; |
| |
| template <typename... Args> |
| static CookieAndLineWithAccessResultPtr New(Args&&... args) { |
| return CookieAndLineWithAccessResultPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieAndLineWithAccessResultPtr From(const U& u) { |
| return mojo::TypeConverter<CookieAndLineWithAccessResultPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieAndLineWithAccessResult>::Convert(*this); |
| } |
| |
| |
| CookieAndLineWithAccessResult(); |
| |
| CookieAndLineWithAccessResult( |
| const absl::optional<::net::CanonicalCookie>& cookie, |
| const WTF::String& cookie_string, |
| CookieAccessResultPtr access_result); |
| |
| CookieAndLineWithAccessResult(const CookieAndLineWithAccessResult&) = delete; |
| CookieAndLineWithAccessResult& operator=(const CookieAndLineWithAccessResult&) = delete; |
| |
| ~CookieAndLineWithAccessResult(); |
| |
| // 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 = CookieAndLineWithAccessResultPtr> |
| CookieAndLineWithAccessResultPtr 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, CookieAndLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieAndLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieAndLineWithAccessResult::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieAndLineWithAccessResult::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::CookieAndLineWithAccessResult_UnserializedMessageContext< |
| UserType, CookieAndLineWithAccessResult::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieAndLineWithAccessResult::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieAndLineWithAccessResult::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::CookieAndLineWithAccessResult_UnserializedMessageContext< |
| UserType, CookieAndLineWithAccessResult::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieAndLineWithAccessResult::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieAndLineWithAccessResult.cookie |
| absl::optional<::net::CanonicalCookie> cookie; |
| |
| // @generated_from: network.mojom.CookieAndLineWithAccessResult.cookie_string |
| WTF::String cookie_string; |
| |
| // @generated_from: network.mojom.CookieAndLineWithAccessResult.access_result |
| CookieAccessResultPtr access_result; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieAndLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieAndLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieAndLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieAndLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieOrLineWithAccessResult |
| class BLINK_PLATFORM_EXPORT CookieOrLineWithAccessResult { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieOrLineWithAccessResult, T>::value>; |
| using DataView = CookieOrLineWithAccessResultDataView; |
| using Data_ = internal::CookieOrLineWithAccessResult_Data; |
| |
| template <typename... Args> |
| static CookieOrLineWithAccessResultPtr New(Args&&... args) { |
| return CookieOrLineWithAccessResultPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieOrLineWithAccessResultPtr From(const U& u) { |
| return mojo::TypeConverter<CookieOrLineWithAccessResultPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieOrLineWithAccessResult>::Convert(*this); |
| } |
| |
| |
| CookieOrLineWithAccessResult(); |
| |
| CookieOrLineWithAccessResult( |
| CookieOrLinePtr cookie_or_line, |
| CookieAccessResultPtr access_result); |
| |
| CookieOrLineWithAccessResult(const CookieOrLineWithAccessResult&) = delete; |
| CookieOrLineWithAccessResult& operator=(const CookieOrLineWithAccessResult&) = delete; |
| |
| ~CookieOrLineWithAccessResult(); |
| |
| // 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 = CookieOrLineWithAccessResultPtr> |
| CookieOrLineWithAccessResultPtr 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, CookieOrLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieOrLineWithAccessResult::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieOrLineWithAccessResult::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::CookieOrLineWithAccessResult_UnserializedMessageContext< |
| UserType, CookieOrLineWithAccessResult::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieOrLineWithAccessResult::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieOrLineWithAccessResult::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::CookieOrLineWithAccessResult_UnserializedMessageContext< |
| UserType, CookieOrLineWithAccessResult::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieOrLineWithAccessResult::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieOrLineWithAccessResult.cookie_or_line |
| CookieOrLinePtr cookie_or_line; |
| |
| // @generated_from: network.mojom.CookieOrLineWithAccessResult.access_result |
| CookieAccessResultPtr access_result; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieAccessResult |
| class BLINK_PLATFORM_EXPORT CookieAccessResult { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieAccessResult, T>::value>; |
| using DataView = CookieAccessResultDataView; |
| using Data_ = internal::CookieAccessResult_Data; |
| |
| template <typename... Args> |
| static CookieAccessResultPtr New(Args&&... args) { |
| return CookieAccessResultPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieAccessResultPtr From(const U& u) { |
| return mojo::TypeConverter<CookieAccessResultPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieAccessResult>::Convert(*this); |
| } |
| |
| |
| CookieAccessResult(); |
| |
| CookieAccessResult( |
| CookieEffectiveSameSite effective_same_site, |
| CookieAccessSemantics access_semantics, |
| ::net::CookieInclusionStatus status, |
| bool is_allowed_to_access_secure_cookies); |
| |
| CookieAccessResult(const CookieAccessResult&) = delete; |
| CookieAccessResult& operator=(const CookieAccessResult&) = delete; |
| |
| ~CookieAccessResult(); |
| |
| // 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 = CookieAccessResultPtr> |
| CookieAccessResultPtr 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, CookieAccessResult::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieAccessResult::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieAccessResult::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::CookieAccessResult_UnserializedMessageContext< |
| UserType, CookieAccessResult::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieAccessResult::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieAccessResult::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::CookieAccessResult_UnserializedMessageContext< |
| UserType, CookieAccessResult::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieAccessResult::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieAccessResult.effective_same_site |
| CookieEffectiveSameSite effective_same_site; |
| |
| // @generated_from: network.mojom.CookieAccessResult.access_semantics |
| CookieAccessSemantics access_semantics; |
| |
| // @generated_from: network.mojom.CookieAccessResult.status |
| ::net::CookieInclusionStatus status; |
| |
| // @generated_from: network.mojom.CookieAccessResult.is_allowed_to_access_secure_cookies |
| bool is_allowed_to_access_secure_cookies; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieWithAccessResult |
| class BLINK_PLATFORM_EXPORT CookieWithAccessResult { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieWithAccessResult, T>::value>; |
| using DataView = CookieWithAccessResultDataView; |
| using Data_ = internal::CookieWithAccessResult_Data; |
| |
| template <typename... Args> |
| static CookieWithAccessResultPtr New(Args&&... args) { |
| return CookieWithAccessResultPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieWithAccessResultPtr From(const U& u) { |
| return mojo::TypeConverter<CookieWithAccessResultPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieWithAccessResult>::Convert(*this); |
| } |
| |
| |
| CookieWithAccessResult(); |
| |
| CookieWithAccessResult( |
| const ::net::CanonicalCookie& cookie, |
| CookieAccessResultPtr access_result); |
| |
| CookieWithAccessResult(const CookieWithAccessResult&) = delete; |
| CookieWithAccessResult& operator=(const CookieWithAccessResult&) = delete; |
| |
| ~CookieWithAccessResult(); |
| |
| // 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 = CookieWithAccessResultPtr> |
| CookieWithAccessResultPtr 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, CookieWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieWithAccessResult::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieWithAccessResult::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::CookieWithAccessResult_UnserializedMessageContext< |
| UserType, CookieWithAccessResult::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieWithAccessResult::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieWithAccessResult::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::CookieWithAccessResult_UnserializedMessageContext< |
| UserType, CookieWithAccessResult::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieWithAccessResult::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieWithAccessResult.cookie |
| ::net::CanonicalCookie cookie; |
| |
| // @generated_from: network.mojom.CookieWithAccessResult.access_result |
| CookieAccessResultPtr access_result; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieWithAccessResult::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: network.mojom.CookieChangeInfo |
| class BLINK_PLATFORM_EXPORT CookieChangeInfo { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CookieChangeInfo, T>::value>; |
| using DataView = CookieChangeInfoDataView; |
| using Data_ = internal::CookieChangeInfo_Data; |
| |
| template <typename... Args> |
| static CookieChangeInfoPtr New(Args&&... args) { |
| return CookieChangeInfoPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CookieChangeInfoPtr From(const U& u) { |
| return mojo::TypeConverter<CookieChangeInfoPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CookieChangeInfo>::Convert(*this); |
| } |
| |
| |
| CookieChangeInfo(); |
| |
| CookieChangeInfo( |
| const ::net::CanonicalCookie& cookie, |
| CookieAccessResultPtr access_result, |
| CookieChangeCause cause); |
| |
| CookieChangeInfo(const CookieChangeInfo&) = delete; |
| CookieChangeInfo& operator=(const CookieChangeInfo&) = delete; |
| |
| ~CookieChangeInfo(); |
| |
| // 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 = CookieChangeInfoPtr> |
| CookieChangeInfoPtr 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, CookieChangeInfo::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CookieChangeInfo::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| CookieChangeInfo::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CookieChangeInfo::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::CookieChangeInfo_UnserializedMessageContext< |
| UserType, CookieChangeInfo::DataView>>(0, 0, std::move(input)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieChangeInfo::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CookieChangeInfo::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::CookieChangeInfo_UnserializedMessageContext< |
| UserType, CookieChangeInfo::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CookieChangeInfo::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieChangeInfo.cookie |
| ::net::CanonicalCookie cookie; |
| |
| // @generated_from: network.mojom.CookieChangeInfo.access_result |
| CookieAccessResultPtr access_result; |
| |
| // @generated_from: network.mojom.CookieChangeInfo.cause |
| CookieChangeCause cause; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, CookieChangeInfo::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CookieChangeInfo::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CookieChangeInfo::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CookieChangeInfo::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( |
| absl::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( |
| absl::optional<::base::Time> created_after_time, |
| absl::optional<::base::Time> created_before_time, |
| absl::optional<WTF::Vector<WTF::String>> excluding_domains, |
| absl::optional<WTF::Vector<WTF::String>> including_domains, |
| const WTF::String& cookie_name, |
| const WTF::String& host_name, |
| const absl::optional<::blink::KURL>& url, |
| CookieDeletionSessionControl session_control, |
| ::network::mojom::blink::CookiePartitionKeyCollectionPtr cookie_partition_key_collection); |
| |
| CookieDeletionFilter(const CookieDeletionFilter&) = delete; |
| CookieDeletionFilter& operator=(const CookieDeletionFilter&) = delete; |
| |
| ~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 T, CookieDeletionFilter::EnableIfSame<T>* = nullptr> |
| bool operator==(const T& rhs) const { return Equals(rhs); } |
| 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)), |
| MOJO_CREATE_MESSAGE_FLAG_NONE); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| mojo::Message message; |
| return mojo::internal::DeserializeImpl<CookieDeletionFilter::DataView>( |
| message, data, data_num_bytes, 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, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.created_after_time |
| absl::optional<::base::Time> created_after_time; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.created_before_time |
| absl::optional<::base::Time> created_before_time; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.excluding_domains |
| absl::optional<WTF::Vector<WTF::String>> excluding_domains; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.including_domains |
| absl::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 |
| absl::optional<::blink::KURL> url; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.session_control |
| CookieDeletionSessionControl session_control; |
| |
| // @generated_from: network.mojom.CookieDeletionFilter.cookie_partition_key_collection |
| ::network::mojom::blink::CookiePartitionKeyCollectionPtr cookie_partition_key_collection; |
| |
| // Serialise this struct into a trace. |
| void WriteIntoTrace(perfetto::TracedValue traced_context) const; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| }; |
| |
| // The comparison operators are templates, so they are only instantiated if they |
| // are used. Thus, the bindings generator does not need to know whether |
| // comparison operators are available for members. |
| template <typename T, 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 UnionPtrType> |
| CookieOrLinePtr CookieOrLine::Clone() const { |
| switch (tag_) { |
| case Tag::kCookie: |
| return NewCookie( |
| mojo::Clone(*data_.cookie)); |
| case Tag::kCookieString: |
| return NewCookieString( |
| mojo::Clone(*data_.cookie_string)); |
| } |
| return nullptr; |
| } |
| |
| template <typename T, |
| typename std::enable_if<std::is_same< |
| T, CookieOrLine>::value>::type*> |
| bool CookieOrLine::Equals(const T& other) const { |
| if (tag_ != other.which()) |
| return false; |
| |
| switch (tag_) { |
| case Tag::kCookie: |
| return mojo::Equals(*(data_.cookie), *(other.data_.cookie)); |
| case Tag::kCookieString: |
| return mojo::Equals(*(data_.cookie_string), *(other.data_.cookie_string)); |
| } |
| |
| return false; |
| } |
| 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), |
| mojo::Clone(settings_for_legacy_cookie_access), |
| mojo::Clone(settings_for_storage_access), |
| mojo::Clone(cookie_access_delegate_type) |
| ); |
| } |
| |
| 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; |
| if (!mojo::Equals(this->settings_for_legacy_cookie_access, other_struct.settings_for_legacy_cookie_access)) |
| return false; |
| if (!mojo::Equals(this->settings_for_storage_access, other_struct.settings_for_storage_access)) |
| return false; |
| if (!mojo::Equals(this->cookie_access_delegate_type, other_struct.cookie_access_delegate_type)) |
| 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; |
| if (lhs.settings_for_legacy_cookie_access < rhs.settings_for_legacy_cookie_access) |
| return true; |
| if (rhs.settings_for_legacy_cookie_access < lhs.settings_for_legacy_cookie_access) |
| return false; |
| if (lhs.settings_for_storage_access < rhs.settings_for_storage_access) |
| return true; |
| if (rhs.settings_for_storage_access < lhs.settings_for_storage_access) |
| return false; |
| if (lhs.cookie_access_delegate_type < rhs.cookie_access_delegate_type) |
| return true; |
| if (rhs.cookie_access_delegate_type < lhs.cookie_access_delegate_type) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieSameSiteContextMetadataPtr CookieSameSiteContextMetadata::Clone() const { |
| return New( |
| mojo::Clone(cross_site_redirect_downgrade), |
| mojo::Clone(redirect_type_bug_1221316) |
| ); |
| } |
| |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>*> |
| bool CookieSameSiteContextMetadata::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->cross_site_redirect_downgrade, other_struct.cross_site_redirect_downgrade)) |
| return false; |
| if (!mojo::Equals(this->redirect_type_bug_1221316, other_struct.redirect_type_bug_1221316)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieSameSiteContextMetadata::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.cross_site_redirect_downgrade < rhs.cross_site_redirect_downgrade) |
| return true; |
| if (rhs.cross_site_redirect_downgrade < lhs.cross_site_redirect_downgrade) |
| return false; |
| if (lhs.redirect_type_bug_1221316 < rhs.redirect_type_bug_1221316) |
| return true; |
| if (rhs.redirect_type_bug_1221316 < lhs.redirect_type_bug_1221316) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieSameSiteContextPtr CookieSameSiteContext::Clone() const { |
| return New( |
| mojo::Clone(context), |
| mojo::Clone(schemeful_context), |
| mojo::Clone(metadata), |
| mojo::Clone(schemeful_metadata) |
| ); |
| } |
| |
| template <typename T, CookieSameSiteContext::EnableIfSame<T>*> |
| bool CookieSameSiteContext::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->context, other_struct.context)) |
| return false; |
| if (!mojo::Equals(this->schemeful_context, other_struct.schemeful_context)) |
| return false; |
| if (!mojo::Equals(this->metadata, other_struct.metadata)) |
| return false; |
| if (!mojo::Equals(this->schemeful_metadata, other_struct.schemeful_metadata)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieSameSiteContext::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.context < rhs.context) |
| return true; |
| if (rhs.context < lhs.context) |
| return false; |
| if (lhs.schemeful_context < rhs.schemeful_context) |
| return true; |
| if (rhs.schemeful_context < lhs.schemeful_context) |
| return false; |
| if (lhs.metadata < rhs.metadata) |
| return true; |
| if (rhs.metadata < lhs.metadata) |
| return false; |
| if (lhs.schemeful_metadata < rhs.schemeful_metadata) |
| return true; |
| if (rhs.schemeful_metadata < lhs.schemeful_metadata) |
| 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(return_excluded_cookies), |
| mojo::Clone(same_party_context), |
| mojo::Clone(full_party_context_size), |
| mojo::Clone(is_in_nontrivial_first_party_set) |
| ); |
| } |
| |
| 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->return_excluded_cookies, other_struct.return_excluded_cookies)) |
| return false; |
| if (!mojo::Equals(this->same_party_context, other_struct.same_party_context)) |
| return false; |
| if (!mojo::Equals(this->full_party_context_size, other_struct.full_party_context_size)) |
| return false; |
| if (!mojo::Equals(this->is_in_nontrivial_first_party_set, other_struct.is_in_nontrivial_first_party_set)) |
| 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.return_excluded_cookies < rhs.return_excluded_cookies) |
| return true; |
| if (rhs.return_excluded_cookies < lhs.return_excluded_cookies) |
| return false; |
| if (lhs.same_party_context < rhs.same_party_context) |
| return true; |
| if (rhs.same_party_context < lhs.same_party_context) |
| return false; |
| if (lhs.full_party_context_size < rhs.full_party_context_size) |
| return true; |
| if (rhs.full_party_context_size < lhs.full_party_context_size) |
| return false; |
| if (lhs.is_in_nontrivial_first_party_set < rhs.is_in_nontrivial_first_party_set) |
| return true; |
| if (rhs.is_in_nontrivial_first_party_set < lhs.is_in_nontrivial_first_party_set) |
| 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(last_update), |
| mojo::Clone(secure), |
| mojo::Clone(httponly), |
| mojo::Clone(site_restrictions), |
| mojo::Clone(priority), |
| mojo::Clone(source_scheme), |
| mojo::Clone(same_party), |
| mojo::Clone(partition_key), |
| mojo::Clone(source_port) |
| ); |
| } |
| |
| 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->last_update, other_struct.last_update)) |
| 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; |
| if (!mojo::Equals(this->source_scheme, other_struct.source_scheme)) |
| return false; |
| if (!mojo::Equals(this->same_party, other_struct.same_party)) |
| return false; |
| if (!mojo::Equals(this->partition_key, other_struct.partition_key)) |
| return false; |
| if (!mojo::Equals(this->source_port, other_struct.source_port)) |
| 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.last_update < rhs.last_update) |
| return true; |
| if (rhs.last_update < lhs.last_update) |
| 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; |
| if (lhs.source_scheme < rhs.source_scheme) |
| return true; |
| if (rhs.source_scheme < lhs.source_scheme) |
| return false; |
| if (lhs.same_party < rhs.same_party) |
| return true; |
| if (rhs.same_party < lhs.same_party) |
| return false; |
| if (lhs.partition_key < rhs.partition_key) |
| return true; |
| if (rhs.partition_key < lhs.partition_key) |
| return false; |
| if (lhs.source_port < rhs.source_port) |
| return true; |
| if (rhs.source_port < lhs.source_port) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieInclusionStatusPtr CookieInclusionStatus::Clone() const { |
| return New( |
| mojo::Clone(exclusion_reasons), |
| mojo::Clone(warning_reasons) |
| ); |
| } |
| |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>*> |
| bool CookieInclusionStatus::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->exclusion_reasons, other_struct.exclusion_reasons)) |
| return false; |
| if (!mojo::Equals(this->warning_reasons, other_struct.warning_reasons)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieInclusionStatus::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.exclusion_reasons < rhs.exclusion_reasons) |
| return true; |
| if (rhs.exclusion_reasons < lhs.exclusion_reasons) |
| return false; |
| if (lhs.warning_reasons < rhs.warning_reasons) |
| return true; |
| if (rhs.warning_reasons < lhs.warning_reasons) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieAndLineWithAccessResultPtr CookieAndLineWithAccessResult::Clone() const { |
| return New( |
| mojo::Clone(cookie), |
| mojo::Clone(cookie_string), |
| mojo::Clone(access_result) |
| ); |
| } |
| |
| template <typename T, CookieAndLineWithAccessResult::EnableIfSame<T>*> |
| bool CookieAndLineWithAccessResult::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->access_result, other_struct.access_result)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieAndLineWithAccessResult::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.access_result < rhs.access_result) |
| return true; |
| if (rhs.access_result < lhs.access_result) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieOrLineWithAccessResultPtr CookieOrLineWithAccessResult::Clone() const { |
| return New( |
| mojo::Clone(cookie_or_line), |
| mojo::Clone(access_result) |
| ); |
| } |
| |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>*> |
| bool CookieOrLineWithAccessResult::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->cookie_or_line, other_struct.cookie_or_line)) |
| return false; |
| if (!mojo::Equals(this->access_result, other_struct.access_result)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieOrLineWithAccessResult::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.cookie_or_line < rhs.cookie_or_line) |
| return true; |
| if (rhs.cookie_or_line < lhs.cookie_or_line) |
| return false; |
| if (lhs.access_result < rhs.access_result) |
| return true; |
| if (rhs.access_result < lhs.access_result) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieAccessResultPtr CookieAccessResult::Clone() const { |
| return New( |
| mojo::Clone(effective_same_site), |
| mojo::Clone(access_semantics), |
| mojo::Clone(status), |
| mojo::Clone(is_allowed_to_access_secure_cookies) |
| ); |
| } |
| |
| template <typename T, CookieAccessResult::EnableIfSame<T>*> |
| bool CookieAccessResult::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->effective_same_site, other_struct.effective_same_site)) |
| return false; |
| if (!mojo::Equals(this->access_semantics, other_struct.access_semantics)) |
| return false; |
| if (!mojo::Equals(this->status, other_struct.status)) |
| return false; |
| if (!mojo::Equals(this->is_allowed_to_access_secure_cookies, other_struct.is_allowed_to_access_secure_cookies)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieAccessResult::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.effective_same_site < rhs.effective_same_site) |
| return true; |
| if (rhs.effective_same_site < lhs.effective_same_site) |
| return false; |
| if (lhs.access_semantics < rhs.access_semantics) |
| return true; |
| if (rhs.access_semantics < lhs.access_semantics) |
| return false; |
| if (lhs.status < rhs.status) |
| return true; |
| if (rhs.status < lhs.status) |
| return false; |
| if (lhs.is_allowed_to_access_secure_cookies < rhs.is_allowed_to_access_secure_cookies) |
| return true; |
| if (rhs.is_allowed_to_access_secure_cookies < lhs.is_allowed_to_access_secure_cookies) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieWithAccessResultPtr CookieWithAccessResult::Clone() const { |
| return New( |
| mojo::Clone(cookie), |
| mojo::Clone(access_result) |
| ); |
| } |
| |
| template <typename T, CookieWithAccessResult::EnableIfSame<T>*> |
| bool CookieWithAccessResult::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->cookie, other_struct.cookie)) |
| return false; |
| if (!mojo::Equals(this->access_result, other_struct.access_result)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieWithAccessResult::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.access_result < rhs.access_result) |
| return true; |
| if (rhs.access_result < lhs.access_result) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| SamePartyContextPtr SamePartyContext::Clone() const { |
| return New( |
| mojo::Clone(context_type), |
| mojo::Clone(ancestors_for_metrics_only), |
| mojo::Clone(top_resource_for_metrics_only) |
| ); |
| } |
| |
| template <typename T, SamePartyContext::EnableIfSame<T>*> |
| bool SamePartyContext::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->context_type, other_struct.context_type)) |
| return false; |
| if (!mojo::Equals(this->ancestors_for_metrics_only, other_struct.ancestors_for_metrics_only)) |
| return false; |
| if (!mojo::Equals(this->top_resource_for_metrics_only, other_struct.top_resource_for_metrics_only)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, SamePartyContext::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.context_type < rhs.context_type) |
| return true; |
| if (rhs.context_type < lhs.context_type) |
| return false; |
| if (lhs.ancestors_for_metrics_only < rhs.ancestors_for_metrics_only) |
| return true; |
| if (rhs.ancestors_for_metrics_only < lhs.ancestors_for_metrics_only) |
| return false; |
| if (lhs.top_resource_for_metrics_only < rhs.top_resource_for_metrics_only) |
| return true; |
| if (rhs.top_resource_for_metrics_only < lhs.top_resource_for_metrics_only) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CookieChangeInfoPtr CookieChangeInfo::Clone() const { |
| return New( |
| mojo::Clone(cookie), |
| mojo::Clone(access_result), |
| mojo::Clone(cause) |
| ); |
| } |
| |
| template <typename T, CookieChangeInfo::EnableIfSame<T>*> |
| bool CookieChangeInfo::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->cookie, other_struct.cookie)) |
| return false; |
| if (!mojo::Equals(this->access_result, other_struct.access_result)) |
| return false; |
| if (!mojo::Equals(this->cause, other_struct.cause)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CookieChangeInfo::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.access_result < rhs.access_result) |
| return true; |
| if (rhs.access_result < lhs.access_result) |
| return false; |
| if (lhs.cause < rhs.cause) |
| return true; |
| if (rhs.cause < lhs.cause) |
| 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), |
| mojo::Clone(cookie_partition_key_collection) |
| ); |
| } |
| |
| 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; |
| if (!mojo::Equals(this->cookie_partition_key_collection, other_struct.cookie_partition_key_collection)) |
| 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; |
| if (lhs.cookie_partition_key_collection < rhs.cookie_partition_key_collection) |
| return true; |
| if (rhs.cookie_partition_key_collection < lhs.cookie_partition_key_collection) |
| 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 const decltype(::network::mojom::blink::CookieManagerParams::settings_for_legacy_cookie_access)& settings_for_legacy_cookie_access( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->settings_for_legacy_cookie_access; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieManagerParams::settings_for_storage_access)& settings_for_storage_access( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->settings_for_storage_access; |
| } |
| |
| static decltype(::network::mojom::blink::CookieManagerParams::cookie_access_delegate_type) cookie_access_delegate_type( |
| const ::network::mojom::blink::CookieManagerParamsPtr& input) { |
| return input->cookie_access_delegate_type; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieManagerParams::DataView input, ::network::mojom::blink::CookieManagerParamsPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieSameSiteContextMetadata::DataView, |
| ::network::mojom::blink::CookieSameSiteContextMetadataPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieSameSiteContextMetadataPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieSameSiteContextMetadataPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CookieSameSiteContextMetadata::cross_site_redirect_downgrade) cross_site_redirect_downgrade( |
| const ::network::mojom::blink::CookieSameSiteContextMetadataPtr& input) { |
| return input->cross_site_redirect_downgrade; |
| } |
| |
| static decltype(::network::mojom::blink::CookieSameSiteContextMetadata::redirect_type_bug_1221316) redirect_type_bug_1221316( |
| const ::network::mojom::blink::CookieSameSiteContextMetadataPtr& input) { |
| return input->redirect_type_bug_1221316; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieSameSiteContextMetadata::DataView input, ::network::mojom::blink::CookieSameSiteContextMetadataPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieSameSiteContext::DataView, |
| ::network::mojom::blink::CookieSameSiteContextPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieSameSiteContextPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieSameSiteContextPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CookieSameSiteContext::context) context( |
| const ::network::mojom::blink::CookieSameSiteContextPtr& input) { |
| return input->context; |
| } |
| |
| static decltype(::network::mojom::blink::CookieSameSiteContext::schemeful_context) schemeful_context( |
| const ::network::mojom::blink::CookieSameSiteContextPtr& input) { |
| return input->schemeful_context; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieSameSiteContext::metadata)& metadata( |
| const ::network::mojom::blink::CookieSameSiteContextPtr& input) { |
| return input->metadata; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieSameSiteContext::schemeful_metadata)& schemeful_metadata( |
| const ::network::mojom::blink::CookieSameSiteContextPtr& input) { |
| return input->schemeful_metadata; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieSameSiteContext::DataView input, ::network::mojom::blink::CookieSameSiteContextPtr* 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 const 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 decltype(::network::mojom::blink::CookieOptions::return_excluded_cookies) return_excluded_cookies( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->return_excluded_cookies; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieOptions::same_party_context)& same_party_context( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->same_party_context; |
| } |
| |
| static decltype(::network::mojom::blink::CookieOptions::full_party_context_size) full_party_context_size( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->full_party_context_size; |
| } |
| |
| static decltype(::network::mojom::blink::CookieOptions::is_in_nontrivial_first_party_set) is_in_nontrivial_first_party_set( |
| const ::network::mojom::blink::CookieOptionsPtr& input) { |
| return input->is_in_nontrivial_first_party_set; |
| } |
| |
| 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 const decltype(::network::mojom::blink::CanonicalCookie::last_update)& last_update( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->last_update; |
| } |
| |
| 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 decltype(::network::mojom::blink::CanonicalCookie::source_scheme) source_scheme( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->source_scheme; |
| } |
| |
| static decltype(::network::mojom::blink::CanonicalCookie::same_party) same_party( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->same_party; |
| } |
| |
| static const decltype(::network::mojom::blink::CanonicalCookie::partition_key)& partition_key( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->partition_key; |
| } |
| |
| static decltype(::network::mojom::blink::CanonicalCookie::source_port) source_port( |
| const ::network::mojom::blink::CanonicalCookiePtr& input) { |
| return input->source_port; |
| } |
| |
| static bool Read(::network::mojom::blink::CanonicalCookie::DataView input, ::network::mojom::blink::CanonicalCookiePtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieInclusionStatus::DataView, |
| ::network::mojom::blink::CookieInclusionStatusPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieInclusionStatusPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieInclusionStatusPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CookieInclusionStatus::exclusion_reasons) exclusion_reasons( |
| const ::network::mojom::blink::CookieInclusionStatusPtr& input) { |
| return input->exclusion_reasons; |
| } |
| |
| static decltype(::network::mojom::blink::CookieInclusionStatus::warning_reasons) warning_reasons( |
| const ::network::mojom::blink::CookieInclusionStatusPtr& input) { |
| return input->warning_reasons; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieInclusionStatus::DataView input, ::network::mojom::blink::CookieInclusionStatusPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieAndLineWithAccessResult::DataView, |
| ::network::mojom::blink::CookieAndLineWithAccessResultPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieAndLineWithAccessResultPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieAndLineWithAccessResultPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieAndLineWithAccessResult::cookie)& cookie( |
| const ::network::mojom::blink::CookieAndLineWithAccessResultPtr& input) { |
| return input->cookie; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieAndLineWithAccessResult::cookie_string)& cookie_string( |
| const ::network::mojom::blink::CookieAndLineWithAccessResultPtr& input) { |
| return input->cookie_string; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieAndLineWithAccessResult::access_result)& access_result( |
| const ::network::mojom::blink::CookieAndLineWithAccessResultPtr& input) { |
| return input->access_result; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieAndLineWithAccessResult::DataView input, ::network::mojom::blink::CookieAndLineWithAccessResultPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieOrLineWithAccessResult::DataView, |
| ::network::mojom::blink::CookieOrLineWithAccessResultPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieOrLineWithAccessResultPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieOrLineWithAccessResultPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieOrLineWithAccessResult::cookie_or_line)& cookie_or_line( |
| const ::network::mojom::blink::CookieOrLineWithAccessResultPtr& input) { |
| return input->cookie_or_line; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieOrLineWithAccessResult::access_result)& access_result( |
| const ::network::mojom::blink::CookieOrLineWithAccessResultPtr& input) { |
| return input->access_result; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieOrLineWithAccessResult::DataView input, ::network::mojom::blink::CookieOrLineWithAccessResultPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieAccessResult::DataView, |
| ::network::mojom::blink::CookieAccessResultPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieAccessResultPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieAccessResultPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::CookieAccessResult::effective_same_site) effective_same_site( |
| const ::network::mojom::blink::CookieAccessResultPtr& input) { |
| return input->effective_same_site; |
| } |
| |
| static decltype(::network::mojom::blink::CookieAccessResult::access_semantics) access_semantics( |
| const ::network::mojom::blink::CookieAccessResultPtr& input) { |
| return input->access_semantics; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieAccessResult::status)& status( |
| const ::network::mojom::blink::CookieAccessResultPtr& input) { |
| return input->status; |
| } |
| |
| static decltype(::network::mojom::blink::CookieAccessResult::is_allowed_to_access_secure_cookies) is_allowed_to_access_secure_cookies( |
| const ::network::mojom::blink::CookieAccessResultPtr& input) { |
| return input->is_allowed_to_access_secure_cookies; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieAccessResult::DataView input, ::network::mojom::blink::CookieAccessResultPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieWithAccessResult::DataView, |
| ::network::mojom::blink::CookieWithAccessResultPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieWithAccessResultPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieWithAccessResultPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieWithAccessResult::cookie)& cookie( |
| const ::network::mojom::blink::CookieWithAccessResultPtr& input) { |
| return input->cookie; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieWithAccessResult::access_result)& access_result( |
| const ::network::mojom::blink::CookieWithAccessResultPtr& input) { |
| return input->access_result; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieWithAccessResult::DataView input, ::network::mojom::blink::CookieWithAccessResultPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::SamePartyContext::DataView, |
| ::network::mojom::blink::SamePartyContextPtr> { |
| static bool IsNull(const ::network::mojom::blink::SamePartyContextPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::SamePartyContextPtr* output) { output->reset(); } |
| |
| static decltype(::network::mojom::blink::SamePartyContext::context_type) context_type( |
| const ::network::mojom::blink::SamePartyContextPtr& input) { |
| return input->context_type; |
| } |
| |
| static decltype(::network::mojom::blink::SamePartyContext::ancestors_for_metrics_only) ancestors_for_metrics_only( |
| const ::network::mojom::blink::SamePartyContextPtr& input) { |
| return input->ancestors_for_metrics_only; |
| } |
| |
| static decltype(::network::mojom::blink::SamePartyContext::top_resource_for_metrics_only) top_resource_for_metrics_only( |
| const ::network::mojom::blink::SamePartyContextPtr& input) { |
| return input->top_resource_for_metrics_only; |
| } |
| |
| static bool Read(::network::mojom::blink::SamePartyContext::DataView input, ::network::mojom::blink::SamePartyContextPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT StructTraits<::network::mojom::blink::CookieChangeInfo::DataView, |
| ::network::mojom::blink::CookieChangeInfoPtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieChangeInfoPtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieChangeInfoPtr* output) { output->reset(); } |
| |
| static const decltype(::network::mojom::blink::CookieChangeInfo::cookie)& cookie( |
| const ::network::mojom::blink::CookieChangeInfoPtr& input) { |
| return input->cookie; |
| } |
| |
| static const decltype(::network::mojom::blink::CookieChangeInfo::access_result)& access_result( |
| const ::network::mojom::blink::CookieChangeInfoPtr& input) { |
| return input->access_result; |
| } |
| |
| static decltype(::network::mojom::blink::CookieChangeInfo::cause) cause( |
| const ::network::mojom::blink::CookieChangeInfoPtr& input) { |
| return input->cause; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieChangeInfo::DataView input, ::network::mojom::blink::CookieChangeInfoPtr* 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 const decltype(::network::mojom::blink::CookieDeletionFilter::cookie_partition_key_collection)& cookie_partition_key_collection( |
| const ::network::mojom::blink::CookieDeletionFilterPtr& input) { |
| return input->cookie_partition_key_collection; |
| } |
| |
| static bool Read(::network::mojom::blink::CookieDeletionFilter::DataView input, ::network::mojom::blink::CookieDeletionFilterPtr* output); |
| }; |
| |
| |
| template <> |
| struct BLINK_PLATFORM_EXPORT UnionTraits<::network::mojom::blink::CookieOrLine::DataView, |
| ::network::mojom::blink::CookieOrLinePtr> { |
| static bool IsNull(const ::network::mojom::blink::CookieOrLinePtr& input) { return !input; } |
| static void SetToNull(::network::mojom::blink::CookieOrLinePtr* output) { output->reset(); } |
| |
| static ::network::mojom::blink::CookieOrLine::Tag GetTag(const ::network::mojom::blink::CookieOrLinePtr& input) { |
| return input->which(); |
| } |
| |
| static const ::net::CanonicalCookie& cookie(const ::network::mojom::blink::CookieOrLinePtr& input) { |
| return input->get_cookie(); |
| } |
| |
| static const WTF::String& cookie_string(const ::network::mojom::blink::CookieOrLinePtr& input) { |
| return input->get_cookie_string(); |
| } |
| |
| static bool Read(::network::mojom::blink::CookieOrLine::DataView input, ::network::mojom::blink::CookieOrLinePtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_NETWORK_PUBLIC_MOJOM_COOKIE_MANAGER_MOJOM_BLINK_H_ |
| |
| /* Metadata comment |
| eyJtZXRhIjogW3siZW5kIjogMTkzODMsICJiZWdpbiI6IDE5MzYzLCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVDaGFuZ2VMaXN0 |
| ZW5lciJ9fSwgeyJlbmQiOiAyMDM0OSwgImJlZ2luIjogMjAzMzUsICJlZGdlIjogIiUva3l0aGUv |
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y |
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl |
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZUNoYW5nZUxpc3Rl |
| bmVyLk9uQ29va2llQ2hhbmdlIn19LCB7ImVuZCI6IDIwNjQwLCAiYmVnaW4iOiAyMDYyNywgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29v |
| a2llTWFuYWdlciJ9fSwgeyJlbmQiOiAyMjQxMiwgImJlZ2luIjogMjIzOTksICJlZGdlIjogIiUv |
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6 |
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh |
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFn |
| ZXIuR2V0QWxsQ29va2llcyJ9fSwgeyJlbmQiOiAyMjc0NywgImJlZ2luIjogMjI3MTUsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tp |
| ZU1hbmFnZXIuR2V0QWxsQ29va2llc1dpdGhBY2Nlc3NTZW1hbnRpY3MifX0sIHsiZW5kIjogMjMw |
| MzcsICJiZWdpbiI6IDIzMDI0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5 |
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n |
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1 |
| cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLkdldENvb2tpZUxpc3QifX0sIHsiZW5k |
| IjogMjM0MTUsICJiZWdpbiI6IDIzMzk3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz |
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1 |
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz |
| aWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLlNldENhbm9uaWNhbENvb2tp |
| ZSJ9fSwgeyJlbmQiOiAyMzc0NSwgImJlZ2luIjogMjM3MjQsICJlZGdlIjogIiUva3l0aGUvZWRn |
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz |
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog |
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXIuRGVsZXRl |
| Q2Fub25pY2FsQ29va2llIn19LCB7ImVuZCI6IDIzOTkyLCAiYmVnaW4iOiAyMzk3OSwgImVkZ2Ui |
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu |
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi |
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2ll |
| TWFuYWdlci5EZWxldGVDb29raWVzIn19LCB7ImVuZCI6IDI0MjU4LCAiYmVnaW4iOiAyNDIzNCwg |
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz |
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1 |
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u |
| Q29va2llTWFuYWdlci5EZWxldGVTZXNzaW9uT25seUNvb2tpZXMifX0sIHsiZW5kIjogMjQ0MjEs |
| ICJiZWdpbiI6IDI0Mzk4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi |
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz |
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi |
| OiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLkFkZENvb2tpZUNoYW5nZUxpc3RlbmVyIn19 |
| LCB7ImVuZCI6IDI0NjQ2LCAiYmVnaW4iOiAyNDYyMywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl |
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi |
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q |
| b20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlci5BZGRHbG9iYWxD |
| aGFuZ2VMaXN0ZW5lciJ9fSwgeyJlbmQiOiAyNDgxNCwgImJlZ2luIjogMjQ4MDAsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1h |
| bmFnZXIuQ2xvbmVJbnRlcmZhY2UifX0sIHsiZW5kIjogMjUwMzgsICJiZWdpbiI6IDI1MDIyLCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D |
| b29raWVNYW5hZ2VyLkZsdXNoQ29va2llU3RvcmUifX0sIHsiZW5kIjogMjUyNjUsICJiZWdpbiI6 |
| IDI1MjQzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y |
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t |
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29y |
| ay5tb2pvbS5Db29raWVNYW5hZ2VyLkFsbG93RmlsZVNjaGVtZUNvb2tpZXMifX0sIHsiZW5kIjog |
| MjU0MjgsICJiZWdpbiI6IDI1NDEwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwg |
| InR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5n |
| b29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWdu |
| YXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLlNldENvbnRlbnRTZXR0aW5ncyJ9 |
| fSwgeyJlbmQiOiAyNTYzOCwgImJlZ2luIjogMjU2MTQsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n |
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog |
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v |
| am9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXIuU2V0Rm9yY2VL |
| ZWVwU2Vzc2lvblN0YXRlIn19LCB7ImVuZCI6IDI1NzU4LCAiYmVnaW4iOiAyNTczNiwgImVkZ2Ui |
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu |
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi |
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2ll |
| TWFuYWdlci5CbG9ja1RoaXJkUGFydHlDb29raWVzIn19LCB7ImVuZCI6IDI1OTIyLCAiYmVnaW4i |
| OiAyNTg4MywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv |
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv |
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdv |
| cmsubW9qb20uQ29va2llTWFuYWdlci5TZXRDb250ZW50U2V0dGluZ3NGb3JMZWdhY3lDb29raWVB |
| Y2Nlc3MifX0sIHsiZW5kIjogMjYyMTksICJiZWdpbiI6IDI2MTkwLCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLlNl |
| dFN0b3JhZ2VBY2Nlc3NHcmFudFNldHRpbmdzIn19LCB7ImVuZCI6IDI2NTA5LCAiYmVnaW4iOiAy |
| NjQ2OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k |
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j |
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsu |
| bW9qb20uQ29va2llTWFuYWdlci5Db252ZXJ0UGFydGl0aW9uZWRDb29raWVzVG9VbnBhcnRpdGlv |
| bmVkIn19LCB7ImVuZCI6IDI2OTI2LCAiYmVnaW4iOiAyNjkxMiwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llQ2hhbmdlTGlzdGVu |
| ZXIuT25Db29raWVDaGFuZ2UifX0sIHsiZW5kIjogMjczNjMsICJiZWdpbiI6IDI3MzUwLCAiZWRn |
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi |
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny |
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29r |
| aWVNYW5hZ2VyLkdldEFsbENvb2tpZXMifX0sIHsiZW5kIjogMjc1MjYsICJiZWdpbiI6IDI3NDk0 |
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu |
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t |
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pv |
| bS5Db29raWVNYW5hZ2VyLkdldEFsbENvb2tpZXNXaXRoQWNjZXNzU2VtYW50aWNzIn19LCB7ImVu |
| ZCI6IDI3NjcwLCAiYmVnaW4iOiAyNzY1NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl |
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p |
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi |
| c2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlci5HZXRDb29raWVMaXN0In19 |
| LCB7ImVuZCI6IDI3OTU0LCAiYmVnaW4iOiAyNzkzNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl |
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi |
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q |
| b20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlci5TZXRDYW5vbmlj |
| YWxDb29raWUifX0sIHsiZW5kIjogMjgyMDQsICJiZWdpbiI6IDI4MTgzLCAiZWRnZSI6ICIlL2t5 |
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7 |
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n |
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2Vy |
| LkRlbGV0ZUNhbm9uaWNhbENvb2tpZSJ9fSwgeyJlbmQiOiAyODM3NSwgImJlZ2luIjogMjgzNjIs |
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l |
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p |
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9t |
| LkNvb2tpZU1hbmFnZXIuRGVsZXRlQ29va2llcyJ9fSwgeyJlbmQiOiAyODU1NCwgImJlZ2luIjog |
| Mjg1MzAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf |
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v |
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3Jr |
| Lm1vam9tLkNvb2tpZU1hbmFnZXIuRGVsZXRlU2Vzc2lvbk9ubHlDb29raWVzIn19LCB7ImVuZCI6 |
| IDI4NzEwLCAiYmVnaW4iOiAyODY4NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs |
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u |
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln |
| bmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlci5BZGRDb29raWVDaGFuZ2VMaXN0 |
| ZW5lciJ9fSwgeyJlbmQiOiAyODkyOCwgImJlZ2luIjogMjg5MDUsICJlZGdlIjogIiUva3l0aGUv |
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y |
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl |
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXIuQWRk |
| R2xvYmFsQ2hhbmdlTGlzdGVuZXIifX0sIHsiZW5kIjogMjkwODksICJiZWdpbiI6IDI5MDc1LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D |
| b29raWVNYW5hZ2VyLkNsb25lSW50ZXJmYWNlIn19LCB7ImVuZCI6IDI5MjQyLCAiYmVnaW4iOiAy |
| OTIyNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k |
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j |
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsu |
| bW9qb20uQ29va2llTWFuYWdlci5GbHVzaENvb2tpZVN0b3JlIn19LCB7ImVuZCI6IDI5Mzg4LCAi |
| YmVnaW4iOiAyOTM2NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog |
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291 |
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog |
| Im5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlci5BbGxvd0ZpbGVTY2hlbWVDb29raWVzIn19LCB7 |
| ImVuZCI6IDI5NTQ0LCAiYmVnaW4iOiAyOTUyNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlci5TZXRDb250ZW50U2V0 |
| dGluZ3MifX0sIHsiZW5kIjogMjk3NDcsICJiZWdpbiI6IDI5NzIzLCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyLlNl |
| dEZvcmNlS2VlcFNlc3Npb25TdGF0ZSJ9fSwgeyJlbmQiOiAyOTg2MCwgImJlZ2luIjogMjk4Mzgs |
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l |
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p |
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9t |
| LkNvb2tpZU1hbmFnZXIuQmxvY2tUaGlyZFBhcnR5Q29va2llcyJ9fSwgeyJlbmQiOiAzMDAxNywg |
| ImJlZ2luIjogMjk5NzgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6 |
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv |
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6 |
| ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXIuU2V0Q29udGVudFNldHRpbmdzRm9yTGVnYWN5 |
| Q29va2llQWNjZXNzIn19LCB7ImVuZCI6IDMwMjMwLCAiYmVnaW4iOiAzMDIwMSwgImVkZ2UiOiAi |
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l |
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi |
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFu |
| YWdlci5TZXRTdG9yYWdlQWNjZXNzR3JhbnRTZXR0aW5ncyJ9fSwgeyJlbmQiOiAzMDUxMywgImJl |
| Z2luIjogMzA0NzMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh |
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj |
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJu |
| ZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXIuQ29udmVydFBhcnRpdGlvbmVkQ29va2llc1RvVW5w |
| YXJ0aXRpb25lZCJ9fSwgeyJlbmQiOiAzMzg5MSwgImJlZ2luIjogMzM4NjIsICJlZGdlIjogIiUv |
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6 |
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh |
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZVNhbWVT |
| aXRlQ29udGV4dE1ldGFkYXRhIn19LCB7ImVuZCI6IDM4MTM5LCAiYmVnaW4iOiAzODExMCwgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29v |
| a2llU2FtZVNpdGVDb250ZXh0TWV0YWRhdGEuY3Jvc3Nfc2l0ZV9yZWRpcmVjdF9kb3duZ3JhZGUi |
| fX0sIHsiZW5kIjogMzgyOTEsICJiZWdpbiI6IDM4MjY2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv |
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6 |
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt |
| b2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVTYW1lU2l0ZUNvbnRleHRN |
| ZXRhZGF0YS5yZWRpcmVjdF90eXBlX2J1Z18xMjIxMzE2In19LCB7ImVuZCI6IDM5NDM0LCAiYmVn |
| aW4iOiAzOTQxMywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu |
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl |
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5l |
| dHdvcmsubW9qb20uQ29va2llSW5jbHVzaW9uU3RhdHVzIn19LCB7ImVuZCI6IDQzMzEzLCAiYmVn |
| aW4iOiA0MzI5NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu |
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl |
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5l |
| dHdvcmsubW9qb20uQ29va2llSW5jbHVzaW9uU3RhdHVzLmV4Y2x1c2lvbl9yZWFzb25zIn19LCB7 |
| ImVuZCI6IDQzNDE2LCAiYmVnaW4iOiA0MzQwMSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llSW5jbHVzaW9uU3RhdHVzLndhcm5p |
| bmdfcmVhc29ucyJ9fSwgeyJlbmQiOiA0NDUxOCwgImJlZ2luIjogNDQ1MDIsICJlZGdlIjogIiUv |
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6 |
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh |
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLlNhbWVQYXJ0eUNv |
| bnRleHQifX0sIHsiZW5kIjogNDg0MjAsICJiZWdpbiI6IDQ4NDA4LCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5TYW1lUGFydHlDb250ZXh0 |
| LmNvbnRleHRfdHlwZSJ9fSwgeyJlbmQiOiA0ODU1OCwgImJlZ2luIjogNDg1MzIsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLlNhbWVQYXJ0 |
| eUNvbnRleHQuYW5jZXN0b3JzX2Zvcl9tZXRyaWNzX29ubHkifX0sIHsiZW5kIjogNDg3MDIsICJi |
| ZWdpbiI6IDQ4NjczLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi |
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy |
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi |
| bmV0d29yay5tb2pvbS5TYW1lUGFydHlDb250ZXh0LnRvcF9yZXNvdXJjZV9mb3JfbWV0cmljc19v |
| bmx5In19LCB7ImVuZCI6IDQ5Nzc0LCAiYmVnaW4iOiA0OTc2MiwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llT3JMaW5lIn19LCB7 |
| ImVuZCI6IDUyMDcxLCAiYmVnaW4iOiA1MjA2MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llT3JMaW5lLmNvb2tpZSJ9fSwgeyJl |
| bmQiOiA1MjIwNywgImJlZ2luIjogNTIxOTcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU9yTGluZS5jb29raWUifX0sIHsiZW5k |
| IjogNTIzNTgsICJiZWdpbiI6IDUyMzQ4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz |
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1 |
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz |
| aWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVPckxpbmUuY29va2llIn19LCB7ImVuZCI6 |
| IDUyNDkyLCAiYmVnaW4iOiA1MjQ3NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs |
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u |
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln |
| bmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llT3JMaW5lLmNvb2tpZV9zdHJpbmcifX0sIHsi |
| ZW5kIjogNTI2MzcsICJiZWdpbiI6IDUyNjIwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVPckxpbmUuY29va2llX3N0cmluZyJ9 |
| fSwgeyJlbmQiOiA1MjgxNSwgImJlZ2luIjogNTI3OTgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n |
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog |
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v |
| am9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU9yTGluZS5jb29raWVfc3Ry |
| aW5nIn19LCB7ImVuZCI6IDUzNzc2LCAiYmVnaW4iOiA1Mzc1NywgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlclBhcmFt |
| cyJ9fSwgeyJlbmQiOiA1ODM1MCwgImJlZ2luIjogNTgzMjUsICJlZGdlIjogIiUva3l0aGUvZWRn |
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz |
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog |
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXJQYXJhbXMu |
| YmxvY2tfdGhpcmRfcGFydHlfY29va2llcyJ9fSwgeyJlbmQiOiA1ODUwNiwgImJlZ2luIjogNTg0 |
| OTgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVm |
| aW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hy |
| b21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1v |
| am9tLkNvb2tpZU1hbmFnZXJQYXJhbXMuc2V0dGluZ3MifX0sIHsiZW5kIjogNTg2NjcsICJiZWdp |
| biI6IDU4NjMwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0 |
| d29yay5tb2pvbS5Db29raWVNYW5hZ2VyUGFyYW1zLnNlY3VyZV9vcmlnaW5fY29va2llc19hbGxv |
| d2VkX3NjaGVtZXMifX0sIHsiZW5kIjogNTg4MzIsICJiZWdpbiI6IDU4NzkzLCAiZWRnZSI6ICIl |
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi |
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs |
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5h |
| Z2VyUGFyYW1zLm1hdGNoaW5nX3NjaGVtZV9jb29raWVzX2FsbG93ZWRfc2NoZW1lcyJ9fSwgeyJl |
| bmQiOiA1ODk4OSwgImJlZ2luIjogNTg5NTQsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU1hbmFnZXJQYXJhbXMudGhpcmRfcGFy |
| dHlfY29va2llc19hbGxvd2VkX3NjaGVtZXMifX0sIHsiZW5kIjogNTkxMDYsICJiZWdpbiI6IDU5 |
| MDgxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl |
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No |
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5t |
| b2pvbS5Db29raWVNYW5hZ2VyUGFyYW1zLmFsbG93X2ZpbGVfc2NoZW1lX2Nvb2tpZXMifX0sIHsi |
| ZW5kIjogNTkzMTIsICJiZWdpbiI6IDU5Mjc5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVNYW5hZ2VyUGFyYW1zLnNldHRpbmdz |
| X2Zvcl9sZWdhY3lfY29va2llX2FjY2VzcyJ9fSwgeyJlbmQiOiA1OTUwNiwgImJlZ2luIjogNTk0 |
| NzksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVm |
| aW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hy |
| b21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1v |
| am9tLkNvb2tpZU1hbmFnZXJQYXJhbXMuc2V0dGluZ3NfZm9yX3N0b3JhZ2VfYWNjZXNzIn19LCB7 |
| ImVuZCI6IDU5NjQ3LCAiYmVnaW4iOiA1OTYyMCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llTWFuYWdlclBhcmFtcy5jb29raWVf |
| YWNjZXNzX2RlbGVnYXRlX3R5cGUifX0sIHsiZW5kIjogNjA3NDgsICJiZWdpbiI6IDYwNzI3LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D |
| b29raWVTYW1lU2l0ZUNvbnRleHQifX0sIHsiZW5kIjogNjQ4ODUsICJiZWdpbiI6IDY0ODc4LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5D |
| b29raWVTYW1lU2l0ZUNvbnRleHQuY29udGV4dCJ9fSwgeyJlbmQiOiA2NDk5NSwgImJlZ2luIjog |
| NjQ5NzgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf |
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v |
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3Jr |
| Lm1vam9tLkNvb2tpZVNhbWVTaXRlQ29udGV4dC5zY2hlbWVmdWxfY29udGV4dCJ9fSwgeyJlbmQi |
| OiA2NTA5OSwgImJlZ2luIjogNjUwNjcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZVNhbWVTaXRlQ29udGV4dC5tZXRhZGF0YSJ9 |
| fSwgeyJlbmQiOiA2NTI0MSwgImJlZ2luIjogNjUyMjMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n |
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog |
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v |
| am9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZVNhbWVTaXRlQ29udGV4dC5z |
| Y2hlbWVmdWxfbWV0YWRhdGEifX0sIHsiZW5kIjogNjYzMzMsICJiZWdpbiI6IDY2MzIwLCAiZWRn |
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi |
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny |
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29r |
| aWVPcHRpb25zIn19LCB7ImVuZCI6IDcwMzYxLCAiYmVnaW4iOiA3MDM0NSwgImVkZ2UiOiAiJS9r |
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog |
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu |
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llT3B0aW9u |
| cy5leGNsdWRlX2h0dHBvbmx5In19LCB7ImVuZCI6IDcwNDkwLCAiYmVnaW4iOiA3MDQ2NiwgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29v |
| a2llT3B0aW9ucy5zYW1lX3NpdGVfY29va2llX2NvbnRleHQifX0sIHsiZW5kIjogNzA1ODcsICJi |
| ZWdpbiI6IDcwNTY5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi |
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy |
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi |
| bmV0d29yay5tb2pvbS5Db29raWVPcHRpb25zLnVwZGF0ZV9hY2Nlc3NfdGltZSJ9fSwgeyJlbmQi |
| OiA3MDY5NCwgImJlZ2luIjogNzA2NzEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZU9wdGlvbnMucmV0dXJuX2V4Y2x1ZGVkX2Nv |
| b2tpZXMifX0sIHsiZW5kIjogNzA4MDYsICJiZWdpbiI6IDcwNzg4LCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVPcHRpb25zLnNh |
| bWVfcGFydHlfY29udGV4dCJ9fSwgeyJlbmQiOiA3MDkxNywgImJlZ2luIjogNzA4OTQsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tp |
| ZU9wdGlvbnMuZnVsbF9wYXJ0eV9jb250ZXh0X3NpemUifX0sIHsiZW5kIjogNzEwNDIsICJiZWdp |
| biI6IDcxMDEwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0 |
| d29yay5tb2pvbS5Db29raWVPcHRpb25zLmlzX2luX25vbnRyaXZpYWxfZmlyc3RfcGFydHlfc2V0 |
| In19LCB7ImVuZCI6IDcyMTA2LCAiYmVnaW4iOiA3MjA5MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdl |
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi |
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi |
| bW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29va2llIn19LCB7 |
| ImVuZCI6IDc2MzczLCAiYmVnaW4iOiA3NjM2OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29va2llLm5hbWUifX0sIHsi |
| ZW5kIjogNzY0NTMsICJiZWdpbiI6IDc2NDQ4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DYW5vbmljYWxDb29raWUudmFsdWUifX0sIHsi |
| ZW5kIjogNzY1MzUsICJiZWdpbiI6IDc2NTI5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DYW5vbmljYWxDb29raWUuZG9tYWluIn19LCB7 |
| ImVuZCI6IDc2NjEzLCAiYmVnaW4iOiA3NjYwOSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29va2llLnBhdGgifX0sIHsi |
| ZW5kIjogNzY3MDAsICJiZWdpbiI6IDc2NjkyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DYW5vbmljYWxDb29raWUuY3JlYXRpb24ifX0s |
| IHsiZW5kIjogNzY3ODMsICJiZWdpbiI6IDc2Nzc3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu |
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj |
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv |
| bSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5DYW5vbmljYWxDb29raWUuZXhwaXJ5In19 |
| LCB7ImVuZCI6IDc2ODc2LCAiYmVnaW4iOiA3Njg2NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl |
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi |
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q |
| b20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29va2llLmxhc3RfYWNj |
| ZXNzIn19LCB7ImVuZCI6IDc2OTY5LCAiYmVnaW4iOiA3Njk1OCwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29va2llLmxh |
| c3RfdXBkYXRlIn19LCB7ImVuZCI6IDc3MDQ0LCAiYmVnaW4iOiA3NzAzOCwgImVkZ2UiOiAiJS9r |
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog |
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu |
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29v |
| a2llLnNlY3VyZSJ9fSwgeyJlbmQiOiA3NzEyMywgImJlZ2luIjogNzcxMTUsICJlZGdlIjogIiUv |
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6 |
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh |
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNhbm9uaWNhbENv |
| b2tpZS5odHRwb25seSJ9fSwgeyJlbmQiOiA3NzIzMCwgImJlZ2luIjogNzcyMTMsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNhbm9uaWNh |
| bENvb2tpZS5zaXRlX3Jlc3RyaWN0aW9ucyJ9fSwgeyJlbmQiOiA3NzMxOSwgImJlZ2luIjogNzcz |
| MTEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVm |
| aW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hy |
| b21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1v |
| am9tLkNhbm9uaWNhbENvb2tpZS5wcmlvcml0eSJ9fSwgeyJlbmQiOiA3NzQyMiwgImJlZ2luIjog |
| Nzc0MDksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf |
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v |
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3Jr |
| Lm1vam9tLkNhbm9uaWNhbENvb2tpZS5zb3VyY2Vfc2NoZW1lIn19LCB7ImVuZCI6IDc3NTA1LCAi |
| YmVnaW4iOiA3NzQ5NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog |
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291 |
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog |
| Im5ldHdvcmsubW9qb20uQ2Fub25pY2FsQ29va2llLnNhbWVfcGFydHkifX0sIHsiZW5kIjogNzc2 |
| MzYsICJiZWdpbiI6IDc3NjIzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5 |
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n |
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1 |
| cmUiOiAibmV0d29yay5tb2pvbS5DYW5vbmljYWxDb29raWUucGFydGl0aW9uX2tleSJ9fSwgeyJl |
| bmQiOiA3NzcyNCwgImJlZ2luIjogNzc3MTMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNhbm9uaWNhbENvb2tpZS5zb3VyY2VfcG9ydCJ9 |
| fSwgeyJlbmQiOiA3ODgyNSwgImJlZ2luIjogNzg3OTYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n |
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog |
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v |
| am9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZUFuZExpbmVXaXRoQWNjZXNz |
| UmVzdWx0In19LCB7ImVuZCI6IDgzMTU2LCAiYmVnaW4iOiA4MzE1MCwgImVkZ2UiOiAiJS9reXRo |
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj |
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh |
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llQW5kTGluZVdp |
| dGhBY2Nlc3NSZXN1bHQuY29va2llIn19LCB7ImVuZCI6IDgzMjY2LCAiYmVnaW4iOiA4MzI1Mywg |
| ImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVz |
| IiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1 |
| bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20u |
| Q29va2llQW5kTGluZVdpdGhBY2Nlc3NSZXN1bHQuY29va2llX3N0cmluZyJ9fSwgeyJlbmQiOiA4 |
| MzM4NiwgImJlZ2luIjogODMzNzMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi |
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv |
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h |
| dHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZUFuZExpbmVXaXRoQWNjZXNzUmVzdWx0LmFjY2Vz |
| c19yZXN1bHQifX0sIHsiZW5kIjogODQ1NDAsICJiZWdpbiI6IDg0NTEyLCAiZWRnZSI6ICIlL2t5 |
| dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7 |
| ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5n |
| dWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVPckxpbmVX |
| aXRoQWNjZXNzUmVzdWx0In19LCB7ImVuZCI6IDg4NzczLCAiYmVnaW4iOiA4ODc1OSwgImVkZ2Ui |
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu |
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi |
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2ll |
| T3JMaW5lV2l0aEFjY2Vzc1Jlc3VsdC5jb29raWVfb3JfbGluZSJ9fSwgeyJlbmQiOiA4ODg5Miwg |
| ImJlZ2luIjogODg4NzksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6 |
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv |
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6 |
| ICJuZXR3b3JrLm1vam9tLkNvb2tpZU9yTGluZVdpdGhBY2Nlc3NSZXN1bHQuYWNjZXNzX3Jlc3Vs |
| dCJ9fSwgeyJlbmQiOiA5MDAyMiwgImJlZ2luIjogOTAwMDQsICJlZGdlIjogIiUva3l0aGUvZWRn |
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz |
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog |
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZUFjY2Vzc1Jlc3VsdCJ9 |
| fSwgeyJlbmQiOiA5NDA5MCwgImJlZ2luIjogOTQwNzEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9n |
| ZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjog |
| ImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1v |
| am9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZUFjY2Vzc1Jlc3VsdC5lZmZl |
| Y3RpdmVfc2FtZV9zaXRlIn19LCB7ImVuZCI6IDk0MjA1LCAiYmVnaW4iOiA5NDE4OSwgImVkZ2Ui |
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu |
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi |
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2ll |
| QWNjZXNzUmVzdWx0LmFjY2Vzc19zZW1hbnRpY3MifX0sIHsiZW5kIjogOTQzMDcsICJiZWdpbiI6 |
| IDk0MzAxLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y |
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t |
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29y |
| ay5tb2pvbS5Db29raWVBY2Nlc3NSZXN1bHQuc3RhdHVzIn19LCB7ImVuZCI6IDk0NDQzLCAiYmVn |
| aW4iOiA5NDQwOCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu |
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl |
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5l |
| dHdvcmsubW9qb20uQ29va2llQWNjZXNzUmVzdWx0LmlzX2FsbG93ZWRfdG9fYWNjZXNzX3NlY3Vy |
| ZV9jb29raWVzIn19LCB7ImVuZCI6IDk1NTQxLCAiYmVnaW4iOiA5NTUxOSwgImVkZ2UiOiAiJS9r |
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog |
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu |
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llV2l0aEFj |
| Y2Vzc1Jlc3VsdCJ9fSwgeyJlbmQiOiA5OTU5NywgImJlZ2luIjogOTk1OTEsICJlZGdlIjogIiUv |
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6 |
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh |
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZVdpdGhB |
| Y2Nlc3NSZXN1bHQuY29va2llIn19LCB7ImVuZCI6IDk5NzEwLCAiYmVnaW4iOiA5OTY5NywgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29v |
| a2llV2l0aEFjY2Vzc1Jlc3VsdC5hY2Nlc3NfcmVzdWx0In19LCB7ImVuZCI6IDEwMDgxMywgImJl |
| Z2luIjogMTAwNzk3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi |
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy |
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi |
| bmV0d29yay5tb2pvbS5Db29raWVDaGFuZ2VJbmZvIn19LCB7ImVuZCI6IDEwNDcyNiwgImJlZ2lu |
| IjogMTA0NzIwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0 |
| d29yay5tb2pvbS5Db29raWVDaGFuZ2VJbmZvLmNvb2tpZSJ9fSwgeyJlbmQiOiAxMDQ4MzMsICJi |
| ZWdpbiI6IDEwNDgyMCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog |
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291 |
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog |
| Im5ldHdvcmsubW9qb20uQ29va2llQ2hhbmdlSW5mby5hY2Nlc3NfcmVzdWx0In19LCB7ImVuZCI6 |
| IDEwNDkyMCwgImJlZ2luIjogMTA0OTE1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz |
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1 |
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz |
| aWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVDaGFuZ2VJbmZvLmNhdXNlIn19LCB7ImVu |
| ZCI6IDEwNjAwNiwgImJlZ2luIjogMTA1OTg2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVEZWxldGlvbkZpbHRlciJ9fSwgeyJl |
| bmQiOiAxMTA0NjAsICJiZWdpbiI6IDExMDQ0MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25GaWx0ZXIuY3JlYXRl |
| ZF9hZnRlcl90aW1lIn19LCB7ImVuZCI6IDExMDU5MCwgImJlZ2luIjogMTEwNTcxLCAiZWRnZSI6 |
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5h |
| bWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIs |
| ICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVE |
| ZWxldGlvbkZpbHRlci5jcmVhdGVkX2JlZm9yZV90aW1lIn19LCB7ImVuZCI6IDExMDcyOCwgImJl |
| Z2luIjogMTEwNzExLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi |
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy |
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi |
| bmV0d29yay5tb2pvbS5Db29raWVEZWxldGlvbkZpbHRlci5leGNsdWRpbmdfZG9tYWlucyJ9fSwg |
| eyJlbmQiOiAxMTA4NjYsICJiZWdpbiI6IDExMDg0OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl |
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi |
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q |
| b20iLCAic2lnbmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25GaWx0ZXIuaW5j |
| bHVkaW5nX2RvbWFpbnMifX0sIHsiZW5kIjogMTEwOTYzLCAiYmVnaW4iOiAxMTA5NTIsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tp |
| ZURlbGV0aW9uRmlsdGVyLmNvb2tpZV9uYW1lIn19LCB7ImVuZCI6IDExMTA1NiwgImJlZ2luIjog |
| MTExMDQ3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y |
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t |
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29y |
| ay5tb2pvbS5Db29raWVEZWxldGlvbkZpbHRlci5ob3N0X25hbWUifX0sIHsiZW5kIjogMTExMTU1 |
| LCAiYmVnaW4iOiAxMTExNTIsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw |
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds |
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy |
| ZSI6ICJuZXR3b3JrLm1vam9tLkNvb2tpZURlbGV0aW9uRmlsdGVyLnVybCJ9fSwgeyJlbmQiOiAx |
| MTEyNzcsICJiZWdpbiI6IDExMTI2MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs |
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u |
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln |
| bmF0dXJlIjogIm5ldHdvcmsubW9qb20uQ29va2llRGVsZXRpb25GaWx0ZXIuc2Vzc2lvbl9jb250 |
| cm9sIn19LCB7ImVuZCI6IDExMTQ1OSwgImJlZ2luIjogMTExNDI4LCAiZWRnZSI6ICIlL2t5dGhl |
| L2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNv |
| cnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFn |
| ZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAibmV0d29yay5tb2pvbS5Db29raWVEZWxldGlvbkZp |
| bHRlci5jb29raWVfcGFydGl0aW9uX2tleV9jb2xsZWN0aW9uIn19XSwgInR5cGUiOiAia3l0aGUw |
| In0= |
| */ |
