summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/async-wrap.cc121
-rw-r--r--src/async-wrap.h9
-rw-r--r--src/inspector_agent.cc4
-rw-r--r--src/node.cc200
-rw-r--r--src/node.h133
-rw-r--r--src/node_crypto.cc6
-rw-r--r--src/node_internals.h21
7 files changed, 342 insertions, 152 deletions
diff --git a/src/async-wrap.cc b/src/async-wrap.cc
index d3776c7333..2efe0e23ec 100644
--- a/src/async-wrap.cc
+++ b/src/async-wrap.cc
@@ -47,6 +47,7 @@ using v8::Object;
using v8::Promise;
using v8::PromiseHookType;
using v8::RetainedObjectInfo;
+using v8::String;
using v8::Symbol;
using v8::TryCatch;
using v8::Uint32Array;
@@ -216,23 +217,28 @@ bool DomainExit(Environment* env, v8::Local<v8::Object> object) {
static bool PreCallbackExecution(AsyncWrap* wrap, bool run_domain_cbs) {
- AsyncHooks* async_hooks = wrap->env()->async_hooks();
-
if (wrap->env()->using_domains() && run_domain_cbs) {
bool is_disposed = DomainEnter(wrap->env(), wrap->object());
if (is_disposed)
return false;
}
+ return AsyncWrap::EmitBefore(wrap->env(), wrap->get_id());
+}
+
+
+bool AsyncWrap::EmitBefore(Environment* env, double async_id) {
+ AsyncHooks* async_hooks = env->async_hooks();
+
if (async_hooks->fields()[AsyncHooks::kBefore] > 0) {
- Local<Value> uid = Number::New(wrap->env()->isolate(), wrap->get_id());
- Local<Function> fn = wrap->env()->async_hooks_before_function();
- TryCatch try_catch(wrap->env()->isolate());
+ Local<Value> uid = Number::New(env->isolate(), async_id);
+ Local<Function> fn = env->async_hooks_before_function();
+ TryCatch try_catch(env->isolate());
MaybeLocal<Value> ar = fn->Call(
- wrap->env()->context(), Undefined(wrap->env()->isolate()), 1, &uid);
+ env->context(), Undefined(env->isolate()), 1, &uid);
if (ar.IsEmpty()) {
- ClearFatalExceptionHandlers(wrap->env());
- FatalException(wrap->env()->isolate(), try_catch);
+ ClearFatalExceptionHandlers(env);
+ FatalException(env->isolate(), try_catch);
return false;
}
}
@@ -242,29 +248,36 @@ static bool PreCallbackExecution(AsyncWrap* wrap, bool run_domain_cbs) {
static bool PostCallbackExecution(AsyncWrap* wrap, bool run_domain_cbs) {
- AsyncHooks* async_hooks = wrap->env()->async_hooks();
+ if (!AsyncWrap::EmitAfter(wrap->env(), wrap->get_id()))
+ return false;
+
+ if (wrap->env()->using_domains() && run_domain_cbs) {
+ bool is_disposed = DomainExit(wrap->env(), wrap->object());
+ if (is_disposed)
+ return false;
+ }
+
+ return true;
+}
+
+bool AsyncWrap::EmitAfter(Environment* env, double async_id) {
+ AsyncHooks* async_hooks = env->async_hooks();
// If the callback failed then the after() hooks will be called at the end
// of _fatalException().
if (async_hooks->fields()[AsyncHooks::kAfter] > 0) {
- Local<Value> uid = Number::New(wrap->env()->isolate(), wrap->get_id());
- Local<Function> fn = wrap->env()->async_hooks_after_function();
- TryCatch try_catch(wrap->env()->isolate());
+ Local<Value> uid = Number::New(env->isolate(), async_id);
+ Local<Function> fn = env->async_hooks_after_function();
+ TryCatch try_catch(env->isolate());
MaybeLocal<Value> ar = fn->Call(
- wrap->env()->context(), Undefined(wrap->env()->isolate()), 1, &uid);
+ env->context(), Undefined(env->isolate()), 1, &uid);
if (ar.IsEmpty()) {
- ClearFatalExceptionHandlers(wrap->env());
- FatalException(wrap->env()->isolate(), try_catch);
+ ClearFatalExceptionHandlers(env);
+ FatalException(env->isolate(), try_catch);
return false;
}
}
- if (wrap->env()->using_domains() && run_domain_cbs) {
- bool is_disposed = DomainExit(wrap->env(), wrap->object());
- if (is_disposed)
- return false;
- }
-
return true;
}
@@ -526,32 +539,44 @@ AsyncWrap::~AsyncWrap() {
// and reused over their lifetime. This way a new uid can be assigned when
// the resource is pulled out of the pool and put back into use.
void AsyncWrap::AsyncReset() {
- AsyncHooks* async_hooks = env()->async_hooks();
async_id_ = env()->new_async_id();
trigger_id_ = env()->get_init_trigger_id();
+ EmitAsyncInit(env(), object(),
+ env()->async_hooks()->provider_string(provider_type()),
+ async_id_, trigger_id_);
+}
+
+
+void AsyncWrap::EmitAsyncInit(Environment* env,
+ Local<Object> object,
+ Local<String> type,
+ double async_id,
+ double trigger_id) {
+ AsyncHooks* async_hooks = env->async_hooks();
+
// Nothing to execute, so can continue normally.
if (async_hooks->fields()[AsyncHooks::kInit] == 0) {
return;
}
- HandleScope scope(env()->isolate());
- Local<Function> init_fn = env()->async_hooks_init_function();
+ HandleScope scope(env->isolate());
+ Local<Function> init_fn = env->async_hooks_init_function();
Local<Value> argv[] = {
- Number::New(env()->isolate(), get_id()),
- env()->async_hooks()->provider_string(provider_type()),
- object(),
- Number::New(env()->isolate(), get_trigger_id()),
+ Number::New(env->isolate(), async_id),
+ type,
+ object,
+ Number::New(env->isolate(), trigger_id),
};
- TryCatch try_catch(env()->isolate());
+ TryCatch try_catch(env->isolate());
MaybeLocal<Value> ret = init_fn->Call(
- env()->context(), object(), arraysize(argv), argv);
+ env->context(), object, arraysize(argv), argv);
if (ret.IsEmpty()) {
- ClearFatalExceptionHandlers(env());
- FatalException(env()->isolate(), try_catch);
+ ClearFatalExceptionHandlers(env);
+ FatalException(env->isolate(), try_catch);
}
}
@@ -620,6 +645,38 @@ Local<Value> AsyncWrap::MakeCallback(const Local<Function> cb,
return rcheck.IsEmpty() ? Local<Value>() : ret_v;
}
+
+/* Public C++ embedder API */
+
+
+async_uid AsyncHooksGetCurrentId(Isolate* isolate) {
+ return Environment::GetCurrent(isolate)->current_async_id();
+}
+
+
+async_uid AsyncHooksGetTriggerId(Isolate* isolate) {
+ return Environment::GetCurrent(isolate)->get_init_trigger_id();
+}
+
+
+async_uid EmitAsyncInit(Isolate* isolate,
+ Local<Object> resource,
+ const char* name,
+ async_uid trigger_id) {
+ Environment* env = Environment::GetCurrent(isolate);
+ async_uid async_id = env->new_async_id();
+
+ Local<String> type =
+ String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized)
+ .ToLocalChecked();
+ AsyncWrap::EmitAsyncInit(env, resource, type, async_id, trigger_id);
+ return async_id;
+}
+
+void EmitAsyncDestroy(Isolate* isolate, async_uid id) {
+ PushBackDestroyId(Environment::GetCurrent(isolate), id);
+}
+
} // namespace node
NODE_MODULE_CONTEXT_AWARE_BUILTIN(async_wrap, node::AsyncWrap::Initialize)
diff --git a/src/async-wrap.h b/src/async-wrap.h
index cf81178747..d3676a01c0 100644
--- a/src/async-wrap.h
+++ b/src/async-wrap.h
@@ -101,6 +101,15 @@ class AsyncWrap : public BaseObject {
static void AsyncReset(const v8::FunctionCallbackInfo<v8::Value>& args);
static void QueueDestroyId(const v8::FunctionCallbackInfo<v8::Value>& args);
+ static void EmitAsyncInit(Environment* env,
+ v8::Local<v8::Object> object,
+ v8::Local<v8::String> type,
+ double id,
+ double trigger_id);
+
+ static bool EmitBefore(Environment* env, double id);
+ static bool EmitAfter(Environment* env, double id);
+
inline ProviderType provider_type() const;
inline double get_id() const;
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index a90edc5038..5daef2e1ba 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -597,8 +597,8 @@ bool Agent::StartIoThread(bool wait_for_connect) {
FIXED_ONE_BYTE_STRING(isolate, "internalMessage"),
message
};
- MakeCallback(parent_env_, process_object.As<Value>(), emit_fn.As<Function>(),
- arraysize(argv), argv);
+ MakeCallback(parent_env_->isolate(), process_object, emit_fn.As<Function>(),
+ arraysize(argv), argv, 0, 0);
return true;
}
diff --git a/src/node.cc b/src/node.cc
index 2c323be9f2..8972dd6135 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -348,7 +348,12 @@ static void CheckImmediate(uv_check_t* handle) {
Environment* env = Environment::from_immediate_check_handle(handle);
HandleScope scope(env->isolate());
Context::Scope context_scope(env->context());
- MakeCallback(env, env->process_object(), env->immediate_callback_string());
+ MakeCallback(env->isolate(),
+ env->process_object(),
+ env->immediate_callback_string(),
+ 0,
+ nullptr,
+ 0, 0).ToLocalChecked();
}
@@ -1281,18 +1286,20 @@ void AddPromiseHook(v8::Isolate* isolate, promise_hook_func fn, void* arg) {
}
-Local<Value> MakeCallback(Environment* env,
- Local<Value> recv,
- const Local<Function> callback,
- int argc,
- Local<Value> argv[]) {
+MaybeLocal<Value> MakeCallback(Environment* env,
+ Local<Value> recv,
+ const Local<Function> callback,
+ int argc,
+ Local<Value> argv[],
+ double async_id,
+ double trigger_id) {
// If you hit this assertion, you forgot to enter the v8::Context first.
CHECK_EQ(env->context(), env->isolate()->GetCurrentContext());
- Local<Object> object, domain;
- bool has_domain = false;
+ Local<Object> object;
Environment::AsyncCallbackScope callback_scope(env);
+ bool disposed_domain = false;
if (recv->IsObject()) {
object = recv.As<Object>();
@@ -1300,51 +1307,38 @@ Local<Value> MakeCallback(Environment* env,
if (env->using_domains()) {
CHECK(recv->IsObject());
- Local<Value> domain_v = object->Get(env->domain_string());
- has_domain = domain_v->IsObject();
- if (has_domain) {
- domain = domain_v.As<Object>();
- if (domain->Get(env->disposed_string())->IsTrue())
- return Undefined(env->isolate());
- }
+ disposed_domain = DomainEnter(env, object);
+ if (disposed_domain) return Undefined(env->isolate());
}
- if (has_domain) {
- Local<Value> enter_v = domain->Get(env->enter_string());
- if (enter_v->IsFunction()) {
- if (enter_v.As<Function>()->Call(domain, 0, nullptr).IsEmpty()) {
- FatalError("node::MakeCallback",
- "domain enter callback threw, please report this");
- }
- }
- }
+ MaybeLocal<Value> ret;
- // TODO(trevnorris): Correct this once node::MakeCallback() support id and
- // triggerId. Consider completely removing it until then so the async id can
- // propagate through to the fatalException after hook calls.
- AsyncHooks::ExecScope exec_scope(env, 0, 0);
+ {
+ AsyncHooks::ExecScope exec_scope(env, async_id, trigger_id);
- Local<Value> ret = callback->Call(recv, argc, argv);
+ if (async_id != 0) {
+ if (!AsyncWrap::EmitBefore(env, async_id)) return Local<Value>();
+ }
- if (ret.IsEmpty()) {
- // NOTE: For backwards compatibility with public API we return Undefined()
- // if the top level call threw.
- return callback_scope.in_makecallback() ?
- ret : Undefined(env->isolate()).As<Value>();
- }
+ ret = callback->Call(env->context(), recv, argc, argv);
- exec_scope.Dispose();
+ if (ret.IsEmpty()) {
+ // NOTE: For backwards compatibility with public API we return Undefined()
+ // if the top level call threw.
+ return callback_scope.in_makecallback() ?
+ ret : Undefined(env->isolate());
+ }
- if (has_domain) {
- Local<Value> exit_v = domain->Get(env->exit_string());
- if (exit_v->IsFunction()) {
- if (exit_v.As<Function>()->Call(domain, 0, nullptr).IsEmpty()) {
- FatalError("node::MakeCallback",
- "domain exit callback threw, please report this");
- }
+ if (async_id != 0) {
+ if (!AsyncWrap::EmitAfter(env, async_id)) return Local<Value>();
}
}
+ if (env->using_domains()) {
+ disposed_domain = DomainExit(env, object);
+ if (disposed_domain) return Undefined(env->isolate());
+ }
+
if (callback_scope.in_makecallback()) {
return ret;
}
@@ -1357,8 +1351,8 @@ Local<Value> MakeCallback(Environment* env,
// Make sure the stack unwound properly. If there are nested MakeCallback's
// then it should return early and not reach this code.
- CHECK_EQ(env->current_async_id(), 0);
- CHECK_EQ(env->trigger_id(), 0);
+ CHECK_EQ(env->current_async_id(), async_id);
+ CHECK_EQ(env->trigger_id(), trigger_id);
Local<Object> process = env->process_object();
@@ -1375,70 +1369,96 @@ Local<Value> MakeCallback(Environment* env,
}
-Local<Value> MakeCallback(Environment* env,
- Local<Object> recv,
- Local<String> symbol,
- int argc,
- Local<Value> argv[]) {
- Local<Value> cb_v = recv->Get(symbol);
- CHECK(cb_v->IsFunction());
- return MakeCallback(env, recv.As<Value>(), cb_v.As<Function>(), argc, argv);
+// Public MakeCallback()s
+
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+ Local<Object> recv,
+ const char* method,
+ int argc,
+ Local<Value> argv[],
+ async_uid async_id,
+ async_uid trigger_id) {
+ Local<String> method_string =
+ String::NewFromUtf8(isolate, method, v8::NewStringType::kNormal)
+ .ToLocalChecked();
+ return MakeCallback(isolate, recv, method_string, argc, argv,
+ async_id, trigger_id);
}
-Local<Value> MakeCallback(Environment* env,
- Local<Object> recv,
- const char* method,
- int argc,
- Local<Value> argv[]) {
- Local<String> method_string = OneByteString(env->isolate(), method);
- return MakeCallback(env, recv, method_string, argc, argv);
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+ Local<Object> recv,
+ Local<String> symbol,
+ int argc,
+ Local<Value> argv[],
+ async_uid async_id,
+ async_uid trigger_id) {
+ Local<Value> callback_v = recv->Get(symbol);
+ if (callback_v.IsEmpty()) return Local<Value>();
+ if (!callback_v->IsFunction()) return Local<Value>();
+ Local<Function> callback = callback_v.As<Function>();
+ return MakeCallback(isolate, recv, callback, argc, argv,
+ async_id, trigger_id);
}
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+ Local<Object> recv,
+ Local<Function> callback,
+ int argc,
+ Local<Value> argv[],
+ async_uid async_id,
+ async_uid trigger_id) {
+ // Observe the following two subtleties:
+ //
+ // 1. The environment is retrieved from the callback function's context.
+ // 2. The context to enter is retrieved from the environment.
+ //
+ // Because of the AssignToContext() call in src/node_contextify.cc,
+ // the two contexts need not be the same.
+ Environment* env = Environment::GetCurrent(callback->CreationContext());
+ Context::Scope context_scope(env->context());
+ return MakeCallback(env, recv.As<Value>(), callback, argc, argv,
+ async_id, trigger_id);
+}
+
+
+// Legacy MakeCallback()s
+
Local<Value> MakeCallback(Isolate* isolate,
Local<Object> recv,
const char* method,
int argc,
- Local<Value> argv[]) {
+ Local<Value>* argv) {
EscapableHandleScope handle_scope(isolate);
- Local<String> method_string = OneByteString(isolate, method);
return handle_scope.Escape(
- MakeCallback(isolate, recv, method_string, argc, argv));
+ MakeCallback(isolate, recv, method, argc, argv, 0, 0)
+ .FromMaybe(Local<Value>()));
}
Local<Value> MakeCallback(Isolate* isolate,
- Local<Object> recv,
- Local<String> symbol,
- int argc,
- Local<Value> argv[]) {
+ Local<Object> recv,
+ Local<String> symbol,
+ int argc,
+ Local<Value>* argv) {
EscapableHandleScope handle_scope(isolate);
- Local<Value> callback_v = recv->Get(symbol);
- if (callback_v.IsEmpty()) return Local<Value>();
- if (!callback_v->IsFunction()) return Local<Value>();
- Local<Function> callback = callback_v.As<Function>();
- return handle_scope.Escape(MakeCallback(isolate, recv, callback, argc, argv));
+ return handle_scope.Escape(
+ MakeCallback(isolate, recv, symbol, argc, argv, 0, 0)
+ .FromMaybe(Local<Value>()));
}
Local<Value> MakeCallback(Isolate* isolate,
- Local<Object> recv,
- Local<Function> callback,
- int argc,
- Local<Value> argv[]) {
- // Observe the following two subtleties:
- //
- // 1. The environment is retrieved from the callback function's context.
- // 2. The context to enter is retrieved from the environment.
- //
- // Because of the AssignToContext() call in src/node_contextify.cc,
- // the two contexts need not be the same.
+ Local<Object> recv,
+ Local<Function> callback,
+ int argc,
+ Local<Value>* argv) {
EscapableHandleScope handle_scope(isolate);
- Environment* env = Environment::GetCurrent(callback->CreationContext());
- Context::Scope context_scope(env->context());
return handle_scope.Escape(
- MakeCallback(env, recv.As<Value>(), callback, argc, argv));
+ MakeCallback(isolate, recv, callback, argc, argv, 0, 0)
+ .FromMaybe(Local<Value>()));
}
@@ -4382,7 +4402,9 @@ void EmitBeforeExit(Environment* env) {
FIXED_ONE_BYTE_STRING(env->isolate(), "beforeExit"),
process_object->Get(exit_code)->ToInteger(env->isolate())
};
- MakeCallback(env, process_object, "emit", arraysize(args), args);
+ MakeCallback(env->isolate(),
+ process_object, "emit", arraysize(args), args,
+ 0, 0).ToLocalChecked();
}
@@ -4401,7 +4423,9 @@ int EmitExit(Environment* env) {
Integer::New(env->isolate(), code)
};
- MakeCallback(env, process_object, "emit", arraysize(args), args);
+ MakeCallback(env->isolate(),
+ process_object, "emit", arraysize(args), args,
+ 0, 0).ToLocalChecked();
// Reload exit code, it may be changed by `emit('exit')`
return process_object->Get(exitCode)->Int32Value();
diff --git a/src/node.h b/src/node.h
index 7ed4521e87..329a3c623b 100644
--- a/src/node.h
+++ b/src/node.h
@@ -142,14 +142,10 @@ inline v8::Local<v8::Value> UVException(int errorno,
}
/*
- * MakeCallback doesn't have a HandleScope. That means the callers scope
- * will retain ownership of created handles from MakeCallback and related.
- * There is by default a wrapping HandleScope before uv_run, if the caller
- * doesn't have a HandleScope on the stack the global will take ownership
- * which won't be reaped until the uv loop exits.
+ * These methods need to be called in a HandleScope.
*
- * If a uv callback is fired, and there is no enclosing HandleScope in the
- * cb, you will appear to leak 4-bytes for every invocation. Take heed.
+ * It is preferred that you use the `MakeCallback` overloads taking
+ * `async_uid` arguments.
*/
NODE_EXTERN v8::Local<v8::Value> MakeCallback(
@@ -521,12 +517,135 @@ typedef void (*promise_hook_func) (v8::PromiseHookType type,
v8::Local<v8::Value> parent,
void* arg);
+typedef double async_uid;
+
/* Registers an additional v8::PromiseHook wrapper. This API exists because V8
* itself supports only a single PromiseHook. */
NODE_EXTERN void AddPromiseHook(v8::Isolate* isolate,
promise_hook_func fn,
void* arg);
+/* Returns the id of the current execution context. If the return value is
+ * zero then no execution has been set. This will happen if the user handles
+ * I/O from native code. */
+NODE_EXTERN async_uid AsyncHooksGetCurrentId(v8::Isolate* isolate);
+
+/* Return same value as async_hooks.triggerId(); */
+NODE_EXTERN async_uid AsyncHooksGetTriggerId(v8::Isolate* isolate);
+
+/* If the native API doesn't inherit from the helper class then the callbacks
+ * must be triggered manually. This triggers the init() callback. The return
+ * value is the uid assigned to the resource.
+ *
+ * The `trigger_id` parameter should correspond to the resource which is
+ * creating the new resource, which will usually be the return value of
+ * `AsyncHooksGetTriggerId()`. */
+NODE_EXTERN async_uid EmitAsyncInit(v8::Isolate* isolate,
+ v8::Local<v8::Object> resource,
+ const char* name,
+ async_uid trigger_id);
+
+/* Emit the destroy() callback. */
+NODE_EXTERN void EmitAsyncDestroy(v8::Isolate* isolate, async_uid id);
+
+/* An API specific to emit before/after callbacks is unnecessary because
+ * MakeCallback will automatically call them for you.
+ *
+ * These methods may create handles on their own, so run them inside a
+ * HandleScope.
+ *
+ * `asyncId` and `triggerId` should correspond to the values returned by
+ * `EmitAsyncInit()` and `AsyncHooksGetTriggerId()`, respectively, when the
+ * invoking resource was created. If these values are unknown, 0 can be passed.
+ * */
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+ v8::Local<v8::Object> recv,
+ v8::Local<v8::Function> callback,
+ int argc,
+ v8::Local<v8::Value>* argv,
+ async_uid asyncId,
+ async_uid triggerId);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+ v8::Local<v8::Object> recv,
+ const char* method,
+ int argc,
+ v8::Local<v8::Value>* argv,
+ async_uid asyncId,
+ async_uid triggerId);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+ v8::Local<v8::Object> recv,
+ v8::Local<v8::String> symbol,
+ int argc,
+ v8::Local<v8::Value>* argv,
+ async_uid asyncId,
+ async_uid triggerId);
+
+/* Helper class users can optionally inherit from. If
+ * `AsyncResource::MakeCallback()` is used, then all four callbacks will be
+ * called automatically. */
+class AsyncResource {
+ public:
+ AsyncResource(v8::Isolate* isolate,
+ v8::Local<v8::Object> resource,
+ const char* name,
+ async_uid trigger_id = -1)
+ : isolate_(isolate),
+ resource_(isolate, resource),
+ trigger_id_(trigger_id) {
+ if (trigger_id_ == -1)
+ trigger_id_ = AsyncHooksGetTriggerId(isolate);
+
+ uid_ = EmitAsyncInit(isolate, resource, name, trigger_id_);
+ }
+
+ ~AsyncResource() {
+ EmitAsyncDestroy(isolate_, uid_);
+ }
+
+ v8::MaybeLocal<v8::Value> MakeCallback(
+ v8::Local<v8::Function> callback,
+ int argc,
+ v8::Local<v8::Value>* argv) {
+ return node::MakeCallback(isolate_, get_resource(),
+ callback, argc, argv,
+ uid_, trigger_id_);
+ }
+
+ v8::MaybeLocal<v8::Value> MakeCallback(
+ const char* method,
+ int argc,
+ v8::Local<v8::Value>* argv) {
+ return node::MakeCallback(isolate_, get_resource(),
+ method, argc, argv,
+ uid_, trigger_id_);
+ }
+
+ v8::MaybeLocal<v8::Value> MakeCallback(
+ v8::Local<v8::String> symbol,
+ int argc,
+ v8::Local<v8::Value>* argv) {
+ return node::MakeCallback(isolate_, get_resource(),
+ symbol, argc, argv,
+ uid_, trigger_id_);
+ }
+
+ v8::Local<v8::Object> get_resource() {
+ return resource_.Get(isolate_);
+ }
+
+ async_uid get_uid() const {
+ return uid_;
+ }
+ private:
+ v8::Isolate* isolate_;
+ v8::Persistent<v8::Object> resource_;
+ async_uid uid_;
+ async_uid trigger_id_;
+};
+
} // namespace node
#endif // SRC_NODE_H_
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index 68613ab565..ef95025229 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -1237,11 +1237,13 @@ int SecureContext::TicketKeyCallback(SSL* ssl,
kTicketPartSize).ToLocalChecked(),
Boolean::New(env->isolate(), enc != 0)
};
- Local<Value> ret = node::MakeCallback(env,
+
+ Local<Value> ret = node::MakeCallback(env->isolate(),
sc->object(),
env->ticketkeycallback_string(),
arraysize(argv),
- argv);
+ argv,
+ 0, 0).ToLocalChecked();
Local<Array> arr = ret.As<Array>();
int r = arr->Get(kTicketKeyReturnIndex)->Int32Value();
diff --git a/src/node_internals.h b/src/node_internals.h
index e07cb9d6d3..a08ab45aff 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -94,27 +94,6 @@ inline v8::Local<TypeName> PersistentToLocal(
v8::Isolate* isolate,
const v8::Persistent<TypeName>& persistent);
-// Call with valid HandleScope and while inside Context scope.
-v8::Local<v8::Value> MakeCallback(Environment* env,
- v8::Local<v8::Object> recv,
- const char* method,
- int argc = 0,
- v8::Local<v8::Value>* argv = nullptr);
-
-// Call with valid HandleScope and while inside Context scope.
-v8::Local<v8::Value> MakeCallback(Environment* env,
- v8::Local<v8::Object> recv,
- v8::Local<v8::String> symbol,
- int argc = 0,
- v8::Local<v8::Value>* argv = nullptr);
-
-// Call with valid HandleScope and while inside Context scope.
-v8::Local<v8::Value> MakeCallback(Environment* env,
- v8::Local<v8::Value> recv,
- v8::Local<v8::Function> callback,
- int argc = 0,
- v8::Local<v8::Value>* argv = nullptr);
-
// Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
// Sets address and port properties on the info object and returns it.
// If |info| is omitted, a new object is returned.
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-23 15:55:21 +0000