Android: lazy initialization for method id.

base/android/jni_android.h

 // 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.
 
 #ifndef BASE_ANDROID_JNI_ANDROID_H_
 #define BASE_ANDROID_JNI_ANDROID_H_
 
 #include <jni.h>
 #include <sys/types.h>
 
 #include "base/android/scoped_java_ref.h"
+#include "base/atomicops.h"
 #include "base/compiler_specific.h"
 
 namespace base {
 namespace android {
 
 // Used to mark symbols to be exported in a shared library's symbol table.
 #define JNI_EXPORT __attribute__ ((visibility("default")))
 
 // Contains the registration method information for initializing JNI bindings.
 struct RegistrationMethod {
@@ skipping 28 matching lines @@
 // Use HasClass if you need to check whether the class exists.
 ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name);
 
 // Similar to the above, but the caller is responsible to manage the jclass
 // lifetime.
 jclass GetUnscopedClass(JNIEnv* env, const char* class_name) WARN_UNUSED_RESULT;
 
 // Returns true iff the class |class_name| could be found.
 bool HasClass(JNIEnv* env, const char* class_name);
 
-// Returns the method ID for the method with the specified name and signature.
-// This method triggers a fatal assertion if the method could not be found.
-// Use HasMethod if you need to check whether a method exists.
-jmethodID GetMethodID(JNIEnv* env,
-                      const JavaRef<jclass>& clazz,
-                      const char* method_name,
-                      const char* jni_signature);
+// This class is a wrapper for JNIEnv Get(Static)MethodID.
+class MethodID {
+ public:
+  enum MethodType {
+    METHODTYPE_STATIC,
+    METHODTYPE_NORMAL,

[joth, 2012/10/05 15:24:57]

- METHOD seems redundant now this is in class MethodID (and that will probably
appear twice already where this is used)
- NORMAL => INSTANCE will help give more context at the call site. So:-

TYPE_STATIC,
TYPE_INSTANCE,

wdyt?

[bulach, 2012/10/05 15:58:15]

good idea joth, thanks!
done.

+  };
 
-// Similar to GetMethodID, but takes a raw jclass.
-jmethodID GetMethodID(JNIEnv* env,
-                      jclass clazz,
-                      const char* method_name,
-                      const char* jni_signature);
+  // Returns the method ID for the method with the specified name and signature.
+  // This method triggers a fatal assertion if the method could not be found.
+  template<MethodType method_type>
+  static jmethodID Get(JNIEnv* env,
+                       jclass clazz,
+                       const char* method_name,
+                       const char* jni_signature);
 
-// Unlike GetMethodID, returns NULL if the method could not be found.
-jmethodID GetMethodIDOrNull(JNIEnv* env,
-                            jclass clazz,
-                            const char* method_name,
-                            const char* jni_signature);
-
-// Returns the method ID for the static method with the specified name and
-// signature.
-// This method triggers a fatal assertion if the method could not be found.
-// Use HasMethod if you need to check whether a method exists.
-jmethodID GetStaticMethodID(JNIEnv* env,
-                            const JavaRef<jclass>& clazz,
-                            const char* method_name,
-                            const char* jni_signature);
-
-// Similar to the GetStaticMethodID, but takes a raw jclass.
-jmethodID GetStaticMethodID(JNIEnv* env,
-                            jclass clazz,
-                            const char* method_name,
-                            const char* jni_signature);
-
-// Unlike GetStaticMethodID, returns NULL if the method could not be found.
-jmethodID GetStaticMethodIDOrNull(JNIEnv* env,
-                                  jclass clazz,
-                                  const char* method_name,
-                                  const char* jni_signature);
-
-// Returns true iff |clazz| has a method with the specified name and signature.
-bool HasMethod(JNIEnv* env,
-               const JavaRef<jclass>& clazz,
-               const char* method_name,
-               const char* jni_signature);
+  // The caller is responsible to zero-initialize |atomic_method_id|.
+  // It's fine to simultaneously call this on multiple threads referencing the
+  // same |atomic_method_id|.
+  template<MethodType method_type>
+  static jmethodID LazyGet(JNIEnv* env,
+                           jclass clazz,
+                           const char* method_name,
+                           const char* jni_signature,
+                           base::subtle::AtomicWord* atomic_method_id);
+};
 
 // Gets the method ID from the class name. Clears the pending Java exception
 // and returns NULL if the method is not found. Caches results. Note that
-// GetMethodID() below avoids a class lookup, but does not cache results.
+// MethodID::Get() above avoids a class lookup, but does not cache results.
 // Strings passed to this function are held in the cache and MUST remain valid
 // beyond the duration of all future calls to this function, across all
 // threads. In practice, this means that the function should only be used with
 // string constants.
 jmethodID GetMethodIDFromClassName(JNIEnv* env,
                                    const char* class_name,
                                    const char* method,
                                    const char* jni_signature);
 
 // Gets the field ID for a class field.
@@ skipping 24 matching lines @@
 // and returns true.
 bool ClearException(JNIEnv* env);
 
 // This function will call CHECK() macro if there's any pending exception.
 void CheckException(JNIEnv* env);
 
 }  // namespace android
 }  // namespace base
 
 #endif  // BASE_ANDROID_JNI_ANDROID_H_