Remove unneeded JNI registrations.

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 712 matching lines @@
           'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
       }
       ret += [template.substitute(values)]
     return '\n'.join(ret)
 
   def GetForwardDeclarationsString(self):
     ret = []
     for native in self.natives:
       if native.type != 'method':
         ret += [self.GetForwardDeclaration(native)]
+    if self.options.native_exports and ret != []:
+      return '\nextern "C" {\n' + "\n".join(ret) + "\n};"

[bulach, 2014/04/14 13:16:02]

nit: use '\n' instead of "\n" in the second string.
also, at the end, it'd probably be nicer to annotate the closing brace:

'\n}; // extern "C"'

ditto for 757 below.

[ostap, 2014/04/15 23:30:20]

Done.

     return '\n'.join(ret)
 
   def GetConstantFieldsString(self):
     if not self.constant_fields:
       return ''
     ret = ['enum Java_%s_constant_fields {' % self.class_name]
     for c in self.constant_fields:
       ret += ['  %s = %s,' % (c.name, c.value)]
     ret += ['};']
     return '\n'.join(ret)
 
   def GetMethodStubsString(self):
     """Returns the code corresponding to method stubs."""
     ret = []
     for native in self.natives:
       if native.type == 'method':
         ret += [self.GetNativeMethodStubString(native)]
     if self.options.eager_called_by_natives:
       ret += self.GetEagerCalledByNativeMethodStubs()
     else:
       ret += self.GetLazyCalledByNativeMethodStubs()
+
+    if self.options.native_exports and ret != []:
+      return '\nextern "C" {\n' + "\n".join(ret) + "\n};"
     return '\n'.join(ret)
 
   def GetLazyCalledByNativeMethodStubs(self):
     return [self.GetLazyCalledByNativeMethodStub(called_by_native)
             for called_by_native in self.called_by_natives]
 
   def GetEagerCalledByNativeMethodStubs(self):
     ret = []
     if self.called_by_natives:
       ret += ['namespace {']
@@ skipping 25 matching lines @@
       kmethods = self.GetKMethodsString(clazz)
       if kmethods:
         values = {'JAVA_CLASS': clazz,
                   'KMETHODS': kmethods}
         ret += [template.substitute(values)]
     if not ret: return ''
     return '\n' + '\n'.join(ret)
 
   def GetJNINativeMethodsString(self):
     """Returns the implementation of the array of native methods."""
+    if self.options.native_exports:
+      return ''
     template = Template("""\
 static const JNINativeMethod kMethods${JAVA_CLASS}[] = {
 ${KMETHODS}
 };
 """)
     return self.SubstituteNativeMethods(template)
 
   def GetRegisterCalledByNativesImplString(self):
     """Returns the code for registering the called by native methods."""
     if not self.options.eager_called_by_natives:
@@ skipping 34 matching lines @@
     called_by_natives = self.GetRegisterCalledByNativesImplString()
     values = {'REGISTER_NATIVES_SIGNATURE': signature,
               'CLASSES': self.GetFindClasses(),
               'NATIVES': natives,
               'CALLED_BY_NATIVES': called_by_natives,
              }
     return template.substitute(values)
 
   def GetRegisterNativesImplString(self):
     """Returns the shared implementation for RegisterNatives."""
+    if self.options.native_exports:
+      return ''
+
     template = Template("""\
   const int kMethods${JAVA_CLASS}Size = arraysize(kMethods${JAVA_CLASS});
 
   if (env->RegisterNatives(g_${JAVA_CLASS}_clazz,
                            kMethods${JAVA_CLASS},
                            kMethods${JAVA_CLASS}Size) < 0) {
     jni_generator::HandleRegistrationError(
         env, g_${JAVA_CLASS}_clazz, __FILE__);
     return false;
   }
 """)
     return self.SubstituteNativeMethods(template)
 
   def GetJNIRegisterNativesString(self):
     """Returns the implementation for the JNI registration of native methods."""
-    if not self.init_native:
+    if self.options.native_exports or not self.init_native:
       return ''
 
     template = Template("""\
 extern "C" JNIEXPORT bool JNICALL
 Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) {
   return ${NAMESPACE}RegisterNativesImpl(env, clazz);
 }
 """)
     fully_qualified_class = self.fully_qualified_class.replace('/', '_')
     namespace = ''
@@ skipping 45 matching lines @@
                           [JavaDataTypeToC(param.datatype) + ' ' +
                            param.name
                            for param in native.params])
 
   def GetCalledByNativeParamsInDeclaration(self, called_by_native):
     return ',\n    '.join([JavaDataTypeToC(param.datatype) + ' ' +
                            param.name
                            for param in called_by_native.params])
 
   def GetForwardDeclaration(self, native):
-    template = Template("""
+    template_str = """
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS});
-""")
+"""
+    if self.options.native_exports:
+      template_str += """
+__attribute__((alias("${NAME}"), visibility("default"))) ${RETURN}

[bulach, 2014/04/14 13:16:02]

nit: move the ${RETURN} to the next line and put it together with the
Java_${JAVA_NAME} ... so that the generated code wouldn't be indented and would
look like:

__attribute__((alias("${NAME}"), visibility("default")))
void Java_Foo_nativeBar(JNIEnv* env, ....)

[ostap, 2014/04/15 23:30:20]

Done.

+    Java_${JAVA_NAME}_native${NAME}(JNIEnv* env, ${PARAMS});
+"""
+    template = Template(template_str)
+
+    java_name = JniParams.RemapClassName(self.fully_qualified_class).replace('_', '_1').replace('/', '_')

