Adding whether a given field is filling a hole.

mojo/public/tools/bindings/pylib/mojom/generate/pack.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import module as mojom
 
 # This module provides a mechanism for determining the packed order and offsets
 # of a mojom.Struct.
 #
 # ps = pack.PackedStruct(struct)
@@ skipping 33 matching lines @@
     if not kind in cls.kind_to_size:
       raise Exception("Invalid kind: %s" % kind.spec)
     return cls.kind_to_size[kind]
 
   def __init__(self, field, ordinal):
     self.field = field
     self.ordinal = ordinal
     self.size = self.GetSizeForKind(field.kind)
     self.offset = None
     self.bit = None
+    self.in_hole = False
 
 
 # Returns the pad necessary to reserve space for alignment of |size|.
 def GetPad(offset, size):
   return (size - (offset % size)) % size
 
 
 # Returns a 2-tuple of the field offset and bit (for BOOLs)
 def GetFieldOffset(field, last_field):
   if field.field.kind == mojom.BOOL and \
@@ skipping 35 matching lines @@
     # Then find first slot that each field will fit.
     for src_field in src_fields[1:]:
       last_field = dst_fields[0]
       for i in xrange(1, len(dst_fields)):
         next_field = dst_fields[i]
         offset, bit = GetFieldOffset(src_field, last_field)
         if offset + src_field.size <= next_field.offset:
           # Found hole.
           src_field.offset = offset
           src_field.bit = bit
+          src_field.in_hole = True
           dst_fields.insert(i, src_field)
           break
         last_field = next_field
       if src_field.offset is None:
         # Add to end
         src_field.offset, src_field.bit = GetFieldOffset(src_field, last_field)
         dst_fields.append(src_field)
 
   def GetTotalSize(self):
     if not self.packed_fields:
@@ skipping 21 matching lines @@
     limit_of_previous_field = packed_field.offset + packed_field.size
 
   for i in xrange(limit_of_previous_field, len(bytes)):
     bytes[i].is_padding = True
 
   for byte in bytes:
     # A given byte cannot both be padding and have a fields packed into it.
     assert not (byte.is_padding and byte.packed_fields)
 
   return bytes