jni_generator: Always generate native exports.

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 800 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 and not self.options.native_exports_optional:
+    if not self.options.native_exports_optional:
       return ''
     template = Template("""\
 static const JNINativeMethod kMethods${JAVA_CLASS}[] = {
 ${KMETHODS}
 };
 """)
     return self.SubstituteNativeMethods(template)
 
   def GetRegisterNativesString(self):
     """Returns the code for RegisterNatives."""
     template = Template("""\
 ${REGISTER_NATIVES_SIGNATURE} {
 ${EARLY_EXIT}
-${CLASSES}
 ${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;
 """
 
     natives = self.GetRegisterNativesImplString()
     values = {'REGISTER_NATIVES_SIGNATURE': signature,
               'EARLY_EXIT': early_exit,
-              'CLASSES': self.GetFindClasses(),
               'NATIVES': natives,
              }
     return template.substitute(values)
 
   def GetRegisterNativesImplString(self):
     """Returns the shared implementation for RegisterNatives."""
-    if self.options.native_exports and not self.options.native_exports_optional:
+    if not self.options.native_exports_optional:
       return ''
 
     template = Template("""\
   const int kMethods${JAVA_CLASS}Size = arraysize(kMethods${JAVA_CLASS});
 
   if (env->RegisterNatives(${JAVA_CLASS}_clazz(env),
                            kMethods${JAVA_CLASS},
                            kMethods${JAVA_CLASS}Size) < 0) {
     jni_generator::HandleRegistrationError(
         env, ${JAVA_CLASS}_clazz(env), __FILE__);
@@ skipping 104 matching lines @@
       params = native.params
     params_in_call = ['env'] + self.GetJNIFirstParamForCall(native)
     for p in params:
       c_type = JavaDataTypeToC(p.datatype)
       if re.match(RE_SCOPED_JNI_TYPES, c_type):
         params_in_call.append(self.GetJavaParamRefForCall(c_type, p.name))
       else:
         params_in_call.append(p.name)
     params_in_call = ', '.join(params_in_call)
 
-    if self.options.native_exports:
-      stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
-    else:
-      stub_visibility = 'static '
     return_type = return_declaration = JavaDataTypeToC(native.return_type)
     post_call = ''
     if re.match(RE_SCOPED_JNI_TYPES, return_type):
       post_call = '.Release()'
       return_declaration = 'ScopedJavaLocalRef<' + return_type + '>'
     values = {
         'RETURN': return_type,
         'RETURN_DECLARATION': return_declaration,
         'NAME': native.name,
         'PARAMS': self.GetParamsInDeclaration(native),
         'PARAMS_IN_STUB': self.GetParamsInStub(native),
         'PARAMS_IN_CALL': params_in_call,
         'POST_CALL': post_call,
         'STUB_NAME': self.GetStubName(native),
-        'STUB_VISIBILITY': stub_visibility,
     }
 
     if is_method:
       optional_error_return = JavaReturnValueToC(native.return_type)
       if optional_error_return:
         optional_error_return = ', ' + optional_error_return
       values.update({
           'OPTIONAL_ERROR_RETURN': optional_error_return,
           'PARAM0_NAME': native.params[0].name,
           'P0_TYPE': native.p0_type,
       })
       template = Template("""\
-${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env,
+extern "C" __attribute__((visibility("default")))
+${RETURN} ${STUB_NAME}(JNIEnv* env,
     ${PARAMS_IN_STUB}) {
   ${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};
 }
 """)
     else:
       template = Template("""
 static ${RETURN_DECLARATION} ${NAME}(JNIEnv* env, ${PARAMS});
 
-${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS_IN_STUB}) {
+extern "C" __attribute__((visibility("default")))
+${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS_IN_STUB}) {
   return ${NAME}(${PARAMS_IN_CALL})${POST_CALL};
 }
 """)
 
     return template.substitute(values)
 
   def GetArgument(self, param):
     return ('as_jint(' + param.name + ')'
             if param.datatype == 'int' else param.name)
 
@@ skipping 111 matching lines @@
         class_name = entry.java_class_name
         jni_class_path = self.fully_qualified_class + '$' + class_name
       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)
-    if self.options.native_exports and not self.options.native_exports_optional:
-      all_classes = called_by_native_classes
-    else:
-      all_classes = native_classes
-      all_classes.update(called_by_native_classes)
+    all_classes = self.GetUniqueClasses(self.called_by_natives)
+    if self.options.native_exports_optional:
+      all_classes.update(self.GetUniqueClasses(self.natives))
 
     for clazz in all_classes:
       values = {
           'JAVA_CLASS': clazz,
           'JNI_CLASS_PATH': all_classes[clazz],
       }
       ret += [template.substitute(values)]
     ret += ''
 
-    if self.options.native_exports:
-      template = Template("""\
+    template = Template("""\
 // Leaking this jclass as we cannot use LazyInstance from some threads.
 base::subtle::AtomicWord g_${JAVA_CLASS}_clazz __attribute__((unused)) = 0;
 #define ${JAVA_CLASS}_clazz(env) \
 base::android::LazyGetClass(env, k${JAVA_CLASS}ClassPath, \
 &g_${JAVA_CLASS}_clazz)""")
-    else:
-      template = Template("""\
-// Leaking this jclass as we cannot use LazyInstance from some threads.
-jclass g_${JAVA_CLASS}_clazz = NULL;
-#define ${JAVA_CLASS}_clazz(env) g_${JAVA_CLASS}_clazz""")
 
     for clazz in all_classes:
       values = {
           'JAVA_CLASS': clazz,
       }
       ret += [template.substitute(values)]
 
     return '\n'.join(ret)
 
-  def GetFindClasses(self):
-    """Returns the imlementation of FindClass for all known classes."""
-    if self.options.native_exports:
-      return '\n'
-    template = Template("""\
-  g_${JAVA_CLASS}_clazz = reinterpret_cast<jclass>(env->NewGlobalRef(
-      base::android::GetClass(env, k${JAVA_CLASS}ClassPath).obj()));""")
-    ret = []
-    all_classes = self.GetUniqueClasses(self.natives)
-    all_classes.update(self.GetUniqueClasses(self.called_by_natives))
-    for clazz in all_classes:
-      values = {'JAVA_CLASS': clazz}
-      ret += [template.substitute(values)]
-    return '\n'.join(ret)
-
   def GetMethodIDImpl(self, called_by_native):
     """Returns the implementation of GetMethodID."""
     template = Template("""\
   base::android::MethodID::LazyGet<
       base::android::MethodID::TYPE_${STATIC}>(
       env, ${JAVA_CLASS}_clazz(env),
       "${JNI_NAME}",
       ${JNI_SIGNATURE},
       &g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
 """)
@@ skipping 142 matching lines @@
                            'include in the generated header.')
   option_parser.add_option('--ptr_type', default='int',
                            type='choice', choices=['int', 'long'],
                            help='The type used to represent native pointers in '
                            'Java code. For 32-bit, use int; '
                            'for 64-bit, use long.')
   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',
-                           help='Native method registration through .so '
-                           'exports.')
   option_parser.add_option('--native_exports_optional', action='store_true',
                            help='Support both explicit and native method'
                            'registration.')
   options, args = option_parser.parse_args(argv)
-  if options.native_exports_optional:
-    options.native_exports = True
   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'
   GenerateJNIHeader(input_file, output_file, options)
 
   if options.depfile:
     build_utils.WriteDepfile(
         options.depfile,
         build_utils.GetPythonDependencies())
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))