Selectively perform JNI registration in render processes on Android.

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 394 matching lines @@
         java_class_name=match.group('java_class_name'),
         native_class_name=match.group('native_class_name'),
         return_type=match.group('return_type'),
         name=match.group('name').replace('native', ''),
         params=JniParams.Parse(match.group('params')),
         ptr_type=ptr_type)
     natives += [native]
   return natives
 
 
+def IsMainDexJavaClass(contents):
+  """Returns "true" if the class is annotated with "@MainDex", "false" if not.
+
+  JNI registration doesn't always need to be completed for non-browser processes
+  since most Java code is only used by the browser process. Classes that are
+  needed by non-browser processes must explicitly be annotated with @MainDex
+  to force JNI registration.
+  """
+  re_maindex = re.compile(r'@MainDex[\s\S]*class\s+\w+\s*{')
+  found = re.search(re_maindex, contents)
+  return 'true' if found else 'false'
+
+
 def GetStaticCastForReturnType(return_type):
   type_map = { 'String' : 'jstring',
                'java/lang/String' : 'jstring',
                'Throwable': 'jthrowable',
                'java/lang/Throwable': 'jthrowable',
                'boolean[]': 'jbooleanArray',
                'byte[]': 'jbyteArray',
                'char[]': 'jcharArray',
                'short[]': 'jshortArray',
                'int[]': 'jintArray',
@@ skipping 202 matching lines @@
         continue
       value = re.match(re_constant_field_value, contents[lineno + 2])
       if not value:
         value = re.match(re_constant_field_value, contents[lineno + 3])
       if value:
         self.constant_fields.append(
             ConstantField(name=match.group('name'),
                           value=value.group('value')))
 
     self.inl_header_file_generator = InlHeaderFileGenerator(
-        self.namespace, self.fully_qualified_class, [],
-        self.called_by_natives, self.constant_fields, options)
+        self.namespace, self.fully_qualified_class, [], self.called_by_natives,
+        self.constant_fields, options)
 
   def GetContent(self):
     return self.inl_header_file_generator.GetContent()
 
   @staticmethod
   def CreateFromClass(class_file, options):
     class_name = os.path.splitext(os.path.basename(class_file))[0]
     p = subprocess.Popen(args=[options.javap, '-c', '-verbose',
                                '-s', class_name],
                          cwd=os.path.dirname(class_file),
@@ skipping 13 matching lines @@
       r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',
       re.DOTALL | re.MULTILINE)
 
   def __init__(self, contents, fully_qualified_class, options):
     contents = self._RemoveComments(contents)
     JniParams.SetFullyQualifiedClass(fully_qualified_class)
     JniParams.ExtractImportsAndInnerClasses(contents)
     jni_namespace = ExtractJNINamespace(contents) or options.namespace
     natives = ExtractNatives(contents, options.ptr_type)
     called_by_natives = ExtractCalledByNatives(contents)
+    maindex = IsMainDexJavaClass(contents)
     if len(natives) == 0 and len(called_by_natives) == 0:
       raise SyntaxError('Unable to find any JNI methods for %s.' %
                         fully_qualified_class)
     inl_header_file_generator = InlHeaderFileGenerator(
-        jni_namespace, fully_qualified_class, natives, called_by_natives,
-        [], options)
+        jni_namespace, fully_qualified_class, natives, called_by_natives, [],
+        options, maindex)
     self.content = inl_header_file_generator.GetContent()
 
   @classmethod
   def _RemoveComments(cls, contents):
     # We need to support both inline and block comments, and we need to handle
     # strings that contain '//' or '/*'.
     # TODO(bulach): This is a bit hacky. It would be cleaner to use a real Java
     # parser. Maybe we could ditch JNIFromJavaSource and just always use
     # JNIFromJavaP; or maybe we could rewrite this script in Java and use APT.
     # http://code.google.com/p/chromium/issues/detail?id=138941
@@ skipping 15 matching lines @@
     contents = file(java_file_name).read()
     fully_qualified_class = ExtractFullyQualifiedJavaClassName(java_file_name,
                                                                contents)
     return JNIFromJavaSource(contents, fully_qualified_class, options)
 
 
 class InlHeaderFileGenerator(object):
   """Generates an inline header file for JNI integration."""
 
   def __init__(self, namespace, fully_qualified_class, natives,
-               called_by_natives, constant_fields, options):
+               called_by_natives, constant_fields, options, maindex='false'):
     self.namespace = namespace
     self.fully_qualified_class = fully_qualified_class
     self.class_name = self.fully_qualified_class.split('/')[-1]
     self.natives = natives
     self.called_by_natives = called_by_natives
     self.header_guard = fully_qualified_class.replace('/', '_') + '_JNI'
     self.constant_fields = constant_fields
+    self.maindex = maindex
     self.options = options
 
 
   def GetContent(self):
     """Returns the content of the JNI binding file."""
     template = Template("""\
 // 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.
 
@@ skipping 124 matching lines @@
 ${REGISTER_NATIVES_SIGNATURE} {
 ${EARLY_EXIT}
 ${NATIVES}
   return true;
 }
 """)
     signature = 'static bool RegisterNativesImpl(JNIEnv* env)'
     early_exit = ''
     if self.options.native_exports_optional:
       early_exit = """\
-  if (base::android::IsManualJniRegistrationDisabled()) return true;
-"""
+  if (jni_generator::ShouldSkipJniRegistration(%s))
+    return true;
+""" % self.maindex
 
     values = {'REGISTER_NATIVES_SIGNATURE': signature,
               'EARLY_EXIT': early_exit,
               'NATIVES': natives,
              }
 
     return template.substitute(values)
 
   def GetRegisterNativesImplString(self):
     """Returns the shared implementation for RegisterNatives."""
@@ skipping 516 matching lines @@
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
   GenerateJNIHeader(input_file, output_file, options)
 
   if options.depfile:
     build_utils.WriteDepfile(options.depfile, output_file)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))