mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl

{%- import "interface_macros.tmpl" as interface_macros %}
{%- set class_name = interface.name %}
{%- set proxy_name = interface.name ~ "Proxy" %}
{%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}

{%- macro alloc_params(parameters) %}
{%-   for param in parameters %}
{%-     if param.kind|is_object_kind  %}
{{param.kind|cpp_result_type}} p{{loop.index}};
Deserialize_(params->{{param.name}}.ptr, &p{{loop.index}});
{%      endif -%}
{%-   endfor %}
{%- endmacro %}

{%- macro pass_params(parameters) %}
{%-   for param in parameters %}
{%-     if param.kind|is_string_kind -%}
p{{loop.index}}
{%-     elif param.kind|is_object_kind -%}
p{{loop.index}}.Pass()
{%-     elif param.kind|is_interface_kind -%}
mojo::MakeProxy<{{param.kind|get_name_for_kind}}>(mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->{{param.name}})))
{%-     elif param.kind|is_interface_request_kind -%}
mojo::MakeRequest<{{param.kind.kind|get_name_for_kind}}>(mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->{{param.name}})))
{%-     elif param.kind|is_any_handle_kind -%}
mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->{{param.name}}))
{%-     elif param.kind|is_enum_kind -%}
static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}})
{%-     else -%}
params->{{param.name}}
{%-     endif -%}
{%-     if not loop.last %}, {% endif %}
{%-   endfor %}
{%- endmacro %}

{%- macro compute_payload_size(params_name, parameters) -%}
  size_t payload_size =
      mojo::internal::Align(sizeof({{params_name}}));
{#--- Computes #}
{%-   for param in parameters %}
{%-     if param.kind|is_object_kind %}
  payload_size += GetSerializedSize_(in_{{param.name}});
{%-     endif %}
{%-   endfor %}
{%- endmacro %}

{%- macro build_message(params_name, parameters, params_description) -%}
  {# TODO(yzshen): Consider refactoring to share code with
     struct_serialization_definition.tmpl #}
  {{params_name}}* params =
      {{params_name}}::New(builder.buffer());
{#--- Sets #}
{%   for param in parameters %}
{%-     if param.kind|is_object_kind %}
{%-       if param.kind|is_array_kind %}
  mojo::SerializeArray_<{{param.kind|get_array_validate_params|indent(24)}}>(
      mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &params->{{param.name}}.ptr);
{%-       elif param.kind|is_map_kind %}
  mojo::SerializeMap_<{{param.kind.value_kind|get_map_validate_params|indent(24)}}>(
      mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &params->{{param.name}}.ptr);
{%-       else %}
  Serialize_(mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &params->{{param.name}}.ptr);
{%-       endif %}
{%-       if not param.kind|is_nullable_kind %}
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !params->{{param.name}}.ptr,
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
      "null {{param.name}} argument in {{params_description}}");
{%-       endif %}
{%-     elif param.kind|is_any_handle_kind %}
{%-       if param.kind|is_interface_kind or
             param.kind|is_interface_request_kind %}
  // Delegate handle.
  params->{{param.name}} = in_{{param.name}}.PassMessagePipe().release();
{%-       else %}
  params->{{param.name}} = in_{{param.name}}.release();
{%-       endif %}
{%-       if not param.kind|is_nullable_kind %}
  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
      !params->{{param.name}}.is_valid(),
      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
      "invalid {{param.name}} argument in {{params_description}}");
{%-       endif %}
{%-     else %}
  params->{{param.name}} = in_{{param.name}};
{%-     endif %}
{%-   endfor %}
  mojo::Message message;
  params->EncodePointersAndHandles(message.mutable_handles());
  builder.Finish(&message);
{%- endmacro %}

{#--- Begin #}
const char* {{class_name}}::Name_ = "{{namespace_as_string}}::{{class_name}}";
{#--- Constants #}
{%  for constant in interface.constants %}
const {{constant.kind|cpp_pod_type}} {{interface.name}}::{{constant.name}} = {{constant|constant_value}};
{%- endfor %}

{#--- 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 {{interface_macros.declare_callback(method)}}& callback)
      : callback_(callback) {
  }
  virtual bool Accept(mojo::Message* message) override;
 private:
  {{interface_macros.declare_callback(method)}} 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_parameters)|indent(2)}}
  callback_.Run({{pass_params(method.response_parameters)}});
  return true;
}
{%-   endif %}
{%- endfor %}

