Reduce Mojo generated C++ code size

Picks some low-hanging fruit that the compiler is not able
to optimize away: reduces repetition of local context object
construction in message decoding logic, and eliminates some
unnecessary inlined move operations.

Bug: 1058101
Change-Id: Ibedb0eb2c506b3a70c5c60d848633e420845f5cb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2083738
Commit-Queue: Ken Rockot <rockot@google.com>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#746500}

mojo/public/cpp/bindings/lib/serialization_context.cc

@@ -59,6 +59,8 @@ void SerializationContext::AddAssociatedInterfaceInfo(
 }
 
 void SerializationContext::TakeHandlesFromMessage(Message* message) {
+  if (!message->is_serialized())
+    return;
   receiver_connection_group_ = message->receiver_connection_group();
   handles_.swap(*message->mutable_handles());
   associated_endpoint_handles_.swap(

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

@@ -8,8 +8,6 @@
 {%- set qualified_class_name = ("::" ~ namespace_as_string_with_variant if namespace_as_string_with_variant) ~ "::" ~ class_name %}
 
 {%- macro alloc_params(struct, params, message, method_number, is_response) %}
-  mojo::internal::SerializationContext serialization_context;
-  serialization_context.TakeHandlesFromMessage({{message}});
   bool success = true;
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_wrapper_call_type}} p_{{param.field.name}}{};
@@ -216,10 +214,10 @@ class {{class_name}}_{{method.name}}_ProxyToResponder {
   static {{class_name}}::{{method.name}}Callback CreateCallback(
       uint64_t request_id,
       bool is_sync,
-      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
+      std::unique_ptr<mojo::MessageReceiverWithStatus>* responder) {
     std::unique_ptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy(
         new {{class_name}}_{{method.name}}_ProxyToResponder(
-            request_id, is_sync, std::move(responder)));
+            request_id, is_sync, responder));
     return base::BindOnce(&{{class_name}}_{{method.name}}_ProxyToResponder::Run,
                           std::move(proxy));
   }
@@ -243,10 +241,10 @@ class {{class_name}}_{{method.name}}_ProxyToResponder {
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
       bool is_sync,
-      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
+      std::unique_ptr<mojo::MessageReceiverWithStatus>* responder)
       : request_id_(request_id),
         is_sync_(is_sync),
-        responder_(std::move(responder)) {
+        responder_(std::move(*responder)) {
   }
 
 #if DCHECK_IS_ON()
@@ -306,6 +304,8 @@ bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
               message->mutable_payload());
 
 {%-     set desc = class_name~"::"~method.name~" response" %}
+  mojo::internal::SerializationContext serialization_context;
+  serialization_context.TakeHandlesFromMessage(message);
   {{alloc_params(method.response_param_struct, "params", "message", method.sequential_ordinal, "true")}}
   if (!callback_.is_null())
     std::move(callback_).Run({{pass_params(method.response_parameters)}});
@@ -378,6 +378,8 @@ bool {{class_name}}_{{method.name}}_HandleSyncResponse::Accept(
           message->mutable_payload());
 
 {%-       set desc = class_name~"::"~method.name~" response" %}
+  mojo::internal::SerializationContext serialization_context;
+  serialization_context.TakeHandlesFromMessage(message);
   {{alloc_params(method.response_param_struct, "params", "message", method.sequential_ordinal, "true")}}
 
 {%-       for param in method.response_parameters %}
@@ -399,6 +401,9 @@ bool {{class_name}}StubDispatch::Accept(
     {{interface.name}}* impl,
     mojo::Message* message) {
 {%- if interface.methods %}
+  mojo::internal::MessageDispatchContext dispatch_context(message);
+  mojo::internal::SerializationContext serialization_context;
+  serialization_context.TakeHandlesFromMessage(message);
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
@@ -412,7 +417,6 @@ bool {{class_name}}StubDispatch::Accept(
       static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
               "(Impl){{namespace_as_string}}::{{class_name}}::{{method.name}}");
       base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
-      mojo::internal::MessageDispatchContext dispatch_context(message);
 {%-       if method|method_supports_lazy_serialization %}
       if (!message->is_serialized()) {
         auto context = message->TakeUnserializedContext<
@@ -457,6 +461,13 @@ bool {{class_name}}StubDispatch::AcceptWithResponder(
     mojo::Message* message,
     std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
 {%- if interface.methods %}
+  mojo::internal::MessageDispatchContext dispatch_context(message);
+  mojo::internal::SerializationContext serialization_context;
+  serialization_context.TakeHandlesFromMessage(message);
+  const bool message_is_sync = message->has_flag(mojo::Message::kFlagIsSync);
+  const uint64_t request_id = message->request_id();
+  ALLOW_UNUSED_LOCAL(message_is_sync);
+  ALLOW_UNUSED_LOCAL(request_id);
   switch (message->header()->name) {
 {%-   for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
@@ -470,7 +481,6 @@ bool {{class_name}}StubDispatch::AcceptWithResponder(
       static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
               "(Impl){{namespace_as_string}}::{{class_name}}::{{method.name}}");
       base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
-      mojo::internal::MessageDispatchContext dispatch_context(message);
 {%-       if method|method_supports_lazy_serialization %}
       if (!message->is_serialized()) {
         auto context = message->TakeUnserializedContext<
@@ -483,9 +493,7 @@ bool {{class_name}}StubDispatch::AcceptWithResponder(
         } else {
           {{class_name}}::{{method.name}}Callback callback =
               {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
-                  message->request_id(),
-                  message->has_flag(mojo::Message::kFlagIsSync),
-                  std::move(responder));
+                  message->request_id(), message_is_sync, &responder);
           context->Dispatch(message, impl, std::move(callback));
           return true;
         }
@@ -502,9 +510,7 @@ bool {{class_name}}StubDispatch::AcceptWithResponder(
           indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
-              message->request_id(),
-              message->has_flag(mojo::Message::kFlagIsSync),
-              std::move(responder));
+              message->request_id(), message_is_sync, &responder);
       // A null |impl| means no implementation was bound.
       DCHECK(impl);
       impl->{{method.name}}(