[bulach, 2014/04/14 13:16:02]

nit: >80cols, suggest:
java_name = java_name = JniParams.RemapClassName(self.fully_qualified_class)
java_name = java_name.replace('_', '_1').replace('/', '_')

[ostap, 2014/04/15 23:30:20]

Done.

+    if native.java_class_name:
+      java_name += "_00024" + native.java_class_name

[bulach, 2014/04/14 13:16:02]

nit: s/"/'/

[ostap, 2014/04/15 23:30:20]

Done.

+
     values = {'RETURN': JavaDataTypeToC(native.return_type),
               'NAME': native.name,
+              'JAVA_NAME': java_name,
               'PARAMS': self.GetParamsInDeclaration(native)}
     return template.substitute(values)
 
   def GetNativeMethodStubString(self, native):
     """Returns stubs for native methods."""
-    template = Template("""\
+    template_str = """\
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS_IN_DECLARATION}) {
   ${P0_TYPE}* native = reinterpret_cast<${P0_TYPE}*>(${PARAM0_NAME});
   CHECK_NATIVE_PTR(env, jcaller, native, "${NAME}"${OPTIONAL_ERROR_RETURN});
   return native->${NAME}(${PARAMS_IN_CALL})${POST_CALL};
 }
-""")
+"""
+    if self.options.native_exports:
+      template_str += """
+__attribute__((alias("${NAME}"), visibility("default")))
+  ${RETURN} Java_${JAVA_NAME}_native${NAME}(JNIEnv* env,

[bulach, 2014/04/14 13:16:02]

nit: unindent this line

[ostap, 2014/04/15 23:30:20]

Done.

+      ${PARAMS_IN_DECLARATION});
+"""
+    template = Template(template_str)
     params = []
     if not self.options.pure_native_methods:
       params = ['env', 'jcaller']
     params_in_call = ', '.join(params + [p.name for p in native.params[1:]])
 
     return_type = JavaDataTypeToC(native.return_type)
     optional_error_return = JavaReturnValueToC(native.return_type)
     if optional_error_return:
       optional_error_return = ', ' + optional_error_return
     post_call = ''
     if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
       post_call = '.Release()'
+
+    if self.options.native_exports:
+      java_name = JniParams.RemapClassName(self.fully_qualified_class).replace('_', '_1').replace('/', '_')

[bulach, 2014/04/14 13:16:02]

nit: as above, >80 cols

[ostap, 2014/04/15 23:30:20]

Done.

+      if native.java_class_name:
+        java_name += "_00024" + native.java_class_name

[bulach, 2014/04/14 13:16:02]

nit: s/"/'/ and below in 998

[ostap, 2014/04/15 23:30:20]

Done.

+    else:
+      java_name = ""
+
     values = {
         'RETURN': return_type,
         'OPTIONAL_ERROR_RETURN': optional_error_return,
+        'JAVA_NAME': java_name,
         'NAME': native.name,
         'PARAMS_IN_DECLARATION': self.GetParamsInDeclaration(native),
         'PARAM0_NAME': native.params[0].name,
         'P0_TYPE': native.p0_type,
         'PARAMS_IN_CALL': params_in_call,
         'POST_CALL': post_call
     }
     return template.substitute(values)
 
   def GetCalledByNativeValues(self, called_by_native):
@@ skipping 119 matching lines @@
       ret[class_name] = jni_class_path
     return ret
 
   def GetClassPathDefinitions(self):
     """Returns the ClassPath constants."""
     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)
+    if self.options.native_exports:
+      all_classes = called_by_native_classes
+      loop_classes = all_classes
+    else:
+      all_classes = native_classes
+      all_classes.update(called_by_native_classes)
+      loop_classes = called_by_native_classes
+
     for clazz in all_classes:
       values = {
           'JAVA_CLASS': clazz,
           'JNI_CLASS_PATH': JniParams.RemapClassName(all_classes[clazz]),
       }
       ret += [template.substitute(values)]
     ret += ''
-    for clazz in called_by_native_classes:
+    for clazz in loop_classes:
       template = Template("""\
 // Leaking this jclass as we cannot use LazyInstance from some threads.
 jclass g_${JAVA_CLASS}_clazz = NULL;""")
       values = {
           'JAVA_CLASS': clazz,
       }
       ret += [template.substitute(values)]
     return '\n'.join(ret)
 
   def GetFindClasses(self):
@@ skipping 190 matching lines @@
                            'will limit the initialization to only the '
                            'top-level class.')
   option_parser.add_option('--eager_called_by_natives',
                            action='store_true', dest='eager_called_by_natives',
                            help='When true, the called-by-native methods will '
                            'be initialized in a non-atomic way.')
   option_parser.add_option('--cpp', default='cpp',
                            help='The path to cpp command.')
   option_parser.add_option('--javap', default='javap',
                            help='The path to javap command.')
+  option_parser.add_option('--native_exports',
+                           action='store_true', dest='native_exports',

[bulach, 2014/04/14 13:16:02]

nit: no need for dest

[ostap, 2014/04/15 23:30:20]

Done.

+                           help='Native method registration through .so '
+                           'exports.')
   options, args = option_parser.parse_args(argv)
   if options.jar_file:
     input_file = ExtractJarInputFile(options.jar_file, options.input_file,
                                      options.output_dir)
   elif options.input_file:
     input_file = options.input_file
   else:
     option_parser.print_help()
     print '\nError: Must specify --jar_file or --input_file.'
     return 1
   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)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))