Mojo C++ bindings: pass SerializationContext to GetSerializedSize_() and Serialize_().

The context will be useful for:
- WTF::String serialization. We need to create WTF::StringUTF8Adapter objects for non-8-bit WTF::Strings and share them between GetSerializedSize_() and Serialize_().
- adding DCHECKs for sending associated interface pointers/requests over correct message pipe.

BUG=583738

Review URL: https://codereview.chromium.org/1752133003

Cr-Commit-Position: refs/heads/master@{#378753}

6 files changed, 77 insertions, 42 deletions

diff --git a/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl
index 1031ba6..8b20615 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl
@@ -26,8 +26,11 @@ p_{{param.name}}
 {%-   endfor %}
 {%- endmacro %}
 
-{%- macro build_message(struct, input_pattern, struct_display_name) -%}
-  {{struct_macros.serialize(struct, struct_display_name, input_pattern, "params", "builder.buffer()")}}
+{%- 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)}}
   params->EncodePointersAndHandles(builder.message()->mutable_handles());
 {%- endmacro %}
 
@@ -135,12 +138,14 @@ bool {{class_name}}_{{method.name}}_ForwardToCallback::Accept(
 {%-   if method.sync %}
 bool {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_sync_method_params("param_", method)}}) {
-  {{struct_macros.get_serialized_size(params_struct, "param_%s")}}
+  {{struct_macros.get_serialized_size(params_struct, "param_%s",
+                                      "&serialization_context_")}}
 
   mojo::internal::RequestMessageBuilder builder({{message_name}}, size,
                                                 mojo::internal::kMessageIsSync);
 
-  {{build_message(params_struct, "param_%s", params_description)}}
+  {{build_message(params_struct, "param_%s", params_description,
+                  "&serialization_context_")}}
 
   bool result = false;
   mojo::MessageReceiver* responder =
@@ -157,7 +162,8 @@ bool {{proxy_name}}::{{method.name}}(
 
 void {{proxy_name}}::{{method.name}}(
     {{interface_macros.declare_request_params("in_", method)}}) {
-  {{struct_macros.get_serialized_size(params_struct, "in_%s")}}
+  {{struct_macros.get_serialized_size(params_struct, "in_%s",
+                                      "&serialization_context_")}}
 
 {%- if method.response_parameters != None %}
   mojo::internal::RequestMessageBuilder builder({{message_name}}, size);
@@ -165,7 +171,8 @@ void {{proxy_name}}::{{method.name}}(
   mojo::internal::MessageBuilder builder({{message_name}}, size);
 {%- endif %}
 
-  {{build_message(params_struct, "in_%s", params_description)}}
+  {{build_message(params_struct, "in_%s", params_description,
+                  "&serialization_context_")}}
 
 {%- if method.response_parameters != None %}
   mojo::MessageReceiver* responder =
@@ -207,10 +214,12 @@ class {{class_name}}_{{method.name}}_ProxyToResponder
   {{class_name}}_{{method.name}}_ProxyToResponder(
       uint64_t request_id,
       bool is_sync,
-      mojo::MessageReceiverWithStatus* responder)
+      mojo::MessageReceiverWithStatus* responder,
+      scoped_refptr<mojo::internal::MultiplexRouter> router)
       : request_id_(request_id),
         is_sync_(is_sync),
-        responder_(responder) {
+        responder_(responder),
+        serialization_context_(std::move(router)) {
   }
 
   void Run({{interface_macros.declare_params("in_", method.response_parameters)}}) const override;
@@ -219,15 +228,19 @@ class {{class_name}}_{{method.name}}_ProxyToResponder
   uint64_t request_id_;
   bool is_sync_;
   mutable mojo::MessageReceiverWithStatus* responder_;
+  // TODO(yzshen): maybe I should use a ref to the original one?
+  mutable mojo::internal::SerializationContext serialization_context_;
   DISALLOW_COPY_AND_ASSIGN({{class_name}}_{{method.name}}_ProxyToResponder);
 };
 void {{class_name}}_{{method.name}}_ProxyToResponder::Run(
     {{interface_macros.declare_params("in_", method.response_parameters)}}) const {
-  {{struct_macros.get_serialized_size(response_params_struct, "in_%s")}}
+  {{struct_macros.get_serialized_size(response_params_struct, "in_%s",
+                                      "&serialization_context_")}}
   mojo::internal::ResponseMessageBuilder builder(
       {{message_name}}, size, request_id_,
       is_sync_ ? mojo::internal::kMessageIsSync : 0);
-  {{build_message(response_params_struct, "in_%s", params_description)}}
+  {{build_message(response_params_struct, "in_%s", params_description,
+                  "&serialization_context_")}}
   bool ok = responder_->Accept(builder.message());
   MOJO_ALLOW_UNUSED_LOCAL(ok);
   // TODO(darin): !ok returned here indicates a malformed message, and that may
@@ -296,7 +309,8 @@ bool {{class_name}}Stub::AcceptWithResponder(
           new {{class_name}}_{{method.name}}_ProxyToResponder(
               message->request_id(),
               message->has_flag(mojo::internal::kMessageIsSync),
-              responder);
+              responder,
+              serialization_context_.router);
       {{class_name}}::{{method.name}}Callback callback(runnable);
       // A null |sink_| means no implementation was bound.
       assert(sink_);
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/struct_macros.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/struct_macros.tmpl
index 91d0bf1..2d32b59 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/struct_macros.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/struct_macros.tmpl
@@ -5,28 +5,29 @@
     |input_field_pattern| should be a pattern that contains one string
     placeholder, for example, "input->%s", "p_%s". The placeholder will be
     substituted with struct field names to refer to the input fields.
+    |context| is the name of the serialization context.
     This macro is expanded to compute seriailized size for both:
     - user-defined structs: the input is an instance of the corresponding struct
       wrapper class.
     - method parameters/response parameters: the input is a list of
       arguments.
     It declares |size| of type size_t to store the resulting size. #}
-{%- macro get_serialized_size(struct, input_field_pattern) -%}
+{%- macro get_serialized_size(struct, input_field_pattern, context) -%}
   size_t size = sizeof(internal::{{struct.name}}_Data);
 {%-   for pf in struct.packed.packed_fields_in_ordinal_order if pf.field.kind|is_object_kind %}
 {%-     set name = pf.field.name -%}
 {%-     set kind = pf.field.kind -%}
 {%-     if kind|is_native_only_kind and kind|is_typemapped_kind %}
   size += mojo::internal::GetSerializedSizeNative_(
-      {{input_field_pattern|format(name)}});
+      {{input_field_pattern|format(name)}}, {{context}});
 {%-     elif kind|is_typemapped_kind %}
   size +=
       {{kind|get_name_for_kind}}_SerializerTraits_<{{kind|cpp_wrapper_type}}>
           ::GetSize({{input_field_pattern|format(name)}});
 {%-     elif kind|is_union_kind %}
-  size += GetSerializedSize_({{input_field_pattern|format(name)}}, true);
+  size += GetSerializedSize_({{input_field_pattern|format(name)}}, true, {{context}});
 {%-     else %}
-  size += GetSerializedSize_({{input_field_pattern|format(name)}});
+  size += GetSerializedSize_({{input_field_pattern|format(name)}}, {{context}});
 {%-     endif %}
 {%-   endfor %}
 {%- endmacro -%}
@@ -40,12 +41,14 @@
     substituted with struct field names to refer to the input fields.
     |output| is the name of the output struct instance.
     |buffer| is the name of the Buffer instance used.
+    |context| is the name of the serialization context.
     This macro is expanded to do serialization for both:
     - user-defined structs: the input is an instance of the corresponding struct
       wrapper class.
     - method parameters/response parameters: the input is a list of
       arguments. #}
-{%- macro serialize(struct, struct_display_name, input_field_pattern, output, buffer) -%}
+{%- macro serialize(struct, struct_display_name, input_field_pattern, output,
+                    buffer, context) -%}
   internal::{{struct.name}}_Data* {{output}} =
       internal::{{struct.name}}_Data::New({{buffer}});
 {%- for pf in struct.packed.packed_fields_in_ordinal_order %}
@@ -58,23 +61,25 @@
   const mojo::internal::ArrayValidateParams {{name}}_validate_params(
       {{kind|get_array_validate_params_ctor_args|indent(10)}});
   mojo::SerializeArray_(std::move({{input_field}}), {{buffer}},
-      &{{output}}->{{name}}.ptr, &{{name}}_validate_params);
+      &{{output}}->{{name}}.ptr, &{{name}}_validate_params, {{context}});
 {%-     elif kind|is_map_kind %}
   const mojo::internal::ArrayValidateParams {{name}}_validate_params(
       {{kind.value_kind|get_map_validate_params_ctor_args|indent(10)}});
   mojo::SerializeMap_(std::move({{input_field}}), {{buffer}},
-      &{{output}}->{{name}}.ptr, &{{name}}_validate_params);
+      &{{output}}->{{name}}.ptr, &{{name}}_validate_params, {{context}});
 {%-     elif kind|is_native_only_kind and kind|is_typemapped_kind %}
   mojo::internal::SerializeNative_(
-      {{input_field}}, {{buffer}}, &{{output}}->{{name}}.ptr);
+      {{input_field}}, {{buffer}}, &{{output}}->{{name}}.ptr, {{context}});
 {%-     elif kind|is_typemapped_kind %}
   {{kind|get_name_for_kind}}_SerializerTraits_<{{kind|cpp_wrapper_type}}>
       ::Serialize({{input_field}}, {{buffer}}, &{{output}}->{{name}}.ptr);
 {%-     elif kind|is_union_kind %}
   internal::{{kind.name}}_Data* {{name}}_ptr = &{{output}}->{{name}};
