Remove env() getter from JavaRef<>

content/browser/renderer_host/java/java_bound_object.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 "content/browser/renderer_host/java/java_bound_object.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/memory/singleton.h"
 #include "base/string_number_conversions.h"
@@ skipping 673 matching lines @@
   // The object is created with a ref count of one.
   NPObject* np_object = WebBindings::createObject(0, const_cast<NPClass*>(
       &JavaNPObject::kNPClass));
   // The NPObject takes ownership of the JavaBoundObject.
   reinterpret_cast<JavaNPObject*>(np_object)->bound_object =
       new JavaBoundObject(object);
   return np_object;
 }
 
 JavaBoundObject::JavaBoundObject(const JavaRef<jobject>& object)
-    : java_object_(object.env()->NewGlobalRef(object.obj())) {
+    : java_object_(object) {
   // We don't do anything with our Java object when first created. We do it all
   // lazily when a method is first invoked.
 }
 
 JavaBoundObject::~JavaBoundObject() {
-  // Use the current thread's JNI env to release our global ref to the Java
-  // object.
-  AttachCurrentThread()->DeleteGlobalRef(java_object_);
 }
 
 jobject JavaBoundObject::GetJavaObject(NPObject* object) {
   DCHECK_EQ(&JavaNPObject::kNPClass, object->_class);
   JavaBoundObject* jbo = reinterpret_cast<JavaNPObject*>(object)->bound_object;
-  return jbo->java_object_;
+  return jbo->java_object_.obj();
 }
 
 bool JavaBoundObject::HasMethod(const std::string& name) const {
   EnsureMethodsAreSetUp();
   return methods_.find(name) != methods_.end();
 }
 
 bool JavaBoundObject::Invoke(const std::string& name, const NPVariant* args,
                              size_t arg_count, NPVariant* result) {
   EnsureMethodsAreSetUp();
@@ skipping 20 matching lines @@
 
   // Coerce
   std::vector<jvalue> parameters(arg_count);
   for (size_t i = 0; i < arg_count; ++i) {
     parameters[i] = CoerceJavaScriptValueToJavaValue(args[i],
                                                      method->parameter_type(i),
                                                      true);
   }
 
   // Call
-  *result = CallJNIMethod(java_object_, method->return_type(), method->id(),
-                          &parameters[0]);
+  *result = CallJNIMethod(java_object_.obj(), method->return_type(),
+                          method->id(), &parameters[0]);
   return true;
 }
 
 void JavaBoundObject::EnsureMethodsAreSetUp() const {
   if (!methods_.empty()) {
     return;
   }
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jclass> clazz(env, static_cast<jclass>(
-      env->CallObjectMethod(java_object_,  GetMethodIDFromClassName(
+      env->CallObjectMethod(java_object_.obj(),  GetMethodIDFromClassName(
           env,
           kJavaLangObject,
           kGetClass,
           kReturningJavaLangClass))));
   ScopedJavaLocalRef<jobjectArray> methods(env, static_cast<jobjectArray>(
       env->CallObjectMethod(clazz.obj(), GetMethodIDFromClassName(
           env,
           kJavaLangClass,
           kGetMethods,
           kReturningJavaLangReflectMethodArray))));
   size_t num_methods = env->GetArrayLength(methods.obj());
   DCHECK(num_methods) << "Java objects always have public methods";
   for (size_t i = 0; i < num_methods; ++i) {
     ScopedJavaLocalRef<jobject> java_method(
         env,
         env->GetObjectArrayElement(methods.obj(), i));
     JavaMethod* method = new JavaMethod(java_method);
     methods_.insert(std::make_pair(method->name(), method));
   }
 }