Mojo C++ bindings: associated interface pointers/requests validation

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

 {%- set class_name = struct.name ~ "_Data" %}
 
-{#- TODO(yzshen): Consider eliminating _validate_object() and
-    _validate_handle(). #}
-
 {#- Validates the specified struct field, which is supposed to be an object
     (struct/array/string/map/union).
     This macro is expanded by the Validate() method. #}
 {%- macro _validate_object(struct, packed_field) %}
 {%-   set name = packed_field.field.name %}
 {%-   set kind = packed_field.field.kind %}
-{%-   set wrapper_type = kind|cpp_wrapper_type %}
 {%-   if not kind|is_nullable_kind %}
 {%-     if kind|is_union_kind %}
-  if (object->{{name}}.is_null()) {
-{%-     else %}
-  if (!object->{{name}}.offset) {
-{%-     endif %}
-    ReportValidationError(
-        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
-        "null {{name}} field in {{struct.name}} struct");
+  if (!mojo::internal::ValidateInlinedUnionNonNullable(
+          object->{{name}}, "null {{name}} field in {{struct.name}} struct")) {
     return false;
   }
-{%-   endif %}
-{%-   if not kind|is_union_kind %}
-  if (!mojo::internal::ValidateEncodedPointer(&object->{{name}}.offset)) {
-    ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_POINTER);
+{%-     else %}
+  if (!mojo::internal::ValidatePointerNonNullable(
+          object->{{name}}, "null {{name}} field in {{struct.name}} struct")) {
     return false;
   }
+{%-     endif %}
 {%-   endif %}
 {%-   if kind|is_array_kind or kind|is_string_kind %}
   const mojo::internal::ArrayValidateParams {{name}}_validate_params(
       {{kind|get_array_validate_params_ctor_args|indent(6)}});
-  if (!{{wrapper_type}}::Data_::Validate(
-              mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
-              bounds_checker, &{{name}}_validate_params)) {
+  if (!mojo::internal::ValidateArray(object->{{name}}, bounds_checker,
+                                     &{{name}}_validate_params)) {
+    return false;
+  }
 {%-   elif kind|is_map_kind %}
   const mojo::internal::ArrayValidateParams {{name}}_validate_params(
       {{kind.value_kind|get_map_validate_params_ctor_args|indent(6)}});
-  if (!{{wrapper_type}}::Data_::Validate(
-              mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
-              bounds_checker, &{{name}}_validate_params)) {
-{%-   elif kind|is_struct_kind %}
-  if (!{{kind|get_name_for_kind}}::Data_::Validate(
-          mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
-          bounds_checker)) {
-{%-   elif kind|is_union_kind %}
-  if (!{{kind|get_name_for_kind}}::Data_::Validate(
-          &object->{{name}}, bounds_checker, true)) {
-{%-   else %}
-  if (!{{wrapper_type}}::Data_::Validate(
-          mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
-          bounds_checker)) {
-{%-   endif %}
+  if (!mojo::internal::ValidateMap(object->{{name}}, bounds_checker,
+                                   &{{name}}_validate_params)) {
     return false;
   }
+{%-   elif kind|is_struct_kind %}
+  if (!mojo::internal::ValidateStruct(object->{{name}}, bounds_checker))
+    return false;
+{%-   elif kind|is_union_kind %}
+  if (!mojo::internal::ValidateInlinedUnion(object->{{name}}, bounds_checker)) {
+    return false;
+  }
+{%-   else %}
+#error Not reached!
+{%-   endif %}
 {%- endmacro %}
 
 {#- Validates the specified struct field, which is supposed to be a handle or
     contain a handle (in the case of interfaces).
     This macro is expanded by the Validate() method. #}
 {%- macro _validate_handle(struct, packed_field) %}
 {%-   set name = packed_field.field.name %}
 {%-   set kind = packed_field.field.kind %}
 {%-   if kind|is_interface_kind %}
   const mojo::Handle {{name}}_handle = object->{{name}}.handle;
 {%-   else %}
   const mojo::Handle {{name}}_handle = object->{{name}};
 {%-   endif %}
 {%-   if not kind|is_nullable_kind %}
-  if ({{name}}_handle.value() == mojo::internal::kEncodedInvalidHandleValue) {
-    ReportValidationError(
-        mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
-        "invalid {{name}} field in {{struct.name}} struct");
+  if (!mojo::internal::ValidateHandleNonNullable(
+          {{name}}_handle,
+          "invalid {{name}} field in {{struct.name}} struct")) {
     return false;
   }
 {%-   endif %}
-  if (!bounds_checker->ClaimHandle({{name}}_handle)) {
-    ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_HANDLE);
+  if (!mojo::internal::ValidateHandle({{name}}_handle, bounds_checker))
     return false;
-  }
 {%- endmacro %}
 
 {#- Validates the specified struct field, which is supposed to be an associated
     interface or an associated interface request.
     This macro is expanded by the Validate() method. #}
 {%- macro _validate_associated(struct, packed_field) %}
-  // TODO(yzshen): add validation for associated kinds.
+{%-   set name = packed_field.field.name %}
+{%-   set kind = packed_field.field.kind %}
+{%-   if kind|is_associated_interface_kind %}
+  const mojo::internal::InterfaceId {{name}}_interface_id =
+      object->{{name}}.interface_id;
+{%-   else %}
+  const mojo::internal::InterfaceId {{name}}_interface_id = object->{{name}};
+{%-   endif %}
+{%-   if not kind|is_nullable_kind %}
+  if (!mojo::internal::ValidateInterfaceIdNonNullable(
+          {{name}}_interface_id,
+          "invalid {{name}} field in {{struct.name}} struct")) {
+    return false;
+  }
+{%-   endif %}
+  if (!mojo::internal::ValidateAssociatedInterfaceId({{name}}_interface_id))
+    return false;
 {%- endmacro %}
 
 // static
 {{class_name}}* {{class_name}}::New(mojo::internal::Buffer* buf) {
   return new (buf->Allocate(sizeof({{class_name}}))) {{class_name}}();
 }
 
 // static
 bool {{class_name}}::Validate(const void* data,
                               mojo::internal::BoundsChecker* bounds_checker) {
@@ skipping 103 matching lines @@
   mojo::internal::DecodeHandle(&{{name}}, handles);
 {%-     endif %}
 {%-   endif %}
 {%- endfor %}
 }
 
 {{class_name}}::{{class_name}}() {
   header_.num_bytes = sizeof(*this);
   header_.version = {{struct.versions[-1].version}};
 }