Mojo C++ bindings: introduce an optional array to store transferred interface IDs in messages.

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

 {%- import "interface_macros.tmpl" as interface_macros %}
 {%- import "struct_macros.tmpl" as struct_macros %}
 
 {%- set class_name = interface.name %}
 {%- set proxy_name = interface.name ~ "Proxy" %}
 {%- set namespace_as_string = "%s"|format(namespace|replace(".","::")) %}
 
-{%- macro alloc_params(struct, params, message, serialization_context,
-                       description) %}
-  ({{serialization_context}})->handles.Swap(({{message}})->mutable_handles());
+{%- macro alloc_params(struct, params, message, description) %}
+  mojo::internal::SerializationContext serialization_context;
+  serialization_context.handles.Swap(({{message}})->mutable_handles());
+  serialization_context.associated_endpoint_handles.swap(
+      *({{message}})->mutable_associated_endpoint_handles());
   bool success = true;
 {%-   for param in struct.packed.packed_fields_in_ordinal_order %}
   {{param.field.kind|cpp_wrapper_type}} p_{{param.field.name}}{};
 {%-   endfor %}
-  {{struct.name}}DataView input_data_view({{params}},
-                                          {{serialization_context}});
+  {{struct.name}}DataView input_data_view({{params}}, &serialization_context);
   {{struct_macros.deserialize(struct, "input_data_view", "p_%s", "success")}}
   if (!success) {
     ReportValidationErrorForMessage(
         {{message}},
         mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
         "{{description}} deserializer");
     return false;
   }
 {%- endmacro %}
 
 {%- macro pass_params(parameters) %}
 {%-   for param in parameters %}
 std::move(p_{{param.name}})
 {%-     if not loop.last %}, {% endif %}
 {%-   endfor %}
 {%- endmacro %}
 
 {%- macro build_message(struct, input_pattern, struct_display_name,
                         serialization_context) -%}
   {{struct_macros.serialize(struct, struct_display_name, input_pattern,
                             "params", "builder.buffer()",
                             serialization_context)}}
   ({{serialization_context}})->handles.Swap(
       builder.message()->mutable_handles());
