mojo: Java bindings: Add name to the manager.

mojo/public/tools/bindings/generators/mojom_java_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 java source files from a mojom.Module."""
 
 import argparse
 import ast
 import os
 import re
@@ skipping 106 matching lines @@
   if isinstance(element, (mojom.Method,
                           mojom.Parameter,
                           mojom.Field)):
     return CamelCase(element.name)
   if isinstance(element,  mojom.EnumValue):
     return (UpperCamelCase(element.enum_name) + '.' +
             ConstantStyle(element.name))
   if isinstance(element, (mojom.NamedValue,
                           mojom.Constant)):
     return ConstantStyle(element.name)
-  raise Exception("Unexpected element: " % element)
+  raise Exception('Unexpected element: ' % element)
 
 def GetInterfaceResponseName(method):
   return UpperCamelCase(method.name + 'Response')
 
 def ParseStringAttribute(attribute):
   assert isinstance(attribute, basestring)
   return attribute
 
 def GetJavaTrueFalse(value):
-  return "true" if value else "false"
+  return 'true' if value else 'false'
 
 def GetArrayNullabilityFlags(kind):
     """Returns nullability flags for an array type, see Decoder.java.
 
     As we have dedicated decoding functions for arrays, we have to pass
     nullability information about both the array itself, as well as the array
     element type there.
     """
     assert mojom.IsAnyArrayKind(kind)
     ARRAY_NULLABLE   = \
-        "org.chromium.mojo.bindings.BindingsHelper.ARRAY_NULLABLE"
+        'org.chromium.mojo.bindings.BindingsHelper.ARRAY_NULLABLE'
     ELEMENT_NULLABLE = \
-        "org.chromium.mojo.bindings.BindingsHelper.ELEMENT_NULLABLE"
+        'org.chromium.mojo.bindings.BindingsHelper.ELEMENT_NULLABLE'
     NOTHING_NULLABLE = \
-        "org.chromium.mojo.bindings.BindingsHelper.NOTHING_NULLABLE"
+        'org.chromium.mojo.bindings.BindingsHelper.NOTHING_NULLABLE'
 
     flags_to_set = []
     if mojom.IsNullableKind(kind):
         flags_to_set.append(ARRAY_NULLABLE)
     if mojom.IsNullableKind(kind.kind):
         flags_to_set.append(ELEMENT_NULLABLE)
 
     if not flags_to_set:
         flags_to_set = [NOTHING_NULLABLE]
-    return " | ".join(flags_to_set)
+    return ' | '.join(flags_to_set)
 
 
 def AppendEncodeDecodeParams(initial_params, context, kind, bit):
   """ Appends standard parameters shared between encode and decode calls. """
   params = list(initial_params)
   if (kind == mojom.BOOL):
     params.append(str(bit))
   if mojom.IsReferenceKind(kind):
     if mojom.IsAnyArrayKind(kind):
       params.append(GetArrayNullabilityFlags(kind))
     else:
       params.append(GetJavaTrueFalse(mojom.IsNullableKind(kind)))
   if mojom.IsAnyArrayKind(kind):
     if mojom.IsFixedArrayKind(kind):
       params.append(str(kind.length))
     else:
       params.append(
-        "org.chromium.mojo.bindings.BindingsHelper.UNSPECIFIED_ARRAY_LENGTH");
+        'org.chromium.mojo.bindings.BindingsHelper.UNSPECIFIED_ARRAY_LENGTH');
   if mojom.IsInterfaceKind(kind):
     params.append('%s.MANAGER' % GetJavaType(context, kind))
   if mojom.IsAnyArrayKind(kind) and mojom.IsInterfaceKind(kind.kind):
     params.append('%s.MANAGER' % GetJavaType(context, kind.kind))
   return params
 
 
 @contextfilter
 def DecodeMethod(context, kind, offset, bit):
   def _DecodeMethodName(kind):
     if mojom.IsAnyArrayKind(kind):
       return _DecodeMethodName(kind.kind) + 's'
     if mojom.IsEnumKind(kind):
       return _DecodeMethodName(mojom.INT32)
     if mojom.IsInterfaceRequestKind(kind):
-      return "readInterfaceRequest"
+      return 'readInterfaceRequest'
     if mojom.IsInterfaceKind(kind):
-      return "readServiceInterface"
+      return 'readServiceInterface'
     return _spec_to_decode_method[kind.spec]
   methodName = _DecodeMethodName(kind)
   params = AppendEncodeDecodeParams([ str(offset) ], context, kind, bit)
   return '%s(%s)' % (methodName, ', '.join(params))
 
 @contextfilter
 def EncodeMethod(context, kind, variable, offset, bit):
   params = AppendEncodeDecodeParams(
       [ variable, str(offset) ], context, kind, bit)
   return 'encode(%s)' % ', '.join(params)
 
 def GetPackage(module):
   if 'JavaPackage' in module.attributes:
     return ParseStringAttribute(module.attributes['JavaPackage'])
   # Default package.
-  return "org.chromium.mojom." + module.namespace
+  return 'org.chromium.mojom.' + module.namespace
 
 def GetNameForKind(context, kind):
   def _GetNameHierachy(kind):
     hierachy = []
     if kind.parent_kind:
       hierachy = _GetNameHierachy(kind.parent_kind)
     hierachy.append(GetNameForElement(kind))
     return hierachy
 
   module = context.resolve('module')
   elements = []
   if GetPackage(module) != GetPackage(kind.module):
     elements += [GetPackage(kind.module)]
   elements += _GetNameHierachy(kind)
   return '.'.join(elements)
 
 def GetBoxedJavaType(context, kind):
   unboxed_type = GetJavaType(context, kind, False)
   if unboxed_type in _java_primitive_to_boxed_type:
     return _java_primitive_to_boxed_type[unboxed_type]
   return unboxed_type
 
 @contextfilter
 def GetJavaType(context, kind, boxed=False):
   if boxed:
     return GetBoxedJavaType(context, kind)
   if mojom.IsStructKind(kind) or mojom.IsInterfaceKind(kind):
     return GetNameForKind(context, kind)
   if mojom.IsInterfaceRequestKind(kind):
-    return ("org.chromium.mojo.bindings.InterfaceRequest<%s>" %
+    return ('org.chromium.mojo.bindings.InterfaceRequest<%s>' %
             GetNameForKind(context, kind.kind))
   if mojom.IsAnyArrayKind(kind):
-    return "%s[]" % GetJavaType(context, kind.kind)
+    return '%s[]' % GetJavaType(context, kind.kind)
   if mojom.IsEnumKind(kind):
-    return "int"
+    return 'int'
   return _spec_to_java_type[kind.spec]
 
 @contextfilter
 def DefaultValue(context, field):
   assert field.default
   if isinstance(field.kind, mojom.Struct):
-    assert field.default == "default"
-    return "new %s()" % GetJavaType(context, field.kind)
-  return "(%s) %s" % (
+    assert field.default == 'default'
+    return 'new %s()' % GetJavaType(context, field.kind)
+  return '(%s) %s' % (
       GetJavaType(context, field.kind),
       ExpressionToText(context, field.default, kind_spec=field.kind.spec))
 
 @contextfilter
 def ConstantValue(context, constant):
-  return "(%s) %s" % (
+  return '(%s) %s' % (
       GetJavaType(context, constant.kind),
       ExpressionToText(context, constant.value, kind_spec=constant.kind.spec))
 
 @contextfilter
 def NewArray(context, kind, size):
   if mojom.IsAnyArrayKind(kind.kind):
     return NewArray(context, kind.kind, size) + '[]'
   return 'new %s[%s]' % (GetJavaType(context, kind.kind), size)
 
 @contextfilter
@@ skipping 17 matching lines @@
     number = ast.literal_eval(token.lstrip('+ '))
     if not isinstance(number, (int, long)):
       raise ValueError('got unexpected type %r for int literal %r' % (
           type(number), token))
     # If the literal is too large to fit a signed long, convert it to the
     # equivalent signed long.
     if number >= 2 ** 63:
       number -= 2 ** 64
     return '%dL' % number
   if isinstance(token, mojom.BuiltinValue):
-    if token.value == "double.INFINITY":
-      return "java.lang.Double.POSITIVE_INFINITY"
-    if token.value == "double.NEGATIVE_INFINITY":
-      return "java.lang.Double.NEGATIVE_INFINITY"
-    if token.value == "double.NAN":
-      return "java.lang.Double.NaN"
-    if token.value == "float.INFINITY":
-      return "java.lang.Float.POSITIVE_INFINITY"
-    if token.value == "float.NEGATIVE_INFINITY":
-      return "java.lang.Float.NEGATIVE_INFINITY"
-    if token.value == "float.NAN":
-      return "java.lang.Float.NaN"
+    if token.value == 'double.INFINITY':
+      return 'java.lang.Double.POSITIVE_INFINITY'
+    if token.value == 'double.NEGATIVE_INFINITY':
+      return 'java.lang.Double.NEGATIVE_INFINITY'
+    if token.value == 'double.NAN':
+      return 'java.lang.Double.NaN'
+    if token.value == 'float.INFINITY':
+      return 'java.lang.Float.POSITIVE_INFINITY'
+    if token.value == 'float.NEGATIVE_INFINITY':
+      return 'java.lang.Float.NEGATIVE_INFINITY'
+    if token.value == 'float.NAN':
+      return 'java.lang.Float.NaN'
   return token
 
 def IsPointerArrayKind(kind):
   if not mojom.IsAnyArrayKind(kind):
     return False
   sub_kind = kind.kind
   return mojom.IsObjectKind(sub_kind)
 
 def GetResponseStructFromMethod(method):
   return generator.GetDataHeader(
       False, generator.GetResponseStructFromMethod(method))
 
 def GetStructFromMethod(method):
   return generator.GetDataHeader(
       False, generator.GetStructFromMethod(method))
 
 def GetConstantsMainEntityName(module):
   if 'JavaConstantsClassName' in module.attributes:
     return ParseStringAttribute(module.attributes['JavaConstantsClassName'])
   # This constructs the name of the embedding classes for module level constants
   # by extracting the mojom's filename and prepending it to Constants.
   return (UpperCamelCase(module.path.split('/')[-1].rsplit('.', 1)[0]) +
           'Constants')
 
 def GetMethodOrdinalName(method):
-  return ConstantStyle(method.name) + "_ORDINAL"
+  return ConstantStyle(method.name) + '_ORDINAL'
 
 def HasMethodWithResponse(interface):
   for method in interface.methods:
     if method.response_parameters:
       return True
   return False
 
 def HasMethodWithoutResponse(interface):
   for method in interface.methods:
     if not method.response_parameters:
       return True
   return False
 
 class Generator(generator.Generator):
 
   java_filters = {
-    "interface_response_name": GetInterfaceResponseName,
-    "constant_value": ConstantValue,
-    "default_value": DefaultValue,
-    "decode_method": DecodeMethod,
-    "expression_to_text": ExpressionToText,
-    "encode_method": EncodeMethod,
-    "has_method_with_response": HasMethodWithResponse,
-    "has_method_without_response": HasMethodWithoutResponse,
-    "is_fixed_array_kind": mojom.IsFixedArrayKind,
-    "is_handle": mojom.IsNonInterfaceHandleKind,
-    "is_nullable_kind": mojom.IsNullableKind,
-    "is_pointer_array_kind": IsPointerArrayKind,
-    "is_struct_kind": mojom.IsStructKind,
-    "java_type": GetJavaType,
-    "java_true_false": GetJavaTrueFalse,
-    "method_ordinal_name": GetMethodOrdinalName,
-    "name": GetNameForElement,
-    "new_array": NewArray,
-    "response_struct_from_method": GetResponseStructFromMethod,
-    "struct_from_method": GetStructFromMethod,
-    "struct_size": lambda ps: ps.GetTotalSize() + _HEADER_SIZE,
+    'interface_response_name': GetInterfaceResponseName,
+    'constant_value': ConstantValue,
+    'default_value': DefaultValue,
+    'decode_method': DecodeMethod,
+    'expression_to_text': ExpressionToText,
+    'encode_method': EncodeMethod,
+    'has_method_with_response': HasMethodWithResponse,
+    'has_method_without_response': HasMethodWithoutResponse,
+    'is_fixed_array_kind': mojom.IsFixedArrayKind,
+    'is_handle': mojom.IsNonInterfaceHandleKind,
+    'is_nullable_kind': mojom.IsNullableKind,
+    'is_pointer_array_kind': IsPointerArrayKind,
+    'is_struct_kind': mojom.IsStructKind,
+    'java_type': GetJavaType,
+    'java_true_false': GetJavaTrueFalse,
+    'method_ordinal_name': GetMethodOrdinalName,
+    'name': GetNameForElement,
+    'new_array': NewArray,
+    'response_struct_from_method': GetResponseStructFromMethod,
+    'struct_from_method': GetStructFromMethod,
+    'struct_size': lambda ps: ps.GetTotalSize() + _HEADER_SIZE,
   }
 
   def GetJinjaExports(self):
     return {
-      "module": self.module,
-      "package": GetPackage(self.module),
+      'package': GetPackage(self.module),
     }
 
   def GetJinjaExportsForInterface(self, interface):
     exports = self.GetJinjaExports()
-    exports.update({"interface": interface})
+    exports.update({'interface': interface})
     if interface.client:
       for client in self.module.interfaces:
         if client.name == interface.client:
-          exports.update({"client": client})
+          exports.update({'client': client})
     return exports
 
-  @UseJinja("java_templates/enum.java.tmpl", filters=java_filters)
+  @UseJinja('java_templates/enum.java.tmpl', filters=java_filters)
   def GenerateEnumSource(self, enum):
     exports = self.GetJinjaExports()
-    exports.update({"enum": enum})
+    exports.update({'enum': enum})
     return exports
 
-  @UseJinja("java_templates/struct.java.tmpl", filters=java_filters)
+  @UseJinja('java_templates/struct.java.tmpl', filters=java_filters)
   def GenerateStructSource(self, struct):
     exports = self.GetJinjaExports()
-    exports.update({"struct": struct})
+    exports.update({'struct': struct})
     return exports
 
-  @UseJinja("java_templates/interface.java.tmpl", filters=java_filters)
+  @UseJinja('java_templates/interface.java.tmpl', filters=java_filters)
   def GenerateInterfaceSource(self, interface):
     return self.GetJinjaExportsForInterface(interface)
 
-  @UseJinja("java_templates/interface_internal.java.tmpl", filters=java_filters)
+  @UseJinja('java_templates/interface_internal.java.tmpl', filters=java_filters)
   def GenerateInterfaceInternalSource(self, interface):
     return self.GetJinjaExportsForInterface(interface)
 
-  @UseJinja("java_templates/constants.java.tmpl", filters=java_filters)
+  @UseJinja('java_templates/constants.java.tmpl', filters=java_filters)
   def GenerateConstantsSource(self, module):
     exports = self.GetJinjaExports()
-    exports.update({"main_entity": GetConstantsMainEntityName(module),
-                    "constants": module.constants})
+    exports.update({'main_entity': GetConstantsMainEntityName(module),
+                    'constants': module.constants})
     return exports
 
   def GenerateFiles(self, unparsed_args):
     parser = argparse.ArgumentParser()
-    parser.add_argument("--java_output_directory", dest="java_output_directory")
+    parser.add_argument('--java_output_directory', dest='java_output_directory')
     args = parser.parse_args(unparsed_args)
     if self.output_dir and args.java_output_directory:
       self.output_dir = os.path.join(args.java_output_directory,
                                      GetPackage(self.module).replace('.', '/'))
       if not os.path.exists(self.output_dir):
         try:
           os.makedirs(self.output_dir)
         except:
           # Ignore errors on directory creation.
           pass
 
     for enum in self.module.enums:
       self.Write(self.GenerateEnumSource(enum),
-                 "%s.java" % GetNameForElement(enum))
+                 '%s.java' % GetNameForElement(enum))
 
     for struct in self.module.structs:
       self.Write(self.GenerateStructSource(struct),
-                 "%s.java" % GetNameForElement(struct))
+                 '%s.java' % GetNameForElement(struct))
 
     for interface in self.module.interfaces:
       self.Write(self.GenerateInterfaceSource(interface),
-                 "%s.java" % GetNameForElement(interface))
+                 '%s.java' % GetNameForElement(interface))
       self.Write(self.GenerateInterfaceInternalSource(interface),
-                 "%s_Internal.java" % GetNameForElement(interface))
+                 '%s_Internal.java' % GetNameForElement(interface))
 
     if self.module.constants:
       self.Write(self.GenerateConstantsSource(self.module),
-                 "%s.java" % GetConstantsMainEntityName(self.module))
+                 '%s.java' % GetConstantsMainEntityName(self.module))
 
   def GetJinjaParameters(self):
     return {
       'lstrip_blocks': True,
       'trim_blocks': True,
     }
 
   def GetGlobals(self):
     return {
+      'namespace': self.module.namespace,
       'module': self.module,
     }