Skip to content

Commit 7f76b60

Browse files
jasonginjasongin
committed
napi: Error handling tests and fixes (V8) (nodejs#72)
 - Update tests for EH API changes - Update api helpers for EH API changes - Fix bugs in EH implementation discovered via testing
1 parent 0db4624 commit 7f76b60

File tree

26 files changed

+1280
-397
lines changed

26 files changed

+1280
-397
lines changed

‎src/node_api_helpers.h

Lines changed: 145 additions & 82 deletions
Original file line numberDiff line numberDiff line change
@@ -44,11 +44,11 @@ namespace Napi {
4444
class HandleScope {
4545
public:
4646
HandleScope() {
47-
env = napi_get_current_env();
48-
scope = napi_open_handle_scope(env);
47+
napi_get_current_env(&env);
48+
napi_open_handle_scope(env, &scope);
4949
}
5050
explicit HandleScope(napi_env e) : env(e) {
51-
scope = napi_open_handle_scope(env);
51+
napi_open_handle_scope(env, &scope);
5252
}
5353
~HandleScope() {
5454
napi_close_handle_scope(env, scope);
@@ -62,18 +62,20 @@ namespace Napi {
6262
class EscapableHandleScope {
6363
public:
6464
EscapableHandleScope() {
65-
env = napi_get_current_env();
66-
scope = napi_open_escapable_handle_scope(env);
65+
napi_get_current_env(&env);
66+
napi_open_escapable_handle_scope(env, &scope);
6767
}
6868
explicit EscapableHandleScope(napi_env e) : env(e) {
69-
scope = napi_open_escapable_handle_scope(e);
69+
napi_open_escapable_handle_scope(e, &scope);
7070
}
7171
~EscapableHandleScope() {
7272
napi_close_escapable_handle_scope(env, scope);
7373
}
7474

7575
napi_value Escape(napi_value escapee) {
76-
return napi_escape_handle(env, scope, escapee);
76+
napi_value result;
77+
napi_escape_handle(env, scope, escapee, &result);
78+
return result;
7779
}
7880

7981
private:
@@ -86,17 +88,21 @@ namespace Napi {
8688
inline explicit Utf8String(napi_value from) :
8789
length_(0), str_(str_st_) {
8890
if (from != NULL) {
89-
napi_env env = napi_get_current_env();
90-
napi_value string = napi_coerce_to_string(env, from);
91+
napi_env env;
92+
napi_get_current_env(&env);
93+
napi_value string;
94+
napi_coerce_to_string(env, from, &string);
9195
if (string != NULL) {
92-
size_t len = 3 * napi_get_string_length(env, string) + 1;
93-
assert(len <= INT_MAX);
94-
if (len > sizeof(str_st_)) {
95-
str_ = new char[len];
96+
int len;
97+
napi_get_string_length(env, string, &len);
98+
size_t utf8len = 3 * len + 1;
99+
assert(utf8len <= INT_MAX);
100+
if (utf8len > sizeof(str_st_)) {
101+
str_ = new char[utf8len];
96102
assert(str_ != 0);
97103
}
98-
length_ = napi_get_string_utf8(env, string, str_,
99-
static_cast<int>(len));
104+
napi_get_string_utf8(env, string, str_,
105+
static_cast<int>(utf8len), &length_);
100106
str_[length_] = '\0';
101107
}
102108
}
@@ -131,37 +137,52 @@ namespace Napi {
131137
class Callback {
132138
public:
133139
Callback() {
134-
napi_env env = napi_get_current_env();
140+
napi_env env;
141+
napi_get_current_env(&env);
135142
HandleScope scope(env);
136-
napi_value obj = napi_create_object(env);
137-
handle = napi_create_persistent(env, obj);
143+
napi_value obj;
144+
napi_create_object(env, &obj);
145+
napi_create_persistent(env, obj, &handle);
138146
}
139147

140148
explicit Callback(napi_value fn) {
141-
napi_env env = napi_get_current_env();
149+
napi_env env;
150+
napi_get_current_env(&env);
142151
HandleScope scope(env);
143-
napi_value obj = napi_create_object(env);
144-
handle = napi_create_persistent(env, obj);
152+
napi_value obj;
153+
napi_create_object(env, &obj);
154+
napi_create_persistent(env, obj, &handle);
145155
SetFunction(fn);
146156
}
147157

148158
~Callback() {
149159
if (handle == NULL) {
150160
return;
151161
}
152-
napi_release_persistent(napi_get_current_env(), handle);
162+
163+
napi_env env;
164+
napi_get_current_env(&env);
165+
napi_release_persistent(env, handle);
153166
}
154167

155168
bool operator==(const Callback &other) const {
156169
HandleScope scope;
157-
napi_env env = napi_get_current_env();
158-
napi_value a = napi_get_element(env,
159-
napi_get_persistent_value(env, handle),
160-
kCallbackIndex);
161-
napi_value b = napi_get_element(env,
162-
napi_get_persistent_value(env,
163-
other.handle), kCallbackIndex);
164-
return napi_strict_equals(env, a, b);
170+
napi_env env;
171+
napi_get_current_env(&env);
172+
173+
napi_value ha;
174+
napi_get_persistent_value(env, handle, &ha);
175+
napi_value hb;
176+
napi_get_persistent_value(env, other.handle, &hb);
177+
178+
napi_value a;
179+
napi_get_element(env, ha, kCallbackIndex, &a);
180+
napi_value b;
181+
napi_get_element(env, hb, kCallbackIndex, &b);
182+
183+
bool result;
184+
napi_strict_equals(env, a, b, &result);
185+
return result;
165186
}
166187

167188
bool operator!=(const Callback &other) const {
@@ -186,26 +207,35 @@ namespace Napi {
186207

187208
inline void SetFunction(napi_value fn) {
188209
HandleScope scope;
189-
napi_env env = napi_get_current_env();
190-
napi_set_element(env, napi_get_persistent_value(env, handle),
191-
kCallbackIndex, fn);
210+
napi_env env;
211+
napi_get_current_env(&env);
212+
napi_value h;
213+
napi_get_persistent_value(env, handle, &h);
214+
napi_set_element(env, h, kCallbackIndex, fn);
192215
}
193216

194217
inline napi_value GetFunction() const {
195218
EscapableHandleScope scope;
196-
napi_env env = napi_get_current_env();
197-
return scope.Escape(
198-
napi_get_element(env, napi_get_persistent_value(env, handle),
199-
kCallbackIndex));
219+
napi_env env;
220+
napi_get_current_env(&env);
221+
napi_value h;
222+
napi_get_persistent_value(env, handle, &h);
223+
napi_value fn;
224+
napi_get_element(env, h, kCallbackIndex, &fn);
225+
return scope.Escape(fn);
200226
}
201227

202228
inline bool IsEmpty() const {
203229
HandleScope scope;
204-
napi_env env = napi_get_current_env();
205-
napi_value fn =
206-
napi_get_element(env,
207-
napi_get_persistent_value(env, handle), kCallbackIndex);
208-
return napi_undefined == napi_get_type_of_value(env, fn);
230+
napi_env env;
231+
napi_get_current_env(&env);
232+
napi_value h;
233+
napi_get_persistent_value(env, handle, &h);
234+
napi_value fn;
235+
napi_get_element(env, h, kCallbackIndex, &fn);
236+
napi_valuetype valuetype;
237+
napi_get_type_of_value(env, fn, &valuetype);
238+
return napi_undefined == valuetype;
209239
}
210240

211241
inline napi_value
@@ -217,8 +247,11 @@ namespace Napi {
217247

218248
inline napi_value
219249
Call(int argc, napi_value argv[]) const {
220-
napi_env env = napi_get_current_env();
221-
return Call_(napi_get_global(env), argc, argv);
250+
napi_env env;
251+
napi_get_current_env(&env);
252+
napi_value global;
253+
napi_get_global(env, &global);
254+
return Call_(global, argc, argv);
222255
}
223256

224257
private:
@@ -230,17 +263,23 @@ namespace Napi {
230263
int argc,
231264
napi_value argv[]) const {
232265
EscapableHandleScope scope;
233-
napi_env env = napi_get_current_env();
266+
napi_env env;
267+
napi_get_current_env(&env);
234268

235-
napi_value callback =
236-
napi_get_element(env, napi_get_persistent_value(env, handle),
237-
kCallbackIndex);
238-
return scope.Escape(napi_make_callback(
269+
napi_value h;
270+
napi_get_persistent_value(env, handle, &h);
271+
napi_value fn;
272+
napi_get_element(env, h, kCallbackIndex, &fn);
273+
274+
napi_value cb;
275+
napi_make_callback(
239276
env,
240277
target,
241-
callback,
278+
fn,
242279
argc,
243-
argv));
280+
argv,
281+
&cb);
282+
return scope.Escape(cb);
244283
}
245284
};
246285

@@ -252,18 +291,21 @@ namespace Napi {
252291
explicit AsyncWorker(Callback *callback_)
253292
: callback(callback_), errmsg_(NULL) {
254293
request = napi_create_async_work();
255-
napi_env env = napi_get_current_env();
294+
napi_env env;
295+
napi_get_current_env(&env);
256296

257297
HandleScope scope;
258-
napi_value obj = napi_create_object(env);
259-
persistentHandle = napi_create_persistent(env, obj);
298+
napi_value obj;
299+
napi_create_object(env, &obj);
300+
napi_create_persistent(env, obj, &persistentHandle);
260301
}
261302

262303
virtual ~AsyncWorker() {
263304
HandleScope scope;
264305

265306
if (persistentHandle != NULL) {
266-
napi_env env = napi_get_current_env();
307+
napi_env env;
308+
napi_get_current_env(&env);
267309
napi_release_persistent(env, persistentHandle);
268310
persistentHandle = NULL;
269311
}
@@ -287,52 +329,69 @@ namespace Napi {
287329
inline void SaveToPersistent(
288330
const char *key, napi_value value) {
289331
HandleScope scope;
290-
napi_env env = napi_get_current_env();
291-
napi_propertyname pnKey = napi_property_name(env, key);
292-
napi_set_property(env, napi_get_persistent_value(env, persistentHandle),
293-
pnKey, value);
332+
napi_env env;
333+
napi_get_current_env(&env);
334+
napi_propertyname pnKey;
335+
napi_property_name(env, key, &pnKey);
336+
napi_value h;
337+
napi_get_persistent_value(env, persistentHandle, &h);
338+
napi_set_property(env, h, pnKey, value);
294339
}
295340

296341
inline void SaveToPersistent(
297342
napi_propertyname key, napi_value value) {
298343
HandleScope scope;
299-
napi_env env = napi_get_current_env();
300-
napi_set_property(env, napi_get_persistent_value(env, persistentHandle),
301-
key, value);
344+
napi_env env;
345+
napi_get_current_env(&env);
346+
napi_value h;
347+
napi_get_persistent_value(env, persistentHandle, &h);
348+
napi_set_property(env, h, key, value);
302349
}
303350

304351
inline void SaveToPersistent(
305352
uint32_t index, napi_value value) {
306353
HandleScope scope;
307-
napi_env env = napi_get_current_env();
308-
napi_set_element(env, napi_get_persistent_value(env, persistentHandle),
309-
index, value);
354+
napi_env env;
355+
napi_get_current_env(&env);
356+
napi_value h;
357+
napi_get_persistent_value(env, persistentHandle, &h);
358+
napi_set_element(env, h, index, value);
310359
}
311360

312361
inline napi_value GetFromPersistent(const char *key) const {
313362
EscapableHandleScope scope;
314-
napi_env env = napi_get_current_env();
315-
napi_propertyname pnKey = napi_property_name(env, key);
316-
return scope.Escape(
317-
napi_get_property(env,
318-
napi_get_persistent_value(env, persistentHandle), pnKey));
363+
napi_env env;
364+
napi_get_current_env(&env);
365+
napi_propertyname pnKey;
366+
napi_property_name(env, key, &pnKey);
367+
napi_value h;
368+
napi_get_persistent_value(env, persistentHandle, &h);
369+
napi_value v;
370+
napi_get_property(env, h, pnKey, &v);
371+
return scope.Escape(v);
319372
}
320373

321374
inline napi_value
322375
GetFromPersistent(napi_propertyname key) const {
323376
EscapableHandleScope scope;
324-
napi_env env = napi_get_current_env();
325-
return scope.Escape(
326-
napi_get_property(env,
327-
napi_get_persistent_value(env, persistentHandle), key));
377+
napi_env env;
378+
napi_get_current_env(&env);
379+
napi_value h;
380+
napi_get_persistent_value(env, persistentHandle, &h);
381+
napi_value v;
382+
napi_get_property(env, h, key, &v);
383+
return scope.Escape(v);
328384
}
329385

330386
inline napi_value GetFromPersistent(uint32_t index) const {
331387
EscapableHandleScope scope;
332-
napi_env env = napi_get_current_env();
333-
return scope.Escape(
334-
napi_get_element(env,
335-
napi_get_persistent_value(env, persistentHandle), index));
388+
napi_env env;
389+
napi_get_current_env(&env);
390+
napi_value h;
391+
napi_get_persistent_value(env, persistentHandle, &h);
392+
napi_value v;
393+
napi_get_element(env, h, index, &v);
394+
return scope.Escape(v);
336395
}
337396

338397
virtual void Execute() = 0;
@@ -368,11 +427,15 @@ namespace Napi {
368427

369428
virtual void HandleErrorCallback() {
370429
HandleScope scope;
371-
napi_env env = napi_get_current_env();
430+
napi_env env;
431+
napi_get_current_env(&env);
432+
433+
napi_value s;
434+
napi_create_string(env, ErrorMessage(), &s);
435+
436+
napi_value argv[1];
437+
napi_create_error(env, s, argv);
372438

373-
napi_value argv[] = {
374-
napi_create_error(env, napi_create_string(env, ErrorMessage()))
375-
};
376439
callback->Call(1, argv);
377440
}
378441

0 commit comments

Comments
 (0)