Skip to content

Commit c820407

Browse files
jsdeveljsdevel
committed
Upgrading NaN to 1.2.0.
Compiles fine on node 10.29 and 8.x.
1 parent 3d17116 commit c820407

6 files changed

Lines changed: 94 additions & 93 deletions

File tree

‎package.json‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@
2828
"dependencies": {
2929
"find-java-home": "0.1.1",
3030
"glob": "~3.2.9",
31-
"nan": "0.8.0"
31+
"nan": "1.2.0"
3232
},
3333
"devDependencies": {
3434
"nodeunit": "~0.6.4",

‎src/java.cpp‎

Lines changed: 45 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
#include "node_NodeDynamicProxyClass.h"
1212
#include <node_version.h>
1313
#include <sstream>
14+
#include <nan.h>
1415

1516
long v8ThreadId;
1617

@@ -38,10 +39,10 @@ long my_getThreadId() {
3839

3940
v8ThreadId = my_getThreadId();
4041

41-
v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(New);
42-
NanAssignPersistent(v8::FunctionTemplate, s_ct, t);
42+
v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>(New);
43+
NanAssignPersistent(s_ct, t);
4344
t->InstanceTemplate()->SetInternalFieldCount(1);
44-
t->SetClassName(v8::String::NewSymbol("Java"));
45+
t->SetClassName(NanNew<v8::String>("Java"));
4546

4647
NODE_SET_PROTOTYPE_METHOD(t, "getClassLoader", getClassLoader);
4748
NODE_SET_PROTOTYPE_METHOD(t, "newInstance", newInstance);
@@ -61,7 +62,7 @@ long my_getThreadId() {
6162
NODE_SET_PROTOTYPE_METHOD(t, "setStaticFieldValue", setStaticFieldValue);
6263
NODE_SET_PROTOTYPE_METHOD(t, "instanceOf", instanceOf);
6364

64-
target->Set(v8::String::NewSymbol("Java"), t->GetFunction());
65+
target->Set(NanNew<v8::String>("Java"), t->GetFunction());
6566
}
6667

6768
NAN_METHOD(Java::New) {
@@ -70,9 +71,9 @@ NAN_METHOD(Java::New) {
7071
Java *self = new Java();
7172
self->Wrap(args.This());
7273

73-
NanObjectWrapHandle(self)->Set(v8::String::New("classpath"), v8::Array::New());
74-
NanObjectWrapHandle(self)->Set(v8::String::New("options"), v8::Array::New());
75-
NanObjectWrapHandle(self)->Set(v8::String::New("nativeBindingLocation"), v8::String::New("Not Set"));
74+
NanObjectWrapHandle(self)->Set(NanNew<v8::String>("classpath"), NanNew<v8::Array>());
75+
NanObjectWrapHandle(self)->Set(NanNew<v8::String>("options"), NanNew<v8::Array>());
76+
NanObjectWrapHandle(self)->Set(NanNew<v8::String>("nativeBindingLocation"), NanNew<v8::String>("Not Set"));
7677

7778
NanReturnValue(args.This());
7879
}
@@ -91,7 +92,7 @@ v8::Handle<v8::Value> Java::ensureJvm() {
9192
return createJVM(&this->m_jvm, &this->m_env);
9293
}
9394

94-
return v8::Undefined();
95+
NanReturnUndefined();
9596
}
9697

9798
v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
@@ -102,12 +103,12 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
102103
std::ostringstream classPath;
103104
classPath << "-Djava.class.path=";
104105

105-
v8::Local<v8::Value> classPathValue = NanObjectWrapHandle(this)->Get(v8::String::New("classpath"));
106+
v8::Local<v8::Value> classPathValue = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("classpath"));
106107
if(!classPathValue->IsArray()) {
107-
return ThrowException(v8::Exception::TypeError(v8::String::New("Classpath must be an array")));
108+
return NanThrowTypeError("Classpath must be an array");
108109
}
109110
v8::Handle<v8::Array> classPathArrayTemp = v8::Handle<v8::Array>::Cast(classPathValue);
110-
NanAssignPersistent(v8::Array, m_classPathArray, classPathArrayTemp);
111+
NanAssignPersistent(m_classPathArray, classPathArrayTemp);
111112
for(uint32_t i=0; i<classPathArrayTemp->Length(); i++) {
112113
if(i != 0) {
113114
#ifdef WIN32
@@ -118,25 +119,25 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
118119
}
119120
v8::Local<v8::Value> arrayItemValue = classPathArrayTemp->Get(i);
120121
if(!arrayItemValue->IsString()) {
121-
return ThrowException(v8::Exception::TypeError(v8::String::New("Classpath must only contain strings")));
122+
return NanThrowTypeError("Classpath must only contain strings");
122123
}
123124
v8::Local<v8::String> arrayItem = arrayItemValue->ToString();
124125
v8::String::AsciiValue arrayItemStr(arrayItem);
125126
classPath << *arrayItemStr;
126127
}
127128

128129
// set the native binding location
129-
v8::Local<v8::Value> v8NativeBindingLocation = NanObjectWrapHandle(this)->Get(v8::String::New("nativeBindingLocation"));
130+
v8::Local<v8::Value> v8NativeBindingLocation = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("nativeBindingLocation"));
130131
v8::String::AsciiValue nativeBindingLocationStr(v8NativeBindingLocation);
131132
s_nativeBindingLocation = *nativeBindingLocationStr;
132133

