Make class lookup lazy in jni_generator when using lazy method lookup.

base/android/jni_android.cc

 // 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.
 
 #include "base/android/jni_android.h"
 
 #include <map>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_string.h"
+#include "base/android/jni_utils.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 
 namespace {
 using base::android::GetClass;
 using base::android::MethodID;
 using base::android::ScopedJavaLocalRef;
 
 JavaVM* g_jvm = NULL;
 // Leak the global app context, as it is used from a non-joinable worker thread
 // that may still be running at shutdown. There is no harm in doing this.
 base::LazyInstance<base::android::ScopedJavaGlobalRef<jobject> >::Leaky
     g_application_context = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<base::android::ScopedJavaGlobalRef<jobject> >::Leaky
+    g_class_loader = LAZY_INSTANCE_INITIALIZER;
+jmethodID g_class_loader_load_class_method_id = 0;
 
 std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) {
   ScopedJavaLocalRef<jclass> throwable_clazz =
       GetClass(env, "java/lang/Throwable");
   jmethodID throwable_printstacktrace =
       MethodID::Get<MethodID::TYPE_INSTANCE>(
           env, throwable_clazz.obj(), "printStackTrace",
           "(Ljava/io/PrintStream;)V");
 
   // Create an instance of ByteArrayOutputStream.
@@ skipping 77 matching lines @@
 
 void InitApplicationContext(JNIEnv* env, const JavaRef<jobject>& context) {
   if (env->IsSameObject(g_application_context.Get().obj(), context.obj())) {
     // It's safe to set the context more than once if it's the same context.
     return;
   }
   DCHECK(g_application_context.Get().is_null());
   g_application_context.Get().Reset(context);
 }
 
+void InitFallbackClassLoader(JNIEnv* env) {
+  DCHECK(g_class_loader.Get().is_null());
+
+  ScopedJavaLocalRef<jclass> class_loader_clazz =
+      GetClass(env, "java/lang/ClassLoader");
+  g_class_loader_load_class_method_id =
+      env->GetMethodID(class_loader_clazz.obj(),
+                       "loadClass",
+                       "(Ljava/lang/String;)Ljava/lang/Class;");
+  ScopedJavaLocalRef<jobject> class_loader = GetClassLoader(env);

[mkosiba (inactive), 2014/08/15 16:53:50]

having jni_android depend on jni initialization having already been performed is
not ideal. The alternative is to pass the instance in as an argument, but that
seems silly, since we're requiring the caller to 'connect the dots' for us.

+  DCHECK(!class_loader.is_null());
+  g_class_loader.Get().Reset(class_loader);
+}
+
 const jobject GetApplicationContext() {
   DCHECK(!g_application_context.Get().is_null());
   return g_application_context.Get().obj();
 }
 
 ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name) {
-  jclass clazz = env->FindClass(class_name);
+  jclass clazz;
+  if (!g_class_loader.Get().is_null()) {
+    clazz = static_cast<jclass>(
+        env->CallObjectMethod(g_class_loader.Get().obj(),
+                              g_class_loader_load_class_method_id,
+                              ConvertUTF8ToJavaString(env, class_name).obj()));
+  } else {
+    clazz = env->FindClass(class_name);
+  }
   CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
   return ScopedJavaLocalRef<jclass>(env, clazz);
 }
 
+jclass LazyGetClass(
+    JNIEnv* env,
+    const char* class_name,
+    base::subtle::AtomicWord* atomic_class_id) {
+  COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jclass),
+                 AtomicWord_SmallerThan_jMethodID);
+  subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_class_id);
+  if (value)
+    return reinterpret_cast<jclass>(value);
+  ScopedJavaGlobalRef<jclass> clazz;
+  clazz.Reset(GetClass(env, class_name));
+  subtle::AtomicWord null_aw = reinterpret_cast<subtle::AtomicWord>(NULL);
+  subtle::AtomicWord old = base::subtle::Release_CompareAndSwap(
+      atomic_class_id,
+      null_aw,
+      reinterpret_cast<subtle::AtomicWord>(clazz.obj()));
+  if (old == null_aw) {
+    // We intentionally release the global ref as that makes it easy to store
+    // the ref in |atomic_class_id|.
+    return clazz.Release();
+  } else {
+    subtle::AtomicWord value = base::subtle::Release_Load(atomic_class_id);
+    CHECK(value);
+    return reinterpret_cast<jclass>(value);
+  }
+}
+
 template<MethodID::Type type>
 jmethodID MethodID::Get(JNIEnv* env,
                         jclass clazz,
                         const char* method_name,
                         const char* jni_signature) {
   jmethodID id = type == TYPE_STATIC ?
       env->GetStaticMethodID(clazz, method_name, jni_signature) :
       env->GetMethodID(clazz, method_name, jni_signature);
   CHECK(base::android::ClearException(env) || id) <<
       "Failed to find " <<
@@ skipping 67 matching lines @@
     base::android::BuildInfo::GetInstance()->set_java_exception_info(
         GetJavaExceptionInfo(env, java_throwable));
   }
 
   // Now, feel good about it and die.
   CHECK(false) << "Please include Java exception stack in crash report";
 }
 
 }  // namespace android
 }  // namespace base