Mojo C++ bindings: support enum validation.

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

 {%- set class_name = struct.name ~ "_Data" %}
 
 {#- 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 %}
 {%-   if not kind|is_nullable_kind %}
 {%-     if kind|is_union_kind %}
@@ skipping 73 matching lines @@
   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 %}
 
+{#- Validates the specified struct field, which is supposed to be an enum.
+    This macro is expanded by the Validate() method. #}
+{%- macro _validate_enum(struct, packed_field) %}
+{%-   set name = packed_field.field.name %}
+{%-   set kind = packed_field.field.kind %}
+  if (!mojo::internal::ValidateEnum(object->{{name}}))
+    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) {
   if (!data)
     return true;
@@ skipping 35 matching lines @@
   }
 
 {#- Before validating fields introduced at a certain version, we need to add
     a version check, which makes sure we skip further validation if |object|
     is from an earlier version. |last_checked_version| records the last
     version that we have added such version check. #}
 {%- set last_checked_version = 0 %}
 {%- for packed_field in struct.packed.packed_fields_in_ordinal_order %}
 {%-   set kind = packed_field.field.kind %}
 {%-   if kind|is_object_kind or kind|is_any_handle_kind or
-         kind|is_interface_kind or kind|is_associated_kind %}
+         kind|is_interface_kind or kind|is_associated_kind or
+         kind|is_enum_kind %}
 {%-     if packed_field.min_version > last_checked_version %}
 {%-       set last_checked_version = packed_field.min_version %}
   if (object->header_.version < {{packed_field.min_version}})
     return true;
 {%-     endif %}
 {%-     if kind|is_object_kind %}
 {{_validate_object(struct, packed_field)}}
 {%-     elif kind|is_any_handle_kind or kind|is_interface_kind %}
 {{_validate_handle(struct, packed_field)}}
+{%-     elif kind|is_associated_kind %}
+{{_validate_associated(struct, packed_field)}}
 {%-     else %}
-{{_validate_associated(struct, packed_field)}}
+{{_validate_enum(struct, packed_field)}}
 {%-     endif %}
 {%-   endif %}
 {%- endfor %}
 
   return true;
 }
 
 void {{class_name}}::EncodePointersAndHandles(
     std::vector<mojo::Handle>* handles) {
   MOJO_CHECK(header_.version == {{struct.versions[-1].version}});
@@ skipping 34 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}};
 }