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