delete local refs to help memory issues

joeferner · joeferner · commit be0067606ed0 · 2012-07-24T23:41:49.000-04:00
diff --git a/src/javaObject.cpp b/src/javaObject.cpp
@@ -30,7 +30,8 @@
   jclass methodClazz = env->FindClass("java/lang/reflect/Method");
   jmethodID method_getName = env->GetMethodID(methodClazz, "getName", "()Ljava/lang/String;");
   for(std::list<jobject>::iterator it = methods.begin(); it != methods.end(); it++) {
-    std::string methodNameStr = javaToString(env, (jstring)env->CallObjectMethod(*it, method_getName));
+    jstring methodNameJava = (jstring)env->CallObjectMethod(*it, method_getName);
+    std::string methodNameStr = javaToString(env, methodNameJava);
 
     v8::Handle<v8::String> methodName = v8::String::New(methodNameStr.c_str());
     v8::Local<v8::FunctionTemplate> methodCallTemplate = v8::FunctionTemplate::New(methodCall, methodName);
@@ -39,16 +40,23 @@
     v8::Handle<v8::String> methodNameSync = v8::String::New((methodNameStr + "Sync").c_str());
     v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = v8::FunctionTemplate::New(methodCallSync, methodName);
     javaObjectObj->Set(methodNameSync, methodCallSyncTemplate->GetFunction());
+
+    env->DeleteLocalRef(methodNameJava);
+    env->DeleteLocalRef(*it);
   }
 
-  self->m_fields = javaReflectionGetFields(env, self->m_class);
+  std::list<jobject> fields = javaReflectionGetFields(env, self->m_class);
   jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
   jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;");
-  for(std::list<jobject>::iterator it = self->m_fields.begin(); it != self->m_fields.end(); it++) {
-    std::string fieldNameStr = javaToString(env, (jstring)env->CallObjectMethod(*it, field_getName));
+  for(std::list<jobject>::iterator it = fields.begin(); it != fields.end(); it++) {
+    jstring fieldNameJava = (jstring)env->CallObjectMethod(*it, field_getName);
+    std::string fieldNameStr = javaToString(env, fieldNameJava);
 
     v8::Handle<v8::String> fieldName = v8::String::New(fieldNameStr.c_str());
     javaObjectObj->SetAccessor(fieldName, fieldGetter, fieldSetter);
+
+    env->DeleteLocalRef(fieldNameJava);
+    env->DeleteLocalRef(*it);
   }
 
   return scope.Close(javaObjectObj);
@@ -105,6 +113,9 @@ JavaObject::~JavaObject() {
   InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback);
   baton->run();
 
+  env->DeleteLocalRef(methodArgs);
+  env->DeleteLocalRef(method);
+
   END_CALLBACK_FUNCTION("\"Method '" << methodNameStr << "' called without a callback did you mean to use the Sync version?\"");
 }
 
diff --git a/src/javaObject.h b/src/javaObject.h
@@ -32,7 +32,6 @@ class JavaObject : public node::ObjectWrap {
   Java* m_java;
   jobject m_obj;
   jclass m_class;
-  std::list<jobject> m_fields;
 };
 
 #endif
diff --git a/src/methodCallBaton.cpp b/src/methodCallBaton.cpp
@@ -136,6 +136,8 @@ void InstanceMethodCallBaton::execute(JNIEnv *env) {
 
   jobject result = env->CallObjectMethod(m_method, method_invoke, m_javaObject->getObject(), m_args);
 
+  env->DeleteLocalRef(methodClazz);
+
   jthrowable err = env->ExceptionOccurred();
   if(err) {
     m_error = (jthrowable)env->NewGlobalRef(err);
@@ -145,6 +147,7 @@ void InstanceMethodCallBaton::execute(JNIEnv *env) {
   }
 
   m_result = env->NewGlobalRef(result);
+  env->DeleteLocalRef(result);
 }
 
 NewInstanceBaton::NewInstanceBaton(
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -26,6 +26,7 @@ std::list<jobject> javaReflectionGetMethods(JNIEnv *env, jclass clazz) {
     }
     results.push_back(method);
   }
+  env->DeleteLocalRef(methodObjects);
 
   return results;
 }
@@ -48,6 +49,7 @@ std::list<jobject> javaReflectionGetFields(JNIEnv *env, jclass clazz) {
     }
     results.push_back(field);
   }
+  env->DeleteLocalRef(fieldObjects);
 
   return results;
 }
@@ -264,7 +266,9 @@ jobjectArray v8ToJava(JNIEnv* env, const v8::Arguments& args, int start, int end
   for(int i=start; i<end; i++) {
     jobject val = v8ToJava(env, args[i]);
     env->SetObjectArrayElement(results, i - start, val);
+    env->DeleteLocalRef(val);
   }
+  env->DeleteLocalRef(clazz);
 
   return results;
 }
