jni_generator: Wrap all native methods in stubs.

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 803 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};  // extern "C"'
     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};  // extern "C"'
     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 186 matching lines @@
         param.name
         for param in called_by_native.params])
 
   def GetStubName(self, native):
     """Return the name of the stub function for this native method.
 
     Args:
       native: the native dictionary describing the method.
 
     Returns:
-      A string with the stub function name. For native exports mode this is the
-      Java_* symbol name required by the JVM; otherwise it is just the name of
-      the native method itself.
+      A string with the stub function name (used by the JVM).
     """
-    if self.options.native_exports:
-      template = Template("Java_${JAVA_NAME}_native${NAME}")
+    template = Template("Java_${JAVA_NAME}_native${NAME}")
 
-      java_name = JniParams.RemapClassName(self.fully_qualified_class)
-      java_name = java_name.replace('_', '_1').replace('/', '_')
-      if native.java_class_name:
-        java_name += '_00024' + native.java_class_name
+    java_name = JniParams.RemapClassName(self.fully_qualified_class)
+    java_name = java_name.replace('_', '_1').replace('/', '_')
+    if native.java_class_name:
+      java_name += '_00024' + native.java_class_name
 
-      values = {'NAME': native.name,
-                'JAVA_NAME': java_name}
-      return template.substitute(values)
-    else:
-      return native.name
+    values = {'NAME': native.name,
+              'JAVA_NAME': java_name}
+    return template.substitute(values)
 
   def GetForwardDeclaration(self, native):
     template_str = """
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS});
-"""
-    if self.options.native_exports:
-      template_str += """
-__attribute__((visibility("default")))
-${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) {
+
+${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) {
   return ${NAME}(${PARAMS_IN_CALL});
 }
 """
     template = Template(template_str)
     params_in_call = []
     if not self.options.pure_native_methods:
       params_in_call = ['env', 'jcaller']
     params_in_call = ', '.join(params_in_call + [p.name for p in native.params])
+    if self.options.native_exports:
+      stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
+    else:
+      stub_visibility = 'static '
 
     values = {'RETURN': JavaDataTypeToC(native.return_type),
               'NAME': native.name,
               'PARAMS': self.GetParamsInDeclaration(native),
               'PARAMS_IN_CALL': params_in_call,
-              'STUB_NAME': self.GetStubName(native)}
+              'STUB_NAME': self.GetStubName(native),
+              'STUB_VISIBILITY': stub_visibility}
     return template.substitute(values)
 
   def GetNativeMethodStubString(self, native):
     """Returns stubs for native methods."""
-    if self.options.native_exports:
-      template_str = """\
-__attribute__((visibility("default")))
-${RETURN} ${STUB_NAME}(JNIEnv* env,
-    ${PARAMS_IN_DECLARATION}) {"""
-    else:
-      template_str = """\
-static ${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS_IN_DECLARATION}) {"""
-    template_str += """
+    template_str = """\
+${STUB_VISIBILITY}${RETURN} ${STUB_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};
 }
 """
-
     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:
+      stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
+    else:
+      stub_visibility = 'static '

[rmcilroy, 2015/08/12 10:35:35]

nit - pull this out to a helper function to avoid duplicating with above.

[Torne, 2015/08/12 10:37:56]

Actually, I could probably just merge these two functions at this point and have
it take a parameter for whether to treat it like a method or function, which is
the general goal anyway (to get to where the only difference is whether it
handles the "this" pointer for you). Will fiddle with that in a bit.

 
     values = {
         'RETURN': return_type,
         'OPTIONAL_ERROR_RETURN': optional_error_return,
         '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,
         'STUB_NAME': self.GetStubName(native),
+        'STUB_VISIBILITY': stub_visibility,
     }
     return template.substitute(values)
 
   def GetArgument(self, param):
     return ('as_jint(' + param.name + ')'
             if param.datatype == 'int' else param.name)
 
   def GetArgumentsInCall(self, params):
     """Return a string of arguments to call from native into Java"""
     return [self.GetArgument(p) for p in params]
@@ skipping 402 matching lines @@
   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))