+  ({{serialization_context}})->associated_endpoint_handles.swap(
+      *builder.message()->mutable_associated_endpoint_handles());
 {%- endmacro %}
 
 {#--- Begin #}
 const char {{class_name}}::Name_[] = "{{namespace_as_string}}::{{class_name}}";
 
 {#--- Constants #}
 {%-  for constant in interface.constants %}
 {%-   if constant.kind|is_string_kind %}
 const char {{interface.name}}::{{constant.name}}[] = {{constant|constant_value}};
 {%-   endif %}
@@ skipping 10 matching lines @@
 {%- endfor %}
 
 {#--- ForwardToCallback definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     if method.sync %}
 class {{class_name}}_{{method.name}}_HandleSyncResponse
     : public mojo::MessageReceiver {
  public:
   {{class_name}}_{{method.name}}_HandleSyncResponse(
-      scoped_refptr<mojo::AssociatedGroupController> group_controller,
       bool* result
 {%-       for param in method.response_parameters -%}
       , {{param.kind|cpp_wrapper_type}}* out_{{param.name}}
 {%-       endfor %})
-      : serialization_context_(std::move(group_controller)), result_(result)
+      : result_(result)
 {%-       for param in method.response_parameters -%}
         , out_{{param.name}}_(out_{{param.name}})
 {%-       endfor %} {
     DCHECK(!*result_);
   }
   bool Accept(mojo::Message* message) override;
  private:
-  mojo::internal::SerializationContext serialization_context_;
   bool* result_;
 {%-       for param in method.response_parameters %}
   {{param.kind|cpp_wrapper_type}}* out_{{param.name}}_;
 {%-       endfor -%}
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_HandleSyncResponse);
 };
 bool {{class_name}}_{{method.name}}_HandleSyncResponse::Accept(
     mojo::Message* message) {
   internal::{{class_name}}_{{method.name}}_ResponseParams_Data* params =
       reinterpret_cast<internal::{{class_name}}_{{method.name}}_ResponseParams_Data*>(
           message->mutable_payload());
 
 {%-       set desc = class_name~"::"~method.name~" response" %}
-  {{alloc_params(method.response_param_struct, "params", "message",
-                 "&serialization_context_", desc)}}
+  {{alloc_params(method.response_param_struct, "params", "message", desc)}}
 
 {%-       for param in method.response_parameters %}
   *out_{{param.name}}_ = std::move(p_{{param.name}});
 {%-       endfor %}
   mojo::internal::SyncMessageResponseSetup::SetCurrentSyncResponseMessage(
       message);
   *result_ = true;
   return true;
 }
 {%-     endif %}
 
 class {{class_name}}_{{method.name}}_ForwardToCallback
     : public mojo::MessageReceiver {
  public:
   {{class_name}}_{{method.name}}_ForwardToCallback(
 {%-     if use_once_callback %}
-      {{class_name}}::{{method.name}}Callback callback,
+      {{class_name}}::{{method.name}}Callback callback
 {%-     else %}
-      const {{class_name}}::{{method.name}}Callback& callback,
+      const {{class_name}}::{{method.name}}Callback& callback
 {%-     endif %}
-      scoped_refptr<mojo::AssociatedGroupController> group_controller)
-      : callback_(std::move(callback)),
-        serialization_context_(std::move(group_controller)) {
+      ) : callback_(std::move(callback)) {
   }
   bool Accept(mojo::Message* message) override;
  private:
   {{class_name}}::{{method.name}}Callback callback_;
-  mojo::internal::SerializationContext serialization_context_;
   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());
 
 {%-     set desc = class_name~"::"~method.name~" response" %}
-  {{alloc_params(method.response_param_struct, "params", "message",
-                 "&serialization_context_", desc)}}
+  {{alloc_params(method.response_param_struct, "params", "message", desc)}}
   if (!callback_.is_null()) {
     mojo::internal::MessageDispatchContext context(message);
     std::move(callback_).Run({{pass_params(method.response_parameters)}});
   }
   return true;
 }
 {%-   endif %}
 {%- endfor %}
 
 {{proxy_name}}::{{proxy_name}}(mojo::MessageReceiverWithResponder* receiver)
     : receiver_(receiver) {
 }
 
 {#--- Proxy definitions #}
 
 {%- for method in interface.methods %}
 {%-   set message_name =
           "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-   set params_struct = method.param_struct %}
 {%-   set params_description =
           "%s.%s request"|format(interface.name, method.name) %}
 {%-   if method.sync %}
 bool {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_sync_method_params("param_", method)}}) {
-   mojo::internal::SerializationContext serialization_context(
-      group_controller_);
+  mojo::internal::SerializationContext serialization_context;
   {{struct_macros.get_serialized_size(params_struct, "param_%s",
                                       "&serialization_context")}}
 
-  mojo::internal::RequestMessageBuilder builder({{message_name}}, size,
-                                                mojo::Message::kFlagIsSync);
+  mojo::internal::MessageBuilder builder(
+      {{message_name}},
+      mojo::Message::kFlagIsSync | mojo::Message::kFlagExpectsResponse,
+      size, serialization_context.associated_endpoint_count);
 
   {{build_message(params_struct, "param_%s", params_description,
                   "&serialization_context")}}
 
   bool result = false;
   mojo::MessageReceiver* responder =
       new {{class_name}}_{{method.name}}_HandleSyncResponse(
-          group_controller_, &result
+          &result
 {%-     for param in method.response_parameters -%}
           , param_{{param.name}}
 {%-     endfor %});
   if (!receiver_->AcceptWithResponder(builder.message(), responder))
     delete responder;
   return result;
 }
 {%-   endif %}
 
 void {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_request_params("in_", method, use_once_callback)}}) {
-   mojo::internal::SerializationContext serialization_context(
-      group_controller_);
+  mojo::internal::SerializationContext serialization_context;
   {{struct_macros.get_serialized_size(params_struct, "in_%s",
                                       "&serialization_context")}}
 
 {%- if method.response_parameters != None %}
-  mojo::internal::RequestMessageBuilder builder({{message_name}}, size);
+  constexpr uint32_t kFlags = mojo::Message::kFlagExpectsResponse;
 {%- else %}
-  mojo::internal::MessageBuilder builder({{message_name}}, size);
+  constexpr uint32_t kFlags = 0;
 {%- endif %}
+  mojo::internal::MessageBuilder builder(
+      {{message_name}}, kFlags, size,
+      serialization_context.associated_endpoint_count);
 
   {{build_message(params_struct, "in_%s", params_description,
                   "&serialization_context")}}
 
 {%- if method.response_parameters != None %}
   mojo::MessageReceiver* responder =
-      new {{class_name}}_{{method.name}}_ForwardToCallback(
-          std::move(callback), group_controller_);
+      new {{class_name}}_{{method.name}}_ForwardToCallback(std::move(callback));
   if (!receiver_->AcceptWithResponder(builder.message(), responder))
     delete responder;
 {%- else %}
   bool ok = receiver_->Accept(builder.message());
   // This return value may be ignored as !ok implies the Connector has
   // encountered an error, which will be visible through other means.
   ALLOW_UNUSED_LOCAL(ok);
 {%- endif %}
 }
 {%- endfor %}
 
 {#--- ProxyToResponder definition #}
 {%- for method in interface.methods -%}
 {%-   if method.response_parameters != None %}
 {%-     set message_name =
             "internal::k%s_%s_Name"|format(interface.name, method.name) %}
 {%-     set response_params_struct = method.response_param_struct %}
 {%-     set params_description =
             "%s.%s response"|format(interface.name, method.name) %}
 class {{class_name}}_{{method.name}}_ProxyToResponder {
  public:
   static {{class_name}}::{{method.name}}Callback CreateCallback(
       uint64_t request_id,
       bool is_sync,
-      mojo::MessageReceiverWithStatus* responder,
-      scoped_refptr<mojo::AssociatedGroupController>
-          group_controller) {
+      mojo::MessageReceiverWithStatus* responder) {
     std::unique_ptr<{{class_name}}_{{method.name}}_ProxyToResponder> proxy(
         new {{class_name}}_{{method.name}}_ProxyToResponder(
-            request_id, is_sync, responder, group_controller));
+            request_id, is_sync, responder));
     return base::Bind(&{{class_name}}_{{method.name}}_ProxyToResponder::Run,
                       base::Passed(&proxy));
   }
 
   ~{{class_name}}_{{method.name}}_ProxyToResponder() {
 #if DCHECK_IS_ON()
     if (responder_) {
       // Is the Service destroying the callback without running it
       // and without first closing the pipe?
       responder_->DCheckInvalid("The callback passed to "
           "{{class_name}}::{{method.name}}() was never run.");
     }
 #endif
     // If the Callback was dropped then deleting the responder will close
     // the pipe so the calling application knows to stop waiting for a reply.
     delete responder_;
   }
 
  private:
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
       bool is_sync,