-  SerializeUnion_(std::move({{input_field}}), {{buffer}}, &{{name}}_ptr, true);
+  SerializeUnion_(std::move({{input_field}}), {{buffer}}, &{{name}}_ptr, true,
+                  {{context}});
 {%-     else %}
-  Serialize_(std::move({{input_field}}), {{buffer}}, &{{output}}->{{name}}.ptr);
+  Serialize_(std::move({{input_field}}), {{buffer}}, &{{output}}->{{name}}.ptr,
+             {{context}});
 {%-     endif %}
 {%-     if not kind|is_nullable_kind %}
   MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
@@ -125,13 +130,13 @@
     |output_field_pattern| should be a pattern that contains one string
     placeholder, for example, "result->%s", "p_%s". The placeholder will be
     substituted with struct field names to refer to the output fields.
+    |context| is the name of the serialization context.
+    |success| is the name of a bool variable to track success of the operation.
     This macro is expanded to do deserialization for both:
     - user-defined structs: the output is an instance of the corresponding
       struct wrapper class.
     - method parameters/response parameters: the output is a list of
       arguments. #}
-    |context| is the name of the serialization context.
-    |success| is the name of a bool variable to track success of the operation.
 {%- macro deserialize(struct, input, output_field_pattern, context, success) -%}
   do {
     // NOTE: The memory backing |{{input}}| may has be smaller than
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_declaration.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_declaration.tmpl
index d0ef30a4..d5e224b 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_declaration.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_declaration.tmpl
@@ -1,6 +1,8 @@
-size_t GetSerializedSize_(const {{struct.name}}Ptr& input);
+size_t GetSerializedSize_(const {{struct.name}}Ptr& input,
+                          mojo::internal::SerializationContext* context);
 void Serialize_({{struct.name}}Ptr input, mojo::internal::Buffer* buffer,
-                internal::{{struct.name}}_Data** output);
+                internal::{{struct.name}}_Data** output,
+                mojo::internal::SerializationContext* context);
 bool Deserialize_(internal::{{struct.name}}_Data* input,
                   {{struct.name}}Ptr* output,
                   mojo::internal::SerializationContext* context);
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
index 485a8ec..3c4c0ef 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/struct_serialization_definition.tmpl
@@ -1,15 +1,17 @@
 {%- import "struct_macros.tmpl" as struct_macros %}
