OLD | NEW |
| (Empty) |
1 {%- import "interface_macros.tmpl" as interface_macros %} | |
2 {%- set class_name = interface.name %} | |
3 {%- set proxy_name = interface.name ~ "Proxy" %} | |
4 | |
5 {%- macro pass_params(parameters) %} | |
6 {%- for param in parameters %} | |
7 {%- if param.kind|is_object_kind -%} | |
8 mojo::internal::Wrap(params->{{param.name}}()) | |
9 {%- elif param.kind|is_handle_kind -%} | |
10 mojo::MakePassable(params->{{param.name}}()).Pass() | |
11 {%- elif param.kind|is_enum_kind -%} | |
12 static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}}()) | |
13 {%- else -%} | |
14 params->{{param.name}}() | |
15 {%- endif -%} | |
16 {%- if not loop.last %}, {% endif %} | |
17 {%- endfor %} | |
18 {%- endmacro %} | |
19 | |
20 {%- macro compute_payload_size(params_name, parameters) -%} | |
21 size_t payload_size = | |
22 mojo::internal::Align(sizeof({{params_name}})); | |
23 {#--- Computes #} | |
24 {%- for param in parameters %} | |
25 {%- if param.kind|is_object_kind %} | |
26 if (!in_{{param.name}}.is_null()) | |
27 payload_size += mojo::internal::Unwrap(in_{{param.name}})->ComputeSize(); | |
28 {%- endif %} | |
29 {%- endfor %} | |
30 {%- endmacro %} | |
31 | |
32 {%- macro build_message(params_name, parameters) -%} | |
33 {{params_name}}* params = | |
34 {{params_name}}::New(builder.buffer()); | |
35 {#--- Sets #} | |
36 {% for param in parameters %} | |
37 {%- if param.kind|is_object_kind %} | |
38 if (!in_{{param.name}}.is_null()) | |
39 params->set_{{param.name}}( | |
40 mojo::internal::Unwrap(in_{{param.name}})->Clone(builder.buffer())); | |
41 {%- elif param.kind|is_handle_kind %} | |
42 params->set_{{param.name}}(in_{{param.name}}.release()); | |
43 {%- else %} | |
44 params->set_{{param.name}}(in_{{param.name}}); | |
45 {%- endif %} | |
46 {%- endfor %} | |
47 mojo::Message message; | |
48 params->EncodePointersAndHandles(message.mutable_handles()); | |
49 builder.Finish(&message); | |
50 {%- endmacro %} | |
51 | |
52 {#--- ForwardToCallback definition #} | |
53 {%- for method in interface.methods -%} | |
54 {%- if method.response_parameters != None %} | |
55 class {{class_name}}_{{method.name}}_ForwardToCallback | |
56 : public mojo::MessageReceiver { | |
57 public: | |
58 {{class_name}}_{{method.name}}_ForwardToCallback( | |
59 const {{interface_macros.declare_callback(method)}}& callback) | |
60 : callback_(callback) { | |
61 } | |
62 virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE; | |
63 virtual bool AcceptWithResponder( | |
64 mojo::Message* message, | |
65 mojo::MessageReceiver* responder) MOJO_OVERRIDE { | |
66 assert(false); | |
67 return false; | |
68 } | |
69 private: | |
70 {{interface_macros.declare_callback(method)}} callback_; | |
71 MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback
); | |
72 }; | |
73 bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept( | |
74 mojo::Message* message) { | |
75 internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params = | |
76 reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_D
ata*>( | |
77 message->mutable_payload()); | |
78 | |
79 if (!params->DecodePointersAndHandles(message)) | |
80 return false; | |
81 callback_.Run({{pass_params(method.response_parameters)}}); | |
82 params->CloseHandles(); | |
83 return true; | |
84 } | |
85 {%- endif %} | |
86 {%- endfor %} | |
87 | |
88 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiver* receiver) | |
89 : receiver_(receiver) { | |
90 } | |
91 | |
92 {#--- Proxy definitions #} | |
93 | |
94 {%- for method in interface.methods %} | |
95 {%- set message_name = | |
96 "internal::k%s_%s_Name"|format(interface.name, method.name) %} | |
97 {%- set params_name = | |
98 "internal::%s_%s_Params_Data"|format(interface.name, method.name) %} | |
99 void {{proxy_name}}::{{method.name}}( | |
100 {{interface_macros.declare_request_params(method)}}) { | |
101 {{compute_payload_size(params_name, method.parameters)}} | |
102 | |
103 {%- if method.response_parameters != None %} | |
104 mojo::internal::RequestMessageBuilder builder({{message_name}}, payload_size); | |
105 {%- else %} | |
106 mojo::internal::MessageBuilder builder({{message_name}}, payload_size); | |
107 {%- endif %} | |
108 | |
109 {{build_message(params_name, method.parameters)}} | |
110 | |
111 {%- if method.response_parameters != None %} | |
112 mojo::MessageReceiver* responder = | |
113 new {{class_name}}_{{method.name}}_ForwardToCallback(callback); | |
114 if (!receiver_->AcceptWithResponder(&message, responder)) | |
115 delete responder; | |
116 {%- else %} | |
117 receiver_->Accept(&message); | |
118 {%- endif %} | |
119 } | |
120 {%- endfor %} | |
121 | |
122 {#--- ProxyToResponder definition #} | |
123 {%- for method in interface.methods -%} | |
124 {%- if method.response_parameters != None %} | |
125 {%- set message_name = | |
126 "internal::k%s_%s_Name"|format(interface.name, method.name) %} | |
127 {%- set params_name = | |
128 "internal::%s_%s_ResponseParams_Data"|format(interface.name, method.
name) %} | |
129 class {{class_name}}_{{method.name}}_ProxyToResponder | |
130 : public {{interface_macros.declare_callback(method)}}::Runnable { | |
131 public: | |
132 virtual ~{{class_name}}_{{method.name}}_ProxyToResponder() { | |
133 delete responder_; | |
134 } | |
135 | |
136 {{class_name}}_{{method.name}}_ProxyToResponder( | |
137 uint64_t request_id, | |
138 mojo::MessageReceiver* responder) | |
139 : request_id_(request_id), | |
140 responder_(responder) { | |
141 } | |
142 | |
143 virtual void Run({{interface_macros.declare_params(method.response_parameters)
}}) const; | |
144 | |
145 private: | |
146 uint64_t request_id_; | |
147 mutable mojo::MessageReceiver* responder_; | |
148 MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder)
; | |
149 }; | |
150 void {{class_name}}_{{method.name}}_ProxyToResponder::Run( | |
151 {{interface_macros.declare_params(method.response_parameters)}}) const { | |
152 {{compute_payload_size(params_name, method.response_parameters)}} | |
153 mojo::internal::ResponseMessageBuilder builder( | |
154 {{message_name}}, payload_size, request_id_); | |
155 {{build_message(params_name, method.response_parameters)}} | |
156 responder_->Accept(&message); | |
157 delete responder_; | |
158 responder_ = NULL; | |
159 } | |
160 {%- endif -%} | |
161 {%- endfor %} | |
162 | |
163 {{class_name}}Stub::{{class_name}}Stub({{class_name}}* sink) | |
164 : sink_(sink) { | |
165 } | |
166 | |
167 {#--- Stub definition #} | |
168 | |
169 bool {{class_name}}Stub::Accept(mojo::Message* message) { | |
170 {%- if interface.methods %} | |
171 switch (message->header()->name) { | |
172 {%- for method in interface.methods %} | |
173 case internal::k{{class_name}}_{{method.name}}_Name: { | |
174 {%- if method.response_parameters == None %} | |
175 internal::{{class_name}}_{{method.name}}_Params_Data* params = | |
176 reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*
>( | |
177 message->mutable_payload()); | |
178 | |
179 if (!params->DecodePointersAndHandles(message)) | |
180 return false; | |
181 sink_->{{method.name}}({{pass_params(method.parameters)}}); | |
182 params->CloseHandles(); | |
183 return true; | |
184 {%- else %} | |
185 break; | |
186 {%- endif %} | |
187 } | |
188 {%- endfor %} | |
189 } | |
190 {%- endif %} | |
191 return false; | |
192 } | |
193 | |
194 bool {{class_name}}Stub::AcceptWithResponder( | |
195 mojo::Message* message, mojo::MessageReceiver* responder) { | |
196 {%- if interface.methods %} | |
197 switch (message->header()->name) { | |
198 {%- for method in interface.methods %} | |
199 case internal::k{{class_name}}_{{method.name}}_Name: { | |
200 {%- if method.response_parameters != None %} | |
201 internal::{{class_name}}_{{method.name}}_Params_Data* params = | |
202 reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*
>( | |
203 message->mutable_payload()); | |
204 | |
205 if (!params->DecodePointersAndHandles(message)) | |
206 return false; | |
207 {{interface_macros.declare_callback(method)}}::Runnable* runnable = | |
208 new {{class_name}}_{{method.name}}_ProxyToResponder( | |
209 message->request_id(), responder); | |
210 {{interface_macros.declare_callback(method)}} callback(runnable); | |
211 sink_->{{method.name}}( | |
212 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}call
back); | |
213 params->CloseHandles(); | |
214 return true; | |
215 {%- else %} | |
216 break; | |
217 {%- endif %} | |
218 } | |
219 {%- endfor %} | |
220 } | |
221 {%- endif %} | |
222 return false; | |
223 } | |
OLD | NEW |