[WIP] 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 581 matching lines @@
 #include "base/logging.h"
 
 using base::android::ScopedJavaLocalRef;
 
 // Step 1: forward declarations.
 namespace {
 $CLASS_PATH_DEFINITIONS
 }  // namespace
 
 $OPEN_NAMESPACE
+extern "C"{
 $FORWARD_DECLARATIONS
 
 // Step 2: method stubs.
 $METHOD_STUBS
+};
 
 // Step 3: RegisterNatives.
 
 static bool RegisterNativesImpl(JNIEnv* env) {
 $REGISTER_NATIVES_IMPL
   return true;
 }
 $CLOSE_NAMESPACE
 #endif  // ${HEADER_GUARD}
 """)
@@ skipping 37 matching lines @@
   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 GetRegisterNativesImplString(self):
     """Returns the implementation for RegisterNatives."""
+    if not self.called_by_natives:
+      return ''
     template = Template("""\
   static const JNINativeMethod kMethods${JAVA_CLASS}[] = {
 ${KMETHODS}
   };
   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) {
     LOG(ERROR) << "RegisterNatives failed in " << __FILE__;
     return false;
   }
 """)
     ret = [self.GetFindClasses()]
     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)]
+    #    ret += [template.substitute(values)]
     if not ret: return ''
     return '\n' + '\n'.join(ret)
 
   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__((visibility("default"))) ${RETURN}
+    Java_${JAVA_NAME}_native${NAME}(JNIEnv* env, ${PARAMS})
+        __attribute__((alias("${NAME}")));

[bulach, 2013/06/28 00:45:54]

I think you can combine the attributes:
__attribute__((alias("${NAME}"), visibility("default")))

 """)
+    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 GetNativeMethodStub(self, native):
     """Returns stubs for native methods."""
     template = Template("""\
 static ${RETURN} ${NAME}(JNIEnv* env, ${PARAMS_IN_DECLARATION}) {
   DCHECK(${PARAM0_NAME}) << "${NAME}";
   ${P0_TYPE}* native = reinterpret_cast<${P0_TYPE}*>(${PARAM0_NAME});
   return native->${NAME}(env, obj${PARAMS_IN_CALL})${POST_CALL};
 }
+__attribute__((visibility("default"))) ${RETURN} Java_${JAVA_NAME}_native${NAME}(JNIEnv* env,
+  ${PARAMS_IN_DECLARATION}) __attribute__((alias("${NAME}")));
 """)
     params_for_call = ', '.join(p.name for p in native.params[1:])
     if params_for_call:
       params_for_call = ', ' + params_for_call
 
     return_type = JavaDataTypeToC(native.return_type)
     if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type):
       scoped_return_type = 'ScopedJavaLocalRef<' + return_type + '>'
       post_call = '.Release()'
     else:
       scoped_return_type = return_type
       post_call = ''
+    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,
         'SCOPED_RETURN': scoped_return_type,
+        '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_for_call,
         'POST_CALL': post_call
     }
     return template.substitute(values)
 
   def GetCalledByNativeMethodStub(self, called_by_native):
@@ skipping 97 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):
@@ skipping 150 matching lines @@
     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.namespace,
                     options.optimize_generation)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))