133134
// get other options
134-
v8::Local<v8::Value> optionsValue = NanObjectWrapHandle(this)->Get(v8::String::New("options"));
135+
v8::Local<v8::Value> optionsValue = NanObjectWrapHandle(this)->Get(NanNew<v8::String>("options"));
135136
if(!optionsValue->IsArray()) {
136-
return ThrowException(v8::Exception::TypeError(v8::String::New("options must be an array")));
137+
return NanThrowTypeError("options must be an array");
137138
}
138139
v8::Handle<v8::Array> optionsArrayTemp = v8::Handle<v8::Array>::Cast(optionsValue);
139-
NanAssignPersistent(v8::Array, m_optionsArray, optionsArrayTemp);
140+
NanAssignPersistent(m_optionsArray, optionsArrayTemp);
140141

141142
// create vm options
142143
int vmOptionsCount = optionsArrayTemp->Length() + 1;
@@ -147,7 +148,7 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
147148
v8::Local<v8::Value> arrayItemValue = optionsArrayTemp->Get(i);
148149
if(!arrayItemValue->IsString()) {
149150
delete[] vmOptions;
150-
return ThrowException(v8::Exception::TypeError(v8::String::New("options must only contain strings")));
151+
return NanThrowTypeError("options must only contain strings");
151152
}
152153
v8::Local<v8::String> arrayItem = arrayItemValue->ToString();
153154
v8::String::AsciiValue arrayItemStr(arrayItem);
@@ -165,11 +166,11 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
165166
m_classLoader = getSystemClassLoader(*env);
166167

