mojo::Serialize*_() calls now propogate/return validation errors.

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

 {#  TODO(yzshen): Make these templates more readable. #}
 
 {#  Computes the serialized size for the specified struct.
     |struct| is the struct definition.
     |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.
     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) -%}
   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 %}
 {%-     if pf.field.kind|is_union_kind %}
   size += GetSerializedSize_({{input_field_pattern|format(pf.field.name)}}, true);
 {%-     elif pf.field.kind|is_struct_kind %}
   size += {{input_field_pattern|format(pf.field.name)}}.is_null()
               ? 0
               : GetSerializedSize_(*{{input_field_pattern|format(pf.field.name)}});
 {%-     else %}
   size += GetSerializedSize_({{input_field_pattern|format(pf.field.name)}});
 {%-     endif %}
 {%-   endfor %}
 {%- endmacro -%}
 
+{# A private macro that prints the C++ log-and-report macro, or test-and-return

[viettrungluu, 2015/10/06 16:40:06]

Why do we need to generate two versions?

[vardhan, 2015/10/06 22:57:14]

Done. (no longer relevant after some changes based on your comments in another
file).

+   macro depending on |should_return_errors|  #}
+{%- macro _validation_check_macro(should_return_errors=false) -%}
+{%- if should_return_errors -%}
+MOJO_INTERNAL_SERIALIZATION_CHECK_AND_RETURN
+{%- else -%}
+MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING
+{%- endif -%}
+{%- endmacro -%}
+
+{# The following 4 macros call |SerializeArray_|, |SerializeMap_|,
+   |SerializeUnion_| and |Serialize_| respectively.  If |should_return_error|
+   is true, these macros do the extra work of propagating non-successful error
+   codes. #} 
+{%- macro call_serialize_array(name, kind, input, buffer, output,
+                               should_return_errors, indent_size) -%}
+  {
+    const mojo::internal::ArrayValidateParams {{name}}_validate_params(
+      {{kind|get_array_validate_params_ctor_args|indent(indent_size)}});
+{%-       if should_return_errors -%}
+    auto retval =
+{%-       endif -%}
+    mojo::SerializeArray_({{input}}, {{buffer}}, {{output}},
+                          &{{name}}_validate_params);
+{%-       if should_return_errors %}
+    if (retval != mojo::internal::ValidationError::VALIDATION_ERROR_NONE)
+      return retval;
+{%-       endif %}
+  }
+{%- endmacro -%}
+
+{%- macro call_serialize_map(name, kind, input, buffer, output,
+                             should_return_errors, indent_size) -%}
+  {
+    const mojo::internal::ArrayValidateParams {{name}}_validate_params(
+        {{kind.value_kind|get_map_validate_params_ctor_args|indent(indent_size)}});
+{%- if should_return_errors -%}
+    auto retval =
+{%- endif -%}
+    mojo::SerializeMap_(
+        {{input}}, {{buffer}}, {{output}},
+        &{{name}}_validate_params);
+{%- if should_return_errors %}
+    if (retval != mojo::internal::ValidationError::VALIDATION_ERROR_NONE)
+      return retval;
+{%- endif %}
+  }
+{%- endmacro -%}
+
+{%- macro call_serialize_union(input, buffer, output, inlined,
+                               should_return_errors) -%}  
+  {
+{%- if should_return_errors -%}
+    auto retval =
+{%- endif -%}
+    SerializeUnion_({{input}},
+                    {{buffer}},
+                    {{output}},
+                    {{inlined}});
+{%- if should_return_errors %}
+    if (retval != mojo::internal::ValidationError::VALIDATION_ERROR_NONE)
+      return retval;
+{%- endif %}
+  }
+{%- endmacro -%}
+
+{%- macro call_serialize_struct(input, buffer, output, should_return_errors) -%}  
+  {
+{%- if should_return_errors -%}
+    auto retval =
+{%- endif -%}
+    Serialize_({{input}},
+               {{buffer}},
+               {{output}});
+{%- if should_return_errors %}
+    if (retval != mojo::internal::ValidationError::VALIDATION_ERROR_NONE)
+      return retval;
+{%- endif %}
+  }
+{%- endmacro -%}
+
 {#  Serializes the specified struct.
     |struct| is the struct definition.
     |struct_display_name| is the display name for the struct that can be showed
     in error/log messages, for example, "FooStruct", "FooMethod request".
     |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.
     |output| is the name of the output struct instance.
     |buffer| is the name of the Buffer instance used.
+    |should_return_errors| is true if validation errors need to be return'd. 
+    This is needed when serializing interface parameters, where you cannot
+    return.
+
     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) -%}
+      arguments.
+    This macro is expanded within the C++ struct serialization methods #}
+{%- macro serialize(struct, struct_display_name, input_field_pattern,
+                    output, buffer, should_return_errors=false) -%}
   internal::{{struct.name}}_Data* {{output}} =
       internal::{{struct.name}}_Data::New({{buffer}});
 {%- for pf in struct.packed.packed_fields_in_ordinal_order %}
 {%-   set input_field = input_field_pattern|format(pf.field.name) %}
 {%-   set name = pf.field.name %}
 {%-   set kind = pf.field.kind %}
 {%-   if kind|is_object_kind %}
 {%-     if kind|is_array_kind %}
-  const mojo::internal::ArrayValidateParams {{name}}_validate_params(
-      {{kind|get_array_validate_params_ctor_args|indent(10)}});
-  mojo::SerializeArray_(&{{input_field}}, {{buffer}},
-      &{{output}}->{{name}}.ptr, &{{name}}_validate_params);
+  {{call_serialize_array(name = name,
+                         kind = kind,
+                         input = '&' ~ input_field,
+                         buffer = buffer,
+                         output = "&%s->%s.ptr"|format(output,name),
+                         should_return_errors = should_return_errors,
+                         indent_size = 10)}}
 {%-     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_(
-      &{{input_field}}, {{buffer}}, &{{output}}->{{name}}.ptr,
-      &{{name}}_validate_params);
+  {{call_serialize_map(name = name,
+                       kind = kind,
+                       input = '&' ~ input_field,
+                       buffer = buffer,
+                       output = '&%s->%s.ptr'|format(output,name),
+                       should_return_errors = should_return_errors,
+                       indent_size = 10)}}
 {%-     elif kind|is_union_kind %}
   internal::{{kind.name}}_Data* {{name}}_ptr = &{{output}}->{{name}};
-  SerializeUnion_({{input_field}}.get(), {{buffer}}, &{{name}}_ptr, true);
+  {{call_serialize_union(input = input_field ~ ".get()",
+                         buffer = buffer,
+                         output = "&%s_ptr"|format(name),
+                         inlined = "true",
+                         should_return_errors = should_return_errors)}}
 {%-     elif kind|is_string_kind %}
   SerializeString_({{input_field}}, {{buffer}}, &{{output}}->{{name}}.ptr);
 {%-     else %}
-  Serialize_({{input_field}}.get(), {{buffer}}, &{{output}}->{{name}}.ptr);
+  {{call_serialize_struct(input = input_field ~ ".get()",
+                          buffer = buffer,
+                          output = "&%s->%s.ptr"|format(output,name),
+                          should_return_errors = should_return_errors)}}
 {%-     endif %}
 {%-     if not kind|is_nullable_kind %}
-  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+  {{_validation_check_macro(should_return_errors)}}(
 {%-       if kind|is_union_kind %}
       {{output}}->{{name}}.is_null(),
 {%-       else %}
       !{{output}}->{{name}}.ptr,
 {%-       endif %}
-      mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+      mojo::internal::ValidationError::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
       "null {{name}} in {{struct_display_name}}");
 {%-     endif %}
 {%-   elif kind|is_any_handle_kind or kind|is_interface_kind %}
 {%-     if kind|is_interface_kind %}
   mojo::internal::InterfacePointerToData({{input_field}}.Pass(), &{{output}}->{{name}});
 {%-     elif kind|is_interface_request_kind %}
   {{output}}->{{name}} = {{input_field}}.PassMessagePipe().release();
 {%-     else %}
   {{output}}->{{name}} = {{input_field}}.release();
 {%-     endif %}
 {%-     if not kind|is_nullable_kind %}
-  MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
+  {{_validation_check_macro(should_return_errors)}}(
 {%-       if kind|is_interface_kind %}
       !{{output}}->{{name}}.handle.is_valid(),
 {%-       else %}
       !{{output}}->{{name}}.is_valid(),
 {%-       endif %}
-      mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+      mojo::internal::ValidationError::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
       "invalid {{name}} in {{struct_display_name}}");
 {%-     endif %}
 {%-   elif kind|is_enum_kind %}
   {{output}}->{{name}} =
     static_cast<int32_t>({{input_field}});
 {%-   else %}
   {{output}}->{{name}} = {{input_field}};
 {%-   endif %}
 {%- endfor %}
 {%- endmacro -%}
@@ skipping 47 matching lines @@
 {%-     elif kind|is_any_handle_kind %}
     {{output_field}}.reset(mojo::internal::FetchAndReset(&{{input}}->{{name}}));
 {%-     elif kind|is_enum_kind %}
     {{output_field}} = static_cast<{{kind|cpp_wrapper_type}}>({{input}}->{{name}});
 {%-     else %}
     {{output_field}} = {{input}}->{{name}};
 {%-     endif %}
 {%-   endfor %}
   } while (false);
 {%- endmacro %}