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}};
+Deserialize_(params->{{param.name}}.ptr, &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())
+mojo::MakeProxy<{{param.kind.name}}>(mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->{{param.name}})))
 {%-     elif param.kind|is_handle_kind -%}
-mojo::MakePassable(params->{{param.name}}()).Pass()
+mojo::MakeScopedHandle(mojo::internal::FetchAndReset(&params->{{param.name}}))
 {%-     elif param.kind|is_enum_kind -%}
-static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}}())
+static_cast<{{param.kind|cpp_wrapper_type}}>(params->{{param.name}})
 {%-     else -%}
-params->{{param.name}}()
+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();
+  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()));
+  Serialize_(mojo::internal::Forward(in_{{param.name}}), builder.buffer(), &params->{{param.name}}.ptr);
 {%-     elif param.kind|is_interface_kind %}
   if (!in_{{param.name}}.get()) {
-    params->set_{{param.name}}(mojo::MessagePipeHandle());
+    params->{{param.name}} = mojo::MessagePipeHandle();
   } else {
     // Delegate handle.
-    params->set_{{param.name}}(
-        in_{{param.name}}.ResetAndReturnMessagePipe().release());
+    params->{{param.name}} =
+        in_{{param.name}}.ResetAndReturnMessagePipe().release();
   }
 {%-     elif param.kind|is_handle_kind %}
-  params->set_{{param.name}}(in_{{param.name}}.release());
+  params->{{param.name}} = in_{{param.name}}.release();
 {%-     else %}
-  params->set_{{param.name}}(in_{{param.name}});
+  params->{{param.name}} = in_{{param.name}};
 {%-     endif %}
 {%-   endfor %}
   mojo::Message message;
   params->EncodePointersAndHandles(message.mutable_handles());
   builder.Finish(&message);
 {%- endmacro %}
 
 {#--- Begin #}
 
 {#--- Constants #}
@@ skipping 17 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::MessageReceiverWithResponder* receiver)
     : receiver_(receiver) {
 }
 
 {#--- Proxy definitions #}
@@ skipping 83 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 %}
   return false;
 }
 
 bool {{class_name}}Stub::AcceptWithResponder(
     mojo::Message* message, mojo::MessageReceiver* responder) {
 {%- if interface.methods %}
   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;
       {{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 %}
   }
 {%- endif %}
   return false;
 }
@@ skipping 13 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 -%}