OLD | NEW |
| (Empty) |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 {% import "struct.tmpl" as struct_macros %} | |
6 {% import "runtime_type_macros.tmpl" as runtime_type_macros %} | |
7 | |
8 {%- macro declare_params(struct) %} | |
9 {%- for field in struct.fields -%} | |
10 {{field|name(False)}} {{field.kind|go_type}}{% if not loop.last %}, {% e
ndif %} | |
11 {%- endfor %} | |
12 {%- endmacro %} | |
13 | |
14 | |
15 | |
16 {% macro declare_request_params(method) %} | |
17 ({{declare_params(method.param_struct)}}) | |
18 {%- if method.response_parameters|is_none_or_empty -%} | |
19 {{' (err error)'}} | |
20 {%- else -%} | |
21 {{' '}}({{declare_params(method.response_param_struct)}}, err error) | |
22 {%- endif -%} | |
23 {% endmacro %} | |
24 | |
25 | |
26 | |
27 {%- macro flags(method, is_response) -%} | |
28 {%- if not method|has_response -%} | |
29 bindings.MessageNoFlag | |
30 {%- elif is_response: -%} | |
31 bindings.MessageIsResponseFlag | |
32 {%- else -%} | |
33 bindings.MessageExpectsResponseFlag | |
34 {%- endif -%} | |
35 {%- endmacro -%} | |
36 | |
37 | |
38 | |
39 {% macro define(interface, descpkg, typepkg, pkg) %} | |
40 type {{interface|name}} interface { | |
41 {% for method in interface.methods %} | |
42 {{method|name}}{{declare_request_params(method)}} | |
43 {% endfor %} | |
44 } | |
45 | |
46 {{runtime_type_macros.maybeWriteStaticMojomTypeAccessor(typepkg, interface)}} | |
47 | |
48 {% if interface.service_name %} | |
49 var {{interface|name(False)}}_Name = "{{interface.service_name}}" | |
50 {% endif %} | |
51 | |
52 type {{interface|name}}_Request bindings.InterfaceRequest | |
53 | |
54 {% if interface.service_name %} | |
55 func (r *{{interface|name}}_Request) Name() string { | |
56 return {{interface|name(False)}}_Name | |
57 } | |
58 {% endif %} | |
59 | |
60 {%- set type_name = interface|name + '_Request' %} | |
61 {{runtime_type_macros.maybeWriteMojomTypeAccessor(typepkg, interface, type_name)
}} | |
62 | |
63 type {{interface|name}}_Pointer bindings.InterfacePointer | |
64 | |
65 {% if interface.service_name %} | |
66 func (p *{{interface|name}}_Pointer) Name() string { | |
67 return {{interface|name(False)}}_Name | |
68 } | |
69 {% endif %} | |
70 | |
71 type {{interface|name}}_ServiceFactory struct{ | |
72 Delegate {{interface|name}}_Factory | |
73 } | |
74 | |
75 type {{interface|name}}_Factory interface { | |
76 Create(request {{interface|name}}_Request) | |
77 } | |
78 | |
79 {% if interface.service_name %} | |
80 func (f *{{interface|name}}_ServiceFactory) Name() string { | |
81 return {{interface|name(False)}}_Name | |
82 } | |
83 {% endif %} | |
84 | |
85 // TODO(rudominer) This should only be defined for top-level interfaces. | |
86 func (f *{{interface|name}}_ServiceFactory) ServiceDescription() {{descpkg}}Serv
iceDescription { | |
87 return &{{interface|name}}_ServiceDescription{} | |
88 } | |
89 | |
90 func (f *{{interface|name}}_ServiceFactory) Create(messagePipe system.MessagePip
eHandle) { | |
91 request := {{interface|name}}_Request{bindings.NewMessagePipeHandleOwner
(messagePipe)} | |
92 f.Delegate.Create(request) | |
93 } | |
94 | |
95 // CreateMessagePipeFor{{interface|name}} creates a message pipe for use with th
e | |
96 // {{interface|name}} interface with a {{interface|name}}_Request on one end and
a {{interface|name}}_Pointer on the other. | |
97 func CreateMessagePipeFor{{interface|name}}() ({{interface|name}}_Request, {{int
erface|name}}_Pointer) { | |
98 r, p := bindings.CreateMessagePipeForMojoInterface() | |
99 return {{interface|name}}_Request(r), {{interface|name}}_Pointer(p) | |
100 } | |
101 | |
102 {% for method in interface.methods %} | |
103 const {{interface|name(False)}}_{{method|name}}_Name uint32 = {{method.ordinal}} | |
104 {% endfor %} | |
105 | |
106 type {{interface|name}}_Proxy struct { | |
107 router *bindings.Router | |
108 ids bindings.Counter | |
109 } | |
110 | |
111 func New{{interface|name}}Proxy(p {{interface|name}}_Pointer, waiter bindings.As
yncWaiter) *{{interface|name}}_Proxy { | |
112 return &{{interface|name}}_Proxy{ | |
113 bindings.NewRouter(p.PassMessagePipe(), waiter), | |
114 bindings.NewCounter(), | |
115 } | |
116 } | |
117 | |
118 func (p *{{interface|name}}_Proxy) Close_Proxy() { | |
119 p.router.Close() | |
120 } | |
121 | |
122 {% for method in interface.methods %} | |
123 {{struct_macros.define(method.param_struct, typepkg, pkg, False)}} | |
124 {%- if method|has_response %} | |
125 {{struct_macros.define(method.response_param_struct, typepkg, pkg, False)}} | |
126 {%- endif %} | |
127 func (p *{{interface|name}}_Proxy) {{method|name}}{{declare_request_params(metho
d)}} { | |
128 payload := &{{method.param_struct|name(False)}}{ | |
129 {% for field in (method.param_struct).fields %} | |
130 {{field|name(False)}}, | |
131 {% endfor %} | |
132 } | |
133 header := bindings.MessageHeader{ | |
134 Type: {{interface|name(False)}}_{{method|name}}_Name, | |
135 Flags: {{flags(method, False)}}, | |
136 {% if method|has_response %} | |
137 RequestId: p.ids.Count(), | |
138 {% endif %} | |
139 } | |
140 var message *bindings.Message | |
141 if message, err = bindings.EncodeMessage(header, payload); err != nil { | |
142 err = fmt.Errorf("can't encode request: %v", err.Error()) | |
143 p.Close_Proxy() | |
144 return | |
145 } | |
146 {% if method|has_response %} | |
147 readResult := <-p.router.AcceptWithResponse(message) | |
148 if err = readResult.Error; err != nil { | |
149 p.Close_Proxy() | |
150 return | |
151 } | |
152 if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { | |
153 err = &bindings.ValidationError{bindings.MessageHeaderInvalidFla
gs, | |
154 fmt.Sprintf("invalid message header flag: %v", readResul
t.Message.Header.Flags), | |
155 } | |
156 return | |
157 } | |
158 if got, want := readResult.Message.Header.Type, {{interface|name(False)}
}_{{method|name}}_Name; got != want { | |
159 err = &bindings.ValidationError{bindings.MessageHeaderUnknownMet
hod, | |
160 fmt.Sprintf("invalid method in response: expected %v, go
t %v", want, got), | |
161 } | |
162 return | |
163 } | |
164 var response {{method.response_param_struct|name(False)}} | |
165 if err = readResult.Message.DecodePayload(&response); err != nil { | |
166 p.Close_Proxy() | |
167 return | |
168 } | |
169 {% for field in (method.response_param_struct).fields %} | |
170 {{field|name(False)}} = response.{{field|name(False)}} | |
171 {% endfor %} | |
172 {% else %} | |
173 if err = p.router.Accept(message); err != nil { | |
174 p.Close_Proxy() | |
175 return | |
176 } | |
177 {% endif %} | |
178 return | |
179 } | |
180 | |
181 {% endfor %} | |
182 type {{interface|name(False)}}_Stub struct { | |
183 connector *bindings.Connector | |
184 impl {{interface|name}} | |
185 } | |
186 | |
187 func New{{interface|name}}Stub(r {{interface|name}}_Request, impl {{interface|na
me}}, waiter bindings.AsyncWaiter) *bindings.Stub { | |
188 connector := bindings.NewConnector(r.PassMessagePipe(), waiter) | |
189 return bindings.NewStub(connector, &{{interface|name(False)}}_Stub{conne
ctor, impl}) | |
190 } | |
191 | |
192 | |
193 func (f *{{interface|name}}_Request) ServiceDescription() {{descpkg}}ServiceDesc
ription { | |
194 return &{{interface|name}}_ServiceDescription{} | |
195 } | |
196 | |
197 | |
198 type {{interface|name}}_ServiceDescription struct{} | |
199 | |
200 {% if should_gen_mojom_types and interface.service_name-%} | |
201 func (sd *{{interface|name}}_ServiceDescription) GetTopLevelInterface() (outMojo
mInterface {{typepkg}}MojomInterface, err error) { | |
202 interfaceTypeKey := getRuntimeTypeInfo().Services["{{interface.service_n
ame}}"] | |
203 userDefinedType := getRuntimeTypeInfo().TypeMap[interfaceTypeKey].(*{{ty
pepkg}}UserDefinedTypeInterfaceType) | |
204 return userDefinedType.Value, nil | |
205 } | |
206 | |
207 func (sd *{{interface|name}}_ServiceDescription) GetTypeDefinition(inTypeKey str
ing) (outType mojom_types.UserDefinedType, err error) { | |
208 if udt, ok := GetAllMojomTypeDefinitions()[inTypeKey]; ok { | |
209 return udt, nil | |
210 } | |
211 return nil, fmt.Errorf("%s_ServiceDescription does not recognize %s", "{
{interface|name}}", inTypeKey) | |
212 } | |
213 | |
214 func (sd *{{interface|name}}_ServiceDescription) GetAllTypeDefinitions() (outDef
initions *map[string]mojom_types.UserDefinedType, err error) { | |
215 o := GetAllMojomTypeDefinitions() | |
216 return &o, nil | |
217 } | |
218 {%- else -%} | |
219 func (sd *{{interface|name}}_ServiceDescription) GetTopLevelInterface() (outMojo
mInterface {{typepkg}}MojomInterface, err error) { | |
220 err = fmt.Errorf("GetTopLevelInterface not implemented") | |
221 return | |
222 } | |
223 | |
224 func (sd *{{interface|name}}_ServiceDescription) GetTypeDefinition(inTypeKey str
ing) (outType mojom_types.UserDefinedType, err error) { | |
225 err = fmt.Errorf("GetTypeDefinition not implemented") | |
226 return | |
227 } | |
228 | |
229 func (sd *{{interface|name}}_ServiceDescription) GetAllTypeDefinitions() (outDef
initions *map[string]mojom_types.UserDefinedType, err error) { | |
230 err = fmt.Errorf("GetAllTypeDefinitions not implemented") | |
231 return | |
232 } | |
233 {%- endif %} | |
234 | |
235 var _ {{descpkg}}ServiceDescription = (*{{interface|name}}_ServiceDescription)(n
il) | |
236 | |
237 | |
238 func (s *{{interface|name(False)}}_Stub) Accept(message *bindings.Message) (err
error) { | |
239 switch message.Header.Type { | |
240 {% for method in interface.methods %} | |
241 case {{interface|name(False)}}_{{method|name}}_Name: | |
242 {% if method|has_response %} | |
243 if message.Header.Flags != bindings.MessageExpectsResponseFlag { | |
244 {% else %} | |
245 if message.Header.Flags != bindings.MessageNoFlag { | |
246 {% endif %} | |
247 return &bindings.ValidationError{bindings.MessageHeaderI
nvalidFlags, | |
248 fmt.Sprintf("invalid message header flag: %v", m
essage.Header.Flags), | |
249 } | |
250 } | |
251 var request {{method.param_struct|name(False)}} | |
252 if err := message.DecodePayload(&request); err != nil { | |
253 return err | |
254 } | |
255 {% if method|has_response %} | |
256 var response {{method.response_param_struct|name(False)}} | |
257 {% endif %} | |
258 {% if method.response_parameters|is_none_or_empty %} | |
259 err = s.impl.{{method|name}}( | |
260 {%- else -%} | |
261 {% for field in (method.response_param_struct).fields %} | |
262 response.{{field|name(False)}}{{', '}} | |
263 {%- endfor -%}err = s.impl.{{method|name}}( | |
264 {%- endif -%} | |
265 {%- for field in (method.param_struct).fields -%} | |
266 request.{{field|name(False)}}{% if not loop.last %}, {%
endif %} | |
267 {%- endfor -%} | |
268 ) | |
269 if err != nil { | |
270 return | |
271 } | |
272 {% if method|has_response %} | |
273 header := bindings.MessageHeader{ | |
274 Type: {{interface|name(False)}}_{{method|name}}_Name, | |
275 Flags: {{flags(method, True)}}, | |
276 RequestId: message.Header.RequestId, | |
277 } | |
278 message, err = bindings.EncodeMessage(header, &response) | |
279 if err != nil { | |
280 return err | |
281 } | |
282 return s.connector.WriteMessage(message) | |
283 {% endif %} | |
284 {% endfor %} | |
285 default: | |
286 return &bindings.ValidationError{ | |
287 bindings.MessageHeaderUnknownMethod, | |
288 fmt.Sprintf("unknown method %v", message.Header.Type), | |
289 } | |
290 } | |
291 return | |
292 } | |
293 | |
294 {% endmacro %} | |
OLD | NEW |