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 746 matching lines @@
 
 #include "base/android/jni_int_wrapper.h"
 
 // Step 1: forward declarations.
 namespace {
 $CLASS_PATH_DEFINITIONS
 $METHOD_ID_DEFINITIONS
 }  // namespace
 
 $OPEN_NAMESPACE
-$FORWARD_DECLARATIONS
 
 $CONSTANT_FIELDS
 
 // Step 2: method stubs.
 $METHOD_STUBS
 
 // Step 3: RegisterNatives.
 $JNI_NATIVE_METHODS
 $REGISTER_NATIVES
 $CLOSE_NAMESPACE
 $JNI_REGISTER_NATIVES
 #endif  // ${HEADER_GUARD}
 """)
     values = {
         'SCRIPT_NAME': self.options.script_name,
         'FULLY_QUALIFIED_CLASS': self.fully_qualified_class,
         'CLASS_PATH_DEFINITIONS': self.GetClassPathDefinitionsString(),
         'METHOD_ID_DEFINITIONS': self.GetMethodIDDefinitionsString(),
-        'FORWARD_DECLARATIONS': self.GetForwardDeclarationsString(),
         'CONSTANT_FIELDS': self.GetConstantFieldsString(),
         'METHOD_STUBS': self.GetMethodStubsString(),
         'OPEN_NAMESPACE': self.GetOpenNamespaceString(),
         'JNI_NATIVE_METHODS': self.GetJNINativeMethodsString(),
         'REGISTER_NATIVES': self.GetRegisterNativesString(),
         'CLOSE_NAMESPACE': self.GetCloseNamespaceString(),
         'HEADER_GUARD': self.header_guard,
         'INCLUDES': self.GetIncludesString(),
         'JNI_REGISTER_NATIVES': self.GetJNIRegisterNativesString()
     }
@@ skipping 12 matching lines @@
 jmethodID g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = NULL;""")
     ret = []
     for called_by_native in self.called_by_natives:
       values = {
           'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
           '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)]
+      ret += [self.GetNativeStub(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)
+    values = {'NAME': native.name,
+              'JAVA_NAME': java_name}
+    return template.substitute(values)
+
+  def GetNativeStub(self, native):
+    is_method = native.type == 'method'
+
+    if is_method:
+      params = native.params[1:]
     else:
-      return native.name
-
-  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}) {
-  return ${NAME}(${PARAMS_IN_CALL});
-}
-"""
-    template = Template(template_str)
+      params = native.params
     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])
+    params_in_call = ', '.join(params_in_call + [p.name for p in params])
 
-    values = {'RETURN': JavaDataTypeToC(native.return_type),
-              'NAME': native.name,
-              'PARAMS': self.GetParamsInDeclaration(native),
-              'PARAMS_IN_CALL': params_in_call,
-              'STUB_NAME': self.GetStubName(native)}
-    return template.substitute(values)
+    if self.options.native_exports:
+      stub_visibility = 'extern "C" __attribute__((visibility("default")))\n'
+    else:
+      stub_visibility = 'static '
+    return_type = JavaDataTypeToC(native.return_type)
+    values = {
+        'RETURN': return_type,
+        'NAME': native.name,
+        'PARAMS': self.GetParamsInDeclaration(native),
+        'PARAMS_IN_CALL': params_in_call,
+        'STUB_NAME': self.GetStubName(native),
+        'STUB_VISIBILITY': stub_visibility,
+    }
 
-  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 += """
+    if is_method:
+      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()'
+      values.update({
+          'OPTIONAL_ERROR_RETURN': optional_error_return,
+          'PARAM0_NAME': native.params[0].name,
+          'P0_TYPE': native.p0_type,
+          'POST_CALL': post_call,
+      })
+      template = Template("""\
+${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env,
+    ${PARAMS}) {
   ${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} ${NAME}(JNIEnv* env, ${PARAMS});
 
-    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:]])
+${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) {
+  return ${NAME}(${PARAMS_IN_CALL});
+}
+""")
 
-    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()'
-
-    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),
-    }
     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 401 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))