OLD | NEW |
| 1 {%- import "interface_macros.tmpl" as interface_macros %} |
1 {%- set class_name = interface.name %} | 2 {%- set class_name = interface.name %} |
2 {%- set proxy_name = interface.name ~ "Proxy" %} | 3 {%- set proxy_name = interface.name ~ "Proxy" %} |
3 | 4 |
4 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiver* receiver) | 5 {%- macro pass_params(parameters) %} |
5 : receiver_(receiver) { | 6 {%- for param in parameters %} |
6 } | 7 {%- if param.kind|is_object_kind -%} |
7 | 8 mojo::internal::Wrap(params->{{param.name}}()) |
8 {#--- Proxy definitions #} | 9 {%- elif param.kind|is_handle_kind -%} |
9 {%- macro params_list(method) %} | 10 mojo::MakePassable(params->{{param.name}}()).Pass() |
10 {%- for param in method.parameters -%} | 11 {%- elif param.kind|is_enum_kind -%} |
11 {{param.kind|cpp_const_wrapper_type}} in_{{param.name}} | 12 static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}}()) |
12 {%- if not loop.last %}, {% endif %} | 13 {%- else -%} |
| 14 params->{{param.name}}() |
| 15 {%- endif -%} |
| 16 {%- if not loop.last %}, {% endif %} |
13 {%- endfor %} | 17 {%- endfor %} |
14 {%- endmacro %} | 18 {%- endmacro %} |
15 | 19 |
16 {%- for method in interface.methods %} | 20 {%- macro compute_payload_size(params_name, parameters) -%} |
17 {%- set name = "internal::k%s_%s_Name"|format(interface.name, method.name) %} | |
18 {%- set params_name = | |
19 "internal::%s_%s_Params_Data"|format(interface.name, method.name) %} | |
20 void {{proxy_name}}::{{method.name}}({{params_list(method)}}) { | |
21 size_t payload_size = | 21 size_t payload_size = |
22 mojo::internal::Align(sizeof({{params_name}})); | 22 mojo::internal::Align(sizeof({{params_name}})); |
23 {#--- Computes #} | 23 {#--- Computes #} |
24 {%- for param in method.parameters %} | 24 {%- for param in parameters %} |
25 {%- if param.kind|is_object_kind %} | 25 {%- if param.kind|is_object_kind %} |
26 if (!in_{{param.name}}.is_null()) | 26 if (!in_{{param.name}}.is_null()) |
27 payload_size += mojo::internal::Unwrap(in_{{param.name}})->ComputeSize(); | 27 payload_size += mojo::internal::Unwrap(in_{{param.name}})->ComputeSize(); |
28 {%- endif %} | 28 {%- endif %} |
29 {%- endfor %} | 29 {%- endfor %} |
| 30 {%- endmacro %} |
30 | 31 |
31 mojo::internal::MessageBuilder builder({{name}}, payload_size); | 32 {%- macro build_message(params_name, parameters) -%} |
32 | |
33 {{params_name}}* params = | 33 {{params_name}}* params = |
34 {{params_name}}::New(builder.buffer()); | 34 {{params_name}}::New(builder.buffer()); |
35 | |
36 {#--- Sets #} | 35 {#--- Sets #} |
37 {% for param in method.parameters %} | 36 {% for param in parameters %} |
38 {%- if param.kind|is_object_kind %} | 37 {%- if param.kind|is_object_kind %} |
39 if (!in_{{param.name}}.is_null()) | 38 if (!in_{{param.name}}.is_null()) |
40 params->set_{{param.name}}( | 39 params->set_{{param.name}}( |
41 mojo::internal::Unwrap(in_{{param.name}})->Clone(builder.buffer())); | 40 mojo::internal::Unwrap(in_{{param.name}})->Clone(builder.buffer())); |
42 {%- elif param.kind|is_handle_kind %} | 41 {%- elif param.kind|is_handle_kind %} |
43 params->set_{{param.name}}(in_{{param.name}}.release()); | 42 params->set_{{param.name}}(in_{{param.name}}.release()); |
44 {%- else %} | 43 {%- else %} |
45 params->set_{{param.name}}(in_{{param.name}}); | 44 params->set_{{param.name}}(in_{{param.name}}); |
46 {%- endif %} | 45 {%- endif %} |
47 {%- endfor %} | 46 {%- endfor %} |
48 | |
49 mojo::Message message; | 47 mojo::Message message; |
50 params->EncodePointersAndHandles(message.mutable_handles()); | 48 params->EncodePointersAndHandles(message.mutable_handles()); |
| 49 builder.Finish(&message); |
| 50 {%- endmacro %} |
51 | 51 |
52 builder.Finish(&message); | 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()); |
53 | 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 %} |
54 receiver_->Accept(&message); | 117 receiver_->Accept(&message); |
| 118 {%- endif %} |
55 } | 119 } |
56 {%- endfor %} | 120 {%- endfor %} |
57 | 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 |
58 {{class_name}}Stub::{{class_name}}Stub({{class_name}}* sink) | 163 {{class_name}}Stub::{{class_name}}Stub({{class_name}}* sink) |
59 : sink_(sink) { | 164 : sink_(sink) { |
60 } | 165 } |
61 | 166 |
62 {#--- Stub definition #} | 167 {#--- Stub definition #} |
63 {%- macro params(method) %} | |
64 {%- for param in method.parameters %} | |
65 {%- if param.kind|is_object_kind -%} | |
66 mojo::internal::Wrap(params->{{param.name}}()) | |
67 {%- elif param.kind|is_handle_kind -%} | |
68 mojo::MakePassable(params->{{param.name}}()).Pass() | |
69 {%- elif param.kind|is_enum_kind -%} | |
70 static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}}()) | |
71 {%- else -%} | |
72 params->{{param.name}}() | |
73 {%- endif -%} | |
74 {%- if not loop.last %}, {% endif %} | |
75 {%- endfor %} | |
76 {%- endmacro %} | |
77 | 168 |
78 bool {{class_name}}Stub::Accept(mojo::Message* message) { | 169 bool {{class_name}}Stub::Accept(mojo::Message* message) { |
79 {%- if interface.methods %} | 170 {%- if interface.methods %} |
80 switch (message->header()->name) { | 171 switch (message->header()->name) { |
81 {%- for method in interface.methods %} | 172 {%- for method in interface.methods %} |
82 case internal::k{{class_name}}_{{method.name}}_Name: { | 173 case internal::k{{class_name}}_{{method.name}}_Name: { |
83 internal::{{class_name}}_{{method.name}}_Params_Data* params = | 174 {%- if method.response_parameters == None %} |
84 reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Dat
a*>( | 175 internal::{{class_name}}_{{method.name}}_Params_Data* params = |
85 message->mutable_payload()); | 176 reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*
>( |
| 177 message->mutable_payload()); |
86 | 178 |
87 if (!params->DecodePointersAndHandles(message)) | 179 if (!params->DecodePointersAndHandles(message)) |
88 return false; | 180 return false; |
89 sink_->{{method.name}}({{params(method)}}); | 181 sink_->{{method.name}}({{pass_params(method.parameters)}}); |
90 params->CloseHandles(); | 182 params->CloseHandles(); |
91 break; | 183 return true; |
92 } | 184 {%- else %} |
| 185 break; |
| 186 {%- endif %} |
| 187 } |
93 {%- endfor %} | 188 {%- endfor %} |
94 } | 189 } |
95 {%- endif %} | 190 {%- endif %} |
96 return true; | 191 return false; |
97 } | 192 } |
98 | 193 |
99 bool {{class_name}}Stub::AcceptWithResponder(mojo::Message* message, | 194 bool {{class_name}}Stub::AcceptWithResponder( |
100 mojo::MessageReceiver* responder) { | 195 mojo::Message* message, mojo::MessageReceiver* responder) { |
101 // TODO(darin): Implement this! | 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 %} |
102 return false; | 222 return false; |
103 } | 223 } |
OLD | NEW |