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

{%- set namespace_as_string = namespace|replace(".","::") %}
{%- for method in interface.methods %}
  var k{{interface.name}}_{{method.name}}_Name = {{method.ordinal}};
{%- endfor %}

  function {{interface.name}}Proxy(receiver) {
    this.receiver_ = receiver;
  }

  {{interface.name}}Proxy.NAME_ = '{{namespace_as_string}}::{{interface.name}}';

{%- for method in interface.methods %}
  {{interface.name}}Proxy.prototype.{{method.name|stylize_method}} = function(
{%- for parameter in method.parameters -%}
{{parameter.name}}{% if not loop.last %}, {% endif %}
{%- endfor -%}
) {
    var params = new {{interface.name}}_{{method.name}}_Params();
{%- for parameter in method.parameters %}
    params.{{parameter.name}} = {{parameter.name}};
{%- endfor %}

{%- if method.response_parameters == None %}
    var builder = new codec.MessageBuilder(
        k{{interface.name}}_{{method.name}}_Name,
        codec.align({{interface.name}}_{{method.name}}_Params.encodedSize));
    builder.encodeStruct({{interface.name}}_{{method.name}}_Params, params);
    var message = builder.finish();
    this.receiver_.accept(message);
{%- else %}
    return new Promise(function(resolve, reject) {
      var builder = new codec.MessageWithRequestIDBuilder(
          k{{interface.name}}_{{method.name}}_Name,
          codec.align({{interface.name}}_{{method.name}}_Params.encodedSize),
          codec.kMessageExpectsResponse, 0);
      builder.encodeStruct({{interface.name}}_{{method.name}}_Params, params);
      var message = builder.finish();
      this.receiver_.acceptWithResponder(message, {
          accept: function(message) {
            var reader = new codec.MessageReader(message);
            var responseParams =
                reader.decodeStruct({{interface.name}}_{{method.name}}_ResponseParams);
            resolve(responseParams);
          },
          reject: function(result) {
            reject(Error("Connection error: " + result));
          },
      }).catch(reject);
    }.bind(this));
{%- endif %}
  };
{%- endfor %}

  function {{interface.name}}Stub() {
  }

  {{interface.name}}Stub.NAME_ = '{{namespace_as_string}}::{{interface.name}}';

  {{interface.name}}Stub.prototype.accept = function(message) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
{%- for method in interface.methods %}
{%- if method.response_parameters == None %}
    case k{{interface.name}}_{{method.name}}_Name:
      var params = reader.decodeStruct({{interface.name}}_{{method.name}}_Params);
      this.{{method.name|stylize_method}}(
{%- for parameter in method.parameters -%}
params.{{parameter.name}}{% if not loop.last %}, {% endif %}
{%- endfor %});
      return true;
{%- endif %}
{%- endfor %}
    default:
      return false;
    }
  };

  {{interface.name}}Stub.prototype.acceptWithResponder =
      function(message, responder) {
    var reader = new codec.MessageReader(message);
    switch (reader.messageName) {
{%- for method in interface.methods %}
{%- if method.response_parameters != None %}
    case k{{interface.name}}_{{method.name}}_Name:
      var params = reader.decodeStruct({{interface.name}}_{{method.name}}_Params);
      return this.{{method.name|stylize_method}}(
{%- for parameter in method.parameters -%}
params.{{parameter.name}}{% if not loop.last %}, {% endif -%}
{%- endfor %}).then(function(response) {
        var responseParams =
            new {{interface.name}}_{{method.name}}_ResponseParams();
{%-     for parameter in method.response_parameters %}
        responseParams.{{parameter.name}} = response.{{parameter.name}};
{%-     endfor %}
        var builder = new codec.MessageWithRequestIDBuilder(
            k{{interface.name}}_{{method.name}}_Name,
            codec.align({{interface.name}}_{{method.name}}_ResponseParams.encodedSize),
            codec.kMessageIsResponse, reader.requestID);
        builder.encodeStruct({{interface.name}}_{{method.name}}_ResponseParams,
                             responseParams);
        var message = builder.finish();
        responder.accept(message);
      });
{%- endif %}
{%- endfor %}
    default:
      return Promise.reject(Error("Unhandled message: " + reader.messageName));
    }
  };

{#--- Validation #}

  function validate{{interface.name}}Request(messageValidator) {
{%- if not(interface.methods) %}
    return validator.validationError.NONE;
{%- else %}
    var message = messageValidator.message;
    var paramsClass = null;
    switch (message.getName()) {
{%-   for method in interface.methods %}
      case k{{interface.name}}_{{method.name}}_Name:
{%-     if method.response_parameters == None %}
        if (!message.expectsResponse() && !message.isResponse())
          paramsClass = {{interface.name}}_{{method.name}}_Params;
{%-     else %}
        if (message.expectsResponse())
          paramsClass = {{interface.name}}_{{method.name}}_Params;
{%-     endif %}
      break;
{%-   endfor %}
    }
    if (paramsClass === null)
      return validator.validationError.NONE;
    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
{%- endif %}
  }

  function validate{{interface.name}}Response(messageValidator) {
{%- if not(interface|has_callbacks) %}
    return validator.validationError.NONE;
{%- else %}
   var message = messageValidator.message;
   var paramsClass = null;
   switch (message.getName()) {
{%-   for method in interface.methods %}
{%-     if method.response_parameters != None %}
      case k{{interface.name}}_{{method.name}}_Name:
        if (message.isResponse())
          paramsClass = {{interface.name}}_{{method.name}}_ResponseParams;
        break;
{%-     endif %}
{%-   endfor %}
    }
    if (paramsClass === null)
      return validator.validationError.NONE;
    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
{%- endif %}
  }

  {{interface.name}}Stub.prototype.validator = validate{{interface.name}}Request;
{%- if interface|has_callbacks %}
  {{interface.name}}Proxy.prototype.validator = validate{{interface.name}}Response;
{%- else %}
  {{interface.name}}Proxy.prototype.validator = null;
{%- endif -%}

{#--- Enums #}
{%  from "enum_definition.tmpl" import enum_def -%}
{%  for enum in interface.enums %}
  {{enum_def("%sProxy.%s"|format(interface.name, enum.name), enum, module)}}
  {{interface.name}}Stub.{{enum.name}} = {{interface.name}}Proxy.{{enum.name}};
{%-  endfor %}

{#--- Constants. #}
{%  for constant in interface.constants %}
  {{interface.name}}Proxy.{{constant.name}} = {{constant.value|expression_to_text}};
  {{interface.name}}Stub.{{constant.name}} = {{interface.name}}Proxy.{{constant.name}};
{%-  endfor %}