Define a Java-side global application context.

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;
 
 bool g_disable_manual_jni_registration = false;
 
 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;
 
 }  // namespace
 
 namespace base {
 namespace android {
 
 bool IsManualJniRegistrationDisabled() {
@@ skipping 34 matching lines @@
 
 void InitVM(JavaVM* vm) {
   DCHECK(!g_jvm || g_jvm == vm);
   g_jvm = vm;
 }
 
 bool IsVMInitialized() {
   return g_jvm != NULL;
 }
 
-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 InitReplacementClassLoader(JNIEnv* env,
                                 const JavaRef<jobject>& class_loader) {
   DCHECK(g_class_loader.Get().is_null());
   DCHECK(!class_loader.is_null());
 
   ScopedJavaLocalRef<jclass> class_loader_clazz =
       GetClass(env, "java/lang/ClassLoader");
   CHECK(!ClearException(env));
   g_class_loader_load_class_method_id =
       env->GetMethodID(class_loader_clazz.obj(),
                        "loadClass",
                        "(Ljava/lang/String;)Ljava/lang/Class;");
   CHECK(!ClearException(env));
 
   DCHECK(env->IsInstanceOf(class_loader.obj(), class_loader_clazz.obj()));
   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;
   if (!g_class_loader.Get().is_null()) {
     // ClassLoader.loadClass expects a classname with components separated by
     // dots instead of the slashes that JNIEnv::FindClass expects. The JNI
     // generator generates names with slashes, so we have to replace them here.
     // TODO(torne): move to an approach where we always use ClassLoader except
     // for the special case of base::android::GetClassLoader(), and change the
     // JNI generator to generate dot-separated names. http://crbug.com/461773
     size_t bufsize = strlen(class_name) + 1;
@@ skipping 168 matching lines @@
       env, static_cast<jstring>(
           env->CallObjectMethod(bytearray_output_stream.obj(),
                                 bytearray_output_stream_tostring)));
 
   return ConvertJavaStringToUTF8(exception_string);
 }
 
 
 }  // namespace android
 }  // namespace base