-      mojo::MessageReceiverWithStatus* responder,
-      scoped_refptr<mojo::AssociatedGroupController> group_controller)
+      mojo::MessageReceiverWithStatus* responder)
       : request_id_(request_id),
         is_sync_(is_sync),
-        responder_(responder),
-        serialization_context_(std::move(group_controller)) {
+        responder_(responder) {
   }
 
   void Run(
       {{interface_macros.declare_responder_params(
           "in_", method.response_parameters, for_blink)}});
 
   uint64_t request_id_;
   bool is_sync_;
   mojo::MessageReceiverWithStatus* responder_;
-  // TODO(yzshen): maybe I should use a ref to the original one?
-  mojo::internal::SerializationContext serialization_context_;
 
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_responder_params(
         "in_", method.response_parameters, for_blink)}}) {
+  mojo::internal::SerializationContext serialization_context;
   {{struct_macros.get_serialized_size(response_params_struct, "in_%s",
-                                      "&serialization_context_")}}
-  mojo::internal::ResponseMessageBuilder builder(
-      {{message_name}}, size, request_id_,
-      is_sync_ ? mojo::Message::kFlagIsSync : 0);
+                                      "&serialization_context")}}
+
+  uint32_t flags = (is_sync_ ? mojo::Message::kFlagIsSync : 0) |
+                   mojo::Message::kFlagIsResponse;
+  mojo::internal::MessageBuilder builder(
+      {{message_name}}, flags, size,
+      serialization_context.associated_endpoint_count);
+  builder.message()->set_request_id(request_id_);
+
   {{build_message(response_params_struct, "in_%s", params_description,
-                  "&serialization_context_")}}
+                  "&serialization_context")}}
   bool ok = responder_->Accept(builder.message());
   ALLOW_UNUSED_LOCAL(ok);
   // TODO(darin): !ok returned here indicates a malformed message, and that may
   // be good reason to close the connection. However, we don't have a way to do
   // that from here. We should add a way.
   delete responder_;
   responder_ = nullptr;
 }
 {%-   endif -%}
 {%- endfor %}
 
 {#--- StubDispatch definition #}
 
 // static
 bool {{class_name}}StubDispatch::Accept(
     {{interface.name}}* impl,
-    mojo::internal::SerializationContext* context,
     mojo::Message* message) {
 {%- 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());
 
 {%-       set desc = class_name~"::"~method.name %}
-      {{alloc_params(method.param_struct, "params", "message", "context", desc)|
+      {{alloc_params(method.param_struct, "params", "message", desc)|
           indent(4)}}
       // A null |impl| means no implementation was bound.
       assert(impl);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       mojo::internal::MessageDispatchContext context(message);
       impl->{{method.name}}({{pass_params(method.parameters)}});
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }
 
 // static
 bool {{class_name}}StubDispatch::AcceptWithResponder(
     {{interface.name}}* impl,
-    mojo::internal::SerializationContext* context,
     mojo::Message* message,
     mojo::MessageReceiverWithStatus* 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());
 
 {%-       set desc = class_name~"::"~method.name %}
-      {{alloc_params(method.param_struct, "params", "message", "context", desc)|
+      {{alloc_params(method.param_struct, "params", "message", desc)|
           indent(4)}}
       {{class_name}}::{{method.name}}Callback callback =
           {{class_name}}_{{method.name}}_ProxyToResponder::CreateCallback(
               message->request_id(),
-              message->has_flag(mojo::Message::kFlagIsSync), responder,
-              context->group_controller);
+              message->has_flag(mojo::Message::kFlagIsSync), responder);
       // A null |impl| means no implementation was bound.
       assert(impl);
       TRACE_EVENT0("mojom", "{{class_name}}::{{method.name}}");
       mojo::internal::MessageDispatchContext context(message);
       impl->{{method.name}}(
 {%- if method.parameters -%}{{pass_params(method.parameters)}}, {% endif -%}std::move(callback));
       return true;
 {%-     else %}
       break;
 {%-     endif %}
     }
 {%-   endfor %}
   }
 {%- endif %}
   return false;
 }
 
 {#--- Request validator definitions #}
 
 bool {{class_name}}RequestValidator::Accept(mojo::Message* message) {
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
     return true;
 
   mojo::internal::ValidationContext validation_context(
-    message->data(), message->data_num_bytes(), message->handles()->size(),
-    message, "{{class_name}} RequestValidator");
+    message->payload(), message->payload_num_bytes(),
+    message->handles()->size(), message->payload_num_interface_ids(), message,
+    "{{class_name}} RequestValidator");
 
   switch (message->header()->name) {
 {%- for method in interface.methods %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
 {%-   if method.response_parameters != None %}
       if (!mojo::internal::ValidateMessageIsRequestExpectingResponse(
               message, &validation_context)) {
         return false;
       }
 {%-   else %}
@@ skipping 21 matching lines @@
   return false;
 }
 
 {#--- Response validator definitions #}
 {% if interface|has_callbacks %}
 bool {{class_name}}ResponseValidator::Accept(mojo::Message* message) {
   if (mojo::internal::ControlMessageHandler::IsControlMessage(message))
     return true;
 
   mojo::internal::ValidationContext validation_context(
-    message->data(), message->data_num_bytes(), message->handles()->size(),
-    message, "{{class_name}} ResponseValidator");
+    message->payload(), message->payload_num_bytes(),
+    message->handles()->size(), message->payload_num_interface_ids(), message,
+    "{{class_name}} ResponseValidator");
 
   if (!mojo::internal::ValidateMessageIsResponse(message, &validation_context))
     return false;
   switch (message->header()->name) {
 {%- for method in interface.methods if method.response_parameters != None %}
     case internal::k{{class_name}}_{{method.name}}_Name: {
       if (!mojo::internal::ValidateMessagePayload<
                internal::{{class_name}}_{{method.name}}_ResponseParams_Data>(
                     message, &validation_context)) {
         return false;
       }
       return true;
     }
 {%- endfor %}
     default:
       break;
   }
 
   // Unrecognized message.
   ReportValidationError(
       &validation_context,
       mojo::internal::VALIDATION_ERROR_MESSAGE_HEADER_UNKNOWN_METHOD);
   return false;
 }
 {%- endif -%}