Update mojo sdk to rev 59145288bae55b0fce4276b017df6a1117bcf00f

mojo/public/tools/bindings/pylib/mojom/generate/data.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.
 
 # TODO(vtl): "data" is a pretty vague name. Rename it?
 
 import copy
 
 import module as mojom
 
@@ skipping 131 matching lines @@
     kind = mojom.Map(KindFromData(kinds, first_kind, scope),
                      KindFromData(kinds, second_kind, scope))
   else:
     kind = mojom.Kind(data)
 
   kinds[data] = kind
   return kind
 
 def KindFromImport(original_kind, imported_from):
   """Used with 'import module' - clones the kind imported from the given
-  module's namespace. Only used with Structs, Interfaces and Enums."""
+  module's namespace. Only used with Structs, Unions, Interfaces and Enums."""
   kind = copy.copy(original_kind)
   # |shared_definition| is used to store various properties (see
   # |AddSharedProperty()| in module.py), including |imported_from|. We don't
   # want the copy to share these with the original, so copy it if necessary.
   if hasattr(original_kind, 'shared_definition'):
     kind.shared_definition = copy.copy(original_kind.shared_definition)
   kind.imported_from = imported_from
   return kind
 
 def ImportFromData(module, data):
   import_module = data['module']
 
   import_item = {}
   import_item['module_name'] = import_module.name
   import_item['namespace'] = import_module.namespace
   import_item['module'] = import_module
 
   # Copy the struct kinds from our imports into the current module.
+  importable_kinds = (mojom.Struct, mojom.Union, mojom.Enum, mojom.Interface)
   for kind in import_module.kinds.itervalues():
-    if (isinstance(kind, (mojom.Struct, mojom.Enum, mojom.Interface)) and
+    if (isinstance(kind, importable_kinds) and
         kind.imported_from is None):
       kind = KindFromImport(kind, import_item)
       module.kinds[kind.spec] = kind
   # Ditto for values.
   for value in import_module.values.itervalues():
     if value.imported_from is None:
       # Values don't have shared definitions (since they're not nullable), so no
       # need to do anything special.
       value = copy.copy(value)
       value.imported_from = import_item
@@ skipping 14 matching lines @@
   struct.spec = 'x:' + module.namespace + '.' + struct.name
   module.kinds[struct.spec] = struct
   struct.enums = map(lambda enum:
       EnumFromData(module, enum, struct), data['enums'])
   struct.constants = map(lambda constant:
       ConstantFromData(module, constant, struct), data['constants'])
   # Stash fields data here temporarily.
   struct.fields_data = data['fields']
   return struct
 
+def UnionToData(union):
+  return {
+    istr(0, 'name'): union.name,
+    istr(1, 'fields'): map(FieldToData, union.fields)
+  }
+
+def UnionFromData(module, data):
+  union = mojom.Union(module=module)
+  union.name = data['name']
+  union.spec = 'x:' + module.namespace + '.' + union.name
+  module.kinds[union.spec] = union
+  # Stash fields data here temporarily.
+  union.fields_data = data['fields']
+  return union
+
 def FieldToData(field):
   data = {
     istr(0, 'name'): field.name,
     istr(1, 'kind'): KindToData(field.kind)
   }
   if field.ordinal != None:
     data[istr(2, 'ordinal')] = field.ordinal
   if field.default != None:
     data[istr(3, 'default')] = field.default
   return data
@@ skipping 117 matching lines @@
 
   value = mojom.ConstantValue(module, parent_kind, constant)
   module.values[value.GetSpec()] = value
   return constant
 
 def ModuleToData(module):
   return {
     istr(0, 'name'):       module.name,
     istr(1, 'namespace'):  module.namespace,
     istr(2, 'structs'):    map(StructToData, module.structs),
-    istr(3, 'interfaces'): map(InterfaceToData, module.interfaces)
+    istr(3, 'interfaces'): map(InterfaceToData, module.interfaces),
+    istr(4, 'unions'):     map(UnionToData, module.unions),
   }
 
 def ModuleFromData(data):
   module = mojom.Module()
   module.kinds = {}
   for kind in mojom.PRIMITIVES:
     module.kinds[kind.spec] = kind
 
   module.values = {}
 
   module.name = data['name']
   module.namespace = data['namespace']
   module.attributes = data['attributes']
   # Imports must come first, because they add to module.kinds which is used
   # by by the others.
   module.imports = map(
       lambda import_data: ImportFromData(module, import_data),
       data['imports'])
 
   # First pass collects kinds.
   module.enums = map(
       lambda enum: EnumFromData(module, enum, None), data['enums'])
   module.structs = map(
       lambda struct: StructFromData(module, struct), data['structs'])
+  module.unions = map(
+      lambda union: UnionFromData(module, struct), data.get('unions', []))
   module.interfaces = map(
       lambda interface: InterfaceFromData(module, interface),
       data['interfaces'])
   module.constants = map(
       lambda constant: ConstantFromData(module, constant, None),
       data['constants'])
 
   # Second pass expands fields and methods. This allows fields and parameters
   # to refer to kinds defined anywhere in the mojom.
   for struct in module.structs:
     struct.fields = map(lambda field:
         FieldFromData(module, field, struct), struct.fields_data)
     del struct.fields_data
+  for union in module.unions:
+    union.fields = map(lambda field:
+        FieldFromData(module, field, union), union.fields_data)
+    del union.fields_data
   for interface in module.interfaces:
     interface.methods = map(lambda method:
         MethodFromData(module, method, interface), interface.methods_data)
     del interface.methods_data
 
   return module
 
 def OrderedModuleFromData(data):
   module = ModuleFromData(data)
   for interface in module.interfaces:
     next_ordinal = 0
     for method in interface.methods:
       if method.ordinal is None:
         method.ordinal = next_ordinal
       next_ordinal = method.ordinal + 1
   return module