| // Copyright 2019 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_PARAMS_DATA_H_ |
| #define SERVICES_SERVICE_MANAGER_TESTS_CONNECT_CONNECT_TEST_MOJOM_PARAMS_DATA_H_ |
| |
| #include "base/logging.h" |
| #include "base/macros.h" |
| #include "mojo/public/cpp/bindings/lib/bindings_internal.h" |
| #include "mojo/public/cpp/bindings/lib/buffer.h" |
| #include "mojo/public/cpp/bindings/lib/validation_context.h" |
| |
| #if defined(__clang__) |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wunused-private-field" |
| #elif defined(_MSC_VER) |
| #pragma warning(push) |
| #pragma warning(disable:4056) |
| #pragma warning(disable:4065) |
| #pragma warning(disable:4756) |
| #endif |
| namespace service_manager { |
| namespace test { |
| namespace mojom { |
| namespace internal { |
| class ConnectTestService_GetTitle_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ConnectTestService_GetTitle_Params_Data)); |
| new (data()) ConnectTestService_GetTitle_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ConnectTestService_GetTitle_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ConnectTestService_GetTitle_Params_Data>(index_); |
| } |
| ConnectTestService_GetTitle_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| ConnectTestService_GetTitle_Params_Data(); |
| ~ConnectTestService_GetTitle_Params_Data() = delete; |
| }; |
| static_assert(sizeof(ConnectTestService_GetTitle_Params_Data) == 8, |
| "Bad sizeof(ConnectTestService_GetTitle_Params_Data)"); |
| class ConnectTestService_GetTitle_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ConnectTestService_GetTitle_ResponseParams_Data)); |
| new (data()) ConnectTestService_GetTitle_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ConnectTestService_GetTitle_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ConnectTestService_GetTitle_ResponseParams_Data>(index_); |
| } |
| ConnectTestService_GetTitle_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<mojo::internal::String_Data> title; |
| |
| private: |
| ConnectTestService_GetTitle_ResponseParams_Data(); |
| ~ConnectTestService_GetTitle_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(ConnectTestService_GetTitle_ResponseParams_Data) == 16, |
| "Bad sizeof(ConnectTestService_GetTitle_ResponseParams_Data)"); |
| class ConnectTestService_GetInstanceId_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ConnectTestService_GetInstanceId_Params_Data)); |
| new (data()) ConnectTestService_GetInstanceId_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ConnectTestService_GetInstanceId_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ConnectTestService_GetInstanceId_Params_Data>(index_); |
| } |
| ConnectTestService_GetInstanceId_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| ConnectTestService_GetInstanceId_Params_Data(); |
| ~ConnectTestService_GetInstanceId_Params_Data() = delete; |
| }; |
| static_assert(sizeof(ConnectTestService_GetInstanceId_Params_Data) == 8, |
| "Bad sizeof(ConnectTestService_GetInstanceId_Params_Data)"); |
| class ConnectTestService_GetInstanceId_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ConnectTestService_GetInstanceId_ResponseParams_Data)); |
| new (data()) ConnectTestService_GetInstanceId_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ConnectTestService_GetInstanceId_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ConnectTestService_GetInstanceId_ResponseParams_Data>(index_); |
| } |
| ConnectTestService_GetInstanceId_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<::mojo_base::mojom::internal::Token_Data> instance_id; |
| |
| private: |
| ConnectTestService_GetInstanceId_ResponseParams_Data(); |
| ~ConnectTestService_GetInstanceId_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(ConnectTestService_GetInstanceId_ResponseParams_Data) == 16, |
| "Bad sizeof(ConnectTestService_GetInstanceId_ResponseParams_Data)"); |
| class ClassInterface_Ping_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ClassInterface_Ping_Params_Data)); |
| new (data()) ClassInterface_Ping_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ClassInterface_Ping_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ClassInterface_Ping_Params_Data>(index_); |
| } |
| ClassInterface_Ping_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| ClassInterface_Ping_Params_Data(); |
| ~ClassInterface_Ping_Params_Data() = delete; |
| }; |
| static_assert(sizeof(ClassInterface_Ping_Params_Data) == 8, |
| "Bad sizeof(ClassInterface_Ping_Params_Data)"); |
| class ClassInterface_Ping_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ClassInterface_Ping_ResponseParams_Data)); |
| new (data()) ClassInterface_Ping_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ClassInterface_Ping_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ClassInterface_Ping_ResponseParams_Data>(index_); |
| } |
| ClassInterface_Ping_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<mojo::internal::String_Data> response; |
| |
| private: |
| ClassInterface_Ping_ResponseParams_Data(); |
| ~ClassInterface_Ping_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(ClassInterface_Ping_ResponseParams_Data) == 16, |
| "Bad sizeof(ClassInterface_Ping_ResponseParams_Data)"); |
| class StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data)); |
| new (data()) StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data>(index_); |
| } |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data(); |
| ~StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data() = delete; |
| }; |
| static_assert(sizeof(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data) == 8, |
| "Bad sizeof(StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data)"); |
| class StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data)); |
| new (data()) StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data>(index_); |
| } |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<mojo::internal::String_Data> title; |
| |
| private: |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data(); |
| ~StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data) == 16, |
| "Bad sizeof(StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data)"); |
| class StandaloneApp_ConnectToClassInterface_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(StandaloneApp_ConnectToClassInterface_Params_Data)); |
| new (data()) StandaloneApp_ConnectToClassInterface_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| StandaloneApp_ConnectToClassInterface_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<StandaloneApp_ConnectToClassInterface_Params_Data>(index_); |
| } |
| StandaloneApp_ConnectToClassInterface_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| StandaloneApp_ConnectToClassInterface_Params_Data(); |
| ~StandaloneApp_ConnectToClassInterface_Params_Data() = delete; |
| }; |
| static_assert(sizeof(StandaloneApp_ConnectToClassInterface_Params_Data) == 8, |
| "Bad sizeof(StandaloneApp_ConnectToClassInterface_Params_Data)"); |
| class StandaloneApp_ConnectToClassInterface_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(StandaloneApp_ConnectToClassInterface_ResponseParams_Data)); |
| new (data()) StandaloneApp_ConnectToClassInterface_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| StandaloneApp_ConnectToClassInterface_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<StandaloneApp_ConnectToClassInterface_ResponseParams_Data>(index_); |
| } |
| StandaloneApp_ConnectToClassInterface_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<mojo::internal::String_Data> class_interface_response; |
| mojo::internal::Pointer<mojo::internal::String_Data> title; |
| |
| private: |
| StandaloneApp_ConnectToClassInterface_ResponseParams_Data(); |
| ~StandaloneApp_ConnectToClassInterface_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(StandaloneApp_ConnectToClassInterface_ResponseParams_Data) == 24, |
| "Bad sizeof(StandaloneApp_ConnectToClassInterface_ResponseParams_Data)"); |
| class IdentityTest_ConnectToClassAppWithFilter_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(IdentityTest_ConnectToClassAppWithFilter_Params_Data)); |
| new (data()) IdentityTest_ConnectToClassAppWithFilter_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| IdentityTest_ConnectToClassAppWithFilter_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<IdentityTest_ConnectToClassAppWithFilter_Params_Data>(index_); |
| } |
| IdentityTest_ConnectToClassAppWithFilter_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<::service_manager::mojom::internal::ServiceFilter_Data> filter; |
| |
| private: |
| IdentityTest_ConnectToClassAppWithFilter_Params_Data(); |
| ~IdentityTest_ConnectToClassAppWithFilter_Params_Data() = delete; |
| }; |
| static_assert(sizeof(IdentityTest_ConnectToClassAppWithFilter_Params_Data) == 16, |
| "Bad sizeof(IdentityTest_ConnectToClassAppWithFilter_Params_Data)"); |
| class IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data)); |
| new (data()) IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data>(index_); |
| } |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| int32_t connection_result; |
| uint8_t pad0_[4]; |
| mojo::internal::Pointer<::service_manager::mojom::internal::Identity_Data> identity; |
| |
| private: |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data(); |
| ~IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data) == 24, |
| "Bad sizeof(IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data)"); |
| class ExposedInterface_ConnectionAccepted_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(ExposedInterface_ConnectionAccepted_Params_Data)); |
| new (data()) ExposedInterface_ConnectionAccepted_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| ExposedInterface_ConnectionAccepted_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<ExposedInterface_ConnectionAccepted_Params_Data>(index_); |
| } |
| ExposedInterface_ConnectionAccepted_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<internal::ConnectionState_Data> state; |
| |
| private: |
| ExposedInterface_ConnectionAccepted_Params_Data(); |
| ~ExposedInterface_ConnectionAccepted_Params_Data() = delete; |
| }; |
| static_assert(sizeof(ExposedInterface_ConnectionAccepted_Params_Data) == 16, |
| "Bad sizeof(ExposedInterface_ConnectionAccepted_Params_Data)"); |
| class BlockedInterface_GetTitleBlocked_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(BlockedInterface_GetTitleBlocked_Params_Data)); |
| new (data()) BlockedInterface_GetTitleBlocked_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| BlockedInterface_GetTitleBlocked_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<BlockedInterface_GetTitleBlocked_Params_Data>(index_); |
| } |
| BlockedInterface_GetTitleBlocked_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| BlockedInterface_GetTitleBlocked_Params_Data(); |
| ~BlockedInterface_GetTitleBlocked_Params_Data() = delete; |
| }; |
| static_assert(sizeof(BlockedInterface_GetTitleBlocked_Params_Data) == 8, |
| "Bad sizeof(BlockedInterface_GetTitleBlocked_Params_Data)"); |
| class BlockedInterface_GetTitleBlocked_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(BlockedInterface_GetTitleBlocked_ResponseParams_Data)); |
| new (data()) BlockedInterface_GetTitleBlocked_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| BlockedInterface_GetTitleBlocked_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<BlockedInterface_GetTitleBlocked_ResponseParams_Data>(index_); |
| } |
| BlockedInterface_GetTitleBlocked_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<mojo::internal::String_Data> blocked_title; |
| |
| private: |
| BlockedInterface_GetTitleBlocked_ResponseParams_Data(); |
| ~BlockedInterface_GetTitleBlocked_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(BlockedInterface_GetTitleBlocked_ResponseParams_Data) == 16, |
| "Bad sizeof(BlockedInterface_GetTitleBlocked_ResponseParams_Data)"); |
| class AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data)); |
| new (data()) AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data>(index_); |
| } |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| |
| private: |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data(); |
| ~AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data() = delete; |
| }; |
| static_assert(sizeof(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data) == 8, |
| "Bad sizeof(AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data)"); |
| class AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data { |
| public: |
| class BufferWriter { |
| public: |
| BufferWriter() = default; |
| |
| void Allocate(mojo::internal::Buffer* serialization_buffer) { |
| serialization_buffer_ = serialization_buffer; |
| index_ = serialization_buffer_->Allocate(sizeof(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data)); |
| new (data()) AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data(); |
| } |
| |
| bool is_null() const { return !serialization_buffer_; } |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data* data() { |
| DCHECK(!is_null()); |
| return serialization_buffer_->Get<AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data>(index_); |
| } |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data* operator->() { return data(); } |
| |
| private: |
| mojo::internal::Buffer* serialization_buffer_ = nullptr; |
| size_t index_ = 0; |
| |
| DISALLOW_COPY_AND_ASSIGN(BufferWriter); |
| }; |
| |
| static bool Validate(const void* data, |
| mojo::internal::ValidationContext* validation_context); |
| |
| mojo::internal::StructHeader header_; |
| mojo::internal::Pointer<mojo::internal::String_Data> title; |
| |
| private: |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data(); |
| ~AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data() = delete; |
| }; |
| static_assert(sizeof(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data) == 16, |
| "Bad sizeof(AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data)"); |
| |
| } // namespace internal |
| class ConnectTestService_GetTitle_ParamsDataView { |
| public: |
| ConnectTestService_GetTitle_ParamsDataView() {} |
| |
| ConnectTestService_GetTitle_ParamsDataView( |
| internal::ConnectTestService_GetTitle_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::ConnectTestService_GetTitle_Params_Data* data_ = nullptr; |
| }; |
| |
| class ConnectTestService_GetTitle_ResponseParamsDataView { |
| public: |
| ConnectTestService_GetTitle_ResponseParamsDataView() {} |
| |
| ConnectTestService_GetTitle_ResponseParamsDataView( |
| internal::ConnectTestService_GetTitle_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetTitleDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadTitle(UserType* output) { |
| auto* pointer = data_->title.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::ConnectTestService_GetTitle_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class ConnectTestService_GetInstanceId_ParamsDataView { |
| public: |
| ConnectTestService_GetInstanceId_ParamsDataView() {} |
| |
| ConnectTestService_GetInstanceId_ParamsDataView( |
| internal::ConnectTestService_GetInstanceId_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::ConnectTestService_GetInstanceId_Params_Data* data_ = nullptr; |
| }; |
| |
| class ConnectTestService_GetInstanceId_ResponseParamsDataView { |
| public: |
| ConnectTestService_GetInstanceId_ResponseParamsDataView() {} |
| |
| ConnectTestService_GetInstanceId_ResponseParamsDataView( |
| internal::ConnectTestService_GetInstanceId_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetInstanceIdDataView( |
| ::mojo_base::mojom::TokenDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadInstanceId(UserType* output) { |
| auto* pointer = data_->instance_id.Get(); |
| return mojo::internal::Deserialize<::mojo_base::mojom::TokenDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::ConnectTestService_GetInstanceId_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class ClassInterface_Ping_ParamsDataView { |
| public: |
| ClassInterface_Ping_ParamsDataView() {} |
| |
| ClassInterface_Ping_ParamsDataView( |
| internal::ClassInterface_Ping_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::ClassInterface_Ping_Params_Data* data_ = nullptr; |
| }; |
| |
| class ClassInterface_Ping_ResponseParamsDataView { |
| public: |
| ClassInterface_Ping_ResponseParamsDataView() {} |
| |
| ClassInterface_Ping_ResponseParamsDataView( |
| internal::ClassInterface_Ping_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetResponseDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadResponse(UserType* output) { |
| auto* pointer = data_->response.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::ClassInterface_Ping_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class StandaloneApp_ConnectToAllowedAppInBlockedPackage_ParamsDataView { |
| public: |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ParamsDataView() {} |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ParamsDataView( |
| internal::StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::StandaloneApp_ConnectToAllowedAppInBlockedPackage_Params_Data* data_ = nullptr; |
| }; |
| |
| class StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParamsDataView { |
| public: |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParamsDataView() {} |
| |
| StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParamsDataView( |
| internal::StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetTitleDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadTitle(UserType* output) { |
| auto* pointer = data_->title.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class StandaloneApp_ConnectToClassInterface_ParamsDataView { |
| public: |
| StandaloneApp_ConnectToClassInterface_ParamsDataView() {} |
| |
| StandaloneApp_ConnectToClassInterface_ParamsDataView( |
| internal::StandaloneApp_ConnectToClassInterface_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::StandaloneApp_ConnectToClassInterface_Params_Data* data_ = nullptr; |
| }; |
| |
| class StandaloneApp_ConnectToClassInterface_ResponseParamsDataView { |
| public: |
| StandaloneApp_ConnectToClassInterface_ResponseParamsDataView() {} |
| |
| StandaloneApp_ConnectToClassInterface_ResponseParamsDataView( |
| internal::StandaloneApp_ConnectToClassInterface_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetClassInterfaceResponseDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadClassInterfaceResponse(UserType* output) { |
| auto* pointer = data_->class_interface_response.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| inline void GetTitleDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadTitle(UserType* output) { |
| auto* pointer = data_->title.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::StandaloneApp_ConnectToClassInterface_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class IdentityTest_ConnectToClassAppWithFilter_ParamsDataView { |
| public: |
| IdentityTest_ConnectToClassAppWithFilter_ParamsDataView() {} |
| |
| IdentityTest_ConnectToClassAppWithFilter_ParamsDataView( |
| internal::IdentityTest_ConnectToClassAppWithFilter_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetFilterDataView( |
| ::service_manager::mojom::ServiceFilterDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadFilter(UserType* output) { |
| auto* pointer = data_->filter.Get(); |
| return mojo::internal::Deserialize<::service_manager::mojom::ServiceFilterDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::IdentityTest_ConnectToClassAppWithFilter_Params_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class IdentityTest_ConnectToClassAppWithFilter_ResponseParamsDataView { |
| public: |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParamsDataView() {} |
| |
| IdentityTest_ConnectToClassAppWithFilter_ResponseParamsDataView( |
| internal::IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| int32_t connection_result() const { |
| return data_->connection_result; |
| } |
| inline void GetIdentityDataView( |
| ::service_manager::mojom::IdentityDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadIdentity(UserType* output) { |
| auto* pointer = data_->identity.Get(); |
| return mojo::internal::Deserialize<::service_manager::mojom::IdentityDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::IdentityTest_ConnectToClassAppWithFilter_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class ExposedInterface_ConnectionAccepted_ParamsDataView { |
| public: |
| ExposedInterface_ConnectionAccepted_ParamsDataView() {} |
| |
| ExposedInterface_ConnectionAccepted_ParamsDataView( |
| internal::ExposedInterface_ConnectionAccepted_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetStateDataView( |
| ConnectionStateDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadState(UserType* output) { |
| auto* pointer = data_->state.Get(); |
| return mojo::internal::Deserialize<::service_manager::test::mojom::ConnectionStateDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::ExposedInterface_ConnectionAccepted_Params_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class BlockedInterface_GetTitleBlocked_ParamsDataView { |
| public: |
| BlockedInterface_GetTitleBlocked_ParamsDataView() {} |
| |
| BlockedInterface_GetTitleBlocked_ParamsDataView( |
| internal::BlockedInterface_GetTitleBlocked_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::BlockedInterface_GetTitleBlocked_Params_Data* data_ = nullptr; |
| }; |
| |
| class BlockedInterface_GetTitleBlocked_ResponseParamsDataView { |
| public: |
| BlockedInterface_GetTitleBlocked_ResponseParamsDataView() {} |
| |
| BlockedInterface_GetTitleBlocked_ResponseParamsDataView( |
| internal::BlockedInterface_GetTitleBlocked_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetBlockedTitleDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadBlockedTitle(UserType* output) { |
| auto* pointer = data_->blocked_title.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::BlockedInterface_GetTitleBlocked_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| class AlwaysAllowedInterface_GetTitleAlwaysAllowed_ParamsDataView { |
| public: |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ParamsDataView() {} |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ParamsDataView( |
| internal::AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data) {} |
| |
| bool is_null() const { return !data_; } |
| private: |
| internal::AlwaysAllowedInterface_GetTitleAlwaysAllowed_Params_Data* data_ = nullptr; |
| }; |
| |
| class AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParamsDataView { |
| public: |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParamsDataView() {} |
| |
| AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParamsDataView( |
| internal::AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data* data, |
| mojo::internal::SerializationContext* context) |
| : data_(data), context_(context) {} |
| |
| bool is_null() const { return !data_; } |
| inline void GetTitleDataView( |
| mojo::StringDataView* output); |
| |
| template <typename UserType> |
| WARN_UNUSED_RESULT bool ReadTitle(UserType* output) { |
| auto* pointer = data_->title.Get(); |
| return mojo::internal::Deserialize<mojo::StringDataView>( |
| pointer, output, context_); |
| } |
| private: |
| internal::AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParams_Data* data_ = nullptr; |
| mojo::internal::SerializationContext* context_ = nullptr; |
| }; |
| |
| |
| |
| |
| inline void ConnectTestService_GetTitle_ResponseParamsDataView::GetTitleDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->title.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| |
| |
| |
| |
| inline void ConnectTestService_GetInstanceId_ResponseParamsDataView::GetInstanceIdDataView( |
| ::mojo_base::mojom::TokenDataView* output) { |
| auto pointer = data_->instance_id.Get(); |
| *output = ::mojo_base::mojom::TokenDataView(pointer, context_); |
| } |
| |
| |
| |
| |
| inline void ClassInterface_Ping_ResponseParamsDataView::GetResponseDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->response.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| |
| |
| |
| |
| inline void StandaloneApp_ConnectToAllowedAppInBlockedPackage_ResponseParamsDataView::GetTitleDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->title.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| |
| |
| |
| |
| inline void StandaloneApp_ConnectToClassInterface_ResponseParamsDataView::GetClassInterfaceResponseDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->class_interface_response.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| inline void StandaloneApp_ConnectToClassInterface_ResponseParamsDataView::GetTitleDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->title.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| |
| |
| inline void IdentityTest_ConnectToClassAppWithFilter_ParamsDataView::GetFilterDataView( |
| ::service_manager::mojom::ServiceFilterDataView* output) { |
| auto pointer = data_->filter.Get(); |
| *output = ::service_manager::mojom::ServiceFilterDataView(pointer, context_); |
| } |
| |
| |
| inline void IdentityTest_ConnectToClassAppWithFilter_ResponseParamsDataView::GetIdentityDataView( |
| ::service_manager::mojom::IdentityDataView* output) { |
| auto pointer = data_->identity.Get(); |
| *output = ::service_manager::mojom::IdentityDataView(pointer, context_); |
| } |
| |
| |
| inline void ExposedInterface_ConnectionAccepted_ParamsDataView::GetStateDataView( |
| ConnectionStateDataView* output) { |
| auto pointer = data_->state.Get(); |
| *output = ConnectionStateDataView(pointer, context_); |
| } |
| |
| |
| |
| |
| inline void BlockedInterface_GetTitleBlocked_ResponseParamsDataView::GetBlockedTitleDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->blocked_title.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| |
| |
| |
| |
| inline void AlwaysAllowedInterface_GetTitleAlwaysAllowed_ResponseParamsDataView::GetTitleDataView( |
| mojo::StringDataView* output) { |
| auto pointer = data_->title.Get(); |
| *output = mojo::StringDataView(pointer, context_); |
| } |
| |
| } // namespace mojom |
| } // namespace test |
| } // namespace service_manager |
| |
| #if defined(__clang__) |
| #pragma clang diagnostic pop |
| #elif defined(_MSC_VER) |
| #pragma warning(pop) |
| #endif |
| |
| #endif // SERVICES_SERVICE_MANAGER_TESTS_CONNECT_CONNECT_TEST_MOJOM_PARAMS_DATA_H_ |