base/android/jni_android.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/android/jni_android.h"
   6
   7 #include <map>
   8
   9 #include "base/android/build_info.h"
  10 #include "base/android/jni_string.h"
  11 #include "base/android/jni_utils.h"
  12 #include "base/lazy_instance.h"
  13 #include "base/logging.h"
  14
  15 namespace {
  16 using base::android::GetClass;
  17 using base::android::MethodID;
  18 using base::android::ScopedJavaLocalRef;
  19
  20 bool g_disable_manual_jni_registration = false;
  21
  22 JavaVM* g_jvm = NULL;
  23 // Leak the global app context, as it is used from a non-joinable worker thread
  24 // that may still be running at shutdown. There is no harm in doing this.
  25 base::LazyInstance<base::android::ScopedJavaGlobalRef<jobject> >::Leaky
  26     g_application_context = LAZY_INSTANCE_INITIALIZER;
  27 base::LazyInstance<base::android::ScopedJavaGlobalRef<jobject> >::Leaky
  28     g_class_loader = LAZY_INSTANCE_INITIALIZER;
  29 jmethodID g_class_loader_load_class_method_id = 0;
  30
  31 }  // namespace
  32
  33 namespace base {
  34 namespace android {
  35
  36 bool IsManualJniRegistrationDisabled() {
  37   return g_disable_manual_jni_registration;
  38 }
  39
  40 void DisableManualJniRegistration() {
  41   DCHECK(!g_disable_manual_jni_registration);
  42   g_disable_manual_jni_registration = true;
  43 }
  44
  45 JNIEnv* AttachCurrentThread() {
  46   DCHECK(g_jvm);
  47   JNIEnv* env = NULL;
  48   jint ret = g_jvm->AttachCurrentThread(&env, NULL);
  49   DCHECK_EQ(JNI_OK, ret);
  50   return env;
  51 }
  52
  53 JNIEnv* AttachCurrentThreadWithName(const std::string& thread_name) {
  54   DCHECK(g_jvm);
  55   JavaVMAttachArgs args;
  56   args.version = JNI_VERSION_1_2;
  57   args.name = thread_name.c_str();
  58   args.group = NULL;
  59   JNIEnv* env = NULL;
  60   jint ret = g_jvm->AttachCurrentThread(&env, &args);
  61   DCHECK_EQ(JNI_OK, ret);
  62   return env;
  63 }
  64
  65 void DetachFromVM() {
  66   // Ignore the return value, if the thread is not attached, DetachCurrentThread
  67   // will fail. But it is ok as the native thread may never be attached.
  68   if (g_jvm)
  69     g_jvm->DetachCurrentThread();
  70 }
  71
  72 void InitVM(JavaVM* vm) {
  73   DCHECK(!g_jvm);
  74   g_jvm = vm;
  75 }
  76
  77 bool IsVMInitialized() {
  78   return g_jvm != NULL;
  79 }
  80
  81 void InitApplicationContext(JNIEnv* env, const JavaRef<jobject>& context) {
  82   if (env->IsSameObject(g_application_context.Get().obj(), context.obj())) {
  83     // It's safe to set the context more than once if it's the same context.
  84     return;
  85   }
  86   DCHECK(g_application_context.Get().is_null());
  87   g_application_context.Get().Reset(context);
  88 }
  89
  90 void InitReplacementClassLoader(JNIEnv* env,
  91                                 const JavaRef<jobject>& class_loader) {
  92   DCHECK(g_class_loader.Get().is_null());
  93   DCHECK(!class_loader.is_null());
  94
  95   ScopedJavaLocalRef<jclass> class_loader_clazz =
  96       GetClass(env, "java/lang/ClassLoader");
  97   CHECK(!ClearException(env));
  98   g_class_loader_load_class_method_id =
  99       env->GetMethodID(class_loader_clazz.obj(),
 100                        "loadClass",
 101                        "(Ljava/lang/String;)Ljava/lang/Class;");
 102   CHECK(!ClearException(env));
 103
 104   DCHECK(env->IsInstanceOf(class_loader.obj(), class_loader_clazz.obj()));
 105   g_class_loader.Get().Reset(class_loader);
 106 }
 107
 108 const jobject GetApplicationContext() {
 109   DCHECK(!g_application_context.Get().is_null());
 110   return g_application_context.Get().obj();
 111 }
 112
 113 ScopedJavaLocalRef<jclass> GetClass(JNIEnv* env, const char* class_name) {
 114   jclass clazz;
 115   if (!g_class_loader.Get().is_null()) {
 116     // ClassLoader.loadClass expects a classname with components separated by
 117     // dots instead of the slashes that JNIEnv::FindClass expects. The JNI
 118     // generator generates names with slashes, so we have to replace them here.
 119     // TODO(torne): move to an approach where we always use ClassLoader except
 120     // for the special case of base::android::GetClassLoader(), and change the
 121     // JNI generator to generate dot-separated names. http://crbug.com/461773
 122     size_t bufsize = strlen(class_name) + 1;
 123     char dotted_name[bufsize];
 124     memmove(dotted_name, class_name, bufsize);
 125     for (size_t i = 0; i < bufsize; ++i) {
 126       if (dotted_name[i] == '/') {
 127         dotted_name[i] = '.';
 128       }
 129     }
 130
 131     clazz = static_cast<jclass>(
 132         env->CallObjectMethod(g_class_loader.Get().obj(),
 133                               g_class_loader_load_class_method_id,
 134                               ConvertUTF8ToJavaString(env, dotted_name).obj()));
 135   } else {
 136     clazz = env->FindClass(class_name);
 137   }
 138   CHECK(!ClearException(env) && clazz) << "Failed to find class " << class_name;
 139   return ScopedJavaLocalRef<jclass>(env, clazz);
 140 }
 141
 142 jclass LazyGetClass(
 143     JNIEnv* env,
 144     const char* class_name,
 145     base::subtle::AtomicWord* atomic_class_id) {
 146   COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jclass),
 147                  AtomicWord_SmallerThan_jMethodID);
 148   subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_class_id);
 149   if (value)
 150     return reinterpret_cast<jclass>(value);
 151   ScopedJavaGlobalRef<jclass> clazz;
 152   clazz.Reset(GetClass(env, class_name));
 153   subtle::AtomicWord null_aw = reinterpret_cast<subtle::AtomicWord>(NULL);
 154   subtle::AtomicWord cas_result = base::subtle::Release_CompareAndSwap(
 155       atomic_class_id,
 156       null_aw,
 157       reinterpret_cast<subtle::AtomicWord>(clazz.obj()));
 158   if (cas_result == null_aw) {
 159     // We intentionally leak the global ref since we now storing it as a raw
 160     // pointer in |atomic_class_id|.
 161     return clazz.Release();
 162   } else {
 163     return reinterpret_cast<jclass>(cas_result);
 164   }
 165 }
 166
 167 template<MethodID::Type type>
 168 jmethodID MethodID::Get(JNIEnv* env,
 169                         jclass clazz,
 170                         const char* method_name,
 171                         const char* jni_signature) {
 172   jmethodID id = type == TYPE_STATIC ?
 173       env->GetStaticMethodID(clazz, method_name, jni_signature) :
 174       env->GetMethodID(clazz, method_name, jni_signature);
 175   CHECK(base::android::ClearException(env) || id) <<
 176       "Failed to find " <<
 177       (type == TYPE_STATIC ? "static " : "") <<
 178       "method " << method_name << " " << jni_signature;
 179   return id;
 180 }
 181
 182 // If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call
 183 // into ::Get() above. If there's a race, it's ok since the values are the same
 184 // (and the duplicated effort will happen only once).
 185 template<MethodID::Type type>
 186 jmethodID MethodID::LazyGet(JNIEnv* env,
 187                             jclass clazz,
 188                             const char* method_name,
 189                             const char* jni_signature,
 190                             base::subtle::AtomicWord* atomic_method_id) {
 191   COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jmethodID),
 192                  AtomicWord_SmallerThan_jMethodID);
 193   subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_method_id);
 194   if (value)
 195     return reinterpret_cast<jmethodID>(value);
 196   jmethodID id = MethodID::Get<type>(env, clazz, method_name, jni_signature);
 197   base::subtle::Release_Store(
 198       atomic_method_id, reinterpret_cast<subtle::AtomicWord>(id));
 199   return id;
 200 }
 201
 202 // Various template instantiations.
 203 template jmethodID MethodID::Get<MethodID::TYPE_STATIC>(
 204     JNIEnv* env, jclass clazz, const char* method_name,
 205     const char* jni_signature);
 206
 207 template jmethodID MethodID::Get<MethodID::TYPE_INSTANCE>(
 208     JNIEnv* env, jclass clazz, const char* method_name,
 209     const char* jni_signature);
 210
 211 template jmethodID MethodID::LazyGet<MethodID::TYPE_STATIC>(
 212     JNIEnv* env, jclass clazz, const char* method_name,
 213     const char* jni_signature, base::subtle::AtomicWord* atomic_method_id);
 214
 215 template jmethodID MethodID::LazyGet<MethodID::TYPE_INSTANCE>(
 216     JNIEnv* env, jclass clazz, const char* method_name,
 217     const char* jni_signature, base::subtle::AtomicWord* atomic_method_id);
 218
 219 bool HasException(JNIEnv* env) {
 220   return env->ExceptionCheck() != JNI_FALSE;
 221 }
 222
 223 bool ClearException(JNIEnv* env) {
 224   if (!HasException(env))
 225     return false;
 226   env->ExceptionDescribe();
 227   env->ExceptionClear();
 228   return true;
 229 }
 230
 231 void CheckException(JNIEnv* env) {
 232   if (!HasException(env))
 233     return;
 234
 235   // Exception has been found, might as well tell breakpad about it.
 236   jthrowable java_throwable = env->ExceptionOccurred();
 237   if (java_throwable) {
 238     // Clear the pending exception, since a local reference is now held.
 239     env->ExceptionDescribe();
 240     env->ExceptionClear();
 241
 242     // Set the exception_string in BuildInfo so that breakpad can read it.
 243     // RVO should avoid any extra copies of the exception string.
 244     base::android::BuildInfo::GetInstance()->SetJavaExceptionInfo(
 245         GetJavaExceptionInfo(env, java_throwable));
 246   }
 247
 248   // Now, feel good about it and die.
 249   CHECK(false) << "Please include Java exception stack in crash report";
 250 }
 251
 252 std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) {
 253   ScopedJavaLocalRef<jclass> throwable_clazz =
 254       GetClass(env, "java/lang/Throwable");
 255   jmethodID throwable_printstacktrace =
 256       MethodID::Get<MethodID::TYPE_INSTANCE>(
 257           env, throwable_clazz.obj(), "printStackTrace",
 258           "(Ljava/io/PrintStream;)V");
 259
 260   // Create an instance of ByteArrayOutputStream.
 261   ScopedJavaLocalRef<jclass> bytearray_output_stream_clazz =
 262       GetClass(env, "java/io/ByteArrayOutputStream");
 263   jmethodID bytearray_output_stream_constructor =
 264       MethodID::Get<MethodID::TYPE_INSTANCE>(
 265           env, bytearray_output_stream_clazz.obj(), "<init>", "()V");
 266   jmethodID bytearray_output_stream_tostring =
 267       MethodID::Get<MethodID::TYPE_INSTANCE>(
 268           env, bytearray_output_stream_clazz.obj(), "toString",
 269           "()Ljava/lang/String;");
 270   ScopedJavaLocalRef<jobject> bytearray_output_stream(env,
 271       env->NewObject(bytearray_output_stream_clazz.obj(),
 272                      bytearray_output_stream_constructor));
 273
 274   // Create an instance of PrintStream.
 275   ScopedJavaLocalRef<jclass> printstream_clazz =
 276       GetClass(env, "java/io/PrintStream");
 277   jmethodID printstream_constructor =
 278       MethodID::Get<MethodID::TYPE_INSTANCE>(
 279           env, printstream_clazz.obj(), "<init>",
 280           "(Ljava/io/OutputStream;)V");
 281   ScopedJavaLocalRef<jobject> printstream(env,
 282       env->NewObject(printstream_clazz.obj(), printstream_constructor,
 283                      bytearray_output_stream.obj()));
 284
 285   // Call Throwable.printStackTrace(PrintStream)
 286   env->CallVoidMethod(java_throwable, throwable_printstacktrace,
 287       printstream.obj());
 288
 289   // Call ByteArrayOutputStream.toString()
 290   ScopedJavaLocalRef<jstring> exception_string(
 291       env, static_cast<jstring>(
 292           env->CallObjectMethod(bytearray_output_stream.obj(),
 293                                 bytearray_output_stream_tostring)));
 294
 295   return ConvertJavaStringToUTF8(exception_string);
 296 }
 297
 298
 299 }  // namespace android
 300 }  // namespace base