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 655 matching lines @@
 
 ${INCLUDES}
 
 // Step 1: forward declarations.
 namespace {
 $CLASS_PATH_DEFINITIONS
 $METHOD_ID_DEFINITIONS
 }  // namespace
 
 $OPEN_NAMESPACE
+extern "C"{
 $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()
     }
     return WrapOutput(template.substitute(values))
 
   def GetClassPathDefinitionsString(self):
     ret = []
     ret += [self.GetClassPathDefinitions()]
     return '\n'.join(ret)
 
   def GetMethodIDDefinitionsString(self):
     """Returns the definition of method ids for the called by native methods."""
@@ skipping 58 matching lines @@
     return '\n'.join('#include "%s"' % x for x in includes)
 
   def GetKMethodsString(self, clazz):
     ret = []
     for native in self.natives:
       if (native.java_class_name == clazz or
           (not native.java_class_name and clazz == self.class_name)):
         ret += [self.GetKMethodArrayEntry(native)]
     return '\n'.join(ret)
 
-  def SubstituteNativeMethods(self, template):
-    """Substitutes JAVA_CLASS and KMETHODS in the provided template."""
-    ret = []
-    all_classes = self.GetUniqueClasses(self.natives)
-    all_classes[self.class_name] = self.fully_qualified_class
-    for clazz in all_classes:
-      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."""
-    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:
       return ''
     template = Template("""\
   g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = ${GET_METHOD_ID_IMPL}
   if (g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} == NULL) {
     return false;
   }
     """)
     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,
           'GET_METHOD_ID_IMPL': self.GetMethodIDImpl(called_by_native),
       }
       ret += [template.substitute(values)]
     return '\n'.join(ret)
 
   def GetRegisterNativesString(self):
     """Returns the code for RegisterNatives."""
+
+    if not self.called_by_natives and not self.options.eager_called_by_natives :
+        return ''
     template = Template("""\
 ${REGISTER_NATIVES_SIGNATURE} {
 ${CLASSES}
-${NATIVES}
 ${CALLED_BY_NATIVES}
   return true;
 }
 """)
     signature = 'static bool RegisterNativesImpl(JNIEnv* env'
     if self.init_native:
       signature += ', jclass clazz)'
     else:
       signature += ')'
 
-    natives = self.GetRegisterNativesImplString()
     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."""
-    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:
       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 = ''
     if self.namespace:
       namespace = self.namespace + '::'
     values = {'FULLY_QUALIFIED_CLASS': fully_qualified_class,
               'INIT_NATIVE_NAME': 'native' + self.init_native.name,
               'NAMESPACE': namespace,
-              'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString()
              }
     return template.substitute(values)
 
   def GetOpenNamespaceString(self):
     if self.namespace:
       all_namespaces = ['namespace %s {' % ns
                         for ns in self.namespace.split('::')]
       return '\n'.join(all_namespaces)
     return ''
 
@@ skipping 31 matching lines @@
                            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("""
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS});
+__attribute__((alias("${NAME}"), visibility("default"))) ${RETURN}
+    Java_${JAVA_NAME}_native${NAME}(JNIEnv* env, ${PARAMS});
 """)
+    java_name = JniParams.RemapClassName(self.fully_qualified_class).replace('_', '_1').replace('/', '_')
+    if native.java_class_name:
+      java_name += "_00024" + native.java_class_name
+
     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("""\
 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};
 }
+__attribute__((alias("${NAME}"), visibility("default")))
+  ${RETURN} Java_${JAVA_NAME}_native${NAME}(JNIEnv* env,
+      ${PARAMS_IN_DECLARATION});
 """)
     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()'
+    java_name = JniParams.RemapClassName(self.fully_qualified_class).replace('_', '_1').replace('/', '_')
+    if native.java_class_name:
+      java_name += "_00024" + native.java_class_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 115 matching lines @@
       jni_class_path = self.fully_qualified_class
       if entry.java_class_name:
         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 = []
+    if not self.called_by_natives:
+      return ''
     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)
+    all_classes = self.GetUniqueClasses(self.called_by_natives)
     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 all_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):
+    if not self.called_by_natives:
+      return ''
     """Returns the imlementation of FindClass for all known classes."""
     if self.init_native:
       template = Template("""\
   g_${JAVA_CLASS}_clazz = static_cast<jclass>(env->NewWeakGlobalRef(clazz));""")
     else:
       template = Template("""\
   g_${JAVA_CLASS}_clazz = reinterpret_cast<jclass>(env->NewGlobalRef(
       base::android::GetClass(env, k${JAVA_CLASS}ClassPath).obj()));""")
     ret = []
     for clazz in self.GetUniqueClasses(self.called_by_natives):
@@ skipping 202 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'
   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))