Android: allow JNI generator to be used with jarjar.

base/android/jni_generator/jni_generator.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
 If you change this, please run and update the tests."""
 
 import collections
 import errno
@@ skipping 101 matching lines @@
     return 'jobjectArray'
   else:
     return 'jobject'
 
 
 class JniParams(object):
   _imports = []
   _fully_qualified_class = ''
   _package = ''
   _inner_classes = []
+  _remappings = []
 
   @staticmethod
   def SetFullyQualifiedClass(fully_qualified_class):
     JniParams._fully_qualified_class = 'L' + fully_qualified_class
     JniParams._package = '/'.join(fully_qualified_class.split('/')[:-1])
 
   @staticmethod
   def ExtractImportsAndInnerClasses(contents):
     contents = contents.replace('\n', '')
     re_import = re.compile(r'import.*?(?P<class>\S*?);')
@@ skipping 34 matching lines @@
     while param[-2:] == '[]':
       prefix += '['
       param = param[:-2]
     # Generic?
     if '<' in param:
       param = param[:param.index('<')]
     if param in pod_param_map:
       return prefix + pod_param_map[param]
     if '/' in param:
       # Coming from javap, use the fully qualified param directly.
-      return prefix + 'L' + param + ';'
+      return prefix + 'L' + JniParams.RemapClassName(param) + ';'
     for qualified_name in (object_param_list +
                            [JniParams._fully_qualified_class] +
                            JniParams._inner_classes):
       if (qualified_name.endswith('/' + param) or
           qualified_name.endswith('$' + param.replace('.', '$')) or
           qualified_name == 'L' + param):
-        return prefix + qualified_name + ';'
+        return prefix + JniParams.RemapClassName(qualified_name) + ';'
 
     # Is it from an import? (e.g. referecing Class from import pkg.Class;
     # note that referencing an inner class Inner from import pkg.Class.Inner
     # is not supported).
     for qualified_name in JniParams._imports:
       if qualified_name.endswith('/' + param):
         # Ensure it's not an inner class.
         components = qualified_name.split('/')
         if len(components) > 2 and components[-2][0].isupper():
           raise SyntaxError('Inner class (%s) can not be imported '
                             'and used by JNI (%s). Please import the outer '
                             'class and use Outer.Inner instead.' %
                             (qualified_name, param))
-        return prefix + qualified_name + ';'
+        return prefix + JniParams.RemapClassName(qualified_name) + ';'
 
     # Is it an inner class from an outer class import? (e.g. referencing
     # Class.Inner from import pkg.Class).
     if '.' in param:
       components = param.split('.')
       outer = '/'.join(components[:-1])
       inner = components[-1]
       for qualified_name in JniParams._imports:
         if qualified_name.endswith('/' + outer):
-          return prefix + qualified_name + '$' + inner + ';'
+          return (prefix + JniParams.RemapClassName(qualified_name) +
+                  '$' + inner + ';')
 
     # Type not found, falling back to same package as this class.
-    return prefix + 'L' + JniParams._package + '/' + param + ';'
+    return (prefix + 'L' +
+            JniParams.RemapClassName(JniParams._package + '/' + param) + ';')
 
   @staticmethod
   def Signature(params, returns, wrap):
     """Returns the JNI signature for the given datatypes."""
     items = ['(']
     items += [JniParams.JavaToJni(param.datatype) for param in params]
     items += [')']
     items += [JniParams.JavaToJni(returns)]
     if wrap:
       return '\n' + '\n'.join(['"' + item + '"' for item in items])
@@ skipping 10 matching lines @@
       items = p.split(' ')
       if 'final' in items:
         items.remove('final')
       param = Param(
           datatype=items[0],
           name=(items[1] if len(items) > 1 else 'p%s' % len(ret)),
       )
       ret += [param]
     return ret
 
+  @staticmethod
+  def RemapClassName(class_name):
+    """Remaps class names using the jarjar mapping table."""
+    for old, new in JniParams._remappings:
+      if old in class_name:
+        return class_name.replace(old, new, 1)
+    return class_name
+
+  @staticmethod
+  def SetJarJarMappings(mappings):
+    """Parse jarjar mappings from a string."""
+    JniParams._remappings = []
+    for line in mappings.splitlines():
+      keyword, src, dest = line.split()
+      if keyword != 'rule':
+        continue
+      assert src.endswith('.**')
+      src = src[:-2].replace('.', '/')
+      dest = dest.replace('.', '/')
+      if dest.endswith('@0'):
+        JniParams._remappings.append((src, dest[:-2] + src))
+      else:
+        assert dest.endswith('@1')
+        JniParams._remappings.append((src, dest[:-2]))
+
 
 def ExtractJNINamespace(contents):
   re_jni_namespace = re.compile('.*?@JNINamespace\("(.*?)"\)')
   m = re.findall(re_jni_namespace, contents)
   if not m:
     return ''
   return m[0]
 
 
 def ExtractFullyQualifiedJavaClassName(java_file_name, contents):
@@ skipping 602 matching lines @@
     ret = []
     template = Template("""\
 const char k${JAVA_CLASS}ClassPath[] = "${JNI_CLASS_PATH}";""")
     native_classes = self.GetUniqueClasses(self.natives)
     called_by_native_classes = self.GetUniqueClasses(self.called_by_natives)
     all_classes = native_classes
     all_classes.update(called_by_native_classes)
     for clazz in all_classes:
       values = {
           'JAVA_CLASS': clazz,
-          'JNI_CLASS_PATH': all_classes[clazz],
+          'JNI_CLASS_PATH': JniParams.RemapClassName(all_classes[clazz]),
       }
       ret += [template.substitute(values)]
     ret += ''
     for clazz in called_by_native_classes:
       template = Template("""\
 // Leaking this jclass as we cannot use LazyInstance from some threads.
 jclass g_${JAVA_CLASS}_clazz = NULL;""")
       values = {
           'JAVA_CLASS': clazz,
       }
@@ skipping 133 matching lines @@
                            help='Single input file name. The output file name '
                            'will be derived from it. Must be used with '
                            '--output_dir.')
   option_parser.add_option('--output_dir',
                            help='The output directory. Must be used with '
                            '--input')
   option_parser.add_option('--optimize_generation', type="int",
                            default=0, help='Whether we should optimize JNI '
                            'generation by not regenerating files if they have '
                            'not changed.')
+  option_parser.add_option('--jarjar',
+                           help='Path to optional jarjar rules file.')
   options, args = option_parser.parse_args(argv)
   if options.jar_file:
     input_file = ExtractJarInputFile(options.jar_file, options.input_file,
                                      options.output_dir)
   else:
     input_file = options.input_file
   output_file = None
   if options.output_dir:
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
+  if options.jarjar:
+    with open(options.jarjar) as f:
+      JniParams.SetJarJarMappings(f.read())
   GenerateJNIHeader(input_file, output_file, options.namespace,
                     options.optimize_generation)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))