fcd7a72428
Add `HandleScope`s to the public C++ API for embedders/addons, since these methods create V8 handles that should not leak into the outer scopes. In particular, for some of the methods it was not clear from the function signatures that these functions previously needed to be invoked with a `HandleScope`. PR-URL: https://github.com/nodejs/node/pull/24285 Reviewed-By: Gus Caplan <me@gus.host> Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com> Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
99 lines
2.5 KiB
C++
99 lines
2.5 KiB
C++
#include <node.h>
|
|
#include <v8.h>
|
|
#include <uv.h>
|
|
|
|
#if defined _WIN32
|
|
#include <windows.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
|
|
struct async_req {
|
|
uv_work_t req;
|
|
int input;
|
|
int output;
|
|
v8::Isolate* isolate;
|
|
v8::Persistent<v8::Function> callback;
|
|
node::async_context context;
|
|
};
|
|
|
|
void DoAsync(uv_work_t* r) {
|
|
async_req* req = reinterpret_cast<async_req*>(r->data);
|
|
// Simulate CPU intensive process...
|
|
#if defined _WIN32
|
|
Sleep(1000);
|
|
#else
|
|
sleep(1);
|
|
#endif
|
|
req->output = req->input * 2;
|
|
}
|
|
|
|
template <bool use_makecallback>
|
|
void AfterAsync(uv_work_t* r) {
|
|
async_req* req = reinterpret_cast<async_req*>(r->data);
|
|
v8::Isolate* isolate = req->isolate;
|
|
v8::HandleScope scope(isolate);
|
|
|
|
v8::Local<v8::Value> argv[2] = {
|
|
v8::Null(isolate),
|
|
v8::Integer::New(isolate, req->output)
|
|
};
|
|
|
|
v8::TryCatch try_catch(isolate);
|
|
|
|
v8::Local<v8::Object> global = isolate->GetCurrentContext()->Global();
|
|
v8::Local<v8::Function> callback =
|
|
v8::Local<v8::Function>::New(isolate, req->callback);
|
|
|
|
if (use_makecallback) {
|
|
v8::Local<v8::Value> ret =
|
|
node::MakeCallback(isolate, global, callback, 2, argv, req->context)
|
|
.ToLocalChecked();
|
|
// This should be changed to an empty handle.
|
|
assert(!ret.IsEmpty());
|
|
} else {
|
|
callback->Call(isolate->GetCurrentContext(),
|
|
global, 2, argv).ToLocalChecked();
|
|
}
|
|
|
|
// None of the following operations should allocate handles into this scope.
|
|
v8::SealHandleScope seal_handle_scope(isolate);
|
|
// cleanup
|
|
node::EmitAsyncDestroy(isolate, req->context);
|
|
req->callback.Reset();
|
|
delete req;
|
|
|
|
if (try_catch.HasCaught()) {
|
|
node::FatalException(isolate, try_catch);
|
|
}
|
|
}
|
|
|
|
template <bool use_makecallback>
|
|
void Method(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|
v8::Isolate* isolate = args.GetIsolate();
|
|
|
|
async_req* req = new async_req;
|
|
req->req.data = req;
|
|
|
|
req->input = args[0].As<v8::Integer>()->Value();
|
|
req->output = 0;
|
|
req->isolate = isolate;
|
|
req->context = node::EmitAsyncInit(isolate, v8::Object::New(isolate), "test");
|
|
|
|
v8::Local<v8::Function> callback = v8::Local<v8::Function>::Cast(args[1]);
|
|
req->callback.Reset(isolate, callback);
|
|
|
|
uv_queue_work(node::GetCurrentEventLoop(isolate),
|
|
&req->req,
|
|
DoAsync,
|
|
(uv_after_work_cb)AfterAsync<use_makecallback>);
|
|
}
|
|
|
|
void init(v8::Local<v8::Object> exports, v8::Local<v8::Object> module) {
|
|
NODE_SET_METHOD(exports, "runCall", Method<false>);
|
|
NODE_SET_METHOD(exports, "runMakeCallback", Method<true>);
|
|
}
|
|
|
|
NODE_MODULE(NODE_GYP_MODULE_NAME, init)
|