Android: lazy initialization for method id.

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.
 
 # TODO (qinmin): Need to refactor this file as base should not know about
 # higher level concepts. Currently this file has knowledge about higher level
 # java classes.
 
 """Extracts native methods from a Java file and generates the JNI bindings.
@@ skipping 566 matching lines @@
 //     ${SCRIPT_NAME}
 // For
 //     ${FULLY_QUALIFIED_CLASS}
 
 #ifndef ${HEADER_GUARD}
 #define ${HEADER_GUARD}
 
 #include <jni.h>
 
 #include "base/android/jni_android.h"
+#include "base/android/jni_method_id.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 using base::android::ScopedJavaLocalRef;
 
 // Step 1: forward declarations.
 namespace {
 $CLASS_PATH_DEFINITIONS
 }  // namespace
 
 $OPEN_NAMESPACE
 $FORWARD_DECLARATIONS
 
 // Step 2: method stubs.
 $METHOD_STUBS
 
-// Step 3: GetMethodIDs and RegisterNatives.
-static void GetMethodIDsImpl(JNIEnv* env) {
-$GET_METHOD_IDS_IMPL
-}
+// Step 3: RegisterNatives.
 
 static bool RegisterNativesImpl(JNIEnv* env) {
-  GetMethodIDsImpl(env);
 $REGISTER_NATIVES_IMPL
   return true;
 }
 $CLOSE_NAMESPACE
 #endif  // ${HEADER_GUARD}
 """)
     script_components = os.path.abspath(sys.argv[0]).split(os.path.sep)
     base_index = script_components.index('base')
     script_name = os.sep.join(script_components[base_index:])
     values = {
         'SCRIPT_NAME': script_name,
         'FULLY_QUALIFIED_CLASS': self.fully_qualified_class,
         'CLASS_PATH_DEFINITIONS': self.GetClassPathDefinitionsString(),
         'FORWARD_DECLARATIONS': self.GetForwardDeclarationsString(),
         'METHOD_STUBS': self.GetMethodStubsString(),
         'OPEN_NAMESPACE': self.GetOpenNamespaceString(),
-        'GET_METHOD_IDS_IMPL': self.GetMethodIDsImplString(),
         'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString(),
         'CLOSE_NAMESPACE': self.GetCloseNamespaceString(),
         'HEADER_GUARD': self.header_guard,
     }
     return WrapOutput(template.substitute(values))
 
   def GetClassPathDefinitionsString(self):
     ret = []
     ret += [self.GetClassPathDefinitions()]
     return '\n'.join(ret)
@@ skipping 15 matching lines @@
     return '\n'.join(ret)
 
   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 GetMethodIDsImplString(self):
-    ret = []
-    ret += [self.GetFindClasses()]
-    for called_by_native in self.called_by_natives:
-      ret += [self.GetMethodIDImpl(called_by_native)]
-    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,
                            kMethods${JAVA_CLASS},
                            kMethods${JAVA_CLASS}Size) < 0) {
     LOG(ERROR) << "RegisterNatives failed in " << __FILE__;
     return false;
   }
 """)
-    ret = []
+    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)]
     if not ret: return ''
     return '\n' + '\n'.join(ret)
@@ skipping 88 matching lines @@
     """Returns a string."""
     function_signature_template = Template("""\
 static ${RETURN_TYPE} Java_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}(\
 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;
+static base::subtle::AtomicWord g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = 0;
 ${FUNCTION_HEADER}
   /* Must call RegisterNativesImpl()  */
   DCHECK(g_${JAVA_CLASS}_clazz);
-  DCHECK(g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
+  jmethodID id =
+    ${GET_METHOD_ID_IMPL}
   ${RETURN_DECLARATION}
   ${PRE_CALL}env->${ENV_CALL}(${FIRST_PARAM_IN_CALL},
-      g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}${PARAMS_IN_CALL})${POST_CALL};
+      id${PARAMS_IN_CALL})${POST_CALL};
   ${CHECK_EXCEPTION}
   ${RETURN_CLAUSE}
 }""")
     if called_by_native.static or called_by_native.is_constructor:
       first_param_in_declaration = ''
       first_param_in_call = ('g_%s_clazz' %
                              (called_by_native.java_class_name or
                               self.class_name))
     else:
       first_param_in_declaration = ', jobject obj'
@@ skipping 34 matching lines @@
         'FIRST_PARAM_IN_DECLARATION': first_param_in_declaration,
         'PARAMS_IN_DECLARATION': params_in_declaration,
         'STATIC': 'Static' if called_by_native.static else '',
         'PRE_CALL': pre_call,
         'POST_CALL': post_call,
         'ENV_CALL': called_by_native.env_call,
         'FIRST_PARAM_IN_CALL': first_param_in_call,
         'PARAMS_IN_CALL': params_for_call,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
         'CHECK_EXCEPTION': check_exception,
+        'GET_METHOD_ID_IMPL': self.GetMethodIDImpl(called_by_native)
     }
     values['FUNCTION_SIGNATURE'] = (
         function_signature_template.substitute(values))
     if called_by_native.system_class:
       values['FUNCTION_HEADER'] = (
           function_header_with_unused_template.substitute(values))
     else:
       values['FUNCTION_HEADER'] = function_header_template.substitute(values)
     return template.substitute(values)
 
@@ skipping 48 matching lines @@
   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${SUFFIX}(
-          env, g_${JAVA_CLASS}_clazz,
-          "${JNI_NAME}",
-          ${JNI_SIGNATURE});
+    template = Template("""
+  base::android::MethodID::LazyGet<
+      base::android::MethodID::METHODTYPE_${STATIC},
+      base::android::MethodID::EXCEPTIONCHECK_${CHECK_EXCEPTION}>(
+      env, g_${JAVA_CLASS}_clazz,
+      "${JNI_NAME}",
+      ${JNI_SIGNATURE},
+      &g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME});
 """)
     jni_name = called_by_native.name
     jni_return_type = called_by_native.return_type
     if called_by_native.is_constructor:
       jni_name = '<init>'
       jni_return_type = 'void'
     values = {
         'JAVA_CLASS': called_by_native.java_class_name or self.class_name,
         'JNI_NAME': jni_name,
         'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name,
-        'STATIC': 'Static' if called_by_native.static else '',
-        'SUFFIX': 'OrNull' if called_by_native.system_class else '',
+        'STATIC': 'STATIC' if called_by_native.static else 'NORMAL',
+        'CHECK_EXCEPTION': 'NO' if called_by_native.system_class else 'YES',
         'JNI_SIGNATURE': JniSignature(called_by_native.params,
                                       jni_return_type,
                                       True)
     }
     return template.substitute(values)
 
 
 def WrapOutput(output):
   ret = []
   for line in output.splitlines():
@@ skipping 92 matching lines @@
     input_file = options.input_file
   output_file = None
   if options.output_dir:
     root_name = os.path.splitext(os.path.basename(input_file))[0]
     output_file = os.path.join(options.output_dir, root_name) + '_jni.h'
   GenerateJNIHeader(input_file, output_file, options.namespace)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))