@@ -405,8 +409,11 @@ jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs) {
     } else {
       jclass objClazz = env->GetObjectClass(elem);
       env->SetObjectArrayElement(results, i, objClazz);
+      env->DeleteLocalRef(objClazz);
     }
+    env->DeleteLocalRef(elem);
   }
+  env->DeleteLocalRef(clazzClazz);
   return results;
 }
 
@@ -418,6 +425,10 @@ jobject javaFindMethod(JNIEnv *env, jclass clazz, std::string& methodName, jobje
   jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs);
   jobject method = env->CallStaticObjectMethod(methodUtilsClazz, methodUtils_getMatchingAccessibleMethod, clazz, methodNameJavaStr, methodArgClasses);
 
+  env->DeleteLocalRef(methodUtilsClazz);
+  env->DeleteLocalRef(methodNameJavaStr);
+  env->DeleteLocalRef(methodArgClasses);
+
   return method;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -136,6 +136,8 @@ void InstanceMethodCallBaton::execute(JNIEnv *env) {`
`136`	`136`
`137`	`137`	`jobject result = env->CallObjectMethod(m_method, method_invoke, m_javaObject->getObject(), m_args);`
`138`	`138`
	`139`	`+ env->DeleteLocalRef(methodClazz);`
	`140`	`+`
`139`	`141`	`jthrowable err = env->ExceptionOccurred();`
`140`	`142`	`if(err) {`
`141`	`143`	`m_error = (jthrowable)env->NewGlobalRef(err);`
`@@ -145,6 +147,7 @@ void InstanceMethodCallBaton::execute(JNIEnv *env) {`
`145`	`147`	`}`
`146`	`148`
`147`	`149`	`m_result = env->NewGlobalRef(result);`
	`150`	`+ env->DeleteLocalRef(result);`
`148`	`151`	`}`
`149`	`152`
`150`	`153`	`NewInstanceBaton::NewInstanceBaton(`
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ std::list<jobject> javaReflectionGetMethods(JNIEnv *env, jclass clazz) {`
`26`	`26`	`}`
`27`	`27`	`results.push_back(method);`
`28`	`28`	`}`
	`29`	`+ env->DeleteLocalRef(methodObjects);`
`29`	`30`
`30`	`31`	`return results;`
`31`	`32`	`}`
`@@ -48,6 +49,7 @@ std::list<jobject> javaReflectionGetFields(JNIEnv *env, jclass clazz) {`
`48`	`49`	`}`
`49`	`50`	`results.push_back(field);`
`50`	`51`	`}`
	`52`	`+ env->DeleteLocalRef(fieldObjects);`
`51`	`53`
`52`	`54`	`return results;`
`53`	`55`	`}`
`@@ -264,7 +266,9 @@ jobjectArray v8ToJava(JNIEnv* env, const v8::Arguments& args, int start, int end`
`264`	`266`	`for(int i=start; i<end; i++) {`
`265`	`267`	`jobject val = v8ToJava(env, args[i]);`
`266`	`268`	`env->SetObjectArrayElement(results, i - start, val);`
	`269`	`+ env->DeleteLocalRef(val);`
`267`	`270`	`}`
	`271`	`+ env->DeleteLocalRef(clazz);`
`268`	`272`
`269`	`273`	`return results;`
`270`	`274`	`}`
`@@ -405,8 +409,11 @@ jobjectArray javaObjectArrayToClasses(JNIEnv *env, jobjectArray objs) {`
`405`	`409`	`} else {`
`406`	`410`	`jclass objClazz = env->GetObjectClass(elem);`
`407`	`411`	`env->SetObjectArrayElement(results, i, objClazz);`
	`412`	`+ env->DeleteLocalRef(objClazz);`
`408`	`413`	`}`
	`414`	`+ env->DeleteLocalRef(elem);`
`409`	`415`	`}`
	`416`	`+ env->DeleteLocalRef(clazzClazz);`
`410`	`417`	`return results;`
`411`	`418`	`}`
`412`	`419`
`@@ -418,6 +425,10 @@ jobject javaFindMethod(JNIEnv *env, jclass clazz, std::string& methodName, jobje`
`418`	`425`	`jobjectArray methodArgClasses = javaObjectArrayToClasses(env, methodArgs);`
`419`	`426`	`jobject method = env->CallStaticObjectMethod(methodUtilsClazz, methodUtils_getMatchingAccessibleMethod, clazz, methodNameJavaStr, methodArgClasses);`
`420`	`427`
	`428`	`+ env->DeleteLocalRef(methodUtilsClazz);`
	`429`	`+ env->DeleteLocalRef(methodNameJavaStr);`
	`430`	`+ env->DeleteLocalRef(methodArgClasses);`
	`431`	`+`
`421`	`432`	`return method;`
`422`	`433`	`}`
`423`	`434`