-size_t GetSerializedSize_(const {{struct.name}}Ptr& input) {
+size_t GetSerializedSize_(const {{struct.name}}Ptr& input,
+                          mojo::internal::SerializationContext* context) {
   if (!input)
     return 0;
-  {{struct_macros.get_serialized_size(struct, "input->%s")}}
+  {{struct_macros.get_serialized_size(struct, "input->%s", "context")}}
   return size;
 }
 
 void Serialize_({{struct.name}}Ptr input, mojo::internal::Buffer* buf,
-                internal::{{struct.name}}_Data** output) {
+                internal::{{struct.name}}_Data** output,
+                mojo::internal::SerializationContext* context) {
   if (input) {
-    {{struct_macros.serialize(struct, struct.name ~ " struct", "input->%s", "result", "buf")|indent(2)}}
+    {{struct_macros.serialize(struct, struct.name ~ " struct", "input->%s", "result", "buf", "context")|indent(2)}}
     *output = result;
   } else {
     *output = nullptr;
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_declaration.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_declaration.tmpl
index 3604763..f2d6a2a 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_declaration.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_declaration.tmpl
@@ -1,6 +1,11 @@
-size_t GetSerializedSize_(const {{union.name}}Ptr& input, bool inlined);
-void SerializeUnion_({{union.name}}Ptr input, mojo::internal::Buffer* buffer,
-                     internal::{{union.name}}_Data** output, bool inlined);
+size_t GetSerializedSize_(const {{union.name}}Ptr& input,
+                          bool inlined,
+                          mojo::internal::SerializationContext* context);
+void SerializeUnion_({{union.name}}Ptr input,
+                     mojo::internal::Buffer* buffer,
+                     internal::{{union.name}}_Data** output,
+                     bool inlined,
+                     mojo::internal::SerializationContext* context);
 bool Deserialize_(internal::{{union.name}}_Data* input,
                   {{union.name}}Ptr* output,
                   mojo::internal::SerializationContext* context);
diff --git a/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl b/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
index 6fde8c9..a7bcc922c 100644
--- a/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
+++ b/mojo/public/tools/bindings/generators/cpp_templates/union_serialization_definition.tmpl
@@ -1,4 +1,6 @@
-size_t GetSerializedSize_(const {{union.name}}Ptr& input, bool inlined) {
+size_t GetSerializedSize_(const {{union.name}}Ptr& input,
+                          bool inlined,
+                          mojo::internal::SerializationContext* context) {
   size_t size = 0U;
   if (!inlined) {
     size += sizeof(internal::{{union.name}}_Data);
@@ -13,9 +15,9 @@ size_t GetSerializedSize_(const {{union.name}}Ptr& input, bool inlined) {
 {%    if field.kind|is_object_kind %}
     case {{union.name}}::Tag::{{field.name|upper}}:
 {%      if field.kind|is_union_kind %}
-      size += GetSerializedSize_(*(input_acc.data()->{{field.name}}), false);
+      size += GetSerializedSize_(*(input_acc.data()->{{field.name}}), false, context);
 {%      else %}
-      size += GetSerializedSize_(*(input_acc.data()->{{field.name}}));
+      size += GetSerializedSize_(*(input_acc.data()->{{field.name}}), context);
 {%      endif %}
       break;
 {%-   endif %}
@@ -26,8 +28,11 @@ size_t GetSerializedSize_(const {{union.name}}Ptr& input, bool inlined) {
   return size;
 }
 
-void SerializeUnion_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
-                     internal::{{union.name}}_Data** output, bool inlined) {
+void SerializeUnion_({{union.name}}Ptr input,
+                     mojo::internal::Buffer* buf,
+                     internal::{{union.name}}_Data** output,
+                     bool inlined,
+                     mojo::internal::SerializationContext* context) {
   internal::{{union.name}}_Data* result = *output;
   if (input) {
     if (!inlined) {
@@ -45,27 +50,29 @@ void SerializeUnion_({{union.name}}Ptr input, mojo::internal::Buffer* buf,
 {%      if field.kind|is_string_kind %}
         Serialize_(
             *(input_acc.data()->{{field.name}}),
-            buf, &result->data.f_{{field.name}}.ptr);
+            buf, &result->data.f_{{field.name}}.ptr, context);
 {%      elif field.kind|is_struct_kind %}
         Serialize_(
             std::move(*(input_acc.data()->{{field.name}})),
-            buf, &result->data.f_{{field.name}}.ptr);
+            buf, &result->data.f_{{field.name}}.ptr, context);
 {%      elif field.kind|is_union_kind %}
         SerializeUnion_(
             std::move(*(input_acc.data()->{{field.name}})),
-            buf, &result->data.f_{{field.name}}.ptr, false);
+            buf, &result->data.f_{{field.name}}.ptr, false, context);
 {%      elif field.kind|is_array_kind %}
         const mojo::internal::ArrayValidateParams {{field.name}}_validate_params(
             {{field.kind|get_array_validate_params_ctor_args|indent(16)}});
         SerializeArray_(
             std::move(*(input_acc.data()->{{field.name}})),
-            buf, &result->data.f_{{field.name}}.ptr, &{{field.name}}_validate_params);
+            buf, &result->data.f_{{field.name}}.ptr,
+            &{{field.name}}_validate_params, context);
 {%      elif field.kind|is_map_kind %}
         const mojo::internal::ArrayValidateParams {{field.name}}_validate_params(
             {{field.kind.value_kind|get_map_validate_params_ctor_args|indent(16)}});
         SerializeMap_(
             std::move(*(input_acc.data()->{{field.name}})),
-            buf, &result->data.f_{{field.name}}.ptr, &{{field.name}}_validate_params);
+            buf, &result->data.f_{{field.name}}.ptr,
+            &{{field.name}}_validate_params, context);
 {%-     endif %}
 {%    elif field.kind|is_any_handle_kind %}
         result->data.f_{{field.name}} =