167168
// TODO: this handles sets put doesn't prevent modifing the underlying data. So java.classpath.push will still work which is invalid.
168-
NanObjectWrapHandle(this)->SetAccessor(v8::String::New("classpath"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
169-
NanObjectWrapHandle(this)->SetAccessor(v8::String::New("options"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
170-
NanObjectWrapHandle(this)->SetAccessor(v8::String::New("nativeBindingLocation"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
169+
NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("classpath"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
170+
NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("options"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
171+
NanObjectWrapHandle(this)->SetAccessor(NanNew<v8::String>("nativeBindingLocation"), AccessorProhibitsOverwritingGetter, AccessorProhibitsOverwritingSetter);
171172

172-
return v8::Undefined();
173+
NanReturnUndefined();
173174
}
174175

175176
NAN_GETTER(Java::AccessorProhibitsOverwritingGetter) {
@@ -181,19 +182,19 @@ NAN_GETTER(Java::AccessorProhibitsOverwritingGetter) {
181182
} else if(!strcmp("options", *nameStr)) {
182183
NanReturnValue(self->m_optionsArray);
183184
} else if(!strcmp("nativeBindingLocation", *nameStr)) {
184-
NanReturnValue(v8::String::New(Java::s_nativeBindingLocation.c_str()));
185+
NanReturnValue(NanNew<v8::String>(Java::s_nativeBindingLocation.c_str()));
185186
}
186187

187188
std::ostringstream errStr;
188189
errStr << "Invalid call to accessor " << *nameStr;
189-
NanReturnValue(v8::Exception::Error(v8::String::New(errStr.str().c_str())));
190+
NanReturnValue(v8::Exception::Error(NanNew<v8::String>(errStr.str().c_str())));
190191
}
191192

192193
NAN_SETTER(Java::AccessorProhibitsOverwritingSetter) {
193194
v8::String::AsciiValue nameStr(property);
194195
std::ostringstream errStr;
195196
errStr << "Cannot set " << *nameStr << " after calling any other java function.";
196-
v8::ThrowException(v8::Exception::Error(v8::String::New(errStr.str().c_str())));
197+
v8::ThrowException(v8::Exception::Error(NanNew<v8::String>(errStr.str().c_str())));
197198
}
198199

199200
void Java::destroyJVM(JavaVM** jvm, JNIEnv** env) {
@@ -324,7 +325,7 @@ NAN_METHOD(Java::newProxy) {
324325
dynamicProxyData->markerEnd = DYNAMIC_PROXY_DATA_MARKER_END;
325326
dynamicProxyData->java = self;
326327
dynamicProxyData->interfaceName = interfaceName;
327-
NanAssignPersistent(v8::Object, dynamicProxyData->functions, functions);
328+
NanAssignPersistent(dynamicProxyData->functions, functions);
328329

329330
// find NodeDynamicProxyClass
330331
std::string className = "node.NodeDynamicProxyClass";
@@ -339,7 +340,7 @@ NAN_METHOD(Java::newProxy) {
339340
// find constructor
340341
jclass objectClazz = env->FindClass("java/lang/Object");
341342
jobjectArray methodArgs = env->NewObjectArray(2, objectClazz, NULL);
342-
env->SetObjectArrayElement(methodArgs, 0, v8ToJava(env, v8::String::New(s_nativeBindingLocation.c_str())));
343+
env->SetObjectArrayElement(methodArgs, 0, v8ToJava(env, NanNew<v8::String>(s_nativeBindingLocation.c_str())));
343344
env->SetObjectArrayElement(methodArgs, 1, longToJavaLongObj(env, (long)dynamicProxyData));
344345
jobject method = javaFindConstructor(env, clazz, methodArgs);
345346
if(method == NULL) {
@@ -492,7 +493,7 @@ NAN_METHOD(Java::newArray) {
492493
if(args.Length() < argsStart+1 || !args[argsStart]->IsArray()) {
493494
std::ostringstream errStr;
494495
errStr << "Argument " << (argsStart+1) << " must be an array";
495-
return NanThrowError(v8::Exception::TypeError(v8::String::New(errStr.str().c_str())));
496+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>(errStr.str().c_str())));
496497
}
497498
v8::Local<v8::Array> arrayObj = v8::Local<v8::Array>::Cast(args[argsStart]);
498499

@@ -593,12 +594,12 @@ NAN_METHOD(Java::newByte) {
593594
JavaScope javaScope(env);
594595

595596
if(args.Length() != 1) {
596-
return NanThrowError(v8::Exception::TypeError(v8::String::New("newByte only takes 1 argument")));
597+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newByte only takes 1 argument")));
597598
}
598599

599600
// argument - value
600601
if(!args[0]->IsNumber()) {
601-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a number")));
602+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
602603
}
603604

604605
v8::Local<v8::Number> val = args[0]->ToNumber();
@@ -621,12 +622,12 @@ NAN_METHOD(Java::newShort) {
621622
JavaScope javaScope(env);
622623

623624
if(args.Length() != 1) {
624-
return NanThrowError(v8::Exception::TypeError(v8::String::New("newShort only takes 1 argument")));
625+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newShort only takes 1 argument")));
625626
}
626627

627628
// argument - value
628629
if(!args[0]->IsNumber()) {
629-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a number")));
630+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
630631
}
631632

632633
v8::Local<v8::Number> val = args[0]->ToNumber();
@@ -649,12 +650,12 @@ NAN_METHOD(Java::newLong) {
649650
JavaScope javaScope(env);
650651

651652
if(args.Length() != 1) {
652-
return NanThrowError(v8::Exception::TypeError(v8::String::New("newLong only takes 1 argument")));
653+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newLong only takes 1 argument")));
653654
}
654655

655656
// argument - value
656657
if(!args[0]->IsNumber()) {
657-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a number")));
658+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
658659
}
659660

660661
v8::Local<v8::Number> val = args[0]->ToNumber();
@@ -677,7 +678,7 @@ NAN_METHOD(Java::newChar) {
677678
JavaScope javaScope(env);
678679

679680
if(args.Length() != 1) {
680-
return NanThrowError(v8::Exception::TypeError(v8::String::New("newChar only takes 1 argument")));
681+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newChar only takes 1 argument")));
681682
}
682683

683684
// argument - value
@@ -688,12 +689,12 @@ NAN_METHOD(Java::newChar) {
688689
} else if(args[0]->IsString()) {
689690
v8::Local<v8::String> val = args[0]->ToString();
690691
if(val->Length() != 1) {
691-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a string of 1 character.")));
692+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a string of 1 character.")));
692693
}
693694
std::string strVal = std::string(*v8::String::Utf8Value(val));
694695
charVal = (jchar)strVal[0];
695696
} else {
696-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a number or string")));
697+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number or string")));
697698
}
698699

699700
jclass clazz = env->FindClass("java/lang/Character");
@@ -714,9 +715,9 @@ NAN_METHOD(Java::newFloat) {
714715
JavaScope javaScope(env);
715716

716717
if(args.Length() != 1) {
717-
return NanThrowError(v8::Exception::TypeError(v8::String::New("newFloat only takes 1 argument")));
718+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newFloat only takes 1 argument")));
718719
} else if(!args[0]->IsNumber()) {
719-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a number")));
720+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
720721
}
721722
v8::Local<v8::Number> val = args[0]->ToNumber();
722723

@@ -738,9 +739,9 @@ NAN_METHOD(Java::newDouble) {
738739
JavaScope javaScope(env);
739740

740741
if(args.Length() != 1) {
741-
return NanThrowError(v8::Exception::TypeError(v8::String::New("newDouble only takes 1 argument")));
742+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("newDouble only takes 1 argument")));
742743
} else if(!args[0]->IsNumber()) {
743-
return NanThrowError(v8::Exception::TypeError(v8::String::New("Argument 1 must be a number")));
744+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>("Argument 1 must be a number")));
744745
}
745746
v8::Local<v8::Number> val = args[0]->ToNumber();
746747

@@ -817,7 +818,7 @@ NAN_METHOD(Java::setStaticFieldValue) {
817818
if(args.Length() < argsStart+1) {
818819
std::ostringstream errStr;
819820
errStr << "setStaticFieldValue requires " << (argsStart+1) << " arguments";
820-
return NanThrowError(v8::Exception::TypeError(v8::String::New(errStr.str().c_str())));
821+
return NanThrowError(v8::Exception::TypeError(NanNew<v8::String>(errStr.str().c_str())));
821822
}
822823
jobject newValue = v8ToJava(env, args[argsStart]);
823824
argsStart++;
@@ -882,7 +883,7 @@ NAN_METHOD(Java::instanceOf) {
882883
}
883884

884885
jboolean res = env->IsInstanceOf(instance, clazz);
885-
NanReturnValue(v8::Boolean::New(res));
886+
NanReturnValue(NanNew<v8::Boolean>(res));
886887
}
887888

888889
void EIO_CallJs(uv_work_t* req) {
@@ -910,8 +911,8 @@ void EIO_AfterCallJs(uv_work_t* req) {
910911
v8::Local<v8::Value> v8Result;
911912
jobject javaResult;
912913

913-
v8::Local<v8::Object> dynamicProxyDataFunctions = NanPersistentToLocal(dynamicProxyData->functions);
914-
v8::Local<v8::Value> fnObj = dynamicProxyDataFunctions->Get(v8::String::New(dynamicProxyData->methodName.c_str()));
914+
v8::Local<v8::Object> dynamicProxyDataFunctions = NanNew(dynamicProxyData->functions);
915+
v8::Local<v8::Value> fnObj = dynamicProxyDataFunctions->Get(NanNew<v8::String>(dynamicProxyData->methodName.c_str()));
915916
if(fnObj->IsUndefined() || fnObj->IsNull()) {
916917
printf("ERROR: Could not find method %s\n", dynamicProxyData->methodName.c_str());
917918
goto CleanUp;

‎src/javaObject.cpp‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -31,13 +31,13 @@
3131
v8::Local<v8::FunctionTemplate> funcTemplate;
3232
if(sFunctionTemplates.find(className) != sFunctionTemplates.end()) {
3333
//printf("existing className: %s\n", className.c_str());
34-
funcTemplate = NanPersistentToLocal(*sFunctionTemplates[className]);
34+
funcTemplate = NanNew(*sFunctionTemplates[className]);
3535
} else {
3636
//printf("create className: %s\n", className.c_str());
3737

38-
funcTemplate = v8::FunctionTemplate::New();
38+
funcTemplate = NanNew<v8::FunctionTemplate>();
3939
funcTemplate->InstanceTemplate()->SetInternalFieldCount(1);
40-
funcTemplate->SetClassName(v8::String::NewSymbol(className.c_str()));
40+
funcTemplate->SetClassName(NanNew<v8::String>(className.c_str()));
4141

4242
std::list<jobject> methods;
4343
javaReflectionGetMethods(env, objClazz, &methods, false);
@@ -48,12 +48,12 @@
4848
assert(!env->ExceptionCheck());
4949
std::string methodNameStr = javaToString(env, methodNameJava);
5050

51-
v8::Handle<v8::String> methodName = v8::String::New(methodNameStr.c_str());
52-
v8::Local<v8::FunctionTemplate> methodCallTemplate = v8::FunctionTemplate::New(methodCall, methodName);
51+
v8::Handle<v8::String> methodName = NanNew<v8::String>(methodNameStr.c_str());
52+
v8::Local<v8::FunctionTemplate> methodCallTemplate = NanNew<v8::FunctionTemplate>(methodCall, methodName);
5353
funcTemplate->PrototypeTemplate()->Set(methodName, methodCallTemplate->GetFunction());
5454

55-
v8::Handle<v8::String> methodNameSync = v8::String::New((methodNameStr + "Sync").c_str());
56-
v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = v8::FunctionTemplate::New(methodCallSync, methodName);
55+
v8::Handle<v8::String> methodNameSync = NanNew<v8::String>((methodNameStr + "Sync").c_str());
56+
v8::Local<v8::FunctionTemplate> methodCallSyncTemplate = NanNew<v8::FunctionTemplate>(methodCallSync, methodName);
5757
funcTemplate->PrototypeTemplate()->Set(methodNameSync, methodCallSyncTemplate->GetFunction());
5858
}
5959

@@ -66,18 +66,18 @@
6666
checkJavaException(env);
6767
std::string fieldNameStr = javaToString(env, fieldNameJava);
6868

69-
v8::Handle<v8::String> fieldName = v8::String::New(fieldNameStr.c_str());
69+
v8::Handle<v8::String> fieldName = NanNew<v8::String>(fieldNameStr.c_str());
7070
funcTemplate->InstanceTemplate()->SetAccessor(fieldName, fieldGetter, fieldSetter);
7171
}
7272

7373
v8::Persistent<v8::FunctionTemplate>* persistentFuncTemplate = new v8::Persistent<v8::FunctionTemplate>();
74-
NanAssignPersistent(v8::FunctionTemplate, (*persistentFuncTemplate), funcTemplate);
74+
NanAssignPersistent(*persistentFuncTemplate, funcTemplate);
7575
sFunctionTemplates[className] = persistentFuncTemplate;
7676
}
7777

7878
v8::Local<v8::Function> ctor = funcTemplate->GetFunction();
7979
v8::Local<v8::Object> javaObjectObj = ctor->NewInstance();
80-
javaObjectObj->SetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_OBJECT), v8::Boolean::New(true));
80+
javaObjectObj->SetHiddenValue(NanNew<v8::String>(V8_HIDDEN_MARKER_JAVA_OBJECT), NanNew<v8::Boolean>(true));
8181
JavaObject *self = new JavaObject(java, obj);
8282
self->Wrap(javaObjectObj);
8383

@@ -225,8 +225,8 @@ NAN_SETTER(JavaObject::fieldSetter) {
225225
if(field == NULL) {
226226
std::ostringstream errStr;
227227
errStr << "Could not find field " << propertyStr;
228-
v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
229-
ThrowException(ex);
228+
v8::Handle<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
229+
NanThrowError(error);
230230
return;
231231
}
232232

@@ -240,8 +240,8 @@ NAN_SETTER(JavaObject::fieldSetter) {
240240
if(env->ExceptionOccurred()) {
241241
std::ostringstream errStr;
242242
errStr << "Could not set field " << propertyStr;
243-
v8::Handle<v8::Value> ex = javaExceptionToV8(self->m_java, env, errStr.str());
244-
ThrowException(ex);
243+
v8::Handle<v8::Value> error = javaExceptionToV8(self->m_java, env, errStr.str());
244+
NanThrowError(error);
245245
return;
246246
}
247247
}

‎src/methodCallBaton.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -97,10 +97,10 @@ v8::Handle<v8::Value> MethodCallBaton::resultsToV8(JNIEnv *env) {
9797
}
9898

9999
v8::Handle<v8::Value> err = javaExceptionToV8(m_java, env, cause, m_errorString);
100-
return scope.Close(err);
100+
NanReturnValue(err);
101101
}
102102

103-
return scope.Close(javaToV8(m_java, env, m_result));
103+
NanReturnValue(javaToV8(m_java, env, m_result));
104104
}
105105

106106
void NewInstanceBaton::execute(JNIEnv *env) {

0 commit comments

Comments
 (0)