Fixes JNI Bindings & startup perf.

base/android/jni_generator/jni_generator.py

 #!/usr/bin/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
@@ skipping 587 matching lines @@
     return '\n'.join(ret)
 
   def GetRegisterNativesImplString(self):
     """Returns the implementation for RegisterNatives."""
     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.obj(),
+  if (env->RegisterNatives(g_${JAVA_CLASS}_clazz,
                            kMethods${JAVA_CLASS},
                            kMethods${JAVA_CLASS}Size) < 0) {
     LOG(ERROR) << "RegisterNatives failed in " << __FILE__;
     return false;
   }
 """)
     ret = []
     all_classes = self.GetUniqueClasses(self.natives)
     all_classes[self.class_name] = self.fully_qualified_class
     for clazz in all_classes:
@@ skipping 98 matching lines @@
 JNIEnv* env${FIRST_PARAM_IN_DECLARATION}${PARAMS_IN_DECLARATION})""")
     function_header_template = Template("""\
 ${FUNCTION_SIGNATURE} {""")
     function_header_with_unused_template = Template("""\
 ${FUNCTION_SIGNATURE} __attribute__ ((unused));
 ${FUNCTION_SIGNATURE} {""")
     template = Template("""
 static jmethodID g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = 0;
 ${FUNCTION_HEADER}
   /* Must call RegisterNativesImpl()  */
-  DCHECK(!g_${JAVA_CLASS}_clazz.is_null());
+  DCHECK(g_${JAVA_CLASS}_clazz);
   DCHECK(g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
   ${RETURN_DECLARATION}
   ${PRE_CALL}env->Call${STATIC}${ENV_CALL}Method(${FIRST_PARAM_IN_CALL},
       g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}${PARAMS_IN_CALL})${POST_CALL};
   ${CHECK_EXCEPTION}
   ${RETURN_CLAUSE}
 }""")
     if called_by_native.static:
       first_param_in_declaration = ''
-      first_param_in_call = ('g_%s_clazz.obj()' %
+      first_param_in_call = ('g_%s_clazz' %
                              (called_by_native.java_class_name or
                               self.class_name))
     else:
       first_param_in_declaration = ', jobject obj'
       first_param_in_call = 'obj'
     params_in_declaration = self.GetCalledByNativeParamsInDeclaration(
         called_by_native)
     if params_in_declaration:
       params_in_declaration = ', ' + params_in_declaration
     params_for_call = ', '.join(param.name
@@ skipping 61 matching lines @@
       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 = []
     template = Template("""\
-const char* const k${JAVA_CLASS}ClassPath = "${JNI_CLASS_PATH}";""")
+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)
     for clazz in all_classes:
       values = {
           'JAVA_CLASS': clazz,
           'JNI_CLASS_PATH': all_classes[clazz],
       }
       ret += [template.substitute(values)]
     ret += ''
     for clazz in called_by_native_classes:
       template = Template("""\
-// Leaking this JavaRef as we cannot use LazyInstance from some threads.
-base::android::ScopedJavaGlobalRef<jclass>&
-    g_${JAVA_CLASS}_clazz =
-        *(new base::android::ScopedJavaGlobalRef<jclass>());""")
+// 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):
     """Returns the imlementation of FindClass for all known classes."""
     template = Template("""\
-  g_${JAVA_CLASS}_clazz.Reset(
-      base::android::GetClass(env, k${JAVA_CLASS}ClassPath));""")
+  g_${JAVA_CLASS}_clazz = reinterpret_cast<jclass>(env->NewGlobalRef(
+      base::android::GetUnscopedClass(env, k${JAVA_CLASS}ClassPath)));""")
     ret = []
     for clazz in self.GetUniqueClasses(self.called_by_natives):
       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("""\
-  g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = base::android::Get${STATIC}MethodID(
-    env, g_${JAVA_CLASS}_clazz,
-    "${NAME}",
-    ${JNI_SIGNATURE});
+  g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} =
+      base::android::Get${STATIC}MethodID(
+          env, g_${JAVA_CLASS}_clazz,
+          "${NAME}",
+          ${JNI_SIGNATURE});
 """)
     values = {
         'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
         'NAME': called_by_native.name,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'STATIC': 'Static' if called_by_native.static else '',
         'JNI_SIGNATURE': JniSignature(called_by_native.params,
                                       called_by_native.return_type,
                                       True)
     }
@@ skipping 92 matching lines @@
   if options.output_files:
     output_files = input_files[len(input_files) / 2:]
     input_files = input_files[:len(input_files) / 2]
   CheckFilenames(input_files, output_files)
   GenerateJNIHeaders(input_files, output_files, options.javap_class,
                      options.namespace)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))