1{%- for method in interface.methods %}
2{%-   set interface_method_id =
3          interface.mojom_name ~ "_" ~ method.mojom_name %}
4  var k{{interface_method_id}}_Name = {{method.ordinal}};
5{%- endfor %}
6
7  function {{interface.name}}Ptr(handleOrPtrInfo) {
8    this.ptr = new bindings.InterfacePtrController({{interface.name}},
9                                                   handleOrPtrInfo);
10  }
11
12  function {{interface.name}}AssociatedPtr(associatedInterfacePtrInfo) {
13    this.ptr = new associatedBindings.AssociatedInterfacePtrController(
14        {{interface.name}}, associatedInterfacePtrInfo);
15  }
16
17  {{interface.name}}AssociatedPtr.prototype =
18      Object.create({{interface.name}}Ptr.prototype);
19  {{interface.name}}AssociatedPtr.prototype.constructor =
20      {{interface.name}}AssociatedPtr;
21
22  function {{interface.name}}Proxy(receiver) {
23    this.receiver_ = receiver;
24  }
25
26{%- for method in interface.methods %}
27{%-   set interface_method_id =
28          interface.mojom_name ~ "_" ~ method.mojom_name %}
29  {{interface.name}}Ptr.prototype.{{method.name}} = function() {
30    return {{interface.name}}Proxy.prototype.{{method.name}}
31        .apply(this.ptr.getProxy(), arguments);
32  };
33
34  {{interface.name}}Proxy.prototype.{{method.name}} = function(
35{%- for parameter in method.parameters -%}
36{{parameter.name|sanitize_identifier}}{% if not loop.last %}, {% endif %}
37{%- endfor -%}
38) {
39    var params_ = new {{interface_method_id}}_Params();
40{%- for parameter in method.parameters %}
41    params_.{{parameter.name}} = {{parameter.name|sanitize_identifier}};
42{%- endfor %}
43
44{%- if method.response_parameters == None %}
45{%-   if method|method_passes_associated_kinds %}
46    var builder = new codec.MessageV2Builder(
47        k{{interface_method_id}}_Name,
48        codec.align({{interface_method_id}}_Params.encodedSize));
49    builder.setPayload({{interface_method_id}}_Params, params_);
50{%-   else %}
51    var builder = new codec.MessageV0Builder(
52        k{{interface_method_id}}_Name,
53        codec.align({{interface_method_id}}_Params.encodedSize));
54    builder.encodeStruct({{interface_method_id}}_Params, params_);
55{%-   endif %}
56    var message = builder.finish();
57    this.receiver_.accept(message);
58{%- else %}
59    return new Promise(function(resolve, reject) {
60{%-   if method|method_passes_associated_kinds %}
61      var builder = new codec.MessageV2Builder(
62          k{{interface_method_id}}_Name,
63          codec.align({{interface_method_id}}_Params.encodedSize),
64          codec.kMessageExpectsResponse, 0);
65      builder.setPayload({{interface_method_id}}_Params, params_);
66{%-   else %}
67      var builder = new codec.MessageV1Builder(
68          k{{interface_method_id}}_Name,
69          codec.align({{interface_method_id}}_Params.encodedSize),
70          codec.kMessageExpectsResponse, 0);
71      builder.encodeStruct({{interface_method_id}}_Params, params_);
72{%-   endif %}
73      var message = builder.finish();
74      this.receiver_.acceptAndExpectResponse(message).then(function(message) {
75        var reader = new codec.MessageReader(message);
76        var responseParams =
77            reader.decodeStruct({{interface_method_id}}_ResponseParams);
78        resolve(responseParams);
79      }).catch(function(result) {
80        reject(Error("Connection error: " + result));
81      });
82    }.bind(this));
83{%- endif %}
84  };
85{%- endfor %}
86
87  function {{interface.name}}Stub(delegate) {
88    this.delegate_ = delegate;
89  }
90
91{%- for method in interface.methods %}
92  {{interface.name}}Stub.prototype.{{method.name}} = function({{method.parameters|map(attribute='name')|map('sanitize_identifier')|join(', ')}}) {
93    return this.delegate_ && this.delegate_.{{method.name}} && this.delegate_.{{method.name}}({{method.parameters|map(attribute='name')|map('sanitize_identifier')|join(', ')}});
94  }
95{%- endfor %}
96
97  {{interface.name}}Stub.prototype.accept = function(message) {
98    var reader = new codec.MessageReader(message);
99    switch (reader.messageName) {
100{%- for method in interface.methods %}
101{%-   set interface_method_id =
102          interface.mojom_name ~ "_" ~ method.mojom_name %}
103{%- if method.response_parameters == None %}
104    case k{{interface_method_id}}_Name:
105      var params = reader.decodeStruct({{interface_method_id}}_Params);
106      this.{{method.name}}(
107{%- for parameter in method.parameters -%}
108  params.{{parameter.name}}{% if not loop.last %}, {% endif %}
109{%- endfor %});
110      return true;
111{%- endif %}
112{%- endfor %}
113    default:
114      return false;
115    }
116  };
117
118  {{interface.name}}Stub.prototype.acceptWithResponder =
119      function(message, responder) {
120    var reader = new codec.MessageReader(message);
121    switch (reader.messageName) {
122{%- for method in interface.methods %}
123{%-   set interface_method_id =
124          interface.mojom_name ~ "_" ~ method.mojom_name %}
125{%- if method.response_parameters != None %}
126    case k{{interface_method_id}}_Name:
127      var params = reader.decodeStruct({{interface_method_id}}_Params);
128      this.{{method.name}}(
129{%- for parameter in method.parameters -%}
130params.{{parameter.name}}{% if not loop.last %}, {% endif -%}
131{%- endfor %}).then(function(response) {
132        var responseParams =
133            new {{interface_method_id}}_ResponseParams();
134{%-     for parameter in method.response_parameters %}
135        responseParams.{{parameter.name}} = response.{{parameter.name}};
136{%-     endfor %}
137{%- if method|method_passes_associated_kinds %}
138        var builder = new codec.MessageV2Builder(
139            k{{interface_method_id}}_Name,
140            codec.align({{interface_method_id}}_ResponseParams
141                .encodedSize),
142            codec.kMessageIsResponse, reader.requestID);
143        builder.setPayload({{interface_method_id}}_ResponseParams,
144                             responseParams);
145{%- else %}
146        var builder = new codec.MessageV1Builder(
147            k{{interface_method_id}}_Name,
148            codec.align({{interface_method_id}}_ResponseParams.encodedSize),
149            codec.kMessageIsResponse, reader.requestID);
150        builder.encodeStruct({{interface_method_id}}_ResponseParams,
151                             responseParams);
152{%- endif %}
153        var message = builder.finish();
154        responder.accept(message);
155      });
156      return true;
157{%- endif %}
158{%- endfor %}
159    default:
160      return false;
161    }
162  };
163
164{#--- Validation #}
165
166  function validate{{interface.name}}Request(messageValidator) {
167{%- if not(interface.methods) %}
168    return validator.validationError.NONE;
169{%- else %}
170    var message = messageValidator.message;
171    var paramsClass = null;
172    switch (message.getName()) {
173{%-   for method in interface.methods %}
174{%-     set interface_method_id =
175            interface.mojom_name ~ "_" ~ method.mojom_name %}
176      case k{{interface_method_id}}_Name:
177{%-     if method.response_parameters == None %}
178        if (!message.expectsResponse() && !message.isResponse())
179          paramsClass = {{interface_method_id}}_Params;
180{%-     else %}
181        if (message.expectsResponse())
182          paramsClass = {{interface_method_id}}_Params;
183{%-     endif %}
184      break;
185{%-   endfor %}
186    }
187    if (paramsClass === null)
188      return validator.validationError.NONE;
189    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
190{%- endif %}
191  }
192
193  function validate{{interface.name}}Response(messageValidator) {
194{%- if not(interface|has_callbacks) %}
195    return validator.validationError.NONE;
196{%- else %}
197   var message = messageValidator.message;
198   var paramsClass = null;
199   switch (message.getName()) {
200{%-   for method in interface.methods %}
201{%-     set interface_method_id =
202            interface.mojom_name ~ "_" ~ method.mojom_name %}
203{%-     if method.response_parameters != None %}
204      case k{{interface_method_id}}_Name:
205        if (message.isResponse())
206          paramsClass = {{interface_method_id}}_ResponseParams;
207        break;
208{%-     endif %}
209{%-   endfor %}
210    }
211    if (paramsClass === null)
212      return validator.validationError.NONE;
213    return paramsClass.validate(messageValidator, messageValidator.message.getHeaderNumBytes());
214{%- endif %}
215  }
216
217  var {{interface.name}} = {
218    name: '{{module.mojom_namespace}}.{{interface.mojom_name}}',
219    kVersion: {{interface.version}},
220    ptrClass: {{interface.name}}Ptr,
221    proxyClass: {{interface.name}}Proxy,
222    stubClass: {{interface.name}}Stub,
223    validateRequest: validate{{interface.name}}Request,
224{%- if interface|has_callbacks %}
225    validateResponse: validate{{interface.name}}Response,
226{%- else %}
227    validateResponse: null,
228{%- endif %}
229{%- if generate_fuzzing %}
230    mojomId: '{{module.path}}',
231    fuzzMethods: {
232      {%- for method in interface.methods %}
233      {%-   set interface_method_id =
234                interface.mojom_name ~ "_" ~ method.mojom_name %}
235      {{ method.name }}: {
236        params: {{interface_method_id}}_Params,
237      },
238      {%- endfor %}
239    },
240{%- endif %}
241  };
242{#--- Interface Constants #}
243{%- for constant in interface.constants %}
244  {{interface.name}}.{{constant.name}} = {{constant.value|expression_to_text}},
245{%-   endfor %}
246{#--- Interface Enums #}
247{%- from "enum_definition.tmpl" import enum_def -%}
248{%- for enum in interface.enums %}
249  {{ enum_def("%s.%s"|format(interface.name, enum.name), enum) }}
250{%-  endfor %}
251  {{interface.name}}Stub.prototype.validator = validate{{interface.name}}Request;
252{%- if interface|has_callbacks %}
253  {{interface.name}}Proxy.prototype.validator = validate{{interface.name}}Response;
254{%- else %}
255  {{interface.name}}Proxy.prototype.validator = null;
256{%- endif %}
257