Dart bindings: support struct versioning.

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

 {#--- Begin #}
 
 {%- macro encode(variable, kind, offset, bit, level=0, check_for_null=True) %}
 {%- if kind|is_pointer_array_kind %}
 {%- set sub_kind = kind.kind %}
 {%-   if check_for_null %}
 if ({{variable}} == null) {
   encoder{{level}}.encodeNullPointer({{offset}}, {{kind|is_nullable_kind|dart_true_false}});
 } else {
 {%-   else %}
@@ skipping 56 matching lines @@
 }
 {%-   endif %}
 {%- else %}
 {{variable}} = decoder{{level}}.{{kind|decode_method(offset, bit)}};
 {%- endif %}
 {%- endmacro %}
 
 
 {%- macro struct_def(struct) %}
 class {{struct|name}} extends bindings.Struct {
-  static const int kStructSize = {{struct.versions[-1].num_bytes}};
-  static const bindings.StructDataHeader kDefaultStructInfo =
-      const bindings.StructDataHeader(kStructSize, {{struct.versions[-1].version}});
+  static const List<bindings.StructDataHeader> kVersions = const [
+{%- for version in struct.versions %}
+    const bindings.StructDataHeader({{version.num_bytes}}, {{version.version}}){% if not loop.last %},{% endif %}
+{%- endfor %}
+  ];
 
 {#--- Enums #}
 {%- from "enum_definition.tmpl" import enum_def %}
 {%-  for enum in struct.enums %}
   {{enum_def("  static ", enum)}}
 {%-  endfor %}
 
 
 {#--- Constants #}
 {%-  for constant in struct.constants %}
   static final {{constant.name}} = {{constant.value|expression_to_text}};
 {%-  endfor %}
 
 {#--- initDefaults() #}
 {%- for packed_field in struct.packed.packed_fields %}
   {{packed_field.field.kind|dart_type}} {{packed_field.field|name}} = {{packed_field.field|default_value}};
 {%- endfor %}
 
-  {{struct|name}}() : super(kStructSize);
+  {{struct|name}}() : super(kVersions.last.size);
 
   static {{struct|name}} deserialize(bindings.Message message) {
     return decode(new bindings.Decoder(message));
   }
 
   static {{struct|name}} decode(bindings.Decoder decoder0) {
     if (decoder0 == null) {
       return null;
     }
     {{struct|name}} result = new {{struct|name}}();
 
     var mainDataHeader = decoder0.decodeStructDataHeader();
-    if ((mainDataHeader.size < kStructSize) ||
-        (mainDataHeader.version < {{struct.versions[-1].version}})) {
-      throw new bindings.MojoCodecError('Malformed header');
+    if (mainDataHeader.version <= kVersions.last.version) {

[zra, 2015/03/31 14:46:41]

I may not understand what the intended semantics are, but it looks like an
incoming message can have a crazy version number (> kVersions.last.version) so
long as the message size matches the size of a known version. I guess that would
allow inc'ing the version number without changing the message size. Is that the
intention here?

[yzshen1, 2015/03/31 15:26:26]

Encountering a version number bigger than the latest version number that we know
about is possible. It means the other side is built with a newer version of the
API definition. In this case, those unknown fields are simply ignored by us.

Also, it is possible that in some cases we increase the version number (adding
more fields) without increasing the message size, because our packing algorithm
places a newly-added field in the first big-enough "hole" in the layout, which
may be some padding area in the middle.

+      // Scan in reverse order to optimize for more recent versions.
+      for (int i = kVersions.length - 1; i >= 0; --i) {
+        if (mainDataHeader.version >= kVersions[i].version) {
+          if (mainDataHeader.size != kVersions[i].size)
+            throw new bindings.MojoCodecError(
+                'Header doesn\'t correspond to any known version.');
+        }
+      }
+    } else if (mainDataHeader.size < kVersions.last.size) {
+      throw new bindings.MojoCodecError(
+        'Message newer than the last known version cannot be shorter than '
+        'required by the last known version.');
     }
 
 {%- for byte in struct.bytes %}
 {%-   for packed_field in byte.packed_fields %}
-    {
+    if (mainDataHeader.version >= {{packed_field.min_version}}) {
       {{decode('result.' ~ packed_field.field|name, packed_field.field.kind, 8+packed_field.offset, packed_field.bit)|indent(6)}}
     }
 {%-   endfor %}
 {%- endfor %}
     return result;
   }
 
   void encode(bindings.Encoder encoder) {
 {%- if not struct.bytes %}
-    encoder.getStructEncoderAtOffset(kDefaultStructInfo);
+    encoder.getStructEncoderAtOffset(kVersions.last);
 {%- else %}
-    var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo);
+    var encoder0 = encoder.getStructEncoderAtOffset(kVersions.last);
 {%- endif %}
 {%- for byte in struct.bytes %}
 {%-   for packed_field in byte.packed_fields %}
     {{encode(packed_field.field|name, packed_field.field.kind, 8+packed_field.offset, packed_field.bit)|indent(4)}}
 {%-   endfor %}
 {%- endfor %}
   }
 
   String toString() {
     return "{{struct|name}}("
 {%- for packed_field in struct.packed.packed_fields %}
            "{{packed_field.field|name}}: ${{packed_field.field|name}}" {% if not loop.last %}", "{% endif %}
 {%- endfor %}")";
   }
 }
 {%- endmacro %}