Update mojo sdk to rev e083961bf11fd0c94d40be8853761da529b6d444

mojo/public/tools/bindings/generators/mojom_python_generator.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.
 
 """Generates Python source files from a mojom.Module."""
 
 import re
 from itertools import ifilter
 
 import mojom.generate.generator as generator
@@ skipping 72 matching lines @@
 def CamelCase(name):
   uccc = UpperCamelCase(name)
   return uccc[0].lower() + uccc[1:]
 
 def ConstantStyle(name):
   components = NameToComponent(name)
   if components[0] == 'k':
     components = components[1:]
   return '_'.join([x.upper() for x in components])
 
+def FieldStyle(name):
+  components = NameToComponent(name)
+  return '_'.join([x.lower() for x in components])
+
 def GetNameForElement(element):
   if (mojom.IsEnumKind(element) or mojom.IsInterfaceKind(element) or
-      mojom.IsStructKind(element)):
+      mojom.IsStructKind(element) or isinstance(element, mojom.Method)):
     return UpperCamelCase(element.name)
   if isinstance(element, mojom.EnumValue):
     return (GetNameForElement(element.enum) + '.' +
             ConstantStyle(element.name))
   if isinstance(element, (mojom.NamedValue,
                           mojom.Constant)):
     return ConstantStyle(element.name)
-  raise Exception('Unexpected element: ' % element)
+  if isinstance(element, mojom.Field):
+    return FieldStyle(element.name)
+  raise Exception('Unexpected element: %s' % element)
 
 def ExpressionToText(token):
   if isinstance(token, (mojom.EnumValue, mojom.NamedValue)):
     return str(token.computed_value)
 
   if isinstance(token, mojom.BuiltinValue):
     if token.value == 'double.INFINITY' or token.value == 'float.INFINITY':
       return 'float(\'inf\')';
     if (token.value == 'double.NEGATIVE_INFINITY' or
         token.value == 'float.NEGATIVE_INFINITY'):
       return 'float(\'-inf\')'
     if token.value == 'double.NAN' or token.value == 'float.NAN':
       return 'float(\'nan\')';
 
   if token in ['true', 'false']:
     return str(token == 'true')
 
   return token
 
-def GetStructClass(kind):
+def GetFullyQualifiedName(kind):
   name = []
   if kind.imported_from:
     name.append(kind.imported_from['python_module'])
   name.append(GetNameForElement(kind))
   return '.'.join(name)
 
 def GetFieldType(kind, field=None):
   if mojom.IsArrayKind(kind):
     arguments = []
     if kind.kind in _kind_to_typecode_for_native_array:
@@ skipping 14 matching lines @@
   if mojom.IsMapKind(kind):
     arguments = [
       GetFieldType(kind.key_kind),
       GetFieldType(kind.value_kind),
     ]
     if mojom.IsNullableKind(kind):
       arguments.append('nullable=True')
     return '_descriptor.MapType(%s)' % ', '.join(arguments)
 
   if mojom.IsStructKind(kind):
-    arguments = [ 'lambda: %s' % GetStructClass(kind) ]
+    arguments = [ 'lambda: %s' % GetFullyQualifiedName(kind) ]
     if mojom.IsNullableKind(kind):
       arguments.append('nullable=True')
     return '_descriptor.StructType(%s)' % ', '.join(arguments)
 
   if mojom.IsEnumKind(kind):
     return GetFieldType(mojom.INT32)
 
   return _kind_to_type.get(kind, '_descriptor.TYPE_NONE')
 
 def GetFieldDescriptor(packed_field):
   field = packed_field.field
   class_name = 'SingleFieldGroup'
   if field.kind == mojom.BOOL:
     class_name = 'FieldDescriptor'
-  arguments = [ '%r' % field.name ]
+  arguments = [ '%r' % GetNameForElement(field) ]
   arguments.append(GetFieldType(field.kind, field))
   arguments.append(str(packed_field.index))
   arguments.append(str(packed_field.ordinal))
   if field.default:
     if mojom.IsStructKind(field.kind):
       arguments.append('default_value=True')
     else:
       arguments.append('default_value=%s' % ExpressionToText(field.default))
   return '_descriptor.%s(%s)' % (class_name, ', '.join(arguments))
 
 def GetFieldGroup(byte):
-  if len(byte.packed_fields) > 1:
+  if byte.packed_fields[0].field.kind == mojom.BOOL:
     descriptors = map(GetFieldDescriptor, byte.packed_fields)
     return '_descriptor.BooleanGroup([%s])' % ', '.join(descriptors)
   assert len(byte.packed_fields) == 1
   return GetFieldDescriptor(byte.packed_fields[0])
 
+def GetResponseStructFromMethod(method):
+  return generator.GetDataHeader(
+      False, generator.GetResponseStructFromMethod(method))
+
+def GetStructFromMethod(method):
+  return generator.GetDataHeader(
+      False, generator.GetStructFromMethod(method))
+
 def ComputeStaticValues(module):
   in_progress = set()
   computed = set()
 
   def GetComputedValue(named_value):
     if isinstance(named_value, mojom.EnumValue):
       field = next(ifilter(lambda field: field.name == named_value.name,
                            named_value.enum.fields), None)
       if not field:
         raise RuntimeError(
@@ skipping 66 matching lines @@
   return module
 
 def MojomToPythonImport(mojom):
   return mojom.replace('.mojom', '_mojom')
 
 class Generator(generator.Generator):
 
   python_filters = {
     'expression_to_text': ExpressionToText,
     'field_group': GetFieldGroup,
+    'fully_qualified_name': GetFullyQualifiedName,
     'name': GetNameForElement,
+    'response_struct_from_method': GetResponseStructFromMethod,
+    'struct_from_method': GetStructFromMethod,
   }
 
   @UseJinja('python_templates/module.py.tmpl', filters=python_filters)
   def GeneratePythonModule(self):
     return {
+      'enums': self.module.enums,
       'imports': self.GetImports(),
-      'enums': self.module.enums,
+      'interfaces': self.GetQualifiedInterfaces(),
       'module': ComputeStaticValues(self.module),
       'structs': self.GetStructs(),
     }
 
   def GenerateFiles(self, args):
     import_path = MojomToPythonImport(self.module.name)
     self.Write(self.GeneratePythonModule(),
                self.MatchMojomFilePath('%s.py' % import_path))
 
   def GetImports(self):
     for each in self.module.imports:
       each['python_module'] = MojomToPythonImport(each['module_name'])
     return self.module.imports
 
+  def GetQualifiedInterfaces(self):
+    """
+    Returns the list of interfaces of the module. Each interface that has a
+    client will have a reference to the representation of the client interface
+    in the 'qualified_client' field.
+    """
+    interfaces = self.module.interfaces
+    all_interfaces = [] + interfaces
+    for each in self.module.imports:
+      all_interfaces += each['module'].interfaces
+    interfaces_by_name = dict((x.name, x) for x in all_interfaces)
+    for interface in interfaces:
+      if interface.client:
+        assert interface.client in interfaces_by_name, (
+            'Unable to find interface %s declared as client of %s.' %
+            (interface.client, interface.name))
+        interface.qualified_client = interfaces_by_name[interface.client]
+    return sorted(interfaces, key=lambda i: (bool(i.client), i.name))
+
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }