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"
+#include "base/logging.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 {
   const char* name;
@@ skipping 106 matching lines @@
 // Returns true if an exception is pending in the provided JNIEnv*.
 bool HasException(JNIEnv* env);
 
 // If an exception is pending in the provided JNIEnv*, this function clears it
 // and returns true.
 bool ClearException(JNIEnv* env);
 
 // This function will call CHECK() macro if there's any pending exception.
 void CheckException(JNIEnv* env);
 
+class LazyMethodID {
+ public:
+  enum MethodType {
+    METHODTYPE_STATIC,
+    METHODTYPE_NORMAL,
+  };
+
+  enum ExceptionCheck {
+    EXCEPTIONCHECK_YES,

[Sami, 2012/10/02 15:14:05]

Super-nit: NO=0, YES=1 would seem more logical.

[bulach, 2012/10/02 15:28:30]

:) done..

+    EXCEPTIONCHECK_NO,
+  };
+
+  template<MethodType method_type, ExceptionCheck exception_check>
+  static void Get(JNIEnv* env,
+                  jclass clazz,
+                  const char* method_name,
+                  const char* jni_signature,
+                  jmethodID* method_id) {
+    subtle::AtomicWord* atomic = reinterpret_cast<subtle::AtomicWord*>(

[Sami, 2012/10/02 15:14:05]

I'm not sure which is better for this use, but an alternative would be to keep
the method id as a thread local value. Of course, there's some overhead to using
TLS too. For instance, every thread needs to redo the lookup.

[bulach, 2012/10/02 15:28:30]

hmm... we have base::internal::ThreadLocalPointer, but I presume the lookup /
set is more expensive than the atomic load / store?
of course, I can try to measure that too if you want.. :)

+        method_id);
+    subtle::AtomicWord value = base::subtle::Acquire_Load(atomic);
+    if (value)
+      return;
+    jmethodID id = method_type == METHODTYPE_STATIC ?
+        env->GetStaticMethodID(clazz, method_name, jni_signature) :
+        env->GetMethodID(clazz, method_name, jni_signature);
+    if (exception_check == EXCEPTIONCHECK_YES) {
+      CHECK(id || base::android::ClearException(env)) <<
+        "Failed to find " <<
+        (method_type == METHODTYPE_STATIC ? "static " : "") <<
+        "method " << method_name << " " << jni_signature;
+    } else if (base::android::HasException(env)) {
+      env->ExceptionClear();
+    }
+    base::subtle::Acquire_Store(
+        atomic, reinterpret_cast<subtle::AtomicWord>(id));
+  }
+};
+
+
 }  // namespace android
 }  // namespace base
 
 #endif  // BASE_ANDROID_JNI_ANDROID_H_