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

   1 {%- for method in interface.methods %}
   2   var k{{interface.name}}_{{method.name}}_Name = {{method.ordinal}};
   3 {%- endfor %}
   4
   5   function {{interface.name}}Proxy(receiver) {
   6     connection.initProxyInstance(this, {{interface.name}}, receiver);
   7   }
   8
   9   {{interface.name}}Proxy.prototype.getConnection$ = function() {
  10     return connection.getProxyConnection(this, {{interface.name}});
  11   }
  12
  13 {%- for method in interface.methods %}
  14   {{interface.name}}Proxy.prototype.{{method.name|stylize_method}} = function(
  15 {%- for parameter in method.parameters -%}
  16 {{parameter.name}}{% if not loop.last %}, {% endif %}
  17 {%- endfor -%}
  18 ) {
  19     var params = new {{interface.name}}_{{method.name}}_Params();
  20 {%- for parameter in method.parameters %}
  21 {%-   if parameter|is_interface_parameter %}
  22     if ({{parameter.name}} instanceof {{parameter.kind|js_type}}.stubClass)
  23       params.{{parameter.name}} = {{parameter.name}}.getConnection$().messagePipeHandle;
  24     else
  25       params.{{parameter.name}} = {{parameter.name}};
  26 {%-   elif parameter|is_interface_request_parameter %}
  27     if ({{parameter.name}} instanceof {{parameter.kind.kind|js_type}}.proxyClass)
  28       params.{{parameter.name}} = {{parameter.name}}.getConnection$().messagePipeHandle;
  29     else
  30       params.{{parameter.name}} = {{parameter.name}};
  31 {%-   else %}
  32     params.{{parameter.name}} = {{parameter.name}};
  33 {%-   endif %}
  34 {%- endfor %}
  35
  36 {%- if method.response_parameters == None %}
  37     var builder = new codec.MessageBuilder(
  38         k{{interface.name}}_{{method.name}}_Name,
  39         codec.align({{interface.name}}_{{method.name}}_Params.encodedSize));
  40     builder.encodeStruct({{interface.name}}_{{method.name}}_Params, params);
  41     var message = builder.finish();
  42     this.receiver_.accept(message);
  43 {%- else %}
  44     return new Promise(function(resolve, reject) {
  45       var builder = new codec.MessageWithRequestIDBuilder(
  46           k{{interface.name}}_{{method.name}}_Name,
  47           codec.align({{interface.name}}_{{method.name}}_Params.encodedSize),
  48           codec.kMessageExpectsResponse, 0);
  49       builder.encodeStruct({{interface.name}}_{{method.name}}_Params, params);
  50       var message = builder.finish();
  51       this.receiver_.acceptAndExpectResponse(message).then(function(message) {
  52         var reader = new codec.MessageReader(message);
  53         var responseParams =
  54             reader.decodeStruct({{interface.name}}_{{method.name}}_ResponseParams);
  55         resolve(responseParams);
  56       }).catch(function(result) {
  57         reject(Error("Connection error: " + result));
  58       });
  59     }.bind(this));
  60 {%- endif %}
  61   };
  62 {%- endfor %}
  63
  64   function {{interface.name}}Stub(delegate) {
  65       this.delegate$ = delegate;
  66   }
  67
  68   {{interface.name}}Stub.prototype.getConnection$ = function() {
  69     return connection.getStubConnection(this, {{interface.name}});
  70   }
  71
  72 {%- for method in interface.methods %}
  73 {% macro stub_method_parameters() -%}
  74 {%- for parameter in method.parameters -%}
  75   {{parameter.name}}{% if not loop.last %}, {% endif %}
  76 {%- endfor %}
  77 {%- endmacro %}
  78   {{interface.name}}Stub.prototype.{{method.name|stylize_method}} = function({{stub_method_parameters()}}) {
  79     if (this.delegate$.{{method.name|stylize_method}})
  80       return this.delegate$.{{method.name|stylize_method}}({{stub_method_parameters()}});
  81   }
  82 {%- endfor %}
  83
  84   {{interface.name}}Stub.prototype.accept = function(message) {
  85     var reader = new codec.MessageReader(message);
  86     switch (reader.messageName) {
  87 {%- for method in interface.methods %}
  88 {%- if method.response_parameters == None %}
  89     case k{{interface.name}}_{{method.name}}_Name:
  90       var params = reader.decodeStruct({{interface.name}}_{{method.name}}_Params);
  91       this.{{method.name|stylize_method}}(
  92 {%- for parameter in method.parameters -%}
  93   params.{{parameter.name}}{% if not loop.last %}, {% endif %}
  94 {%- endfor %});
  95       return true;
  96 {%- endif %}
  97 {%- endfor %}
  98     default:
  99       return false;
 100     }
 101   };
 102
 103   {{interface.name}}Stub.prototype.acceptWithResponder =
 104       function(message, responder) {
 105     var reader = new codec.MessageReader(message);
 106     switch (reader.messageName) {
 107 {%- for method in interface.methods %}
 108 {%- if method.response_parameters != None %}
 109     case k{{interface.name}}_{{method.name}}_Name:
 110       var params = reader.decodeStruct({{interface.name}}_{{method.name}}_Params);
 111       return this.{{method.name|stylize_method}}(
 112 {%- for parameter in method.parameters -%}
 113 params.{{parameter.name}}{% if not loop.last %}, {% endif -%}
 114 {%- endfor %}).then(function(response) {
 115         var responseParams =
 116             new {{interface.name}}_{{method.name}}_ResponseParams();
 117 {%-     for parameter in method.response_parameters %}
 118         responseParams.{{parameter.name}} = response.{{parameter.name}};
 119 {%-     endfor %}
 120         var builder = new codec.MessageWithRequestIDBuilder(
 121             k{{interface.name}}_{{method.name}}_Name,
 122             codec.align({{interface.name}}_{{method.name}}_ResponseParams.encodedSize),
 123             codec.kMessageIsResponse, reader.requestID);
 124         builder.encodeStruct({{interface.name}}_{{method.name}}_ResponseParams,
 125                              responseParams);
 126         var message = builder.finish();
 127         responder.accept(message);
 128       });
 129 {%- endif %}
 130 {%- endfor %}
 131     default:
 132       return Promise.reject(Error("Unhandled message: " + reader.messageName));
 133     }
 134   };
 135
 136 {#--- Validation #}
 137
 138   function validate{{interface.name}}Request(messageValidator) {
 139 {%- if not(interface.methods) %}
 140     return validator.validationError.NONE;
 141 {%- else %}
 142     var message = messageValidator.message;
 143     var paramsClass = null;
 144     switch (message.getName()) {
 145 {%-   for method in interface.methods %}
 146       case k{{interface.name}}_{{method.name}}_Name:
 147 {%-     if method.response_parameters == None %}
 148         if (!message.expectsResponse() && !message.isResponse())
 149           paramsClass = {{interface.name}}_{{method.name}}_Params;
 150 {%-     else %}
 151         if (message.expectsResponse())
 152           paramsClass = {{interface.name}}_{{method.name}}_Params;
 153 {%-     endif %}
 154       break;
 155 {%-   endfor %}
 156     }
 157     if (paramsClass === null)
 158       return validator.validationError.NONE;
 159     return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
 160 {%- endif %}
 161   }
 162
 163   function validate{{interface.name}}Response(messageValidator) {
 164 {%- if not(interface|has_callbacks) %}
 165     return validator.validationError.NONE;
 166 {%- else %}
 167    var message = messageValidator.message;
 168    var paramsClass = null;
 169    switch (message.getName()) {
 170 {%-   for method in interface.methods %}
 171 {%-     if method.response_parameters != None %}
 172       case k{{interface.name}}_{{method.name}}_Name:
 173         if (message.isResponse())
 174           paramsClass = {{interface.name}}_{{method.name}}_ResponseParams;
 175         break;
 176 {%-     endif %}
 177 {%-   endfor %}
 178     }
 179     if (paramsClass === null)
 180       return validator.validationError.NONE;
 181     return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
 182 {%- endif %}
 183   }
 184
 185   var {{interface.name}} = {
 186     name: '{{namespace|replace(".","::")}}::{{interface.name}}',
 187     proxyClass: {{interface.name}}Proxy,
 188     stubClass: {{interface.name}}Stub,
 189     validateRequest: validate{{interface.name}}Request,
 190 {%- if interface|has_callbacks %}
 191     validateResponse: validate{{interface.name}}Response,
 192 {%- else %}
 193     validateResponse: null,
 194 {%- endif %}
 195   };
 196 {#--- Interface Constants #}
 197 {%- for constant in interface.constants %}
 198   {{interface.name}}.{{constant.name}} = {{constant.value|expression_to_text}},
 199 {%-   endfor %}
 200 {#--- Interface Enums #}
 201 {%- from "enum_definition.tmpl" import enum_def -%}
 202 {%- for enum in interface.enums %}
 203   {{ enum_def("%s.%s"|format(interface.name, enum.name), enum) }}
 204 {%-  endfor %}
 205   {{interface.name}}Stub.prototype.validator = validate{{interface.name}}Request;
 206 {%- if interface|has_callbacks %}
 207   {{interface.name}}Proxy.prototype.validator = validate{{interface.name}}Response;
 208 {%- else %}
 209   {{interface.name}}Proxy.prototype.validator = null;
 210 {%- endif %}