mojo: Add deserialization to python structs.

This is a reland of https://codereview.chromium.org/578263003 using
buffer instead of memoryview, because on some early version of python
2.7, memoryview cannot be used with struct.unpack_from.

BUG=415491
R=sdefresne@chromium.org,cmasone@chromium.org

Review URL: https://codereview.chromium.org/588493002

Cr-Commit-Position: refs/heads/master@{#295684}

mojo/public/python/mojo/bindings/reflection.py

@@ -107,6 +107,14 @@ class MojoStructType(type):
       return serialization_object.Serialize(self, handle_offset)
     dictionary['Serialize'] = Serialize
 
+    def Deserialize(cls, data, handles):
+      result = cls.__new__(cls)
+      fields = {}
+      serialization_object.Deserialize(fields, data, handles)
+      result._fields = fields
+      return result
+    dictionary['Deserialize'] = classmethod(Deserialize)
+
     return type.__new__(mcs, name, bases, dictionary)
 
   # Prevent adding new attributes, or mutating constants.

mojo/public/python/mojo/bindings/serialization.py

@@ -16,28 +16,42 @@ class SerializationException(Exception):
   pass
 
 
+class DeserializationException(Exception):
+  """Error when strying to deserialize a struct."""
+  pass
+
+
 class Serialization(object):
   """
   Helper class to serialize/deserialize a struct.
   """
   def __init__(self, groups):
-    self._groups = groups
     self.version = _GetVersion(groups)
+    self._groups = groups
     main_struct = _GetStruct(groups)
     self.size = HEADER_STRUCT.size + main_struct.size
     self._struct_per_version = {
-      self.version: main_struct,
+        self.version: main_struct,
+    }
+    self._groups_per_version = {
+        self.version: groups,
     }
 
   def _GetMainStruct(self):
     return self._GetStruct(self.version)
 
+  def _GetGroups(self, version):
+    # If asking for a version greater than the last known.
+    version = min(version, self.version)
+    if version not in self._groups_per_version:
+      self._groups_per_version[version] = _FilterGroups(self._groups, version)
+    return self._groups_per_version[version]
+
   def _GetStruct(self, version):
-    # If asking for a greater ver
+    # If asking for a version greater than the last known.
     version = min(version, self.version)
     if version not in self._struct_per_version:
-      self._struct_per_version[version] = _GetStruct(_FilterGroups(self._groups,
-                                                                   version))
+      self._struct_per_version[version] = _GetStruct(self._GetGroups(version))
     return self._struct_per_version[version]
 
   def Serialize(self, obj, handle_offset):
@@ -64,6 +78,18 @@ class Serialization(object):
     self._GetMainStruct().pack_into(data, HEADER_STRUCT.size, *to_pack)
     return (data, handles)
 
+  def Deserialize(self, fields, data, handles):
+    (_, version) = HEADER_STRUCT.unpack_from(data)
+    version_struct = self._GetStruct(version)
+    entitities = version_struct.unpack_from(data, HEADER_STRUCT.size)
+    filtered_groups = self._GetGroups(version)
+    position = HEADER_STRUCT.size
+    for (group, value) in zip(filtered_groups, entitities):
+      position = position + NeededPaddingForAlignment(position,
+                                                      group.GetByteSize())
+      fields.update(group.Deserialize(value, buffer(data, position), handles))
+      position += group.GetByteSize()
+
 
 def NeededPaddingForAlignment(value, alignment=8):
   """Returns the padding necessary to align value with the given alignment."""
@@ -77,7 +103,7 @@ def _GetVersion(groups):
 
 
 def _FilterGroups(groups, version):
-  return [group for group in groups if group.version < version]
+  return [group for group in groups if group.GetVersion() < version]
 
 
 def _GetStruct(groups):

mojo/python/tests/bindings_serialization_deserialization_unittest.py

@@ -2,19 +2,67 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import math
 import unittest
 
 # pylint: disable=F0401
+import mojo.bindings.reflection as reflection
 import mojo.system
 
 # Generated files
 # pylint: disable=F0401
+import sample_import_mojom
+import sample_import2_mojom
 import sample_service_mojom
 
 
 def _NewHandle():
   return mojo.system.MessagePipe().handle0
 
+
+def _TestEquality(x, y):
+  if x == y:
+    return True
+
+  if type(x) != type(y):
+    print '\n%r != %r. Element are not of the same type.' % (x, y)
+    return False
+
+  if isinstance(x, float) and math.isnan(x) and math.isnan(y):
+    return True
+
+  if hasattr(x, '__len__'):
+    if len(x) != len(y):
+      print '\n%r != %r. Iterables are not of the same size.' % (x, y)
+      return False
+    for (x1, y1) in zip(x, y):
+      if not _TestEquality(x1, y1):
+        return False
+    return True
+
+  if (hasattr(x, '__metaclass__') and
+      x.__metaclass__ == reflection.MojoStructType):
+    properties = [p for p in dir(x) if not p.startswith('_')]
+    for p in properties:
+      p1 = getattr(x, p)
+      p2 = getattr(y, p)
+      if not hasattr(p1, '__call__') and not _TestEquality(p1, p2):
+        print '\n%r != %r. Not equal for property %r.' % (x, y, p)
+        return False
+    return True
+
+  return False
+
+
+def _NewBar():
+  bar_instance = sample_service_mojom.Bar()
+  bar_instance.alpha = 22
+  bar_instance.beta = 87
+  bar_instance.gamma = 122
+  bar_instance.type = sample_service_mojom.Bar.Type.BOTH
+  return bar_instance
+
+
 def _NewFoo():
   foo_instance = sample_service_mojom.Foo()
   foo_instance.name = "Foo.name"
@@ -23,10 +71,10 @@ def _NewFoo():
   foo_instance.a = False
   foo_instance.b = True
   foo_instance.c = True
-  foo_instance.bar = sample_service_mojom.Bar()
+  foo_instance.bar = _NewBar()
   foo_instance.extra_bars = [
-      sample_service_mojom.Bar(),
-      sample_service_mojom.Bar()
+      _NewBar(),
+      _NewBar(),
   ]
   foo_instance.data = 'Hello world'
   foo_instance.source = _NewHandle()
@@ -41,12 +89,42 @@ def _NewFoo():
       ],
       [],
   ]
