added check for reference counting

joeferner · joeferner · commit d45e0a97965e · 2012-06-06T11:18:22.000-04:00
diff --git a/README.md b/README.md
@@ -194,6 +194,9 @@ __Example__
 
 Creates a new java Proxy for the given interface. Functions passed in will run on the v8 main thread and not a new thread.
 
+The returned object has two methods ref() and unref() which you can use to maintain references to prevent premature
+garbage collection. You must call these methods to ensure the proxy stays around.
+
 __Arguments__
 
  * interfaceName - The name of the interface to proxy. For subclasses seperate using a '$' (eg. com.nearinfinty.MyClass$SubClass)
diff --git a/src-java/node/NodeDynamicProxyClass.class b/src-java/node/NodeDynamicProxyClass.class
diff --git a/src-java/node/NodeDynamicProxyClass.java b/src-java/node/NodeDynamicProxyClass.java
@@ -18,4 +18,12 @@ public Object invoke(Object proxy, java.lang.reflect.Method m, Object[] args) th
   {
     return callJs(this.ptr, m, args);
   }
+
+  public void ref() {
+
+  }
+
+  public void unref() {
+
+  }
 }
diff --git a/src/java.cpp b/src/java.cpp
@@ -245,6 +245,8 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
   ARGS_FRONT_OBJECT(functions);
 
   DynamicProxyData* dynamicProxyData = new DynamicProxyData();
+  dynamicProxyData->markerStart = DYNAMIC_PROXY_DATA_MARKER_START;
+  dynamicProxyData->markerEnd = DYNAMIC_PROXY_DATA_MARKER_END;
   dynamicProxyData->java = self;
   dynamicProxyData->interfaceName = interfaceName;
   dynamicProxyData->functions = v8::Persistent<v8::Object>::New(functions);
@@ -598,6 +600,9 @@ void EIO_CallJs(uv_work_t* req) {
 
 void EIO_AfterCallJs(uv_work_t* req) {
   DynamicProxyData* dynamicProxyData = static_cast<DynamicProxyData*>(req->data);
+  if(!dynamicProxyDataVerify(dynamicProxyData)) {
+    return;
+  }
   dynamicProxyData->result = NULL;
 
   JNIEnv* env = dynamicProxyData->env;
@@ -631,6 +636,9 @@ void EIO_AfterCallJs(uv_work_t* req) {
   }
   v8Result = fn->Call(dynamicProxyData->functions, argc, argv);
   delete[] argv;
+  if(!dynamicProxyDataVerify(dynamicProxyData)) {
+    return;
+  }
 
   javaResult = v8ToJava(env, v8Result);
   if(javaResult == NULL) {
@@ -668,6 +676,9 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo
     }
   }
 
+  if(!dynamicProxyDataVerify(dynamicProxyData)) {
+    return NULL;
+  }
   if(dynamicProxyData->result) {
     env->DeleteGlobalRef(dynamicProxyData->result);
   }
diff --git a/src/javaObject.cpp b/src/javaObject.cpp
@@ -67,7 +67,9 @@ JavaObject::~JavaObject() {
   if(env->IsInstanceOf(m_obj, nodeDynamicProxyClass)) {
     jfieldID ptrField = env->GetFieldID(nodeDynamicProxyClass, "ptr", "J");
     DynamicProxyData* proxyData = (DynamicProxyData*)(long)env->GetLongField(m_obj, ptrField);
-    delete proxyData;
+    if(dynamicProxyDataVerify(proxyData)) {
+      delete proxyData;
+    }
   }
 
   m_java->getJavaEnv()->DeleteGlobalRef(m_obj);
diff --git a/src/node_NodeDynamicProxyClass.h b/src/node_NodeDynamicProxyClass.h
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -208,6 +208,9 @@ jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
       if(env->IsInstanceOf(jobj, nodeDynamicProxyClass)) {
         jfieldID ptrField = env->GetFieldID(nodeDynamicProxyClass, "ptr", "J");
         DynamicProxyData* proxyData = (DynamicProxyData*)(long)env->GetLongField(jobj, ptrField);
+        if(!dynamicProxyDataVerify(proxyData)) {
+          return NULL;
+        }
 
         jclass dynamicInterface = javaFindClass(env, proxyData->interfaceName);
         if(dynamicInterface == NULL) {
@@ -431,4 +434,13 @@ jobject longToJavaLongObj(JNIEnv *env, long val) {
   jclass longClass = env->FindClass("java/lang/Long");
   jmethodID constructor = env->GetMethodID(longClass, "<init>", "(J)V");
   return env->NewObject(longClass, constructor, val);
-}
+}
+
+int dynamicProxyDataVerify(DynamicProxyData* data) {
+  if(data->markerStart == DYNAMIC_PROXY_DATA_MARKER_START && data->markerEnd == DYNAMIC_PROXY_DATA_MARKER_END) {
+    return 1;
+  }
+
+  printf("*** ERROR: Lost reference to the dynamic proxy. You must maintain a reference in javascript land using ref() and unref(). ***\n");
+  return 0;
+}
diff --git a/src/utils.h b/src/utils.h
@@ -25,6 +25,7 @@ typedef enum _jvalueType {
 } jvalueType;
 
 struct DynamicProxyData {
+  unsigned int markerStart;
   JNIEnv* env;
   Java* java;
   std::string interfaceName;
@@ -33,8 +34,14 @@ struct DynamicProxyData {
   jobjectArray args;
   jobject result;
   int done;
+  unsigned int markerEnd;
 };
 
+#define DYNAMIC_PROXY_DATA_MARKER_START 0x12345678
+#define DYNAMIC_PROXY_DATA_MARKER_END   0x87654321
+
+int dynamicProxyDataVerify(DynamicProxyData* data);
+
 std::list<jobject> javaReflectionGetMethods(JNIEnv *env, jclass clazz);
 std::list<jobject> javaReflectionGetFields(JNIEnv *env, jclass clazz);
 std::string javaToString(JNIEnv *env, jstring str);

Original file line number	Diff line number	Diff line change
`@@ -18,4 +18,12 @@ public Object invoke(Object proxy, java.lang.reflect.Method m, Object[] args) th`
`18`	`18`	`{`
`19`	`19`	`return callJs(this.ptr, m, args);`
`20`	`20`	`}`
	`21`	`+`
	`22`	`+ public void ref() {`
	`23`	`+`
	`24`	`+ }`
	`25`	`+`
	`26`	`+ public void unref() {`
	`27`	`+`
	`28`	`+ }`
`21`	`29`	`}`