| // 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_SERVICE_MANAGER_TESTS_CONNECT_CONNECT_TEST_MOJOM_BLINK_H_ |
| #define SERVICES_SERVICE_MANAGER_TESTS_CONNECT_CONNECT_TEST_MOJOM_BLINK_H_ |
| |
| #include <stdint.h> |
| |
| #include <limits> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "base/callback.h" |
| #include "base/macros.h" |
| #include "base/optional.h" |
| |
| #include "mojo/public/cpp/bindings/mojo_buildflags.h" |
| #if BUILDFLAG(MOJO_TRACE_ENABLED) |
| #include "base/trace_event/trace_event.h" |
| #endif |
| #include "mojo/public/cpp/bindings/clone_traits.h" |
| #include "mojo/public/cpp/bindings/equals_traits.h" |
| #include "mojo/public/cpp/bindings/lib/serialization.h" |
| #include "mojo/public/cpp/bindings/struct_ptr.h" |
| #include "mojo/public/cpp/bindings/struct_traits.h" |
| #include "mojo/public/cpp/bindings/union_traits.h" |
| #include "services/service_manager/tests/connect/connect.test-mojom-shared.h" |
| #include "services/service_manager/tests/connect/connect.test-mojom-blink-forward.h" |
| #include "mojo/public/mojom/base/token.mojom-blink.h" |
| #include "services/service_manager/public/mojom/connector.mojom-blink.h" |
| #include "services/service_manager/public/mojom/service_filter.mojom-blink.h" |
| |
| #include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h" |
| #include "mojo/public/cpp/bindings/lib/wtf_hash_util.h" |
| #include "third_party/blink/renderer/platform/wtf/hash_functions.h" |
| #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h" |
| |
| #include "mojo/public/cpp/bindings/associated_interface_ptr.h" |
| #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h" |
| #include "mojo/public/cpp/bindings/associated_interface_request.h" |
| #include "mojo/public/cpp/bindings/interface_ptr.h" |
| #include "mojo/public/cpp/bindings/interface_request.h" |
| #include "mojo/public/cpp/bindings/lib/control_message_handler.h" |
| #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h" |
| #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h" |
| |
| |
| #include "mojo/public/cpp/bindings/lib/native_enum_serialization.h" |
| #include "mojo/public/cpp/bindings/lib/native_struct_serialization.h" |
| |
| #ifdef KYTHE_IS_RUNNING |
| #pragma kythe_inline_metadata "Metadata comment" |
| #endif |
| |
| |
| namespace service_manager { |
| namespace test { |
| namespace mojom { |
| namespace blink { |
| |
| class ConnectTestServiceProxy; |
| |
| template <typename ImplRefTraits> |
| class ConnectTestServiceStub; |
| |
| class ConnectTestServiceRequestValidator; |
| class ConnectTestServiceResponseValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.ConnectTestService |
| class ConnectTestService |
| : public ConnectTestServiceInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = ConnectTestServiceInterfaceBase; |
| using Proxy_ = ConnectTestServiceProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = ConnectTestServiceStub<ImplRefTraits>; |
| |
| using RequestValidator_ = ConnectTestServiceRequestValidator; |
| using ResponseValidator_ = ConnectTestServiceResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kGetTitleMinVersion = 0, |
| kGetInstanceIdMinVersion = 0, |
| }; |
| virtual ~ConnectTestService() {} |
| |
| |
| using GetTitleCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: service_manager.test.mojom.ConnectTestService.GetTitle |
| virtual void GetTitle(GetTitleCallback callback) = 0; |
| |
| |
| using GetInstanceIdCallback = base::OnceCallback<void(::mojo_base::mojom::blink::TokenPtr)>; |
| |
| // @generated_from: service_manager.test.mojom.ConnectTestService.GetInstanceId |
| virtual void GetInstanceId(GetInstanceIdCallback callback) = 0; |
| }; |
| |
| class ClassInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| class ClassInterfaceStub; |
| |
| class ClassInterfaceRequestValidator; |
| class ClassInterfaceResponseValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.ClassInterface |
| class ClassInterface |
| : public ClassInterfaceInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = ClassInterfaceInterfaceBase; |
| using Proxy_ = ClassInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = ClassInterfaceStub<ImplRefTraits>; |
| |
| using RequestValidator_ = ClassInterfaceRequestValidator; |
| using ResponseValidator_ = ClassInterfaceResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kPingMinVersion = 0, |
| }; |
| virtual ~ClassInterface() {} |
| |
| |
| using PingCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: service_manager.test.mojom.ClassInterface.Ping |
| virtual void Ping(PingCallback callback) = 0; |
| }; |
| |
| class StandaloneAppProxy; |
| |
| template <typename ImplRefTraits> |
| class StandaloneAppStub; |
| |
| class StandaloneAppRequestValidator; |
| class StandaloneAppResponseValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.StandaloneApp |
| class StandaloneApp |
| : public StandaloneAppInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = StandaloneAppInterfaceBase; |
| using Proxy_ = StandaloneAppProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = StandaloneAppStub<ImplRefTraits>; |
| |
| using RequestValidator_ = StandaloneAppRequestValidator; |
| using ResponseValidator_ = StandaloneAppResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kConnectToAllowedAppInBlockedPackageMinVersion = 0, |
| kConnectToClassInterfaceMinVersion = 0, |
| }; |
| virtual ~StandaloneApp() {} |
| |
| |
| using ConnectToAllowedAppInBlockedPackageCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: service_manager.test.mojom.StandaloneApp.ConnectToAllowedAppInBlockedPackage |
| virtual void ConnectToAllowedAppInBlockedPackage(ConnectToAllowedAppInBlockedPackageCallback callback) = 0; |
| |
| |
| using ConnectToClassInterfaceCallback = base::OnceCallback<void(const WTF::String&, const WTF::String&)>; |
| |
| // @generated_from: service_manager.test.mojom.StandaloneApp.ConnectToClassInterface |
| virtual void ConnectToClassInterface(ConnectToClassInterfaceCallback callback) = 0; |
| }; |
| |
| class IdentityTestProxy; |
| |
| template <typename ImplRefTraits> |
| class IdentityTestStub; |
| |
| class IdentityTestRequestValidator; |
| class IdentityTestResponseValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.IdentityTest |
| class IdentityTest |
| : public IdentityTestInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = IdentityTestInterfaceBase; |
| using Proxy_ = IdentityTestProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = IdentityTestStub<ImplRefTraits>; |
| |
| using RequestValidator_ = IdentityTestRequestValidator; |
| using ResponseValidator_ = IdentityTestResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kConnectToClassAppWithFilterMinVersion = 0, |
| }; |
| virtual ~IdentityTest() {} |
| |
| |
| using ConnectToClassAppWithFilterCallback = base::OnceCallback<void(int32_t, ::service_manager::mojom::blink::IdentityPtr)>; |
| |
| // @generated_from: service_manager.test.mojom.IdentityTest.ConnectToClassAppWithFilter |
| virtual void ConnectToClassAppWithFilter(::service_manager::mojom::blink::ServiceFilterPtr filter, ConnectToClassAppWithFilterCallback callback) = 0; |
| }; |
| |
| class ExposedInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| class ExposedInterfaceStub; |
| |
| class ExposedInterfaceRequestValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.ExposedInterface |
| class ExposedInterface |
| : public ExposedInterfaceInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = ExposedInterfaceInterfaceBase; |
| using Proxy_ = ExposedInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = ExposedInterfaceStub<ImplRefTraits>; |
| |
| using RequestValidator_ = ExposedInterfaceRequestValidator; |
| using ResponseValidator_ = mojo::PassThroughFilter; |
| enum MethodMinVersions : uint32_t { |
| kConnectionAcceptedMinVersion = 0, |
| }; |
| virtual ~ExposedInterface() {} |
| |
| |
| // @generated_from: service_manager.test.mojom.ExposedInterface.ConnectionAccepted |
| virtual void ConnectionAccepted(ConnectionStatePtr state) = 0; |
| }; |
| |
| class BlockedInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| class BlockedInterfaceStub; |
| |
| class BlockedInterfaceRequestValidator; |
| class BlockedInterfaceResponseValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.BlockedInterface |
| class BlockedInterface |
| : public BlockedInterfaceInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = BlockedInterfaceInterfaceBase; |
| using Proxy_ = BlockedInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = BlockedInterfaceStub<ImplRefTraits>; |
| |
| using RequestValidator_ = BlockedInterfaceRequestValidator; |
| using ResponseValidator_ = BlockedInterfaceResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kGetTitleBlockedMinVersion = 0, |
| }; |
| virtual ~BlockedInterface() {} |
| |
| |
| using GetTitleBlockedCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: service_manager.test.mojom.BlockedInterface.GetTitleBlocked |
| virtual void GetTitleBlocked(GetTitleBlockedCallback callback) = 0; |
| }; |
| |
| class AlwaysAllowedInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| class AlwaysAllowedInterfaceStub; |
| |
| class AlwaysAllowedInterfaceRequestValidator; |
| class AlwaysAllowedInterfaceResponseValidator; |
| |
| |
| // @generated_from: service_manager.test.mojom.AlwaysAllowedInterface |
| class AlwaysAllowedInterface |
| : public AlwaysAllowedInterfaceInterfaceBase { |
| public: |
| static const char Name_[]; |
| static constexpr uint32_t Version_ = 0; |
| static constexpr bool PassesAssociatedKinds_ = false; |
| static constexpr bool HasSyncMethods_ = false; |
| |
| using Base_ = AlwaysAllowedInterfaceInterfaceBase; |
| using Proxy_ = AlwaysAllowedInterfaceProxy; |
| |
| template <typename ImplRefTraits> |
| using Stub_ = AlwaysAllowedInterfaceStub<ImplRefTraits>; |
| |
| using RequestValidator_ = AlwaysAllowedInterfaceRequestValidator; |
| using ResponseValidator_ = AlwaysAllowedInterfaceResponseValidator; |
| enum MethodMinVersions : uint32_t { |
| kGetTitleAlwaysAllowedMinVersion = 0, |
| }; |
| virtual ~AlwaysAllowedInterface() {} |
| |
| |
| using GetTitleAlwaysAllowedCallback = base::OnceCallback<void(const WTF::String&)>; |
| |
| // @generated_from: service_manager.test.mojom.AlwaysAllowedInterface.GetTitleAlwaysAllowed |
| virtual void GetTitleAlwaysAllowed(GetTitleAlwaysAllowedCallback callback) = 0; |
| }; |
| |
| class ConnectTestServiceProxy |
| : public ConnectTestService { |
| public: |
| using InterfaceType = ConnectTestService; |
| |
| explicit ConnectTestServiceProxy(mojo::MessageReceiverWithResponder* receiver); |
| void GetTitle(GetTitleCallback callback) final; |
| void GetInstanceId(GetInstanceIdCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class ClassInterfaceProxy |
| : public ClassInterface { |
| public: |
| using InterfaceType = ClassInterface; |
| |
| explicit ClassInterfaceProxy(mojo::MessageReceiverWithResponder* receiver); |
| void Ping(PingCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class StandaloneAppProxy |
| : public StandaloneApp { |
| public: |
| using InterfaceType = StandaloneApp; |
| |
| explicit StandaloneAppProxy(mojo::MessageReceiverWithResponder* receiver); |
| void ConnectToAllowedAppInBlockedPackage(ConnectToAllowedAppInBlockedPackageCallback callback) final; |
| void ConnectToClassInterface(ConnectToClassInterfaceCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class IdentityTestProxy |
| : public IdentityTest { |
| public: |
| using InterfaceType = IdentityTest; |
| |
| explicit IdentityTestProxy(mojo::MessageReceiverWithResponder* receiver); |
| void ConnectToClassAppWithFilter(::service_manager::mojom::blink::ServiceFilterPtr filter, ConnectToClassAppWithFilterCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class ExposedInterfaceProxy |
| : public ExposedInterface { |
| public: |
| using InterfaceType = ExposedInterface; |
| |
| explicit ExposedInterfaceProxy(mojo::MessageReceiverWithResponder* receiver); |
| void ConnectionAccepted(ConnectionStatePtr state) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class BlockedInterfaceProxy |
| : public BlockedInterface { |
| public: |
| using InterfaceType = BlockedInterface; |
| |
| explicit BlockedInterfaceProxy(mojo::MessageReceiverWithResponder* receiver); |
| void GetTitleBlocked(GetTitleBlockedCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| |
| class AlwaysAllowedInterfaceProxy |
| : public AlwaysAllowedInterface { |
| public: |
| using InterfaceType = AlwaysAllowedInterface; |
| |
| explicit AlwaysAllowedInterfaceProxy(mojo::MessageReceiverWithResponder* receiver); |
| void GetTitleAlwaysAllowed(GetTitleAlwaysAllowedCallback callback) final; |
| |
| private: |
| mojo::MessageReceiverWithResponder* receiver_; |
| }; |
| class ConnectTestServiceStubDispatch { |
| public: |
| static bool Accept(ConnectTestService* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| ConnectTestService* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<ConnectTestService>> |
| class ConnectTestServiceStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| ConnectTestServiceStub() {} |
| ~ConnectTestServiceStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ConnectTestServiceStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ConnectTestServiceStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class ClassInterfaceStubDispatch { |
| public: |
| static bool Accept(ClassInterface* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| ClassInterface* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<ClassInterface>> |
| class ClassInterfaceStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| ClassInterfaceStub() {} |
| ~ClassInterfaceStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ClassInterfaceStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ClassInterfaceStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class StandaloneAppStubDispatch { |
| public: |
| static bool Accept(StandaloneApp* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| StandaloneApp* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<StandaloneApp>> |
| class StandaloneAppStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| StandaloneAppStub() {} |
| ~StandaloneAppStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return StandaloneAppStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return StandaloneAppStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class IdentityTestStubDispatch { |
| public: |
| static bool Accept(IdentityTest* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| IdentityTest* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<IdentityTest>> |
| class IdentityTestStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| IdentityTestStub() {} |
| ~IdentityTestStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return IdentityTestStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return IdentityTestStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class ExposedInterfaceStubDispatch { |
| public: |
| static bool Accept(ExposedInterface* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| ExposedInterface* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<ExposedInterface>> |
| class ExposedInterfaceStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| ExposedInterfaceStub() {} |
| ~ExposedInterfaceStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ExposedInterfaceStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return ExposedInterfaceStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class BlockedInterfaceStubDispatch { |
| public: |
| static bool Accept(BlockedInterface* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| BlockedInterface* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<BlockedInterface>> |
| class BlockedInterfaceStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| BlockedInterfaceStub() {} |
| ~BlockedInterfaceStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return BlockedInterfaceStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return BlockedInterfaceStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class AlwaysAllowedInterfaceStubDispatch { |
| public: |
| static bool Accept(AlwaysAllowedInterface* impl, mojo::Message* message); |
| static bool AcceptWithResponder( |
| AlwaysAllowedInterface* impl, |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder); |
| }; |
| |
| template <typename ImplRefTraits = |
| mojo::RawPtrImplRefTraits<AlwaysAllowedInterface>> |
| class AlwaysAllowedInterfaceStub |
| : public mojo::MessageReceiverWithResponderStatus { |
| public: |
| using ImplPointerType = typename ImplRefTraits::PointerType; |
| |
| AlwaysAllowedInterfaceStub() {} |
| ~AlwaysAllowedInterfaceStub() override {} |
| |
| void set_sink(ImplPointerType sink) { sink_ = std::move(sink); } |
| ImplPointerType& sink() { return sink_; } |
| |
| bool Accept(mojo::Message* message) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return AlwaysAllowedInterfaceStubDispatch::Accept( |
| ImplRefTraits::GetRawPointer(&sink_), message); |
| } |
| |
| bool AcceptWithResponder( |
| mojo::Message* message, |
| std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { |
| if (ImplRefTraits::IsNull(sink_)) |
| return false; |
| return AlwaysAllowedInterfaceStubDispatch::AcceptWithResponder( |
| ImplRefTraits::GetRawPointer(&sink_), message, std::move(responder)); |
| } |
| |
| private: |
| ImplPointerType sink_; |
| }; |
| class ConnectTestServiceRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class ClassInterfaceRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class StandaloneAppRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class IdentityTestRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class ExposedInterfaceRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BlockedInterfaceRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class AlwaysAllowedInterfaceRequestValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class ConnectTestServiceResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class ClassInterfaceResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class StandaloneAppResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class IdentityTestResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class BlockedInterfaceResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| class AlwaysAllowedInterfaceResponseValidator : public mojo::MessageReceiver { |
| public: |
| bool Accept(mojo::Message* message) override; |
| }; |
| |
| |
| |
| |
| |
| |
| |
| |
| // @generated_from: service_manager.test.mojom.ConnectionState |
| class ConnectionState { |
| public: |
| template <typename T> |
| using EnableIfSame = std::enable_if_t<std::is_same<ConnectionState, T>::value>; |
| using DataView = ConnectionStateDataView; |
| using Data_ = internal::ConnectionState_Data; |
| |
| template <typename... Args> |
| static ConnectionStatePtr New(Args&&... args) { |
| return ConnectionStatePtr( |
| base::in_place, std::forward<Args>(args)...); |
| } |
| |
| template <typename U> |
| static ConnectionStatePtr From(const U& u) { |
| return mojo::TypeConverter<ConnectionStatePtr, U>::Convert(u); |
| } |
| |
| template <typename U> |
| U To() const { |
| return mojo::TypeConverter<U, ConnectionState>::Convert(*this); |
| } |
| |
| |
| ConnectionState(); |
| |
| ConnectionState( |
| const WTF::String& connection_remote_name, |
| ::mojo_base::mojom::blink::TokenPtr connection_remote_instance_group, |
| const WTF::String& initialize_local_name, |
| ::mojo_base::mojom::blink::TokenPtr initialize_local_instance_group); |
| |
| ~ConnectionState(); |
| |
| // 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 = ConnectionStatePtr> |
| ConnectionStatePtr 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, ConnectionState::EnableIfSame<T>* = nullptr> |
| bool Equals(const T& other) const; |
| |
| template <typename UserType> |
| static WTF::Vector<uint8_t> Serialize(UserType* input) { |
| return mojo::internal::SerializeImpl< |
| ConnectionState::DataView, WTF::Vector<uint8_t>>(input); |
| } |
| |
| template <typename UserType> |
| static mojo::Message SerializeAsMessage(UserType* input) { |
| return mojo::internal::SerializeAsMessageImpl< |
| ConnectionState::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::ConnectionState_UnserializedMessageContext< |
| UserType, ConnectionState::DataView>>(0, 0, std::move(input))); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const void* data, |
| size_t data_num_bytes, |
| UserType* output) { |
| return mojo::internal::DeserializeImpl<ConnectionState::DataView>( |
| data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate); |
| } |
| |
| template <typename UserType> |
| static bool Deserialize(const WTF::Vector<uint8_t>& input, |
| UserType* output) { |
| return ConnectionState::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::ConnectionState_UnserializedMessageContext< |
| UserType, ConnectionState::DataView>>(); |
| if (context) { |
| *output = std::move(context->TakeData()); |
| return true; |
| } |
| input.SerializeIfNecessary(); |
| return mojo::internal::DeserializeImpl<ConnectionState::DataView>( |
| input.payload(), input.payload_num_bytes(), |
| std::move(*input.mutable_handles()), output, Validate); |
| } |
| |
| |
| // @generated_from: service_manager.test.mojom.ConnectionState.connection_remote_name |
| WTF::String connection_remote_name; |
| |
| // @generated_from: service_manager.test.mojom.ConnectionState.connection_remote_instance_group |
| ::mojo_base::mojom::blink::TokenPtr connection_remote_instance_group; |
| |
| // @generated_from: service_manager.test.mojom.ConnectionState.initialize_local_name |
| WTF::String initialize_local_name; |
| |
| // @generated_from: service_manager.test.mojom.ConnectionState.initialize_local_instance_group |
| ::mojo_base::mojom::blink::TokenPtr initialize_local_instance_group; |
| |
| private: |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| DISALLOW_COPY_AND_ASSIGN(ConnectionState); |
| }; |
| |
| // 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, ConnectionState::EnableIfSame<T>* = nullptr> |
| bool operator<(const T& lhs, const T& rhs); |
| |
| template <typename T, ConnectionState::EnableIfSame<T>* = nullptr> |
| bool operator<=(const T& lhs, const T& rhs) { |
| return !(rhs < lhs); |
| } |
| |
| template <typename T, ConnectionState::EnableIfSame<T>* = nullptr> |
| bool operator>(const T& lhs, const T& rhs) { |
| return rhs < lhs; |
| } |
| |
| template <typename T, ConnectionState::EnableIfSame<T>* = nullptr> |
| bool operator>=(const T& lhs, const T& rhs) { |
| return !(lhs < rhs); |
| } |
| |
| template <typename StructPtrType> |
| ConnectionStatePtr ConnectionState::Clone() const { |
| return New( |
| mojo::Clone(connection_remote_name), |
| mojo::Clone(connection_remote_instance_group), |
| mojo::Clone(initialize_local_name), |
| mojo::Clone(initialize_local_instance_group) |
| ); |
| } |
| |
| template <typename T, ConnectionState::EnableIfSame<T>*> |
| bool ConnectionState::Equals(const T& other_struct) const { |
| if (!mojo::Equals(this->connection_remote_name, other_struct.connection_remote_name)) |
| return false; |
| if (!mojo::Equals(this->connection_remote_instance_group, other_struct.connection_remote_instance_group)) |
| return false; |
| if (!mojo::Equals(this->initialize_local_name, other_struct.initialize_local_name)) |
| return false; |
| if (!mojo::Equals(this->initialize_local_instance_group, other_struct.initialize_local_instance_group)) |
| return false; |
| return true; |
| } |
| |
| template <typename T, ConnectionState::EnableIfSame<T>*> |
| bool operator<(const T& lhs, const T& rhs) { |
| if (lhs.connection_remote_name < rhs.connection_remote_name) |
| return true; |
| if (rhs.connection_remote_name < lhs.connection_remote_name) |
| return false; |
| if (lhs.connection_remote_instance_group < rhs.connection_remote_instance_group) |
| return true; |
| if (rhs.connection_remote_instance_group < lhs.connection_remote_instance_group) |
| return false; |
| if (lhs.initialize_local_name < rhs.initialize_local_name) |
| return true; |
| if (rhs.initialize_local_name < lhs.initialize_local_name) |
| return false; |
| if (lhs.initialize_local_instance_group < rhs.initialize_local_instance_group) |
| return true; |
| if (rhs.initialize_local_instance_group < lhs.initialize_local_instance_group) |
| return false; |
| return false; |
| } |
| |
| |
| } // namespace blink |
| } // namespace mojom |
| } // namespace test |
| } // namespace service_manager |
| |
| namespace mojo { |
| |
| |
| template <> |
| struct StructTraits<::service_manager::test::mojom::blink::ConnectionState::DataView, |
| ::service_manager::test::mojom::blink::ConnectionStatePtr> { |
| static bool IsNull(const ::service_manager::test::mojom::blink::ConnectionStatePtr& input) { return !input; } |
| static void SetToNull(::service_manager::test::mojom::blink::ConnectionStatePtr* output) { output->reset(); } |
| |
| static const decltype(::service_manager::test::mojom::blink::ConnectionState::connection_remote_name)& connection_remote_name( |
| const ::service_manager::test::mojom::blink::ConnectionStatePtr& input) { |
| return input->connection_remote_name; |
| } |
| |
| static const decltype(::service_manager::test::mojom::blink::ConnectionState::connection_remote_instance_group)& connection_remote_instance_group( |
| const ::service_manager::test::mojom::blink::ConnectionStatePtr& input) { |
| return input->connection_remote_instance_group; |
| } |
| |
| static const decltype(::service_manager::test::mojom::blink::ConnectionState::initialize_local_name)& initialize_local_name( |
| const ::service_manager::test::mojom::blink::ConnectionStatePtr& input) { |
| return input->initialize_local_name; |
| } |
| |
| static const decltype(::service_manager::test::mojom::blink::ConnectionState::initialize_local_instance_group)& initialize_local_instance_group( |
| const ::service_manager::test::mojom::blink::ConnectionStatePtr& input) { |
| return input->initialize_local_instance_group; |
| } |
| |
| static bool Read(::service_manager::test::mojom::blink::ConnectionState::DataView input, ::service_manager::test::mojom::blink::ConnectionStatePtr* output); |
| }; |
| |
| } // namespace mojo |
| |
| #endif // SERVICES_SERVICE_MANAGER_TESTS_CONNECT_CONNECT_TEST_MOJOM_BLINK_H_
|
| /* Metadata comment
|
| eyJtZXRhIjogW3siZW5kIjogMjYzMiwgImJlZ2luIjogMjYxNCwgImVkZ2UiOiAiJS9reXRoZS9l
|
| ZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3Jw
|
| dXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2Ui
|
| OiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLkNvbm5l
|
| Y3RUZXN0U2VydmljZSJ9fSwgeyJlbmQiOiAzNDk3LCAiYmVnaW4iOiAzNDg5LCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2VyLnRlc3QubW9q
|
| b20uQ29ubmVjdFRlc3RTZXJ2aWNlLkdldFRpdGxlIn19LCB7ImVuZCI6IDM3MzgsICJiZWdpbiI6
|
| IDM3MjUsICJlZGdlIjogIiUva3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3Jf
|
| ZGVmaW5lcyIsICJ2bmFtZSI6IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20v
|
| Y2hyb21pdW0vc3JjIiwgImxhbmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJzZXJ2aWNl
|
| X21hbmFnZXIudGVzdC5tb2pvbS5Db25uZWN0VGVzdFNlcnZpY2UuR2V0SW5zdGFuY2VJZCJ9fSwg
|
| eyJlbmQiOiA0MDMxLCAiYmVnaW4iOiA0MDE3LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh
|
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJzaWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2VyLnRlc3QubW9qb20uQ2xhc3NJbnRlcmZhY2Ui
|
| fX0sIHsiZW5kIjogNDgxNCwgImJlZ2luIjogNDgxMCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLkNsYXNzSW50ZXJm
|
| YWNlLlBpbmcifX0sIHsiZW5kIjogNTA5MiwgImJlZ2luIjogNTA3OSwgImVkZ2UiOiAiJS9reXRo
|
| ZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJj
|
| b3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3Vh
|
| Z2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLlN0
|
| YW5kYWxvbmVBcHAifX0sIHsiZW5kIjogNjAzNSwgImJlZ2luIjogNjAwMCwgImVkZ2UiOiAiJS9r
|
| eXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjog
|
| eyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFu
|
| Z3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9t
|
| LlN0YW5kYWxvbmVBcHAuQ29ubmVjdFRvQWxsb3dlZEFwcEluQmxvY2tlZFBhY2thZ2UifX0sIHsi
|
| ZW5kIjogNjMzMSwgImJlZ2luIjogNjMwOCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRl
|
| cyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21p
|
| dW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAi
|
| c2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLlN0YW5kYWxvbmVBcHAuQ29u
|
| bmVjdFRvQ2xhc3NJbnRlcmZhY2UifX0sIHsiZW5kIjogNjYyMiwgImJlZ2luIjogNjYxMCwgImVk
|
| Z2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwg
|
| InZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9z
|
| cmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50
|
| ZXN0Lm1vam9tLklkZW50aXR5VGVzdCJ9fSwgeyJlbmQiOiA3NTE2LCAiYmVnaW4iOiA3NDg5LCAi
|
| ZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMi
|
| LCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVt
|
| L3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2Vy
|
| LnRlc3QubW9qb20uSWRlbnRpdHlUZXN0LkNvbm5lY3RUb0NsYXNzQXBwV2l0aEZpbHRlciJ9fSwg
|
| eyJlbmQiOiA3ODUyLCAiYmVnaW4iOiA3ODM2LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJh
|
| dGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJv
|
| bWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIs
|
| ICJzaWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2VyLnRlc3QubW9qb20uRXhwb3NlZEludGVyZmFj
|
| ZSJ9fSwgeyJlbmQiOiA4NjEzLCAiYmVnaW4iOiA4NTk1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2Uv
|
| Z2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6
|
| ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJt
|
| b2pvbSIsICJzaWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2VyLnRlc3QubW9qb20uRXhwb3NlZElu
|
| dGVyZmFjZS5Db25uZWN0aW9uQWNjZXB0ZWQifX0sIHsiZW5kIjogODkxMiwgImJlZ2luIjogODg5
|
| NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZp
|
| bmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJv
|
| bWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFu
|
| YWdlci50ZXN0Lm1vam9tLkJsb2NrZWRJbnRlcmZhY2UifX0sIHsiZW5kIjogOTc1NSwgImJlZ2lu
|
| IjogOTc0MCwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hv
|
| cl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNv
|
| bS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZp
|
| Y2VfbWFuYWdlci50ZXN0Lm1vam9tLkJsb2NrZWRJbnRlcmZhY2UuR2V0VGl0bGVCbG9ja2VkIn19
|
| LCB7ImVuZCI6IDEwMDk4LCAiYmVnaW4iOiAxMDA3NiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLkFsd2F5c0FsbG93
|
| ZWRJbnRlcmZhY2UifX0sIHsiZW5kIjogMTEwMTMsICJiZWdpbiI6IDEwOTkyLCAiZWRnZSI6ICIl
|
| L2t5dGhlL2VkZ2UvZ2VuZXJhdGVzIiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUi
|
| OiB7ImNvcnB1cyI6ICJjaHJvbWl1bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJs
|
| YW5ndWFnZSI6ICJtb2pvbSIsICJzaWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2VyLnRlc3QubW9q
|
| b20uQWx3YXlzQWxsb3dlZEludGVyZmFjZS5HZXRUaXRsZUFsd2F5c0FsbG93ZWQifX0sIHsiZW5k
|
| IjogMjQ0OTAsICJiZWdpbiI6IDI0NDc1LCAiZWRnZSI6ICIlL2t5dGhlL2VkZ2UvZ2VuZXJhdGVz
|
| IiwgInR5cGUiOiAiYW5jaG9yX2RlZmluZXMiLCAidm5hbWUiOiB7ImNvcnB1cyI6ICJjaHJvbWl1
|
| bS5nb29nbGVzb3VyY2UuY29tL2Nocm9taXVtL3NyYyIsICJsYW5ndWFnZSI6ICJtb2pvbSIsICJz
|
| aWduYXR1cmUiOiAic2VydmljZV9tYW5hZ2VyLnRlc3QubW9qb20uQ29ubmVjdGlvblN0YXRlIn19
|
| LCB7ImVuZCI6IDI4MjkzLCAiYmVnaW4iOiAyODI3MSwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dl
|
| bmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAi
|
| Y2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9q
|
| b20iLCAic2lnbmF0dXJlIjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLkNvbm5lY3Rpb25T
|
| dGF0ZS5jb25uZWN0aW9uX3JlbW90ZV9uYW1lIn19LCB7ImVuZCI6IDI4NDY0LCAiYmVnaW4iOiAy
|
| ODQzMiwgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBlIjogImFuY2hvcl9k
|
| ZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xlc291cmNlLmNvbS9j
|
| aHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJlIjogInNlcnZpY2Vf
|
| bWFuYWdlci50ZXN0Lm1vam9tLkNvbm5lY3Rpb25TdGF0ZS5jb25uZWN0aW9uX3JlbW90ZV9pbnN0
|
| YW5jZV9ncm91cCJ9fSwgeyJlbmQiOiAyODU4OSwgImJlZ2luIjogMjg1NjgsICJlZGdlIjogIiUv
|
| a3l0aGUvZWRnZS9nZW5lcmF0ZXMiLCAidHlwZSI6ICJhbmNob3JfZGVmaW5lcyIsICJ2bmFtZSI6
|
| IHsiY29ycHVzIjogImNocm9taXVtLmdvb2dsZXNvdXJjZS5jb20vY2hyb21pdW0vc3JjIiwgImxh
|
| bmd1YWdlIjogIm1vam9tIiwgInNpZ25hdHVyZSI6ICJzZXJ2aWNlX21hbmFnZXIudGVzdC5tb2pv
|
| bS5Db25uZWN0aW9uU3RhdGUuaW5pdGlhbGl6ZV9sb2NhbF9uYW1lIn19LCB7ImVuZCI6IDI4NzU4
|
| LCAiYmVnaW4iOiAyODcyNywgImVkZ2UiOiAiJS9reXRoZS9lZGdlL2dlbmVyYXRlcyIsICJ0eXBl
|
| IjogImFuY2hvcl9kZWZpbmVzIiwgInZuYW1lIjogeyJjb3JwdXMiOiAiY2hyb21pdW0uZ29vZ2xl
|
| c291cmNlLmNvbS9jaHJvbWl1bS9zcmMiLCAibGFuZ3VhZ2UiOiAibW9qb20iLCAic2lnbmF0dXJl
|
| IjogInNlcnZpY2VfbWFuYWdlci50ZXN0Lm1vam9tLkNvbm5lY3Rpb25TdGF0ZS5pbml0aWFsaXpl
|
| X2xvY2FsX2luc3RhbmNlX2dyb3VwIn19XSwgInR5cGUiOiAia3l0aGUwIn0=
|
| */ |