{{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

{#--- Proxy definitions #}

{%- for method in interface.methods %}
{%-   set message_name =
          "internal::k%s_%s_Name"|format(interface.name, method.name) %}
{%-   set params_name =
          "internal::%s_%s_Params_Data"|format(interface.name, method.name) %}
{%-   set params_description =
          "%s.%s request"|format(interface.name, method.name) %}
void {{proxy_name}}::{{method.name}}(
    {{interface_macros.declare_request_params("in_", method)}}) {
  {{compute_payload_size(params_name, method.parameters)}}

{%- if method.response_parameters != None %}
  mojo::internal::RequestMessageBuilder builder({{message_name}}, payload_size);
{%- else %}
  mojo::internal::MessageBuilder builder({{message_name}}, payload_size);
{%- endif %}

  {{build_message(params_name, method.parameters, params_description)}}

{%- if method.response_parameters != None %}
  mojo::MessageReceiver* responder =
      new {{class_name}}_{{method.name}}_ForwardToCallback(callback);
  if (!receiver_->AcceptWithResponder(&message, responder))
    delete responder;
{%- else %}
  bool ok = receiver_->Accept(&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 =
            "internal::k%s_%s_Name"|format(interface.name, method.name) %}
{%-     set params_name =
            "internal::%s_%s_ResponseParams_Data"|format(interface.name, method.name) %}
{%-     set params_description =
            "%s.%s response"|format(interface.name, method.name) %}
class {{class_name}}_{{method.name}}_ProxyToResponder
    : public {{interface_macros.declare_callback(method)}}::Runnable {
 public:
  virtual ~{{class_name}}_{{method.name}}_ProxyToResponder() {
    delete responder_;
  }

  {{class_name}}_{{method.name}}_ProxyToResponder(
      uint64_t request_id,
      mojo::MessageReceiver* responder)
      : request_id_(request_id),
        responder_(responder) {
  }

  virtual void Run({{interface_macros.declare_params("in_", method.response_parameters)}}) const override;

 private:
  uint64_t request_id_;
  mutable mojo::MessageReceiver* responder_;
  MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
};
void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
    {{interface_macros.declare_params("in_", method.response_parameters)}}) const {
  {{compute_payload_size(params_name, method.response_parameters)}}
  mojo::internal::ResponseMessageBuilder builder(
      {{message_name}}, payload_size, request_id_);
  {{build_message(params_name, method.response_parameters, params_description)}}
  bool ok = responder_->Accept(&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) {
}

{#--- Stub definition #}

bool {{class_name}}Stub::Accept(mojo::Message* message) {
{%- if interface.methods %}
  switch (message->header()->name) {
{%-   for method in interface.methods %}
    case internal::k{{class_name}}_{{method.name}}_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.parameters)|indent(6)}}
      // A null |sink_| typically means there is a missing call to
      // InterfacePtr::set_client().
      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::MessageReceiver* responder) {
{%- if interface.methods %}
  switch (message->header()->name) {
{%-   for method in interface.methods %}
    case internal::k{{class_name}}_{{method.name}}_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());
      {{interface_macros.declare_callback(method)}}::Runnable* runnable =
          new {{class_name}}_{{method.name}}_ProxyToResponder(
              message->request_id(), responder);
      {{interface_macros.declare_callback(method)}} callback(runnable);
      {{alloc_params(method.parameters)|indent(6)}}
      // A null |sink_| typically means there is a missing call to
      // InterfacePtr::set_client().
      assert(sink_);
      sink_->{{method.name}}(
{%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
      return true;
{%-     else %}
      break;
{%-     endif %}
    }
{%-   endfor %}
  }
{%- endif %}
  return false;
}

{#--- Request validator definitions #}

{{class_name}}RequestValidator::{{class_name}}RequestValidator(
    mojo::MessageReceiver* sink) : MessageFilter(sink) {
}

bool {{class_name}}RequestValidator::Accept(mojo::Message* message) {
{%- if interface.methods %}
  switch (message->header()->name) {
{%-   for method in interface.methods %}
    case internal::k{{class_name}}_{{method.name}}_Name: {
{%-     if method.response_parameters != None %}
      if (!message->has_flag(mojo::internal::kMessageExpectsResponse))
        break;
{%-     else %}
      if (message->has_flag(mojo::internal::kMessageExpectsResponse) ||
          message->has_flag(mojo::internal::kMessageIsResponse)) {
        break;
      }
{%-     endif %}
      mojo::internal::BoundsChecker bounds_checker(
          message->payload(), message->payload_num_bytes(),
          message->handles()->size());
      if (!internal::{{class_name}}_{{method.name}}_Params_Data::Validate(
              message->payload(), &bounds_checker)) {
        return false;
      }
      break;
    }
{%-   endfor %}
  }
{%- endif %}

  // A null |sink_| typically means there is a missing call to
  // InterfacePtr::set_client().
  assert(sink_);
  return sink_->Accept(message);
}

{#--- Response validator definitions #}
{% if interface|has_callbacks %}
{{class_name}}ResponseValidator::{{class_name}}ResponseValidator(
    mojo::MessageReceiver* sink) : MessageFilter(sink) {
}

bool {{class_name}}ResponseValidator::Accept(mojo::Message* message) {
{%- if interface.methods %}
  switch (message->header()->name) {
{%-   for method in interface.methods if method.response_parameters != None %}
    case internal::k{{class_name}}_{{method.name}}_Name: {
      if (!message->has_flag(mojo::internal::kMessageIsResponse))
        break;
      mojo::internal::BoundsChecker bounds_checker(
          message->payload(), message->payload_num_bytes(),
          message->handles()->size());
      if (!internal::{{class_name}}_{{method.name}}_ResponseParams_Data::Validate(
              message->payload(), &bounds_checker)) {
        return false;
      }
      break;
    }
{%-   endfor %}
  }
{%- endif %}

  // A null |sink_| typically means there is a missing call to
  // InterfacePtr::set_client().
  assert(sink_);
  return sink_->Accept(message);
}
{%- endif -%}