-  foo_instance.array_of_bools = [ True, 0, 1, 2, 0 ]
+  foo_instance.array_of_bools = [ True, 0, 1, 2, 0, 0, 0, 0, 0, True ]
   return foo_instance
 
+
 class SerializationDeserializationTest(unittest.TestCase):
 
+  def testTestEquality(self):
+    self.assertFalse(_TestEquality(1, 2))
+
   def testFooSerialization(self):
     (data, _) = _NewFoo().Serialize()
     self.assertTrue(len(data))
     self.assertEquals(len(data) % 8, 0)
+
+  def testFooDeserialization(self):
+    (data, handles) = _NewFoo().Serialize()
+    self.assertTrue(
+        sample_service_mojom.Foo.Deserialize(data, handles))
+
+  def testFooSerializationDeserialization(self):
+    foo1 = _NewFoo()
+    (data, handles) = foo1.Serialize()
+    foo2 = sample_service_mojom.Foo.Deserialize(data, handles)
+    self.assertTrue(_TestEquality(foo1, foo2))
+
+  def testDefaultsTestSerializationDeserialization(self):
+    v1 = sample_service_mojom.DefaultsTest()
+    v1.a18 = []
+    v1.a19 = ""
+    v1.a21 = sample_import_mojom.Point()
+    v1.a22.location = sample_import_mojom.Point()
+    v1.a22.size = sample_import2_mojom.Size()
+    (data, handles) = v1.Serialize()
+    v2 = sample_service_mojom.DefaultsTest.Deserialize(data, handles)
+    self.assertTrue(_TestEquality(v1, v2))
+
+  def testFooDeserializationError(self):
+    with self.assertRaises(Exception):
+      sample_service_mojom.Foo.Deserialize("", [])