Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

third_party/mojo/src/mojo/public/python/mojo_bindings/descriptor.py

 # Copyright 2014 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.
 
 """
 The descriptors used to define generated elements of the mojo python bindings.
 """
 
 import array
 import itertools
@@ skipping 16 matching lines @@
     """
     return value
 
   def GetDefaultValue(self, value):
     """
     Returns the default value for this type associated with the given value.
     This method must be able to correcly handle value being None.
     """
     return self.Convert(value)
 
+  def IsUnion(self):
+    """
+    Returns true if the type is a union. This is necessary to be able to
+    identify a union when descriptor.py cannot be imported.
+    """
+    return False
+
 
 class SerializableType(Type):
   """Describe a type that can be serialized by itself."""
 
   def __init__(self, typecode):
     Type.__init__(self)
     self.typecode = typecode
     self.byte_size = struct.calcsize('<%s' % self.GetTypeCode())
 
   def GetTypeCode(self):
@@ skipping 99 matching lines @@
   """Type object for floating point number types."""
 
   def Convert(self, value):
     if value is None:
       raise TypeError('None is not an floating point number.')
     if not isinstance(value, (int, long, float)):
       raise TypeError('%r is not a numeric type' % value)
     return float(value)
 
 
+class UnionType(SerializableType):
+  """Base Type object for union."""
+
+  def __init__(self, union_type_getter, nullable=False):
+    SerializableType.__init__(self, 'IIQ')
+    self.nullable = nullable
+    self._union_type_getter = union_type_getter
+    self._union_type = None
+
+  def IsUnion(self):
+    return True
+
+  @property
+  def union_type(self):
+    if not self._union_type:
+      self._union_type = self._union_type_getter()
+    return self._union_type
+
+  def Serialize(self, value, data_offset, data, handle_offset):
+    if not value:
+      if not self.nullable:
+        raise serialization.SerializationException(
+            'Trying to serialize null for non nullable type.')
+      return ((0, 0, 0), [])
+
+    ((size, tag, entry, new_data), new_handles) = (
+        value.SerializeInline(handle_offset))
+    if len(new_data) > 0:
+      data.extend(new_data)
+      entry = data_offset - 8
+
+    return ((size, tag, entry), new_handles)
+
+  def Deserialize(self, value, context):
+    result = self.union_type.Deserialize(context)
+    if not result and not self.nullable:
+      raise serialization.DeserializationException(
+          'Trying to deserialize null for non nullable type.')
+    return result
+
+
 class PointerType(SerializableType):
   """Base Type object for pointers."""
 
   def __init__(self, nullable=False):
     SerializableType.__init__(self, 'Q')
     self.nullable = nullable
 
   def Serialize(self, value, data_offset, data, handle_offset):
     if value is None and not self.nullable:
       raise serialization.SerializationException(
@@ skipping 261 matching lines @@
     to_pack = []
     for item in value:
       (new_data, new_handles) = self.sub_type.Serialize(
           item,
           len(data) - position,
           data,
           handle_offset + len(returned_handles))
       to_pack.extend(serialization.Flatten(new_data))
       returned_handles.extend(new_handles)
       position = position + self.sub_type.GetByteSize()
+
     serialization.HEADER_STRUCT.pack_into(data, data_end, size, len(value))
-    struct.pack_into('%d%s' % (len(value), self.sub_type.GetTypeCode()),
+    # TODO(azani): Refactor so we don't have to create big formatting strings.
+    struct.pack_into(('%s' % self.sub_type.GetTypeCode()) * len(value),
                      data,
                      data_end + serialization.HEADER_STRUCT.size,
                      *to_pack)
     return (data_offset, returned_handles)
 
   def DeserializeArray(self, size, nb_elements, context):
+    # TODO(azani): Refactor so the format string isn't so big.
     values = struct.unpack_from(
-        '%d%s' % (nb_elements, self.sub_type.GetTypeCode()),
+        nb_elements * self.sub_type.GetTypeCode(),
         buffer(context.data, serialization.HEADER_STRUCT.size))
     values_per_element = len(self.sub_type.GetTypeCode())
     assert nb_elements * values_per_element == len(values)
 
     result = []
     sub_context = context.GetSubContext(serialization.HEADER_STRUCT.size)
     for index in xrange(nb_elements):
       if values_per_element == 1:
         value = values[index]
       else:
@@ skipping 292 matching lines @@
 
 
 def _ConvertByteToBooleans(value, min_size=0):
   """Unpack an integer into a list of booleans."""
   res = []
   while value:
     res.append(bool(value&1))
     value = value / 2
   res.extend([False] * (min_size - len(res)))
   return res