Mojo: more idiomatic C++ bindings

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 
+{%- macro alloc_params(parameters) %}
+{%-   for param in parameters %}
+{%-     if param.kind|is_object_kind  %}
+{{param.kind|cpp_result_type}} p{{loop.index}};
+if (params->{{param.name}}())
+  Deserialize_(params->{{param.name}}(), &p{{loop.index}});
+{%      endif -%}
+{%-   endfor %}
+{%- endmacro %}
+
 {%- macro pass_params(parameters) %}
 {%-   for param in parameters %}
-{%-     if param.kind|is_object_kind -%}
-mojo::internal::Wrap(params->{{param.name}}())
+{%-     if param.kind|is_string_kind -%}
+p{{loop.index}}
+{%-     elif param.kind|is_object_kind -%}
+p{{loop.index}}.Pass()
 {%-     elif param.kind|is_interface_kind -%}
 mojo::MakeProxy<{{param.kind.name}}>(mojo::MakePassable(params->{{param.name}}()).Pass())
 {%-     elif param.kind|is_handle_kind -%}
 mojo::MakePassable(params->{{param.name}}()).Pass()
 {%-     elif param.kind|is_enum_kind -%}
 static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}}())
 {%-     else -%}
 params->{{param.name}}()
 {%-     endif -%}
 {%-     if not loop.last %}, {% endif %}
 {%-   endfor %}
 {%- endmacro %}
 
 {%- macro compute_payload_size(params_name, parameters) -%}
   size_t payload_size =
       mojo::internal::Align(sizeof({{params_name}}));
 {#--- Computes #}
 {%-   for param in parameters %}
 {%-     if param.kind|is_object_kind %}
-  if (!in_{{param.name}}.is_null())
-    payload_size += mojo::internal::Unwrap(in_{{param.name}})->ComputeSize();
+  if (in_{{param.name}})
+    payload_size += GetSerializedSize_(in_{{param.name}});
 {%-     endif %}
 {%-   endfor %}
 {%- endmacro %}
 
 {%- macro build_message(params_name, parameters) -%}
   {{params_name}}* params =
       {{params_name}}::New(builder.buffer());
 {#--- Sets #}
 {%   for param in parameters %}
 {%-     if param.kind|is_object_kind %}
-  if (!in_{{param.name}}.is_null())
-    params->set_{{param.name}}(
-        mojo::internal::Unwrap(in_{{param.name}})->Clone(builder.buffer()));
+  if (in_{{param.name}}) {
+    {{param.kind|cpp_type}} tmp;
+    Serialize_(mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &tmp);
+    params->set_{{param.name}}(tmp);
+  }
 {%-     elif param.kind|is_interface_kind %}
   if (!in_{{param.name}}.get()) {
     params->set_{{param.name}}(mojo::MessagePipeHandle());
   } else {
     // Delegate handle.
     params->set_{{param.name}}(
         in_{{param.name}}.ResetAndReturnMessagePipe().release());
   }
 {%-     elif param.kind|is_handle_kind %}
   params->set_{{param.name}}(in_{{param.name}}.release());
@@ skipping 35 matching lines @@
   MOJO_DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ForwardToCallback);
 };
 bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
     mojo::Message* message) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
   if (!params->DecodePointersAndHandles(message))
     return false;
+  {{alloc_params(method.response_parameters)|indent(2)}}
   callback_.Run({{pass_params(method.response_parameters)}});
   params->CloseHandles();
   return true;
 }
 {%-   endif %}
 {%- endfor %}
 
 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiver* receiver)
     : receiver_(receiver) {
 }
@@ skipping 85 matching lines @@
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-     if method.response_parameters == None %}
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       if (!params->DecodePointersAndHandles(message))
         return false;
+      {{alloc_params(method.parameters)|indent(6)}}
       sink_->{{method.name}}({{pass_params(method.parameters)}});
       params->CloseHandles();
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
@@ skipping 10 matching lines @@
       internal::{{class_name}}_{{method.name}}_Params_Data* params =
           reinterpret_cast<internal::{{class_name}}_{{method.name}}_Params_Data*>(
               message->mutable_payload());
 
       if (!params->DecodePointersAndHandles(message))
         return false;
       {{interface_macros.declare_callback(method)}}::Runnable* runnable =
           new {{class_name}}_{{method.name}}_ProxyToResponder(
               message->request_id(), responder);
       {{interface_macros.declare_callback(method)}} callback(runnable);
+      {{alloc_params(method.parameters)|indent(6)}}
       sink_->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}callback);
       params->CloseHandles();
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
@@ skipping 16 matching lines @@
 {% if interface|has_callbacks %}
 {{class_name}}ResponseValidator::{{class_name}}ResponseValidator(
     mojo::MessageReceiver* sink) : MessageFilter(sink) {
 }
 
 bool {{class_name}}ResponseValidator::Accept(mojo::Message* message) {
   // TODO(yzshen): implement validation logic.
   return sink_->Accept(message);
 }
 {%- endif -%}