Index: mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl |
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl |
deleted file mode 100644 |
index 9a7fbc1f8855c15ead1aeaaf8164b75cac1646e6..0000000000000000000000000000000000000000 |
--- a/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl |
+++ /dev/null |
@@ -1,233 +0,0 @@ |
-{%- import "interface_macros.tmpl" as interface_macros %} |
-{%- import "struct_macros.tmpl" as struct_macros %} |
-{%- from "enum_macros.tmpl" import is_valid_enum_def %} |
-{%- from "enum_macros.tmpl" import global_enum_operators_def %} |
- |
-{%- set class_name = interface.name -%} |
-{%- set base_name = "internal::%s_Base"|format(interface.name) -%} |
-{%- set proxy_name = interface.name ~ "Proxy" -%} |
- |
-{%- macro alloc_params(struct) %} |
-{%- for param in struct.packed.packed_fields_in_ordinal_order %} |
- {{param.field.kind|cpp_result_type}} p_{{param.field.name}} {}; |
-{%- endfor %} |
- {{struct_macros.deserialize(struct, "params", "p_%s")}} |
-{%- endmacro %} |
- |
-{%- macro pass_params(parameters) %} |
-{%- for param in parameters %} |
-{%- if param.kind|is_move_only_kind -%} |
-p_{{param.name}}.Pass() |
-{%- else -%} |
-p_{{param.name}} |
-{%- endif -%} |
-{%- if not loop.last %}, {% endif %} |
-{%- endfor %} |
-{%- endmacro %} |
- |
-{%- macro build_message(struct, struct_display_name) -%} |
- {{struct_macros.serialize(struct, struct_display_name, "in_%s", "params", "builder.buffer()", false)}} |
- params->EncodePointersAndHandles(builder.message()->mutable_handles()); |
-{%- endmacro %} |
- |
-{#--- ForwardToCallback definition #} |
-{%- for method in interface.methods -%} |
-{%- if method.response_parameters != None %} |
-class {{class_name}}_{{method.name}}_ForwardToCallback |
- : public mojo::MessageReceiver { |
- public: |
- {{class_name}}_{{method.name}}_ForwardToCallback( |
- const {{class_name}}::{{method.name}}Callback& callback) |
- : callback_(callback) { |
- } |
- bool Accept(mojo::Message* message) override; |
- private: |
- {{class_name}}::{{method.name}}Callback callback_; |
- MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback); |
-}; |
-bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept( |
- mojo::Message* message) { |
- internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params = |
- reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>( |
- message->mutable_payload()); |
- |
- params->DecodePointersAndHandles(message->mutable_handles()); |
- {{alloc_params(method.response_param_struct)}} |
- callback_.Run({{pass_params(method.response_parameters)}}); |
- return true; |
-} |
-{%- endif %} |
-{%- endfor %} |
- |
-{{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver) |
- : ControlMessageProxy(receiver) { |
-} |
- |
-{#--- Proxy definitions #} |
- |
-{%- for method in interface.methods %} |
-{%- set message_name = |
- "%s::MessageOrdinals::%s"|format(base_name, method.name) %} |
-{%- set params_struct = method.param_struct %} |
-{%- set params_description = |
- "%s.%s request"|format(interface.name, method.name) %} |
-void {{proxy_name}}::{{method.name}}( |
- {{interface_macros.declare_request_params("in_", method)}}) { |
- {{struct_macros.get_serialized_size(params_struct, "in_%s")}} |
- |
-{%- if method.response_parameters != None %} |
- mojo::RequestMessageBuilder builder( |
- static_cast<uint32_t>({{message_name}}), size); |
-{%- else %} |
- mojo::MessageBuilder builder( |
- static_cast<uint32_t>({{message_name}}), size); |
-{%- endif %} |
- |
- {{build_message(params_struct, params_description)}} |
- |
-{%- if method.response_parameters != None %} |
- mojo::MessageReceiver* responder = |
- new {{class_name}}_{{method.name}}_ForwardToCallback(callback); |
- if (!receiver_->AcceptWithResponder(builder.message(), responder)) |
- delete responder; |
-{%- else %} |
- bool ok = receiver_->Accept(builder.message()); |
- // This return value may be ignored as !ok implies the Connector has |
- // encountered an error, which will be visible through other means. |
- MOJO_ALLOW_UNUSED_LOCAL(ok); |
-{%- endif %} |
-} |
-{%- endfor %} |
- |
-{#--- ProxyToResponder definition #} |
-{%- for method in interface.methods -%} |
-{%- if method.response_parameters != None %} |
-{%- set message_name = |
- "%s::MessageOrdinals::%s"|format(base_name, method.name) %} |
-{%- set response_params_struct = method.response_param_struct %} |
-{%- set params_description = |
- "%s.%s response"|format(interface.name, method.name) %} |
-// This class implements a method's response callback: it serializes the |
-// response args into a mojo message and passes it to the MessageReceiver it |
-// was created with. |
-class {{class_name}}_{{method.name}}_ProxyToResponder |
- : public {{class_name}}::{{method.name}}Callback::Runnable { |
- public: |
- ~{{class_name}}_{{method.name}}_ProxyToResponder() override { |
- // Is the Mojo application destroying the callback without running it |
- // and without first closing the pipe? |
- bool callback_was_dropped = responder_ && responder_->IsValid(); |
- // If the Callback was dropped then deleting the responder will close |
- // the pipe so the calling application knows to stop waiting for a reply. |
- delete responder_; |
- MOJO_DCHECK(!callback_was_dropped) << "The callback passed to " |
- "{{class_name}}::{{method.name}}({%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback) " |
- "was never run."; |
- } |
- |
- {{class_name}}_{{method.name}}_ProxyToResponder( |
- uint64_t request_id, |
- mojo::MessageReceiverWithStatus* responder) |
- : request_id_(request_id), |
- responder_(responder) { |
- } |
- |
- void Run({{interface_macros.declare_params_as_args("in_", method.response_parameters)}}) const override; |
- |
- private: |
- uint64_t request_id_; |
- mutable mojo::MessageReceiverWithStatus* responder_; |
- MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder); |
-}; |
- |
-void {{class_name}}_{{method.name}}_ProxyToResponder::Run( |
- {{interface_macros.declare_params_as_args("in_", method.response_parameters)}}) const { |
- {{struct_macros.get_serialized_size(response_params_struct, "in_%s")}} |
- mojo::ResponseMessageBuilder builder( |
- static_cast<uint32_t>({{message_name}}), size, request_id_); |
- {{build_message(response_params_struct, params_description)}} |
- bool ok = responder_->Accept(builder.message()); |
- MOJO_ALLOW_UNUSED_LOCAL(ok); |
- // TODO(darin): !ok returned here indicates a malformed message, and that may |
- // be good reason to close the connection. However, we don't have a way to do |
- // that from here. We should add a way. |
- delete responder_; |
- responder_ = nullptr; |
-} |
-{%- endif -%} |
-{%- endfor %} |
- |
-{{class_name}}Stub::{{class_name}}Stub() |
- : sink_(nullptr), |
- control_message_handler_({{interface.name}}::Version_) { |
-} |
- |
-{{class_name}}Stub::~{{interface.name}}Stub() {} |
- |
-{#--- Stub definition #} |
- |
-bool {{class_name}}Stub::Accept(mojo::Message* message) { |
- if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) |
- return control_message_handler_.Accept(message); |
-{%- if interface.methods %} |
- {{base_name}}::MessageOrdinals method_ordinal = |
- static_cast<{{base_name}}::MessageOrdinals>(message->header()->name); |
- switch (method_ordinal) { |
-{%- for method in interface.methods %} |
- case {{base_name}}::MessageOrdinals::{{method.name}}: { |
-{%- if method.response_parameters == None %} |
- internal::{{class_name}}_{{method.name}}_Params_Data* params = |
- reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>( |
- message->mutable_payload()); |
- |
- params->DecodePointersAndHandles(message->mutable_handles()); |
- {{alloc_params(method.param_struct)|indent(4)}} |
- // A null |sink_| means no implementation was bound. |
- assert(sink_); |
- sink_->{{method.name}}({{pass_params(method.parameters)}}); |
- return true; |
-{%- else %} |
- break; |
-{%- endif %} |
- } |
-{%- endfor %} |
- } |
-{%- endif %} |
- return false; |
-} |
- |
-bool {{class_name}}Stub::AcceptWithResponder( |
- mojo::Message* message, mojo::MessageReceiverWithStatus* responder) { |
- if (mojo::internal::ControlMessageHandler::IsControlMessage(message)) |
- return control_message_handler_.AcceptWithResponder(message, responder); |
-{%- if interface.methods %} |
- {{base_name}}::MessageOrdinals method_ordinal = |
- static_cast<{{base_name}}::MessageOrdinals>(message->header()->name); |
- switch (method_ordinal) { |
-{%- for method in interface.methods %} |
- case {{base_name}}::MessageOrdinals::{{method.name}}: { |
-{%- if method.response_parameters != None %} |
- internal::{{class_name}}_{{method.name}}_Params_Data* params = |
- reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>( |
- message->mutable_payload()); |
- |
- params->DecodePointersAndHandles(message->mutable_handles()); |
- {{class_name}}::{{method.name}}Callback::Runnable* runnable = |
- new {{class_name}}_{{method.name}}_ProxyToResponder( |
- message->request_id(), responder); |
- {{class_name}}::{{method.name}}Callback callback(runnable); |
- {{alloc_params(method.param_struct)|indent(4)}} |
- // A null |sink_| means no implementation was bound. |
- assert(sink_); |
- sink_->{{method.name}}( |
-{%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback); |
- return true; |
-{%- else %} |
- break; |
-{%- endif %} |
- } |
-{%- endfor %} |
- } |
-{%- endif %} |
- return false; |
-} |