| // services/tracing/public/mojom/perfetto_service.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_TRACING_PUBLIC_MOJOM_PERFETTO_SERVICE_MOJOM_BLINK_H_ |
| #define SERVICES_TRACING_PUBLIC_MOJOM_PERFETTO_SERVICE_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/tracing/public/mojom/perfetto_service.mojom-shared.h" |
| #include "services/tracing/public/mojom/perfetto_service.mojom-blink-forward.h" |
| #include "mojo/public/mojom/base/file.mojom-blink.h" |
| #include "mojo/public/mojom/base/shared_memory.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 "base/component_export.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace WTF { |
| struct tracing_mojom_internal_BufferFillPolicy_DataHashFn { |
| static unsigned GetHash(const ::tracing::mojom::BufferFillPolicy& value) { |
| using utype = std::underlying_type<::tracing::mojom::BufferFillPolicy>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::tracing::mojom::BufferFillPolicy& left, const ::tracing::mojom::BufferFillPolicy& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::tracing::mojom::BufferFillPolicy> |
| : public GenericHashTraits<::tracing::mojom::BufferFillPolicy> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::tracing::mojom::BufferFillPolicy EmptyValue() { return static_cast<::tracing::mojom::BufferFillPolicy>(-1000000); } |
| static void ConstructDeletedValue(::tracing::mojom::BufferFillPolicy& slot, bool) { |
| slot = static_cast<::tracing::mojom::BufferFillPolicy>(-1000001); |
| } |
| static bool IsDeletedValue(const ::tracing::mojom::BufferFillPolicy& value) { |
| return value == static_cast<::tracing::mojom::BufferFillPolicy>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace WTF { |
| struct tracing_mojom_internal_TracingClientPriority_DataHashFn { |
| static unsigned GetHash(const ::tracing::mojom::TracingClientPriority& value) { |
| using utype = std::underlying_type<::tracing::mojom::TracingClientPriority>::type; |
| return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value)); |
| } |
| static bool Equal(const ::tracing::mojom::TracingClientPriority& left, const ::tracing::mojom::TracingClientPriority& right) { |
| return left == right; |
| } |
| static const bool safe_to_compare_to_empty_or_deleted = true; |
| }; |
| |
| template <> |
| struct HashTraits<::tracing::mojom::TracingClientPriority> |
| : public GenericHashTraits<::tracing::mojom::TracingClientPriority> { |
| static_assert(true, |
| "-1000000 is a reserved enum value"); |
| static_assert(true, |
| "-1000001 is a reserved enum value"); |
| static const bool kEmptyValueIsZero = false; |
| static ::tracing::mojom::TracingClientPriority EmptyValue() { return static_cast<::tracing::mojom::TracingClientPriority>(-1000000); } |
| static void ConstructDeletedValue(::tracing::mojom::TracingClientPriority& slot, bool) { |
| slot = static_cast<::tracing::mojom::TracingClientPriority>(-1000001); |
| } |
| static bool IsDeletedValue(const ::tracing::mojom::TracingClientPriority& value) { |
| return value == static_cast<::tracing::mojom::TracingClientPriority>(-1000001); |
| } |
| }; |
| } // namespace WTF |
| |
| |
| namespace tracing { |
| namespace mojom { |
| namespace blink { |
| |
| class ProducerHostProxy; |
| |
| template <typename ImplRefTraits> |
| class ProducerHostStub; |
| |
| class ProducerHostRequestValidator; |
| class ProducerHostResponseValidator; |
| |
| |
| // @generated_from: tracing.mojom.ProducerHost |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerHost |
| : public ProducerHostInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(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_ = ProducerHostInterfaceBase; |
| using Proxy_ = ProducerHostProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = ProducerHostStub<ImplRefTraits>; |
| |
| using RequestValidator_ = ProducerHostRequestValidator; |
| using ResponseValidator_ = ProducerHostResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kCommitDataMinVersion = 0, |
| kRegisterDataSourceMinVersion = 0, |
| kRegisterTraceWriterMinVersion = 0, |
| kUnregisterTraceWriterMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct CommitData_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct RegisterDataSource_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct RegisterTraceWriter_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct UnregisterTraceWriter_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~ProducerHost() = default; |
| |
| |
| using CommitDataCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: tracing.mojom.ProducerHost.CommitData |
| virtual void CommitData(CommitDataRequestPtr data_request, CommitDataCallback callback) = 0; |
| |
| |
| // @generated_from: tracing.mojom.ProducerHost.RegisterDataSource |
| virtual void RegisterDataSource(DataSourceRegistrationPtr registration_info) = 0; |
| |
| |
| // @generated_from: tracing.mojom.ProducerHost.RegisterTraceWriter |
| virtual void RegisterTraceWriter(uint32_t writer_id, uint32_t target_buffer) = 0; |
| |
| |
| // @generated_from: tracing.mojom.ProducerHost.UnregisterTraceWriter |
| virtual void UnregisterTraceWriter(uint32_t writer_id) = 0; |
| }; |
| |
| class ProducerClientProxy; |
| |
| template <typename ImplRefTraits> |
| class ProducerClientStub; |
| |
| class ProducerClientRequestValidator; |
| class ProducerClientResponseValidator; |
| |
| |
| // @generated_from: tracing.mojom.ProducerClient |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerClient |
| : public ProducerClientInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(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_ = ProducerClientInterfaceBase; |
| using Proxy_ = ProducerClientProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = ProducerClientStub<ImplRefTraits>; |
| |
| using RequestValidator_ = ProducerClientRequestValidator; |
| using ResponseValidator_ = ProducerClientResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kOnTracingStartMinVersion = 0, |
| kStartDataSourceMinVersion = 0, |
| kStopDataSourceMinVersion = 0, |
| kFlushMinVersion = 0, |
| kClearIncrementalStateMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct OnTracingStart_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct StartDataSource_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct StopDataSource_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct Flush_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct ClearIncrementalState_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~ProducerClient() = default; |
| |
| |
| // @generated_from: tracing.mojom.ProducerClient.OnTracingStart |
| virtual void OnTracingStart() = 0; |
| |
| |
| using StartDataSourceCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: tracing.mojom.ProducerClient.StartDataSource |
| virtual void StartDataSource(uint64_t id, DataSourceConfigPtr data_source_config, StartDataSourceCallback callback) = 0; |
| |
| |
| using StopDataSourceCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: tracing.mojom.ProducerClient.StopDataSource |
| virtual void StopDataSource(uint64_t id, StopDataSourceCallback callback) = 0; |
| |
| |
| // @generated_from: tracing.mojom.ProducerClient.Flush |
| virtual void Flush(uint64_t flush_request_id, const WTF::Vector<uint64_t>& data_source_ids) = 0; |
| |
| |
| // @generated_from: tracing.mojom.ProducerClient.ClearIncrementalState |
| virtual void ClearIncrementalState() = 0; |
| }; |
| |
| class PerfettoServiceProxy; |
| |
| template <typename ImplRefTraits> |
| class PerfettoServiceStub; |
| |
| class PerfettoServiceRequestValidator; |
| |
| |
| // @generated_from: tracing.mojom.PerfettoService |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) PerfettoService |
| : public PerfettoServiceInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(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_ = PerfettoServiceInterfaceBase; |
| using Proxy_ = PerfettoServiceProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = PerfettoServiceStub<ImplRefTraits>; |
| |
| using RequestValidator_ = PerfettoServiceRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kConnectToProducerHostMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct ConnectToProducerHost_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~PerfettoService() = default; |
| |
| |
| // @generated_from: tracing.mojom.PerfettoService.ConnectToProducerHost |
| virtual void ConnectToProducerHost(::mojo::PendingRemote<ProducerClient> producer_client, ::mojo::PendingReceiver<ProducerHost> producer_host_receiver, ::base::UnsafeSharedMemoryRegion shared_memory, uint64_t shared_memory_buffer_page_size_bytes) = 0; |
| }; |
| |
| class ConsumerHostProxy; |
| |
| template <typename ImplRefTraits> |
| class ConsumerHostStub; |
| |
| class ConsumerHostRequestValidator; |
| |
| |
| // @generated_from: tracing.mojom.ConsumerHost |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ConsumerHost |
| : public ConsumerHostInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(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_ = ConsumerHostInterfaceBase; |
| using Proxy_ = ConsumerHostProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = ConsumerHostStub<ImplRefTraits>; |
| |
| using RequestValidator_ = ConsumerHostRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kEnableTracingMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct EnableTracing_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~ConsumerHost() = default; |
| |
| |
| // @generated_from: tracing.mojom.ConsumerHost.EnableTracing |
| virtual void EnableTracing(::mojo::PendingReceiver<TracingSessionHost> tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> tracing_session_client, TraceConfigPtr config, ::base::File output_file) = 0; |
| }; |
| |
| class TracingSessionHostProxy; |
| |
| template <typename ImplRefTraits> |
| class TracingSessionHostStub; |
| |
| class TracingSessionHostRequestValidator; |
| class TracingSessionHostResponseValidator; |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionHost |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionHost |
| : public TracingSessionHostInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(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_ = TracingSessionHostInterfaceBase; |
| using Proxy_ = TracingSessionHostProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = TracingSessionHostStub<ImplRefTraits>; |
| |
| using RequestValidator_ = TracingSessionHostRequestValidator; |
| using ResponseValidator_ = TracingSessionHostResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kChangeTraceConfigMinVersion = 0, |
| kDisableTracingMinVersion = 0, |
| kReadBuffersMinVersion = 0, |
| kRequestBufferUsageMinVersion = 0, |
| kDisableTracingAndEmitJsonMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct ChangeTraceConfig_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct DisableTracing_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct ReadBuffers_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct RequestBufferUsage_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct DisableTracingAndEmitJson_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~TracingSessionHost() = default; |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.ChangeTraceConfig |
| virtual void ChangeTraceConfig(TraceConfigPtr config) = 0; |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.DisableTracing |
| virtual void DisableTracing() = 0; |
| |
| |
| using ReadBuffersCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.ReadBuffers |
| virtual void ReadBuffers(::mojo::ScopedDataPipeProducerHandle stream, ReadBuffersCallback callback) = 0; |
| |
| |
| using RequestBufferUsageCallback = base::OnceCallback<void(bool, float, bool)>; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.RequestBufferUsage |
| virtual void RequestBufferUsage(RequestBufferUsageCallback callback) = 0; |
| |
| |
| using DisableTracingAndEmitJsonCallback = base::OnceCallback<void()>; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.DisableTracingAndEmitJson |
| virtual void DisableTracingAndEmitJson(const WTF::String& agent_label_filter, ::mojo::ScopedDataPipeProducerHandle stream, bool privacy_filtering_enabled, DisableTracingAndEmitJsonCallback callback) = 0; |
| }; |
| |
| class TracingSessionClientProxy; |
| |
| template <typename ImplRefTraits> |
| class TracingSessionClientStub; |
| |
| class TracingSessionClientRequestValidator; |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionClient |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionClient |
| : public TracingSessionClientInterfaceBase { |
| public: |
| static const char Name_[]; |
| static std::pair<uint32_t, const void*> MessageToMethodInfo_(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_ = TracingSessionClientInterfaceBase; |
| using Proxy_ = TracingSessionClientProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = TracingSessionClientStub<ImplRefTraits>; |
| |
| using RequestValidator_ = TracingSessionClientRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kOnTracingEnabledMinVersion = 0, |
| kOnTracingDisabledMinVersion = 0, |
| }; |
| |
| // crbug.com/1340245 - this causes binary size bloat on Fuchsia, and we're OK |
| // with not having this data in traces there. |
| #if !BUILDFLAG(IS_FUCHSIA) |
| struct OnTracingEnabled_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| struct OnTracingDisabled_Sym { |
| NOINLINE static void IPCSymbol(); |
| }; |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
| virtual ~TracingSessionClient() = default; |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionClient.OnTracingEnabled |
| virtual void OnTracingEnabled() = 0; |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionClient.OnTracingDisabled |
| virtual void OnTracingDisabled(bool tracing_succeeded) = 0; |
| }; |
| |
| |
| |
| // @generated_from: tracing.mojom.ProducerHost |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerHostProxy |
| : public ProducerHost { |
| public: |
| using InterfaceType = ProducerHost; |
| |
| explicit ProducerHostProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: tracing.mojom.ProducerHost.CommitData |
| void CommitData(CommitDataRequestPtr data_request, CommitDataCallback callback) final; |
| |
| // @generated_from: tracing.mojom.ProducerHost.RegisterDataSource |
| void RegisterDataSource(DataSourceRegistrationPtr registration_info) final; |
| |
| // @generated_from: tracing.mojom.ProducerHost.RegisterTraceWriter |
| void RegisterTraceWriter(uint32_t writer_id, uint32_t target_buffer) final; |
| |
| // @generated_from: tracing.mojom.ProducerHost.UnregisterTraceWriter |
| void UnregisterTraceWriter(uint32_t writer_id) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| |
| |
| // @generated_from: tracing.mojom.ProducerClient |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerClientProxy |
| : public ProducerClient { |
| public: |
| using InterfaceType = ProducerClient; |
| |
| explicit ProducerClientProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: tracing.mojom.ProducerClient.OnTracingStart |
| void OnTracingStart() final; |
| |
| // @generated_from: tracing.mojom.ProducerClient.StartDataSource |
| void StartDataSource(uint64_t id, DataSourceConfigPtr data_source_config, StartDataSourceCallback callback) final; |
| |
| // @generated_from: tracing.mojom.ProducerClient.StopDataSource |
| void StopDataSource(uint64_t id, StopDataSourceCallback callback) final; |
| |
| // @generated_from: tracing.mojom.ProducerClient.Flush |
| void Flush(uint64_t flush_request_id, const WTF::Vector<uint64_t>& data_source_ids) final; |
| |
| // @generated_from: tracing.mojom.ProducerClient.ClearIncrementalState |
| void ClearIncrementalState() final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| |
| |
| // @generated_from: tracing.mojom.PerfettoService |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) PerfettoServiceProxy |
| : public PerfettoService { |
| public: |
| using InterfaceType = PerfettoService; |
| |
| explicit PerfettoServiceProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: tracing.mojom.PerfettoService.ConnectToProducerHost |
| void ConnectToProducerHost(::mojo::PendingRemote<ProducerClient> producer_client, ::mojo::PendingReceiver<ProducerHost> producer_host_receiver, ::base::UnsafeSharedMemoryRegion shared_memory, uint64_t shared_memory_buffer_page_size_bytes) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| |
| |
| // @generated_from: tracing.mojom.ConsumerHost |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ConsumerHostProxy |
| : public ConsumerHost { |
| public: |
| using InterfaceType = ConsumerHost; |
| |
| explicit ConsumerHostProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: tracing.mojom.ConsumerHost.EnableTracing |
| void EnableTracing(::mojo::PendingReceiver<TracingSessionHost> tracing_session_host, ::mojo::PendingRemote<TracingSessionClient> tracing_session_client, TraceConfigPtr config, ::base::File output_file) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionHost |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionHostProxy |
| : public TracingSessionHost { |
| public: |
| using InterfaceType = TracingSessionHost; |
| |
| explicit TracingSessionHostProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.ChangeTraceConfig |
| void ChangeTraceConfig(TraceConfigPtr config) final; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.DisableTracing |
| void DisableTracing() final; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.ReadBuffers |
| void ReadBuffers(::mojo::ScopedDataPipeProducerHandle stream, ReadBuffersCallback callback) final; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.RequestBufferUsage |
| void RequestBufferUsage(RequestBufferUsageCallback callback) final; |
| |
| // @generated_from: tracing.mojom.TracingSessionHost.DisableTracingAndEmitJson |
| void DisableTracingAndEmitJson(const WTF::String& agent_label_filter, ::mojo::ScopedDataPipeProducerHandle stream, bool privacy_filtering_enabled, DisableTracingAndEmitJsonCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| |
| |
| // @generated_from: tracing.mojom.TracingSessionClient |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionClientProxy |
| : public TracingSessionClient { |
| public: |
| using InterfaceType = TracingSessionClient; |
| |
| explicit TracingSessionClientProxy(mojo::MessageReceiverWithResponder* receiver); |
| |
| // @generated_from: tracing.mojom.TracingSessionClient.OnTracingEnabled |
| void OnTracingEnabled() final; |
| |
| // @generated_from: tracing.mojom.TracingSessionClient.OnTracingDisabled |
| void OnTracingDisabled(bool tracing_succeeded) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerHostStubDispatch { |
| public: |
| static bool Accept(ProducerHost* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| ProducerHost* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<ProducerHost>> |
| class ProducerHostStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| ProducerHostStub() = default; |
| ~ProducerHostStub() 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 ProducerHostStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ProducerHostStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerClientStubDispatch { |
| public: |
| static bool Accept(ProducerClient* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| ProducerClient* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<ProducerClient>> |
| class ProducerClientStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| ProducerClientStub() = default; |
| ~ProducerClientStub() 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 ProducerClientStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ProducerClientStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) PerfettoServiceStubDispatch { |
| public: |
| static bool Accept(PerfettoService* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| PerfettoService* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<PerfettoService>> |
| class PerfettoServiceStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| PerfettoServiceStub() = default; |
| ~PerfettoServiceStub() 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 PerfettoServiceStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return PerfettoServiceStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ConsumerHostStubDispatch { |
| public: |
| static bool Accept(ConsumerHost* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| ConsumerHost* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<ConsumerHost>> |
| class ConsumerHostStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| ConsumerHostStub() = default; |
| ~ConsumerHostStub() 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 ConsumerHostStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ConsumerHostStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionHostStubDispatch { |
| public: |
| static bool Accept(TracingSessionHost* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| TracingSessionHost* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<TracingSessionHost>> |
| class TracingSessionHostStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| TracingSessionHostStub() = default; |
| ~TracingSessionHostStub() 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 TracingSessionHostStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return TracingSessionHostStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionClientStubDispatch { |
| public: |
| static bool Accept(TracingSessionClient* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| TracingSessionClient* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<TracingSessionClient>> |
| class TracingSessionClientStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| TracingSessionClientStub() = default; |
| ~TracingSessionClientStub() 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 TracingSessionClientStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return TracingSessionClientStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerHostRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerClientRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) PerfettoServiceRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ConsumerHostRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionHostRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionClientRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerHostResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ProducerClientResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TracingSessionHostResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.ChunksToMove |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ChunksToMove { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ChunksToMove, T>::value>; |
| using DataView = ChunksToMoveDataView; |
| using Data_ = internal::ChunksToMove_Data; |
| |
| template <typename... Args> |
| static ChunksToMovePtr New(Args&&... args) { |
| return ChunksToMovePtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ChunksToMovePtr From(const U& u) { |
| return mojo::TypeConverter<ChunksToMovePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ChunksToMove>::Convert(*this); |
| } |
| |
| |
| ChunksToMove(); |
| |
| ChunksToMove( |
| uint32_t page, |
| uint32_t chunk, |
| uint32_t target_buffer); |
| |
| |
| ~ChunksToMove(); |
| |
| // 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 = ChunksToMovePtr> |
| ChunksToMovePtr 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, ChunksToMove::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, ChunksToMove::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< |
| ChunksToMove::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ChunksToMove::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::ChunksToMove_UnserializedMessageContext< |
| UserType, ChunksToMove::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<ChunksToMove::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ChunksToMove::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::ChunksToMove_UnserializedMessageContext< |
| UserType, ChunksToMove::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ChunksToMove::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.ChunksToMove.page |
| uint32_t page; |
| |
| // @generated_from: tracing.mojom.ChunksToMove.chunk |
| uint32_t chunk; |
| |
| // @generated_from: tracing.mojom.ChunksToMove.target_buffer |
| uint32_t target_buffer; |
| |
| // 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, ChunksToMove::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ChunksToMove::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ChunksToMove::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ChunksToMove::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.ChunkPatch |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ChunkPatch { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ChunkPatch, T>::value>; |
| using DataView = ChunkPatchDataView; |
| using Data_ = internal::ChunkPatch_Data; |
| |
| template <typename... Args> |
| static ChunkPatchPtr New(Args&&... args) { |
| return ChunkPatchPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ChunkPatchPtr From(const U& u) { |
| return mojo::TypeConverter<ChunkPatchPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ChunkPatch>::Convert(*this); |
| } |
| |
| |
| ChunkPatch(); |
| |
| ChunkPatch( |
| uint32_t offset, |
| const WTF::String& data); |
| |
| |
| ~ChunkPatch(); |
| |
| // 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 = ChunkPatchPtr> |
| ChunkPatchPtr 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, ChunkPatch::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, ChunkPatch::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< |
| ChunkPatch::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ChunkPatch::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::ChunkPatch_UnserializedMessageContext< |
| UserType, ChunkPatch::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<ChunkPatch::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ChunkPatch::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::ChunkPatch_UnserializedMessageContext< |
| UserType, ChunkPatch::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ChunkPatch::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.ChunkPatch.offset |
| uint32_t offset; |
| |
| // @generated_from: tracing.mojom.ChunkPatch.data |
| WTF::String data; |
| |
| // 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, ChunkPatch::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ChunkPatch::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ChunkPatch::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ChunkPatch::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.ChromeConfig |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ChromeConfig { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ChromeConfig, T>::value>; |
| using DataView = ChromeConfigDataView; |
| using Data_ = internal::ChromeConfig_Data; |
| |
| template <typename... Args> |
| static ChromeConfigPtr New(Args&&... args) { |
| return ChromeConfigPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ChromeConfigPtr From(const U& u) { |
| return mojo::TypeConverter<ChromeConfigPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ChromeConfig>::Convert(*this); |
| } |
| |
| |
| ChromeConfig(); |
| |
| ChromeConfig( |
| const WTF::String& trace_config, |
| bool privacy_filtering_enabled, |
| bool convert_to_legacy_json, |
| TracingClientPriority client_priority); |
| |
| |
| ~ChromeConfig(); |
| |
| // 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 = ChromeConfigPtr> |
| ChromeConfigPtr 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, ChromeConfig::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, ChromeConfig::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< |
| ChromeConfig::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ChromeConfig::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::ChromeConfig_UnserializedMessageContext< |
| UserType, ChromeConfig::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<ChromeConfig::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ChromeConfig::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::ChromeConfig_UnserializedMessageContext< |
| UserType, ChromeConfig::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ChromeConfig::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.ChromeConfig.trace_config |
| WTF::String trace_config; |
| |
| // @generated_from: tracing.mojom.ChromeConfig.privacy_filtering_enabled |
| bool privacy_filtering_enabled; |
| |
| // @generated_from: tracing.mojom.ChromeConfig.convert_to_legacy_json |
| bool convert_to_legacy_json; |
| |
| // @generated_from: tracing.mojom.ChromeConfig.client_priority |
| TracingClientPriority client_priority; |
| |
| // 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, ChromeConfig::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ChromeConfig::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ChromeConfig::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ChromeConfig::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.DataSourceRegistration |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) DataSourceRegistration { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<DataSourceRegistration, T>::value>; |
| using DataView = DataSourceRegistrationDataView; |
| using Data_ = internal::DataSourceRegistration_Data; |
| |
| template <typename... Args> |
| static DataSourceRegistrationPtr New(Args&&... args) { |
| return DataSourceRegistrationPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static DataSourceRegistrationPtr From(const U& u) { |
| return mojo::TypeConverter<DataSourceRegistrationPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, DataSourceRegistration>::Convert(*this); |
| } |
| |
| |
| DataSourceRegistration(); |
| |
| DataSourceRegistration( |
| const WTF::String& name, |
| bool will_notify_on_start, |
| bool will_notify_on_stop, |
| bool handles_incremental_state_clear); |
| |
| |
| ~DataSourceRegistration(); |
| |
| // 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 = DataSourceRegistrationPtr> |
| DataSourceRegistrationPtr 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, DataSourceRegistration::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, DataSourceRegistration::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< |
| DataSourceRegistration::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| DataSourceRegistration::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::DataSourceRegistration_UnserializedMessageContext< |
| UserType, DataSourceRegistration::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<DataSourceRegistration::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return DataSourceRegistration::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::DataSourceRegistration_UnserializedMessageContext< |
| UserType, DataSourceRegistration::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<DataSourceRegistration::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.DataSourceRegistration.name |
| WTF::String name; |
| |
| // @generated_from: tracing.mojom.DataSourceRegistration.will_notify_on_start |
| bool will_notify_on_start; |
| |
| // @generated_from: tracing.mojom.DataSourceRegistration.will_notify_on_stop |
| bool will_notify_on_stop; |
| |
| // @generated_from: tracing.mojom.DataSourceRegistration.handles_incremental_state_clear |
| bool handles_incremental_state_clear; |
| |
| // 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, DataSourceRegistration::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, DataSourceRegistration::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, DataSourceRegistration::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, DataSourceRegistration::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.BufferConfig |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) BufferConfig { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<BufferConfig, T>::value>; |
| using DataView = BufferConfigDataView; |
| using Data_ = internal::BufferConfig_Data; |
| |
| template <typename... Args> |
| static BufferConfigPtr New(Args&&... args) { |
| return BufferConfigPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static BufferConfigPtr From(const U& u) { |
| return mojo::TypeConverter<BufferConfigPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, BufferConfig>::Convert(*this); |
| } |
| |
| |
| BufferConfig(); |
| |
| BufferConfig( |
| uint32_t size_kb, |
| BufferFillPolicy fill_policy); |
| |
| |
| ~BufferConfig(); |
| |
| // 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 = BufferConfigPtr> |
| BufferConfigPtr 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, BufferConfig::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, BufferConfig::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< |
| BufferConfig::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| BufferConfig::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::BufferConfig_UnserializedMessageContext< |
| UserType, BufferConfig::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<BufferConfig::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return BufferConfig::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::BufferConfig_UnserializedMessageContext< |
| UserType, BufferConfig::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<BufferConfig::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.BufferConfig.size_kb |
| uint32_t size_kb; |
| |
| // @generated_from: tracing.mojom.BufferConfig.fill_policy |
| BufferFillPolicy fill_policy; |
| |
| // 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, BufferConfig::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, BufferConfig::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, BufferConfig::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, BufferConfig::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.IncrementalStateConfig |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) IncrementalStateConfig { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<IncrementalStateConfig, T>::value>; |
| using DataView = IncrementalStateConfigDataView; |
| using Data_ = internal::IncrementalStateConfig_Data; |
| |
| template <typename... Args> |
| static IncrementalStateConfigPtr New(Args&&... args) { |
| return IncrementalStateConfigPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static IncrementalStateConfigPtr From(const U& u) { |
| return mojo::TypeConverter<IncrementalStateConfigPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, IncrementalStateConfig>::Convert(*this); |
| } |
| |
| |
| IncrementalStateConfig(); |
| |
| explicit IncrementalStateConfig( |
| uint32_t clear_period_ms); |
| |
| |
| ~IncrementalStateConfig(); |
| |
| // 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 = IncrementalStateConfigPtr> |
| IncrementalStateConfigPtr 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, IncrementalStateConfig::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, IncrementalStateConfig::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< |
| IncrementalStateConfig::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| IncrementalStateConfig::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::IncrementalStateConfig_UnserializedMessageContext< |
| UserType, IncrementalStateConfig::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<IncrementalStateConfig::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return IncrementalStateConfig::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::IncrementalStateConfig_UnserializedMessageContext< |
| UserType, IncrementalStateConfig::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<IncrementalStateConfig::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.IncrementalStateConfig.clear_period_ms |
| uint32_t clear_period_ms; |
| |
| // 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, IncrementalStateConfig::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, IncrementalStateConfig::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, IncrementalStateConfig::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, IncrementalStateConfig::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.ChunksToPatch |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) ChunksToPatch { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ChunksToPatch, T>::value>; |
| using DataView = ChunksToPatchDataView; |
| using Data_ = internal::ChunksToPatch_Data; |
| |
| template <typename... Args> |
| static ChunksToPatchPtr New(Args&&... args) { |
| return ChunksToPatchPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ChunksToPatchPtr From(const U& u) { |
| return mojo::TypeConverter<ChunksToPatchPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ChunksToPatch>::Convert(*this); |
| } |
| |
| |
| ChunksToPatch(); |
| |
| ChunksToPatch( |
| uint32_t target_buffer, |
| uint32_t writer_id, |
| uint32_t chunk_id, |
| WTF::Vector<ChunkPatchPtr> patches, |
| bool has_more_patches); |
| |
| ChunksToPatch(const ChunksToPatch&) = delete; |
| ChunksToPatch& operator=(const ChunksToPatch&) = delete; |
| |
| ~ChunksToPatch(); |
| |
| // 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 = ChunksToPatchPtr> |
| ChunksToPatchPtr 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, ChunksToPatch::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, ChunksToPatch::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< |
| ChunksToPatch::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ChunksToPatch::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::ChunksToPatch_UnserializedMessageContext< |
| UserType, ChunksToPatch::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<ChunksToPatch::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ChunksToPatch::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::ChunksToPatch_UnserializedMessageContext< |
| UserType, ChunksToPatch::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ChunksToPatch::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.ChunksToPatch.target_buffer |
| uint32_t target_buffer; |
| |
| // @generated_from: tracing.mojom.ChunksToPatch.writer_id |
| uint32_t writer_id; |
| |
| // @generated_from: tracing.mojom.ChunksToPatch.chunk_id |
| uint32_t chunk_id; |
| |
| // @generated_from: tracing.mojom.ChunksToPatch.patches |
| WTF::Vector<ChunkPatchPtr> patches; |
| |
| // @generated_from: tracing.mojom.ChunksToPatch.has_more_patches |
| bool has_more_patches; |
| |
| // 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, ChunksToPatch::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ChunksToPatch::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ChunksToPatch::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ChunksToPatch::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.CommitDataRequest |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) CommitDataRequest { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<CommitDataRequest, T>::value>; |
| using DataView = CommitDataRequestDataView; |
| using Data_ = internal::CommitDataRequest_Data; |
| |
| template <typename... Args> |
| static CommitDataRequestPtr New(Args&&... args) { |
| return CommitDataRequestPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static CommitDataRequestPtr From(const U& u) { |
| return mojo::TypeConverter<CommitDataRequestPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, CommitDataRequest>::Convert(*this); |
| } |
| |
| |
| CommitDataRequest(); |
| |
| CommitDataRequest( |
| WTF::Vector<ChunksToMovePtr> chunks_to_move, |
| WTF::Vector<ChunksToPatchPtr> chunks_to_patch, |
| uint64_t flush_request_id); |
| |
| CommitDataRequest(const CommitDataRequest&) = delete; |
| CommitDataRequest& operator=(const CommitDataRequest&) = delete; |
| |
| ~CommitDataRequest(); |
| |
| // 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 = CommitDataRequestPtr> |
| CommitDataRequestPtr 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, CommitDataRequest::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, CommitDataRequest::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< |
| CommitDataRequest::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| CommitDataRequest::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::CommitDataRequest_UnserializedMessageContext< |
| UserType, CommitDataRequest::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<CommitDataRequest::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return CommitDataRequest::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::CommitDataRequest_UnserializedMessageContext< |
| UserType, CommitDataRequest::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<CommitDataRequest::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.CommitDataRequest.chunks_to_move |
| WTF::Vector<ChunksToMovePtr> chunks_to_move; |
| |
| // @generated_from: tracing.mojom.CommitDataRequest.chunks_to_patch |
| WTF::Vector<ChunksToPatchPtr> chunks_to_patch; |
| |
| // @generated_from: tracing.mojom.CommitDataRequest.flush_request_id |
| uint64_t flush_request_id; |
| |
| // 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, CommitDataRequest::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, CommitDataRequest::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, CommitDataRequest::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, CommitDataRequest::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.DataSourceConfig |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) DataSourceConfig { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<DataSourceConfig, T>::value>; |
| using DataView = DataSourceConfigDataView; |
| using Data_ = internal::DataSourceConfig_Data; |
| |
| template <typename... Args> |
| static DataSourceConfigPtr New(Args&&... args) { |
| return DataSourceConfigPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static DataSourceConfigPtr From(const U& u) { |
| return mojo::TypeConverter<DataSourceConfigPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, DataSourceConfig>::Convert(*this); |
| } |
| |
| |
| DataSourceConfig(); |
| |
| DataSourceConfig( |
| const WTF::String& name, |
| uint32_t target_buffer, |
| uint32_t trace_duration_ms, |
| uint64_t tracing_session_id, |
| ChromeConfigPtr chrome_config, |
| const WTF::String& legacy_config); |
| |
| DataSourceConfig(const DataSourceConfig&) = delete; |
| DataSourceConfig& operator=(const DataSourceConfig&) = delete; |
| |
| ~DataSourceConfig(); |
| |
| // 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 = DataSourceConfigPtr> |
| DataSourceConfigPtr 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, DataSourceConfig::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, DataSourceConfig::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< |
| DataSourceConfig::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| DataSourceConfig::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::DataSourceConfig_UnserializedMessageContext< |
| UserType, DataSourceConfig::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<DataSourceConfig::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return DataSourceConfig::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::DataSourceConfig_UnserializedMessageContext< |
| UserType, DataSourceConfig::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<DataSourceConfig::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.DataSourceConfig.name |
| WTF::String name; |
| |
| // @generated_from: tracing.mojom.DataSourceConfig.target_buffer |
| uint32_t target_buffer; |
| |
| // @generated_from: tracing.mojom.DataSourceConfig.trace_duration_ms |
| uint32_t trace_duration_ms; |
| |
| // @generated_from: tracing.mojom.DataSourceConfig.tracing_session_id |
| uint64_t tracing_session_id; |
| |
| // @generated_from: tracing.mojom.DataSourceConfig.chrome_config |
| ChromeConfigPtr chrome_config; |
| |
| // @generated_from: tracing.mojom.DataSourceConfig.legacy_config |
| WTF::String legacy_config; |
| |
| // 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, DataSourceConfig::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, DataSourceConfig::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, DataSourceConfig::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, DataSourceConfig::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.DataSource |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) DataSource { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<DataSource, T>::value>; |
| using DataView = DataSourceDataView; |
| using Data_ = internal::DataSource_Data; |
| |
| template <typename... Args> |
| static DataSourcePtr New(Args&&... args) { |
| return DataSourcePtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static DataSourcePtr From(const U& u) { |
| return mojo::TypeConverter<DataSourcePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, DataSource>::Convert(*this); |
| } |
| |
| |
| DataSource(); |
| |
| DataSource( |
| DataSourceConfigPtr config, |
| WTF::Vector<WTF::String> producer_name_filter); |
| |
| DataSource(const DataSource&) = delete; |
| DataSource& operator=(const DataSource&) = delete; |
| |
| ~DataSource(); |
| |
| // 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 = DataSourcePtr> |
| DataSourcePtr 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, DataSource::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, DataSource::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< |
| DataSource::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| DataSource::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::DataSource_UnserializedMessageContext< |
| UserType, DataSource::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<DataSource::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return DataSource::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::DataSource_UnserializedMessageContext< |
| UserType, DataSource::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<DataSource::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.DataSource.config |
| DataSourceConfigPtr config; |
| |
| // @generated_from: tracing.mojom.DataSource.producer_name_filter |
| WTF::Vector<WTF::String> producer_name_filter; |
| |
| // 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, DataSource::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, DataSource::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, DataSource::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, DataSource::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.PerfettoBuiltinDataSource |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) PerfettoBuiltinDataSource { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<PerfettoBuiltinDataSource, T>::value>; |
| using DataView = PerfettoBuiltinDataSourceDataView; |
| using Data_ = internal::PerfettoBuiltinDataSource_Data; |
| |
| template <typename... Args> |
| static PerfettoBuiltinDataSourcePtr New(Args&&... args) { |
| return PerfettoBuiltinDataSourcePtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static PerfettoBuiltinDataSourcePtr From(const U& u) { |
| return mojo::TypeConverter<PerfettoBuiltinDataSourcePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, PerfettoBuiltinDataSource>::Convert(*this); |
| } |
| |
| |
| PerfettoBuiltinDataSource(); |
| |
| PerfettoBuiltinDataSource( |
| bool disable_clock_snapshotting, |
| bool disable_trace_config, |
| bool disable_system_info, |
| bool disable_service_events, |
| int32_t primary_trace_clock_id); |
| |
| |
| ~PerfettoBuiltinDataSource(); |
| |
| // 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 = PerfettoBuiltinDataSourcePtr> |
| PerfettoBuiltinDataSourcePtr 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, PerfettoBuiltinDataSource::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, PerfettoBuiltinDataSource::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< |
| PerfettoBuiltinDataSource::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| PerfettoBuiltinDataSource::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::PerfettoBuiltinDataSource_UnserializedMessageContext< |
| UserType, PerfettoBuiltinDataSource::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<PerfettoBuiltinDataSource::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return PerfettoBuiltinDataSource::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::PerfettoBuiltinDataSource_UnserializedMessageContext< |
| UserType, PerfettoBuiltinDataSource::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<PerfettoBuiltinDataSource::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.PerfettoBuiltinDataSource.disable_clock_snapshotting |
| bool disable_clock_snapshotting; |
| |
| // @generated_from: tracing.mojom.PerfettoBuiltinDataSource.disable_trace_config |
| bool disable_trace_config; |
| |
| // @generated_from: tracing.mojom.PerfettoBuiltinDataSource.disable_system_info |
| bool disable_system_info; |
| |
| // @generated_from: tracing.mojom.PerfettoBuiltinDataSource.disable_service_events |
| bool disable_service_events; |
| |
| // @generated_from: tracing.mojom.PerfettoBuiltinDataSource.primary_trace_clock_id |
| int32_t primary_trace_clock_id; |
| |
| // 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, PerfettoBuiltinDataSource::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, PerfettoBuiltinDataSource::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, PerfettoBuiltinDataSource::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, PerfettoBuiltinDataSource::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| |
| |
| |
| |
| |
| // @generated_from: tracing.mojom.TraceConfig |
| class COMPONENT_EXPORT(TRACING_MOJOM_BLINK) TraceConfig { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<TraceConfig, T>::value>; |
| using DataView = TraceConfigDataView; |
| using Data_ = internal::TraceConfig_Data; |
| |
| template <typename... Args> |
| static TraceConfigPtr New(Args&&... args) { |
| return TraceConfigPtr( |
| absl::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static TraceConfigPtr From(const U& u) { |
| return mojo::TypeConverter<TraceConfigPtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, TraceConfig>::Convert(*this); |
| } |
| |
| |
| TraceConfig(); |
| |
| TraceConfig( |
| WTF::Vector<DataSourcePtr> data_sources, |
| PerfettoBuiltinDataSourcePtr perfetto_builtin_data_source, |
| WTF::Vector<BufferConfigPtr> buffers, |
| IncrementalStateConfigPtr incremental_state_config, |
| uint32_t duration_ms, |
| bool write_into_file); |
| |
| TraceConfig(const TraceConfig&) = delete; |
| TraceConfig& operator=(const TraceConfig&) = delete; |
| |
| ~TraceConfig(); |
| |
| // 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 = TraceConfigPtr> |
| TraceConfigPtr 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, TraceConfig::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename T, TraceConfig::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< |
| TraceConfig::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| TraceConfig::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::TraceConfig_UnserializedMessageContext< |
| UserType, TraceConfig::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<TraceConfig::DataView>( |
| message, data, data_num_bytes, output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return TraceConfig::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::TraceConfig_UnserializedMessageContext< |
| UserType, TraceConfig::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<TraceConfig::DataView>( |
| input, input.payload(), input.payload_num_bytes(), output, Validate); |
| } |
| |
| |
| // @generated_from: tracing.mojom.TraceConfig.data_sources |
| WTF::Vector<DataSourcePtr> data_sources; |
| |
| // @generated_from: tracing.mojom.TraceConfig.perfetto_builtin_data_source |
| PerfettoBuiltinDataSourcePtr perfetto_builtin_data_source; |
| |
| // @generated_from: tracing.mojom.TraceConfig.buffers |
| WTF::Vector<BufferConfigPtr> buffers; |
| |
| // @generated_from: tracing.mojom.TraceConfig.incremental_state_config |
| IncrementalStateConfigPtr incremental_state_config; |
| |
| // @generated_from: tracing.mojom.TraceConfig.duration_ms |
| uint32_t duration_ms; |
| |
| // @generated_from: tracing.mojom.TraceConfig.write_into_file |
| bool write_into_file; |
| |
| // 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, TraceConfig::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, TraceConfig::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, TraceConfig::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, TraceConfig::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| ChunksToMovePtr ChunksToMove::Clone() const { |
| return New( |
| mojo::Clone(page), |
| mojo::Clone(chunk), |
| mojo::Clone(target_buffer) |
| ); |
| } |
| |
| template <typename T, ChunksToMove::EnableIfSame<T>*> |
| bool ChunksToMove::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->page, other_struct.page)) |
| return false; |
| if (!mojo::Equals(this->chunk, other_struct.chunk)) |
| return false; |
| if (!mojo::Equals(this->target_buffer, other_struct.target_buffer)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ChunksToMove::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.page < rhs.page) |
| return true; |
| if (rhs.page < lhs.page) |
| return false; |
| if (lhs.chunk < rhs.chunk) |
| return true; |
| if (rhs.chunk < lhs.chunk) |
| return false; |
| if (lhs.target_buffer < rhs.target_buffer) |
| return true; |
| if (rhs.target_buffer < lhs.target_buffer) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ChunkPatchPtr ChunkPatch::Clone() const { |
| return New( |
| mojo::Clone(offset), |
| mojo::Clone(data) |
| ); |
| } |
| |
| template <typename T, ChunkPatch::EnableIfSame<T>*> |
| bool ChunkPatch::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->offset, other_struct.offset)) |
| return false; |
| if (!mojo::Equals(this->data, other_struct.data)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ChunkPatch::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.offset < rhs.offset) |
| return true; |
| if (rhs.offset < lhs.offset) |
| return false; |
| if (lhs.data < rhs.data) |
| return true; |
| if (rhs.data < lhs.data) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ChunksToPatchPtr ChunksToPatch::Clone() const { |
| return New( |
| mojo::Clone(target_buffer), |
| mojo::Clone(writer_id), |
| mojo::Clone(chunk_id), |
| mojo::Clone(patches), |
| mojo::Clone(has_more_patches) |
| ); |
| } |
| |
| template <typename T, ChunksToPatch::EnableIfSame<T>*> |
| bool ChunksToPatch::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->target_buffer, other_struct.target_buffer)) |
| return false; |
| if (!mojo::Equals(this->writer_id, other_struct.writer_id)) |
| return false; |
| if (!mojo::Equals(this->chunk_id, other_struct.chunk_id)) |
| return false; |
| if (!mojo::Equals(this->patches, other_struct.patches)) |
| return false; |
| if (!mojo::Equals(this->has_more_patches, other_struct.has_more_patches)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ChunksToPatch::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.target_buffer < rhs.target_buffer) |
| return true; |
| if (rhs.target_buffer < lhs.target_buffer) |
| return false; |
| if (lhs.writer_id < rhs.writer_id) |
| return true; |
| if (rhs.writer_id < lhs.writer_id) |
| return false; |
| if (lhs.chunk_id < rhs.chunk_id) |
| return true; |
| if (rhs.chunk_id < lhs.chunk_id) |
| return false; |
| if (lhs.patches < rhs.patches) |
| return true; |
| if (rhs.patches < lhs.patches) |
| return false; |
| if (lhs.has_more_patches < rhs.has_more_patches) |
| return true; |
| if (rhs.has_more_patches < lhs.has_more_patches) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| CommitDataRequestPtr CommitDataRequest::Clone() const { |
| return New( |
| mojo::Clone(chunks_to_move), |
| mojo::Clone(chunks_to_patch), |
| mojo::Clone(flush_request_id) |
| ); |
| } |
| |
| template <typename T, CommitDataRequest::EnableIfSame<T>*> |
| bool CommitDataRequest::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->chunks_to_move, other_struct.chunks_to_move)) |
| return false; |
| if (!mojo::Equals(this->chunks_to_patch, other_struct.chunks_to_patch)) |
| return false; |
| if (!mojo::Equals(this->flush_request_id, other_struct.flush_request_id)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, CommitDataRequest::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.chunks_to_move < rhs.chunks_to_move) |
| return true; |
| if (rhs.chunks_to_move < lhs.chunks_to_move) |
| return false; |
| if (lhs.chunks_to_patch < rhs.chunks_to_patch) |
| return true; |
| if (rhs.chunks_to_patch < lhs.chunks_to_patch) |
| return false; |
| if (lhs.flush_request_id < rhs.flush_request_id) |
| return true; |
| if (rhs.flush_request_id < lhs.flush_request_id) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| ChromeConfigPtr ChromeConfig::Clone() const { |
| return New( |
| mojo::Clone(trace_config), |
| mojo::Clone(privacy_filtering_enabled), |
| mojo::Clone(convert_to_legacy_json), |
| mojo::Clone(client_priority) |
| ); |
| } |
| |
| template <typename T, ChromeConfig::EnableIfSame<T>*> |
| bool ChromeConfig::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->trace_config, other_struct.trace_config)) |
| return false; |
| if (!mojo::Equals(this->privacy_filtering_enabled, other_struct.privacy_filtering_enabled)) |
| return false; |
| if (!mojo::Equals(this->convert_to_legacy_json, other_struct.convert_to_legacy_json)) |
| return false; |
| if (!mojo::Equals(this->client_priority, other_struct.client_priority)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ChromeConfig::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.trace_config < rhs.trace_config) |
| return true; |
| if (rhs.trace_config < lhs.trace_config) |
| return false; |
| if (lhs.privacy_filtering_enabled < rhs.privacy_filtering_enabled) |
| return true; |
| if (rhs.privacy_filtering_enabled < lhs.privacy_filtering_enabled) |
| return false; |
| if (lhs.convert_to_legacy_json < rhs.convert_to_legacy_json) |
| return true; |
| if (rhs.convert_to_legacy_json < lhs.convert_to_legacy_json) |
| return false; |
| if (lhs.client_priority < rhs.client_priority) |
| return true; |
| if (rhs.client_priority < lhs.client_priority) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| DataSourceConfigPtr DataSourceConfig::Clone() const { |
| return New( |
| mojo::Clone(name), |
| mojo::Clone(target_buffer), |
| mojo::Clone(trace_duration_ms), |
| mojo::Clone(tracing_session_id), |
| mojo::Clone(chrome_config), |
| mojo::Clone(legacy_config) |
| ); |
| } |
| |
| template <typename T, DataSourceConfig::EnableIfSame<T>*> |
| bool DataSourceConfig::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->name, other_struct.name)) |
| return false; |
| if (!mojo::Equals(this->target_buffer, other_struct.target_buffer)) |
| return false; |
| if (!mojo::Equals(this->trace_duration_ms, other_struct.trace_duration_ms)) |
| return false; |
| if (!mojo::Equals(this->tracing_session_id, other_struct.tracing_session_id)) |
| return false; |
| if (!mojo::Equals(this->chrome_config, other_struct.chrome_config)) |
| return false; |
| if (!mojo::Equals(this->legacy_config, other_struct.legacy_config)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, DataSourceConfig::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.target_buffer < rhs.target_buffer) |
| return true; |
| if (rhs.target_buffer < lhs.target_buffer) |
| return false; |
| if (lhs.trace_duration_ms < rhs.trace_duration_ms) |
| return true; |
| if (rhs.trace_duration_ms < lhs.trace_duration_ms) |
| return false; |
| if (lhs.tracing_session_id < rhs.tracing_session_id) |
| return true; |
| if (rhs.tracing_session_id < lhs.tracing_session_id) |
| return false; |
| if (lhs.chrome_config < rhs.chrome_config) |
| return true; |
| if (rhs.chrome_config < lhs.chrome_config) |
| return false; |
| if (lhs.legacy_config < rhs.legacy_config) |
| return true; |
| if (rhs.legacy_config < lhs.legacy_config) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| DataSourceRegistrationPtr DataSourceRegistration::Clone() const { |
| return New( |
| mojo::Clone(name), |
| mojo::Clone(will_notify_on_start), |
| mojo::Clone(will_notify_on_stop), |
| mojo::Clone(handles_incremental_state_clear) |
| ); |
| } |
| |
| template <typename T, DataSourceRegistration::EnableIfSame<T>*> |
| bool DataSourceRegistration::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->name, other_struct.name)) |
| return false; |
| if (!mojo::Equals(this->will_notify_on_start, other_struct.will_notify_on_start)) |
| return false; |
| if (!mojo::Equals(this->will_notify_on_stop, other_struct.will_notify_on_stop)) |
| return false; |
| if (!mojo::Equals(this->handles_incremental_state_clear, other_struct.handles_incremental_state_clear)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, DataSourceRegistration::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.will_notify_on_start < rhs.will_notify_on_start) |
| return true; |
| if (rhs.will_notify_on_start < lhs.will_notify_on_start) |
| return false; |
| if (lhs.will_notify_on_stop < rhs.will_notify_on_stop) |
| return true; |
| if (rhs.will_notify_on_stop < lhs.will_notify_on_stop) |
| return false; |
| if (lhs.handles_incremental_state_clear < rhs.handles_incremental_state_clear) |
| return true; |
| if (rhs.handles_incremental_state_clear < lhs.handles_incremental_state_clear) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| BufferConfigPtr BufferConfig::Clone() const { |
| return New( |
| mojo::Clone(size_kb), |
| mojo::Clone(fill_policy) |
| ); |
| } |
| |
| template <typename T, BufferConfig::EnableIfSame<T>*> |
| bool BufferConfig::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->size_kb, other_struct.size_kb)) |
| return false; |
| if (!mojo::Equals(this->fill_policy, other_struct.fill_policy)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, BufferConfig::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.size_kb < rhs.size_kb) |
| return true; |
| if (rhs.size_kb < lhs.size_kb) |
| return false; |
| if (lhs.fill_policy < rhs.fill_policy) |
| return true; |
| if (rhs.fill_policy < lhs.fill_policy) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| DataSourcePtr DataSource::Clone() const { |
| return New( |
| mojo::Clone(config), |
| mojo::Clone(producer_name_filter) |
| ); |
| } |
| |
| template <typename T, DataSource::EnableIfSame<T>*> |
| bool DataSource::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->config, other_struct.config)) |
| return false; |
| if (!mojo::Equals(this->producer_name_filter, other_struct.producer_name_filter)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, DataSource::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.config < rhs.config) |
| return true; |
| if (rhs.config < lhs.config) |
| return false; |
| if (lhs.producer_name_filter < rhs.producer_name_filter) |
| return true; |
| if (rhs.producer_name_filter < lhs.producer_name_filter) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| PerfettoBuiltinDataSourcePtr PerfettoBuiltinDataSource::Clone() const { |
| return New( |
| mojo::Clone(disable_clock_snapshotting), |
| mojo::Clone(disable_trace_config), |
| mojo::Clone(disable_system_info), |
| mojo::Clone(disable_service_events), |
| mojo::Clone(primary_trace_clock_id) |
| ); |
| } |
| |
| template <typename T, PerfettoBuiltinDataSource::EnableIfSame<T>*> |
| bool PerfettoBuiltinDataSource::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->disable_clock_snapshotting, other_struct.disable_clock_snapshotting)) |
| return false; |
| if (!mojo::Equals(this->disable_trace_config, other_struct.disable_trace_config)) |
| return false; |
| if (!mojo::Equals(this->disable_system_info, other_struct.disable_system_info)) |
| return false; |
| if (!mojo::Equals(this->disable_service_events, other_struct.disable_service_events)) |
| return false; |
| if (!mojo::Equals(this->primary_trace_clock_id, other_struct.primary_trace_clock_id)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, PerfettoBuiltinDataSource::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.disable_clock_snapshotting < rhs.disable_clock_snapshotting) |
| return true; |
| if (rhs.disable_clock_snapshotting < lhs.disable_clock_snapshotting) |
| return false; |
| if (lhs.disable_trace_config < rhs.disable_trace_config) |
| return true; |
| if (rhs.disable_trace_config < lhs.disable_trace_config) |
| return false; |
| if (lhs.disable_system_info < rhs.disable_system_info) |
| return true; |
| if (rhs.disable_system_info < lhs.disable_system_info) |
| return false; |
| if (lhs.disable_service_events < rhs.disable_service_events) |
| return true; |
| if (rhs.disable_service_events < lhs.disable_service_events) |
| return false; |
| if (lhs.primary_trace_clock_id < rhs.primary_trace_clock_id) |
| return true; |
| if (rhs.primary_trace_clock_id < lhs.primary_trace_clock_id) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| IncrementalStateConfigPtr IncrementalStateConfig::Clone() const { |
| return New( |
| mojo::Clone(clear_period_ms) |
| ); |
| } |
| |
| template <typename T, IncrementalStateConfig::EnableIfSame<T>*> |
| bool IncrementalStateConfig::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->clear_period_ms, other_struct.clear_period_ms)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, IncrementalStateConfig::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.clear_period_ms < rhs.clear_period_ms) |
| return true; |
| if (rhs.clear_period_ms < lhs.clear_period_ms) |
| return false; |
| return false; |
| } |
| template <typename StructPtrType> |
| TraceConfigPtr TraceConfig::Clone() const { |
| return New( |
| mojo::Clone(data_sources), |
| mojo::Clone(perfetto_builtin_data_source), |
| mojo::Clone(buffers), |
| mojo::Clone(incremental_state_config), |
| mojo::Clone(duration_ms), |
| mojo::Clone(write_into_file) |
| ); |
| } |
| |
| template <typename T, TraceConfig::EnableIfSame<T>*> |
| bool TraceConfig::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->data_sources, other_struct.data_sources)) |
| return false; |
| if (!mojo::Equals(this->perfetto_builtin_data_source, other_struct.perfetto_builtin_data_source)) |
| return false; |
| if (!mojo::Equals(this->buffers, other_struct.buffers)) |
| return false; |
| if (!mojo::Equals(this->incremental_state_config, other_struct.incremental_state_config)) |
| return false; |
| if (!mojo::Equals(this->duration_ms, other_struct.duration_ms)) |
| return false; |
| if (!mojo::Equals(this->write_into_file, other_struct.write_into_file)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, TraceConfig::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.data_sources < rhs.data_sources) |
| return true; |
| if (rhs.data_sources < lhs.data_sources) |
| return false; |
| if (lhs.perfetto_builtin_data_source < rhs.perfetto_builtin_data_source) |
| return true; |
| if (rhs.perfetto_builtin_data_source < lhs.perfetto_builtin_data_source) |
| return false; |
| if (lhs.buffers < rhs.buffers) |
| return true; |
| if (rhs.buffers < lhs.buffers) |
| return false; |
| if (lhs.incremental_state_config < rhs.incremental_state_config) |
| return true; |
| if (rhs.incremental_state_config < lhs.incremental_state_config) |
| return false; |
| if (lhs.duration_ms < rhs.duration_ms) |
| return true; |
| if (rhs.duration_ms < lhs.duration_ms) |
| return false; |
| if (lhs.write_into_file < rhs.write_into_file) |
| return true; |
| if (rhs.write_into_file < lhs.write_into_file) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace tracing |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::ChunksToMove::DataView, |
| ::tracing::mojom::blink::ChunksToMovePtr> { |
| static bool IsNull(const ::tracing::mojom::blink::ChunksToMovePtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::ChunksToMovePtr* output) { output->reset(); } |
| |
| static decltype(::tracing::mojom::blink::ChunksToMove::page) page( |
| const ::tracing::mojom::blink::ChunksToMovePtr& input) { |
| return input->page; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChunksToMove::chunk) chunk( |
| const ::tracing::mojom::blink::ChunksToMovePtr& input) { |
| return input->chunk; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChunksToMove::target_buffer) target_buffer( |
| const ::tracing::mojom::blink::ChunksToMovePtr& input) { |
| return input->target_buffer; |
| } |
| |
| static bool Read(::tracing::mojom::blink::ChunksToMove::DataView input, ::tracing::mojom::blink::ChunksToMovePtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::ChunkPatch::DataView, |
| ::tracing::mojom::blink::ChunkPatchPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::ChunkPatchPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::ChunkPatchPtr* output) { output->reset(); } |
| |
| static decltype(::tracing::mojom::blink::ChunkPatch::offset) offset( |
| const ::tracing::mojom::blink::ChunkPatchPtr& input) { |
| return input->offset; |
| } |
| |
| static const decltype(::tracing::mojom::blink::ChunkPatch::data)& data( |
| const ::tracing::mojom::blink::ChunkPatchPtr& input) { |
| return input->data; |
| } |
| |
| static bool Read(::tracing::mojom::blink::ChunkPatch::DataView input, ::tracing::mojom::blink::ChunkPatchPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::ChunksToPatch::DataView, |
| ::tracing::mojom::blink::ChunksToPatchPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::ChunksToPatchPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::ChunksToPatchPtr* output) { output->reset(); } |
| |
| static decltype(::tracing::mojom::blink::ChunksToPatch::target_buffer) target_buffer( |
| const ::tracing::mojom::blink::ChunksToPatchPtr& input) { |
| return input->target_buffer; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChunksToPatch::writer_id) writer_id( |
| const ::tracing::mojom::blink::ChunksToPatchPtr& input) { |
| return input->writer_id; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChunksToPatch::chunk_id) chunk_id( |
| const ::tracing::mojom::blink::ChunksToPatchPtr& input) { |
| return input->chunk_id; |
| } |
| |
| static const decltype(::tracing::mojom::blink::ChunksToPatch::patches)& patches( |
| const ::tracing::mojom::blink::ChunksToPatchPtr& input) { |
| return input->patches; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChunksToPatch::has_more_patches) has_more_patches( |
| const ::tracing::mojom::blink::ChunksToPatchPtr& input) { |
| return input->has_more_patches; |
| } |
| |
| static bool Read(::tracing::mojom::blink::ChunksToPatch::DataView input, ::tracing::mojom::blink::ChunksToPatchPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::CommitDataRequest::DataView, |
| ::tracing::mojom::blink::CommitDataRequestPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::CommitDataRequestPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::CommitDataRequestPtr* output) { output->reset(); } |
| |
| static const decltype(::tracing::mojom::blink::CommitDataRequest::chunks_to_move)& chunks_to_move( |
| const ::tracing::mojom::blink::CommitDataRequestPtr& input) { |
| return input->chunks_to_move; |
| } |
| |
| static const decltype(::tracing::mojom::blink::CommitDataRequest::chunks_to_patch)& chunks_to_patch( |
| const ::tracing::mojom::blink::CommitDataRequestPtr& input) { |
| return input->chunks_to_patch; |
| } |
| |
| static decltype(::tracing::mojom::blink::CommitDataRequest::flush_request_id) flush_request_id( |
| const ::tracing::mojom::blink::CommitDataRequestPtr& input) { |
| return input->flush_request_id; |
| } |
| |
| static bool Read(::tracing::mojom::blink::CommitDataRequest::DataView input, ::tracing::mojom::blink::CommitDataRequestPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::ChromeConfig::DataView, |
| ::tracing::mojom::blink::ChromeConfigPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::ChromeConfigPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::ChromeConfigPtr* output) { output->reset(); } |
| |
| static const decltype(::tracing::mojom::blink::ChromeConfig::trace_config)& trace_config( |
| const ::tracing::mojom::blink::ChromeConfigPtr& input) { |
| return input->trace_config; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChromeConfig::privacy_filtering_enabled) privacy_filtering_enabled( |
| const ::tracing::mojom::blink::ChromeConfigPtr& input) { |
| return input->privacy_filtering_enabled; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChromeConfig::convert_to_legacy_json) convert_to_legacy_json( |
| const ::tracing::mojom::blink::ChromeConfigPtr& input) { |
| return input->convert_to_legacy_json; |
| } |
| |
| static decltype(::tracing::mojom::blink::ChromeConfig::client_priority) client_priority( |
| const ::tracing::mojom::blink::ChromeConfigPtr& input) { |
| return input->client_priority; |
| } |
| |
| static bool Read(::tracing::mojom::blink::ChromeConfig::DataView input, ::tracing::mojom::blink::ChromeConfigPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::DataSourceConfig::DataView, |
| ::tracing::mojom::blink::DataSourceConfigPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::DataSourceConfigPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::DataSourceConfigPtr* output) { output->reset(); } |
| |
| static const decltype(::tracing::mojom::blink::DataSourceConfig::name)& name( |
| const ::tracing::mojom::blink::DataSourceConfigPtr& input) { |
| return input->name; |
| } |
| |
| static decltype(::tracing::mojom::blink::DataSourceConfig::target_buffer) target_buffer( |
| const ::tracing::mojom::blink::DataSourceConfigPtr& input) { |
| return input->target_buffer; |
| } |
| |
| static decltype(::tracing::mojom::blink::DataSourceConfig::trace_duration_ms) trace_duration_ms( |
| const ::tracing::mojom::blink::DataSourceConfigPtr& input) { |
| return input->trace_duration_ms; |
| } |
| |
| static decltype(::tracing::mojom::blink::DataSourceConfig::tracing_session_id) tracing_session_id( |
| const ::tracing::mojom::blink::DataSourceConfigPtr& input) { |
| return input->tracing_session_id; |
| } |
| |
| static const decltype(::tracing::mojom::blink::DataSourceConfig::chrome_config)& chrome_config( |
| const ::tracing::mojom::blink::DataSourceConfigPtr& input) { |
| return input->chrome_config; |
| } |
| |
| static const decltype(::tracing::mojom::blink::DataSourceConfig::legacy_config)& legacy_config( |
| const ::tracing::mojom::blink::DataSourceConfigPtr& input) { |
| return input->legacy_config; |
| } |
| |
| static bool Read(::tracing::mojom::blink::DataSourceConfig::DataView input, ::tracing::mojom::blink::DataSourceConfigPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::DataSourceRegistration::DataView, |
| ::tracing::mojom::blink::DataSourceRegistrationPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::DataSourceRegistrationPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::DataSourceRegistrationPtr* output) { output->reset(); } |
| |
| static const decltype(::tracing::mojom::blink::DataSourceRegistration::name)& name( |
| const ::tracing::mojom::blink::DataSourceRegistrationPtr& input) { |
| return input->name; |
| } |
| |
| static decltype(::tracing::mojom::blink::DataSourceRegistration::will_notify_on_start) will_notify_on_start( |
| const ::tracing::mojom::blink::DataSourceRegistrationPtr& input) { |
| return input->will_notify_on_start; |
| } |
| |
| static decltype(::tracing::mojom::blink::DataSourceRegistration::will_notify_on_stop) will_notify_on_stop( |
| const ::tracing::mojom::blink::DataSourceRegistrationPtr& input) { |
| return input->will_notify_on_stop; |
| } |
| |
| static decltype(::tracing::mojom::blink::DataSourceRegistration::handles_incremental_state_clear) handles_incremental_state_clear( |
| const ::tracing::mojom::blink::DataSourceRegistrationPtr& input) { |
| return input->handles_incremental_state_clear; |
| } |
| |
| static bool Read(::tracing::mojom::blink::DataSourceRegistration::DataView input, ::tracing::mojom::blink::DataSourceRegistrationPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::BufferConfig::DataView, |
| ::tracing::mojom::blink::BufferConfigPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::BufferConfigPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::BufferConfigPtr* output) { output->reset(); } |
| |
| static decltype(::tracing::mojom::blink::BufferConfig::size_kb) size_kb( |
| const ::tracing::mojom::blink::BufferConfigPtr& input) { |
| return input->size_kb; |
| } |
| |
| static decltype(::tracing::mojom::blink::BufferConfig::fill_policy) fill_policy( |
| const ::tracing::mojom::blink::BufferConfigPtr& input) { |
| return input->fill_policy; |
| } |
| |
| static bool Read(::tracing::mojom::blink::BufferConfig::DataView input, ::tracing::mojom::blink::BufferConfigPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::DataSource::DataView, |
| ::tracing::mojom::blink::DataSourcePtr> { |
| static bool IsNull(const ::tracing::mojom::blink::DataSourcePtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::DataSourcePtr* output) { output->reset(); } |
| |
| static const decltype(::tracing::mojom::blink::DataSource::config)& config( |
| const ::tracing::mojom::blink::DataSourcePtr& input) { |
| return input->config; |
| } |
| |
| static const decltype(::tracing::mojom::blink::DataSource::producer_name_filter)& producer_name_filter( |
| const ::tracing::mojom::blink::DataSourcePtr& input) { |
| return input->producer_name_filter; |
| } |
| |
| static bool Read(::tracing::mojom::blink::DataSource::DataView input, ::tracing::mojom::blink::DataSourcePtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::PerfettoBuiltinDataSource::DataView, |
| ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr> { |
| static bool IsNull(const ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr* output) { output->reset(); } |
| |
| static decltype(::tracing::mojom::blink::PerfettoBuiltinDataSource::disable_clock_snapshotting) disable_clock_snapshotting( |
| const ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr& input) { |
| return input->disable_clock_snapshotting; |
| } |
| |
| static decltype(::tracing::mojom::blink::PerfettoBuiltinDataSource::disable_trace_config) disable_trace_config( |
| const ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr& input) { |
| return input->disable_trace_config; |
| } |
| |
| static decltype(::tracing::mojom::blink::PerfettoBuiltinDataSource::disable_system_info) disable_system_info( |
| const ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr& input) { |
| return input->disable_system_info; |
| } |
| |
| static decltype(::tracing::mojom::blink::PerfettoBuiltinDataSource::disable_service_events) disable_service_events( |
| const ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr& input) { |
| return input->disable_service_events; |
| } |
| |
| static decltype(::tracing::mojom::blink::PerfettoBuiltinDataSource::primary_trace_clock_id) primary_trace_clock_id( |
| const ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr& input) { |
| return input->primary_trace_clock_id; |
| } |
| |
| static bool Read(::tracing::mojom::blink::PerfettoBuiltinDataSource::DataView input, ::tracing::mojom::blink::PerfettoBuiltinDataSourcePtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::IncrementalStateConfig::DataView, |
| ::tracing::mojom::blink::IncrementalStateConfigPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::IncrementalStateConfigPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::IncrementalStateConfigPtr* output) { output->reset(); } |
| |
| static decltype(::tracing::mojom::blink::IncrementalStateConfig::clear_period_ms) clear_period_ms( |
| const ::tracing::mojom::blink::IncrementalStateConfigPtr& input) { |
| return input->clear_period_ms; |
| } |
| |
| static bool Read(::tracing::mojom::blink::IncrementalStateConfig::DataView input, ::tracing::mojom::blink::IncrementalStateConfigPtr* output); |
| }; |
| |
| |
| template <> |
| struct COMPONENT_EXPORT(TRACING_MOJOM_BLINK) StructTraits<::tracing::mojom::blink::TraceConfig::DataView, |
| ::tracing::mojom::blink::TraceConfigPtr> { |
| static bool IsNull(const ::tracing::mojom::blink::TraceConfigPtr& input) { return !input; } |
| static void SetToNull(::tracing::mojom::blink::TraceConfigPtr* output) { output->reset(); } |
| |
| static const decltype(::tracing::mojom::blink::TraceConfig::data_sources)& data_sources( |
| const ::tracing::mojom::blink::TraceConfigPtr& input) { |
| return input->data_sources; |
| } |
| |
| static const decltype(::tracing::mojom::blink::TraceConfig::perfetto_builtin_data_source)& perfetto_builtin_data_source( |
| const ::tracing::mojom::blink::TraceConfigPtr& input) { |
| return input->perfetto_builtin_data_source; |
| } |
| |
| static const decltype(::tracing::mojom::blink::TraceConfig::buffers)& buffers( |
| const ::tracing::mojom::blink::TraceConfigPtr& input) { |
| return input->buffers; |
| } |
| |
| static const decltype(::tracing::mojom::blink::TraceConfig::incremental_state_config)& incremental_state_config( |
| const ::tracing::mojom::blink::TraceConfigPtr& input) { |
| return input->incremental_state_config; |
| } |
| |
| static decltype(::tracing::mojom::blink::TraceConfig::duration_ms) duration_ms( |
| const ::tracing::mojom::blink::TraceConfigPtr& input) { |
| return input->duration_ms; |
| } |
| |
| static decltype(::tracing::mojom::blink::TraceConfig::write_into_file) write_into_file( |
| const ::tracing::mojom::blink::TraceConfigPtr& input) { |
| return input->write_into_file; |
| } |
| |
| static bool Read(::tracing::mojom::blink::TraceConfig::DataView input, ::tracing::mojom::blink::TraceConfigPtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_TRACING_PUBLIC_MOJOM_PERFETTO_SERVICE_MOJOM_BLINK_H_ |
| |
| /* Metadata comment |
| eyJtZXRhIjogW3siZW5kIjogNDgwMywgImJlZ2luIjogNDc5MSwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUHJvZHVjZXJIb3N0In19LCB7 |
| ImVuZCI6IDYzOTYsICJiZWdpbiI6IDYzODYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlByb2R1Y2VySG9zdC5Db21taXREYXRhIn19LCB7 |
| ImVuZCI6IDY1NjksICJiZWdpbiI6IDY1NTEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlByb2R1Y2VySG9zdC5SZWdpc3RlckRhdGFTb3Vy |
| Y2UifX0sIHsiZW5kIjogNjcyNSwgImJlZ2luIjogNjcwNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdl |
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi |
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi |
| bW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUHJvZHVjZXJIb3N0LlJlZ2lzdGVy |
| VHJhY2VXcml0ZXIifX0sIHsiZW5kIjogNjg4NCwgImJlZ2luIjogNjg2MywgImVkZ2UiOiAiJS9r |
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog |
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu |
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUHJvZHVjZXJIb3N0 |
| LlVucmVnaXN0ZXJUcmFjZVdyaXRlciJ9fSwgeyJlbmQiOiA3MTg5LCAiYmVnaW4iOiA3MTc1LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5Q |
| cm9kdWNlckNsaWVudCJ9fSwgeyJlbmQiOiA4ODMwLCAiYmVnaW4iOiA4ODE2LCAiZWRnZSI6ICIl |
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi |
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs |
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5Qcm9kdWNlckNs |
| aWVudC5PblRyYWNpbmdTdGFydCJ9fSwgeyJlbmQiOiA5MDAwLCAiYmVnaW4iOiA4OTg1LCAiZWRn |
| ZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAi |
| dm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3Ny |
| YyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5Qcm9k |
| dWNlckNsaWVudC5TdGFydERhdGFTb3VyY2UifX0sIHsiZW5kIjogOTI1MiwgImJlZ2luIjogOTIz |
| OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp |
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv |
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9q |
| b20uUHJvZHVjZXJDbGllbnQuU3RvcERhdGFTb3VyY2UifX0sIHsiZW5kIjogOTM4MywgImJlZ2lu |
| IjogOTM3OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv |
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv |
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNp |
| bmcubW9qb20uUHJvZHVjZXJDbGllbnQuRmx1c2gifX0sIHsiZW5kIjogOTU3MywgImJlZ2luIjog |
| OTU1MiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k |
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j |
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcu |
| bW9qb20uUHJvZHVjZXJDbGllbnQuQ2xlYXJJbmNyZW1lbnRhbFN0YXRlIn19LCB7ImVuZCI6IDk4 |
| MjYsICJiZWdpbiI6IDk4MTEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw |
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds |
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy |
| ZSI6ICJ0cmFjaW5nLm1vam9tLlBlcmZldHRvU2VydmljZSJ9fSwgeyJlbmQiOiAxMTA2NCwgImJl |
| Z2luIjogMTEwNDMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJh |
| bmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJj |
| ZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0 |
| cmFjaW5nLm1vam9tLlBlcmZldHRvU2VydmljZS5Db25uZWN0VG9Qcm9kdWNlckhvc3QifX0sIHsi |
| ZW5kIjogMTE1MTIsICJiZWdpbiI6IDExNTAwLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5Db25zdW1lckhvc3QifX0sIHsiZW5kIjogMTI2 |
| OTcsICJiZWdpbiI6IDEyNjg0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5 |
| cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29n |
| bGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1 |
| cmUiOiAidHJhY2luZy5tb2pvbS5Db25zdW1lckhvc3QuRW5hYmxlVHJhY2luZyJ9fSwgeyJlbmQi |
| OiAxMzE4OSwgImJlZ2luIjogMTMxNzEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdTZXNzaW9uSG9zdCJ9fSwgeyJlbmQiOiAx |
| NDkwMCwgImJlZ2luIjogMTQ4ODMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi |
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv |
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h |
| dHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdTZXNzaW9uSG9zdC5DaGFuZ2VUcmFjZUNvbmZp |
| ZyJ9fSwgeyJlbmQiOiAxNTAzMCwgImJlZ2luIjogMTUwMTYsICJlZGdlIjogIiUva3l0aGUvZWRn |
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz |
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog |
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdTZXNzaW9uSG9zdC5E |
| aXNhYmxlVHJhY2luZyJ9fSwgeyJlbmQiOiAxNTE5MiwgImJlZ2luIjogMTUxODEsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdT |
| ZXNzaW9uSG9zdC5SZWFkQnVmZmVycyJ9fSwgeyJlbmQiOiAxNTQ2NSwgImJlZ2luIjogMTU0NDcs |
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l |
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p |
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9t |
| LlRyYWNpbmdTZXNzaW9uSG9zdC5SZXF1ZXN0QnVmZmVyVXNhZ2UifX0sIHsiZW5kIjogMTU3MDQs |
| ICJiZWdpbiI6IDE1Njc5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi |
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz |
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi |
| OiAidHJhY2luZy5tb2pvbS5UcmFjaW5nU2Vzc2lvbkhvc3QuRGlzYWJsZVRyYWNpbmdBbmRFbWl0 |
| SnNvbiJ9fSwgeyJlbmQiOiAxNjE0MCwgImJlZ2luIjogMTYxMjAsICJlZGdlIjogIiUva3l0aGUv |
| ZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29y |
| cHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdl |
| IjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdTZXNzaW9uQ2xp |
| ZW50In19LCB7ImVuZCI6IDE3NTA3LCAiYmVnaW4iOiAxNzQ5MSwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uVHJhY2luZ1Nlc3Npb25DbGll |
| bnQuT25UcmFjaW5nRW5hYmxlZCJ9fSwgeyJlbmQiOiAxNzYyNCwgImJlZ2luIjogMTc2MDcsICJl |
| ZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIs |
| ICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0v |
| c3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRy |
| YWNpbmdTZXNzaW9uQ2xpZW50Lk9uVHJhY2luZ0Rpc2FibGVkIn19LCB7ImVuZCI6IDE3OTk5LCAi |
| YmVnaW4iOiAxNzk4OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog |
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291 |
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog |
| InRyYWNpbmcubW9qb20uUHJvZHVjZXJIb3N0LkNvbW1pdERhdGEifX0sIHsiZW5kIjogMTgxNjUs |
| ICJiZWdpbiI6IDE4MTQ3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUi |
| OiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVz |
| b3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUi |
| OiAidHJhY2luZy5tb2pvbS5Qcm9kdWNlckhvc3QuUmVnaXN0ZXJEYXRhU291cmNlIn19LCB7ImVu |
| ZCI6IDE4MzE0LCAiYmVnaW4iOiAxODI5NSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl |
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p |
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi |
| c2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUHJvZHVjZXJIb3N0LlJlZ2lzdGVyVHJhY2VXcml0 |
| ZXIifX0sIHsiZW5kIjogMTg0NjYsICJiZWdpbiI6IDE4NDQ1LCAiZWRnZSI6ICIlL2t5dGhlL2Vk |
| Z2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1 |
| cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6 |
| ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5Qcm9kdWNlckhvc3QuVW5yZWdp |
| c3RlclRyYWNlV3JpdGVyIn19LCB7ImVuZCI6IDE4OTE5LCAiYmVnaW4iOiAxODkwNSwgImVkZ2Ui |
| OiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZu |
| YW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMi |
| LCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUHJvZHVj |
| ZXJDbGllbnQuT25UcmFjaW5nU3RhcnQifX0sIHsiZW5kIjogMTkwMTksICJiZWdpbiI6IDE5MDA0 |
| LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmlu |
| ZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9t |
| aXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pv |
| bS5Qcm9kdWNlckNsaWVudC5TdGFydERhdGFTb3VyY2UifX0sIHsiZW5kIjogMTkyMDIsICJiZWdp |
| biI6IDE5MTg4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJh |
| Y2luZy5tb2pvbS5Qcm9kdWNlckNsaWVudC5TdG9wRGF0YVNvdXJjZSJ9fSwgeyJlbmQiOiAxOTMy |
| NiwgImJlZ2luIjogMTkzMjEsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlw |
| ZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2ds |
| ZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVy |
| ZSI6ICJ0cmFjaW5nLm1vam9tLlByb2R1Y2VyQ2xpZW50LkZsdXNoIn19LCB7ImVuZCI6IDE5NTA5 |
| LCAiYmVnaW4iOiAxOTQ4OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl |
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl |
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl |
| IjogInRyYWNpbmcubW9qb20uUHJvZHVjZXJDbGllbnQuQ2xlYXJJbmNyZW1lbnRhbFN0YXRlIn19 |
| LCB7ImVuZCI6IDE5OTY0LCAiYmVnaW4iOiAxOTk0MywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl |
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi |
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q |
| b20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUGVyZmV0dG9TZXJ2aWNlLkNvbm5lY3RU |
| b1Byb2R1Y2VySG9zdCJ9fSwgeyJlbmQiOiAyMDU5NSwgImJlZ2luIjogMjA1ODIsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkNvbnN1bWVy |
| SG9zdC5FbmFibGVUcmFjaW5nIn19LCB7ImVuZCI6IDIxMjQxLCAiYmVnaW4iOiAyMTIyNCwgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uVHJh |
| Y2luZ1Nlc3Npb25Ib3N0LkNoYW5nZVRyYWNlQ29uZmlnIn19LCB7ImVuZCI6IDIxMzY0LCAiYmVn |
| aW4iOiAyMTM1MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu |
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl |
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRy |
| YWNpbmcubW9qb20uVHJhY2luZ1Nlc3Npb25Ib3N0LkRpc2FibGVUcmFjaW5nIn19LCB7ImVuZCI6 |
| IDIxNDYwLCAiYmVnaW4iOiAyMTQ0OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIs |
| ICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0u |
| Z29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2ln |
| bmF0dXJlIjogInRyYWNpbmcubW9qb20uVHJhY2luZ1Nlc3Npb25Ib3N0LlJlYWRCdWZmZXJzIn19 |
| LCB7ImVuZCI6IDIxNjQzLCAiYmVnaW4iOiAyMTYyNSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl |
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi |
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q |
| b20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uVHJhY2luZ1Nlc3Npb25Ib3N0LlJlcXVl |
| c3RCdWZmZXJVc2FnZSJ9fSwgeyJlbmQiOiAyMTgwMiwgImJlZ2luIjogMjE3NzcsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdT |
| ZXNzaW9uSG9zdC5EaXNhYmxlVHJhY2luZ0FuZEVtaXRKc29uIn19LCB7ImVuZCI6IDIyNDM1LCAi |
| YmVnaW4iOiAyMjQxOSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog |
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291 |
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog |
| InRyYWNpbmcubW9qb20uVHJhY2luZ1Nlc3Npb25DbGllbnQuT25UcmFjaW5nRW5hYmxlZCJ9fSwg |
| eyJlbmQiOiAyMjU0NSwgImJlZ2luIjogMjI1MjgsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l |
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo |
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t |
| IiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNpbmdTZXNzaW9uQ2xpZW50Lk9uVHJh |
| Y2luZ0Rpc2FibGVkIn19LCB7ImVuZCI6IDMyMzc1LCAiYmVnaW4iOiAzMjM2MywgImVkZ2UiOiAi |
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l |
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi |
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ2h1bmtzVG9N |
| b3ZlIn19LCB7ImVuZCI6IDM2MDQ0LCAiYmVnaW4iOiAzNjA0MCwgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ2h1bmtzVG9Nb3ZlLnBhZ2Ui |
| fX0sIHsiZW5kIjogMzYxMTgsICJiZWdpbiI6IDM2MTEzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv |
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6 |
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt |
| b2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5DaHVua3NUb01vdmUuY2h1bmsifX0s |
| IHsiZW5kIjogMzYyMDgsICJiZWdpbiI6IDM2MTk1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2Vu |
| ZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJj |
| aHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pv |
| bSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5DaHVua3NUb01vdmUudGFyZ2V0X2J1ZmZl |
| ciJ9fSwgeyJlbmQiOiAzNzI3NCwgImJlZ2luIjogMzcyNjQsICJlZGdlIjogIiUva3l0aGUvZWRn |
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz |
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog |
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkNodW5rUGF0Y2gifX0sIHsiZW5k |
| IjogNDA4NzgsICJiZWdpbiI6IDQwODcyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz |
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1 |
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz |
| aWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5DaHVua1BhdGNoLm9mZnNldCJ9fSwgeyJlbmQiOiA0 |
| MDk1MSwgImJlZ2luIjogNDA5NDcsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAi |
| dHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdv |
| b2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25h |
| dHVyZSI6ICJ0cmFjaW5nLm1vam9tLkNodW5rUGF0Y2guZGF0YSJ9fSwgeyJlbmQiOiA0MjAxNSwg |
| ImJlZ2luIjogNDIwMDMsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6 |
| ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNv |
| dXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6 |
| ICJ0cmFjaW5nLm1vam9tLkNocm9tZUNvbmZpZyJ9fSwgeyJlbmQiOiA0NTc4NywgImJlZ2luIjog |
| NDU3NzUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf |
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v |
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5n |
| Lm1vam9tLkNocm9tZUNvbmZpZy50cmFjZV9jb25maWcifX0sIHsiZW5kIjogNDU4OTcsICJiZWdp |
| biI6IDQ1ODcyLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJh |
| Y2luZy5tb2pvbS5DaHJvbWVDb25maWcucHJpdmFjeV9maWx0ZXJpbmdfZW5hYmxlZCJ9fSwgeyJl |
| bmQiOiA0NjAwMSwgImJlZ2luIjogNDU5NzksICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkNocm9tZUNvbmZpZy5jb252ZXJ0X3RvX2xlZ2Fj |
| eV9qc29uIn19LCB7ImVuZCI6IDQ2MTA4LCAiYmVnaW4iOiA0NjA5MywgImVkZ2UiOiAiJS9reXRo |
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj |
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh |
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ2hyb21lQ29uZmlnLmNs |
| aWVudF9wcmlvcml0eSJ9fSwgeyJlbmQiOiA0NzE5OSwgImJlZ2luIjogNDcxNzcsICJlZGdlIjog |
| IiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFt |
| ZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwg |
| Imxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkRhdGFTb3Vy |
| Y2VSZWdpc3RyYXRpb24ifX0sIHsiZW5kIjogNTExODgsICJiZWdpbiI6IDUxMTg0LCAiZWRnZSI6 |
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5h |
| bWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIs |
| ICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5EYXRhU291 |
| cmNlUmVnaXN0cmF0aW9uLm5hbWUifX0sIHsiZW5kIjogNTEyOTgsICJiZWdpbiI6IDUxMjc4LCAi |
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi |
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt |
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5E |
| YXRhU291cmNlUmVnaXN0cmF0aW9uLndpbGxfbm90aWZ5X29uX3N0YXJ0In19LCB7ImVuZCI6IDUx |
| NDA2LCAiYmVnaW4iOiA1MTM4NywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0 |
| eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29v |
| Z2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0 |
| dXJlIjogInRyYWNpbmcubW9qb20uRGF0YVNvdXJjZVJlZ2lzdHJhdGlvbi53aWxsX25vdGlmeV9v |
| bl9zdG9wIn19LCB7ImVuZCI6IDUxNTM4LCAiYmVnaW4iOiA1MTUwNywgImVkZ2UiOiAiJS9reXRo |
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj |
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh |
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uRGF0YVNvdXJjZVJlZ2lz |
| dHJhdGlvbi5oYW5kbGVzX2luY3JlbWVudGFsX3N0YXRlX2NsZWFyIn19LCB7ImVuZCI6IDUyNjQ4 |
| LCAiYmVnaW4iOiA1MjYzNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl |
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl |
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl |
| IjogInRyYWNpbmcubW9qb20uQnVmZmVyQ29uZmlnIn19LCB7ImVuZCI6IDU2MzEwLCAiYmVnaW4i |
| OiA1NjMwMywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv |
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv |
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNp |
| bmcubW9qb20uQnVmZmVyQ29uZmlnLnNpemVfa2IifX0sIHsiZW5kIjogNTY0MDQsICJiZWdpbiI6 |
| IDU2MzkzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9y |
| X2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29t |
| L2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2lu |
| Zy5tb2pvbS5CdWZmZXJDb25maWcuZmlsbF9wb2xpY3kifX0sIHsiZW5kIjogNTc0OTYsICJiZWdp |
| biI6IDU3NDc0LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5j |
| aG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2Uu |
| Y29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJh |
| Y2luZy5tb2pvbS5JbmNyZW1lbnRhbFN0YXRlQ29uZmlnIn19LCB7ImVuZCI6IDYxNDA1LCAiYmVn |
| aW4iOiA2MTM5MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFu |
| Y2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNl |
| LmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRy |
| YWNpbmcubW9qb20uSW5jcmVtZW50YWxTdGF0ZUNvbmZpZy5jbGVhcl9wZXJpb2RfbXMifX0sIHsi |
| ZW5kIjogNjI1MjIsICJiZWdpbiI6IDYyNTA5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5DaHVua3NUb1BhdGNoIn19LCB7ImVuZCI6IDY2 |
| MzgyLCAiYmVnaW4iOiA2NjM2OSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0 |
| eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29v |
| Z2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0 |
| dXJlIjogInRyYWNpbmcubW9qb20uQ2h1bmtzVG9QYXRjaC50YXJnZXRfYnVmZmVyIn19LCB7ImVu |
| ZCI6IDY2NDY1LCAiYmVnaW4iOiA2NjQ1NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl |
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p |
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi |
| c2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ2h1bmtzVG9QYXRjaC53cml0ZXJfaWQifX0sIHsi |
| ZW5kIjogNjY1NDYsICJiZWdpbiI6IDY2NTM4LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh |
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv |
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs |
| ICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5DaHVua3NUb1BhdGNoLmNodW5rX2lkIn19LCB7 |
| ImVuZCI6IDY2NjQzLCAiYmVnaW4iOiA2NjYzNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ2h1bmtzVG9QYXRjaC5wYXRjaGVzIn19LCB7 |
| ImVuZCI6IDY2NzM2LCAiYmVnaW4iOiA2NjcyMCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVy |
| YXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hy |
| b21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20i |
| LCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ2h1bmtzVG9QYXRjaC5oYXNfbW9yZV9wYXRj |
| aGVzIn19LCB7ImVuZCI6IDY3ODIwLCAiYmVnaW4iOiA2NzgwMywgImVkZ2UiOiAiJS9reXRoZS9l |
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw |
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui |
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uQ29tbWl0RGF0YVJlcXVlc3Qi |
| fX0sIHsiZW5kIjogNzE4MDMsICJiZWdpbiI6IDcxNzg5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv |
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6 |
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt |
| b2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5Db21taXREYXRhUmVxdWVzdC5jaHVu |
| a3NfdG9fbW92ZSJ9fSwgeyJlbmQiOiA3MTkyMywgImJlZ2luIjogNzE5MDgsICJlZGdlIjogIiUv |
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6 |
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh |
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkNvbW1pdERhdGFS |
| ZXF1ZXN0LmNodW5rc190b19wYXRjaCJ9fSwgeyJlbmQiOiA3MjAyNCwgImJlZ2luIjogNzIwMDgs |
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l |
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p |
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9t |
| LkNvbW1pdERhdGFSZXF1ZXN0LmZsdXNoX3JlcXVlc3RfaWQifX0sIHsiZW5kIjogNzMxMjMsICJi |
| ZWdpbiI6IDczMTA3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAi |
| YW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3Vy |
| Y2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAi |
| dHJhY2luZy5tb2pvbS5EYXRhU291cmNlQ29uZmlnIn19LCB7ImVuZCI6IDc3MTQ0LCAiYmVnaW4i |
| OiA3NzE0MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv |
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv |
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNp |
| bmcubW9qb20uRGF0YVNvdXJjZUNvbmZpZy5uYW1lIn19LCB7ImVuZCI6IDc3MjM4LCAiYmVnaW4i |
| OiA3NzIyNSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv |
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv |
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNp |
| bmcubW9qb20uRGF0YVNvdXJjZUNvbmZpZy50YXJnZXRfYnVmZmVyIn19LCB7ImVuZCI6IDc3MzQw |
| LCAiYmVnaW4iOiA3NzMyMywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl |
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl |
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl |
| IjogInRyYWNpbmcubW9qb20uRGF0YVNvdXJjZUNvbmZpZy50cmFjZV9kdXJhdGlvbl9tcyJ9fSwg |
| eyJlbmQiOiA3NzQ0NCwgImJlZ2luIjogNzc0MjYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5l |
| cmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNo |
| cm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9t |
| IiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkRhdGFTb3VyY2VDb25maWcudHJhY2luZ19z |
| ZXNzaW9uX2lkIn19LCB7ImVuZCI6IDc3NTQ1LCAiYmVnaW4iOiA3NzUzMiwgImVkZ2UiOiAiJS9r |
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog |
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu |
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uRGF0YVNvdXJjZUNv |
| bmZpZy5jaHJvbWVfY29uZmlnIn19LCB7ImVuZCI6IDc3NjQyLCAiYmVnaW4iOiA3NzYyOSwgImVk |
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg |
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z |
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uRGF0 |
| YVNvdXJjZUNvbmZpZy5sZWdhY3lfY29uZmlnIn19LCB7ImVuZCI6IDc4NzI2LCAiYmVnaW4iOiA3 |
| ODcxNiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k |
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j |
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcu |
| bW9qb20uRGF0YVNvdXJjZSJ9fSwgeyJlbmQiOiA4MjQyNCwgImJlZ2luIjogODI0MDUsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLkRhdGFT |
| b3VyY2UuY29uZmlnIn19LCB7ImVuZCI6IDgyNTQ5LCAiYmVnaW4iOiA4MjUyOSwgImVkZ2UiOiAi |
| JS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1l |
| IjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAi |
| bGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uRGF0YVNvdXJj |
| ZS5wcm9kdWNlcl9uYW1lX2ZpbHRlciJ9fSwgeyJlbmQiOiA4MzYzNywgImJlZ2luIjogODM2MTIs |
| ICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5l |
| cyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21p |
| dW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9t |
| LlBlcmZldHRvQnVpbHRpbkRhdGFTb3VyY2UifX0sIHsiZW5kIjogODc3NzUsICJiZWdpbiI6IDg3 |
| NzQ5LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2Rl |
| ZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2No |
| cm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5t |
| b2pvbS5QZXJmZXR0b0J1aWx0aW5EYXRhU291cmNlLmRpc2FibGVfY2xvY2tfc25hcHNob3R0aW5n |
| In19LCB7ImVuZCI6IDg3ODg4LCAiYmVnaW4iOiA4Nzg2OCwgImVkZ2UiOiAiJS9reXRoZS9lZGdl |
| L2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMi |
| OiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAi |
| bW9qb20iLCAic2lnbmF0dXJlIjogInRyYWNpbmcubW9qb20uUGVyZmV0dG9CdWlsdGluRGF0YVNv |
| dXJjZS5kaXNhYmxlX3RyYWNlX2NvbmZpZyJ9fSwgeyJlbmQiOiA4Nzk5OSwgImJlZ2luIjogODc5 |
| ODAsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVm |
| aW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hy |
| b21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1v |
| am9tLlBlcmZldHRvQnVpbHRpbkRhdGFTb3VyY2UuZGlzYWJsZV9zeXN0ZW1faW5mbyJ9fSwgeyJl |
| bmQiOiA4ODExNiwgImJlZ2luIjogODgwOTQsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0 |
| ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9t |
| aXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwg |
| InNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlBlcmZldHRvQnVpbHRpbkRhdGFTb3VyY2UuZGlz |
| YWJsZV9zZXJ2aWNlX2V2ZW50cyJ9fSwgeyJlbmQiOiA4ODIzNiwgImJlZ2luIjogODgyMTQsICJl |
| ZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIs |
| ICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0v |
| c3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlBl |
| cmZldHRvQnVpbHRpbkRhdGFTb3VyY2UucHJpbWFyeV90cmFjZV9jbG9ja19pZCJ9fSwgeyJlbmQi |
| OiA4OTM1NywgImJlZ2luIjogODkzNDYsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMi |
| LCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVt |
| Lmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNp |
| Z25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNlQ29uZmlnIn19LCB7ImVuZCI6IDkzMjkzLCAi |
| YmVnaW4iOiA5MzI4MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjog |
| ImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291 |
| cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjog |
| InRyYWNpbmcubW9qb20uVHJhY2VDb25maWcuZGF0YV9zb3VyY2VzIn19LCB7ImVuZCI6IDkzNDMy |
| LCAiYmVnaW4iOiA5MzQwNCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl |
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl |
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl |
| IjogInRyYWNpbmcubW9qb20uVHJhY2VDb25maWcucGVyZmV0dG9fYnVpbHRpbl9kYXRhX3NvdXJj |
| ZSJ9fSwgeyJlbmQiOiA5MzUyOSwgImJlZ2luIjogOTM1MjIsICJlZGdlIjogIiUva3l0aGUvZWRn |
| ZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVz |
| IjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjog |
| Im1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNlQ29uZmlnLmJ1ZmZlcnMi |
| fX0sIHsiZW5kIjogOTM2NTcsICJiZWdpbiI6IDkzNjMzLCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv |
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6 |
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt |
| b2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5UcmFjZUNvbmZpZy5pbmNyZW1lbnRh |
| bF9zdGF0ZV9jb25maWcifX0sIHsiZW5kIjogOTM3NDIsICJiZWdpbiI6IDkzNzMxLCAiZWRnZSI6 |
| ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5h |
| bWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIs |
| ICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAidHJhY2luZy5tb2pvbS5UcmFjZUNv |
| bmZpZy5kdXJhdGlvbl9tcyJ9fSwgeyJlbmQiOiA5MzgzMSwgImJlZ2luIjogOTM4MTYsICJlZGdl |
| IjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2 |
| bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3Jj |
| IiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJ0cmFjaW5nLm1vam9tLlRyYWNl |
| Q29uZmlnLndyaXRlX2ludG9fZmlsZSJ9fV0sICJ0eXBlIjogImt5dGhlMCJ9 |
| */ |