smallsolar
/
node
mirror of https://github.com/nodejs/node.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

src: split property helpers from node::Environment 

PR-URL: https://github.com/nodejs/node/pull/44056
Refs: https://github.com/nodejs/node/issues/42528
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Feng Yu <F3n67u@outlook.com>
This commit is contained in:
legendecas 2022-08-02 00:01:02 +08:00
parent 7f7a899fa5
commit a7e5b413ef
No known key found for this signature in database
GPG Key ID: CB3C9EC2BC27057C
78 changed files with 1471 additions and 1255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/README.md
View File

@ -390,32 +390,33 @@ void Initialize(Local<Object> target,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "getaddrinfo", GetAddrInfo);
env->SetMethod(target, "getnameinfo", GetNameInfo);
SetMethod(context, target, "getaddrinfo", GetAddrInfo);
SetMethod(context, target, "getnameinfo", GetNameInfo);
// 'SetMethodNoSideEffect' means that debuggers can safely execute this
// function for e.g. previews.
env->SetMethodNoSideEffect(target, "canonicalizeIP", CanonicalizeIP);
SetMethodNoSideEffect(context, target, "canonicalizeIP", CanonicalizeIP);
// ... more code ...
Isolate* isolate = env->isolate();
// Building the `ChannelWrap` class for JS:
Local<FunctionTemplate> channel_wrap =
env->NewFunctionTemplate(ChannelWrap::New);
NewFunctionTemplate(isolate, ChannelWrap::New);
// Allow for 1 internal field, see `BaseObject` for details on this:
channel_wrap->InstanceTemplate()->SetInternalFieldCount(1);
channel_wrap->Inherit(AsyncWrap::GetConstructorTemplate(env));
// Set various methods on the class (i.e. on the prototype):
env->SetProtoMethod(channel_wrap, "queryAny", Query<QueryAnyWrap>);
env->SetProtoMethod(channel_wrap, "queryA", Query<QueryAWrap>);
SetProtoMethod(isolate, channel_wrap, "queryAny", Query<QueryAnyWrap>);
SetProtoMethod(isolate, channel_wrap, "queryA", Query<QueryAWrap>);
// ...
env->SetProtoMethod(channel_wrap, "querySoa", Query<QuerySoaWrap>);
env->SetProtoMethod(channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
SetProtoMethod(isolate, channel_wrap, "querySoa", Query<QuerySoaWrap>);
SetProtoMethod(isolate, channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers);
SetProtoMethodNoSideEffect(isolate, channel_wrap, "getServers", GetServers);
env->SetConstructorFunction(target, "ChannelWrap", channel_wrap);
SetConstructorFunction(context, target, "ChannelWrap", channel_wrap);
}
// Run the `Initialize` function when loading this module through

28
src/async_wrap.cc
View File

@ -337,12 +337,14 @@ void AsyncWrap::SetCallbackTrampoline(const FunctionCallbackInfo<Value>& args) {
Local<FunctionTemplate> AsyncWrap::GetConstructorTemplate(Environment* env) {
Local<FunctionTemplate> tmpl = env->async_wrap_ctor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(nullptr);
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, nullptr);
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "AsyncWrap"));
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(tmpl, "getAsyncId", AsyncWrap::GetAsyncId);
env->SetProtoMethod(tmpl, "asyncReset", AsyncWrap::AsyncReset);
env->SetProtoMethod(tmpl, "getProviderType", AsyncWrap::GetProviderType);
SetProtoMethod(isolate, tmpl, "getAsyncId", AsyncWrap::GetAsyncId);
SetProtoMethod(isolate, tmpl, "asyncReset", AsyncWrap::AsyncReset);
SetProtoMethod(
isolate, tmpl, "getProviderType", AsyncWrap::GetProviderType);
env->set_async_wrap_ctor_template(tmpl);
}
return tmpl;
@ -356,15 +358,15 @@ void AsyncWrap::Initialize(Local<Object> target,
Isolate* isolate = env->isolate();
HandleScope scope(isolate);
env->SetMethod(target, "setupHooks", SetupHooks);
env->SetMethod(target, "setCallbackTrampoline", SetCallbackTrampoline);
env->SetMethod(target, "pushAsyncContext", PushAsyncContext);
env->SetMethod(target, "popAsyncContext", PopAsyncContext);
env->SetMethod(target, "executionAsyncResource", ExecutionAsyncResource);
env->SetMethod(target, "clearAsyncIdStack", ClearAsyncIdStack);
env->SetMethod(target, "queueDestroyAsyncId", QueueDestroyAsyncId);
env->SetMethod(target, "setPromiseHooks", SetPromiseHooks);
env->SetMethod(target, "registerDestroyHook", RegisterDestroyHook);
SetMethod(context, target, "setupHooks", SetupHooks);
SetMethod(context, target, "setCallbackTrampoline", SetCallbackTrampoline);
SetMethod(context, target, "pushAsyncContext", PushAsyncContext);
SetMethod(context, target, "popAsyncContext", PopAsyncContext);
SetMethod(context, target, "executionAsyncResource", ExecutionAsyncResource);
SetMethod(context, target, "clearAsyncIdStack", ClearAsyncIdStack);
SetMethod(context, target, "queueDestroyAsyncId", QueueDestroyAsyncId);
SetMethod(context, target, "setPromiseHooks", SetPromiseHooks);
SetMethod(context, target, "registerDestroyHook", RegisterDestroyHook);
PropertyAttribute ReadOnlyDontDelete =
static_cast<PropertyAttribute>(ReadOnly | DontDelete);

54
src/cares_wrap.cc
View File

@ -1886,12 +1886,13 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "getaddrinfo", GetAddrInfo);
env->SetMethod(target, "getnameinfo", GetNameInfo);
env->SetMethodNoSideEffect(target, "canonicalizeIP", CanonicalizeIP);
SetMethod(context, target, "getaddrinfo", GetAddrInfo);
SetMethod(context, target, "getnameinfo", GetNameInfo);
SetMethodNoSideEffect(context, target, "canonicalizeIP", CanonicalizeIP);
env->SetMethod(target, "strerror", StrError);
SetMethod(context, target, "strerror", StrError);
target->Set(env->context(), FIXED_ONE_BYTE_STRING(env->isolate(), "AF_INET"),
Integer::New(env->isolate(), AF_INET)).Check();
@ -1913,44 +1914,45 @@ void Initialize(Local<Object> target,
Local<FunctionTemplate> aiw =
BaseObject::MakeLazilyInitializedJSTemplate(env);
aiw->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "GetAddrInfoReqWrap", aiw);
SetConstructorFunction(context, target, "GetAddrInfoReqWrap", aiw);
Local<FunctionTemplate> niw =
BaseObject::MakeLazilyInitializedJSTemplate(env);
niw->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "GetNameInfoReqWrap", niw);
SetConstructorFunction(context, target, "GetNameInfoReqWrap", niw);
Local<FunctionTemplate> qrw =
BaseObject::MakeLazilyInitializedJSTemplate(env);
qrw->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "QueryReqWrap", qrw);
SetConstructorFunction(context, target, "QueryReqWrap", qrw);
Local<FunctionTemplate> channel_wrap =
env->NewFunctionTemplate(ChannelWrap::New);
NewFunctionTemplate(isolate, ChannelWrap::New);
channel_wrap->InstanceTemplate()->SetInternalFieldCount(
ChannelWrap::kInternalFieldCount);
channel_wrap->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(channel_wrap, "queryAny", Query<QueryAnyWrap>);
env->SetProtoMethod(channel_wrap, "queryA", Query<QueryAWrap>);
env->SetProtoMethod(channel_wrap, "queryAaaa", Query<QueryAaaaWrap>);
env->SetProtoMethod(channel_wrap, "queryCaa", Query<QueryCaaWrap>);
env->SetProtoMethod(channel_wrap, "queryCname", Query<QueryCnameWrap>);
env->SetProtoMethod(channel_wrap, "queryMx", Query<QueryMxWrap>);
env->SetProtoMethod(channel_wrap, "queryNs", Query<QueryNsWrap>);
env->SetProtoMethod(channel_wrap, "queryTxt", Query<QueryTxtWrap>);
env->SetProtoMethod(channel_wrap, "querySrv", Query<QuerySrvWrap>);
env->SetProtoMethod(channel_wrap, "queryPtr", Query<QueryPtrWrap>);
env->SetProtoMethod(channel_wrap, "queryNaptr", Query<QueryNaptrWrap>);
env->SetProtoMethod(channel_wrap, "querySoa", Query<QuerySoaWrap>);
env->SetProtoMethod(channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
SetProtoMethod(isolate, channel_wrap, "queryAny", Query<QueryAnyWrap>);
SetProtoMethod(isolate, channel_wrap, "queryA", Query<QueryAWrap>);
SetProtoMethod(isolate, channel_wrap, "queryAaaa", Query<QueryAaaaWrap>);
SetProtoMethod(isolate, channel_wrap, "queryCaa", Query<QueryCaaWrap>);
SetProtoMethod(isolate, channel_wrap, "queryCname", Query<QueryCnameWrap>);
SetProtoMethod(isolate, channel_wrap, "queryMx", Query<QueryMxWrap>);
SetProtoMethod(isolate, channel_wrap, "queryNs", Query<QueryNsWrap>);
SetProtoMethod(isolate, channel_wrap, "queryTxt", Query<QueryTxtWrap>);
SetProtoMethod(isolate, channel_wrap, "querySrv", Query<QuerySrvWrap>);
SetProtoMethod(isolate, channel_wrap, "queryPtr", Query<QueryPtrWrap>);
SetProtoMethod(isolate, channel_wrap, "queryNaptr", Query<QueryNaptrWrap>);
SetProtoMethod(isolate, channel_wrap, "querySoa", Query<QuerySoaWrap>);
SetProtoMethod(
isolate, channel_wrap, "getHostByAddr", Query<GetHostByAddrWrap>);
env->SetProtoMethodNoSideEffect(channel_wrap, "getServers", GetServers);
env->SetProtoMethod(channel_wrap, "setServers", SetServers);
env->SetProtoMethod(channel_wrap, "setLocalAddress", SetLocalAddress);
env->SetProtoMethod(channel_wrap, "cancel", Cancel);
SetProtoMethodNoSideEffect(isolate, channel_wrap, "getServers", GetServers);
SetProtoMethod(isolate, channel_wrap, "setServers", SetServers);
SetProtoMethod(isolate, channel_wrap, "setLocalAddress", SetLocalAddress);
SetProtoMethod(isolate, channel_wrap, "cancel", Cancel);
env->SetConstructorFunction(target, "ChannelWrap", channel_wrap);
SetConstructorFunction(context, target, "ChannelWrap", channel_wrap);
}
} // namespace cares_wrap

71
src/crypto/crypto_cipher.cc
View File

@ -13,10 +13,12 @@ namespace node {
using v8::Array;
using v8::ArrayBuffer;
using v8::BackingStore;
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Uint32;
@ -270,43 +272,54 @@ void CipherBase::MemoryInfo(MemoryTracker* tracker) const {
}
void CipherBase::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<Context> context = env->context();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
CipherBase::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "init", Init);
env->SetProtoMethod(t, "initiv", InitIv);
env->SetProtoMethod(t, "update", Update);
env->SetProtoMethod(t, "final", Final);
env->SetProtoMethod(t, "setAutoPadding", SetAutoPadding);
env->SetProtoMethodNoSideEffect(t, "getAuthTag", GetAuthTag);
env->SetProtoMethod(t, "setAuthTag", SetAuthTag);
env->SetProtoMethod(t, "setAAD", SetAAD);
env->SetConstructorFunction(target, "CipherBase", t);
SetProtoMethod(isolate, t, "init", Init);
SetProtoMethod(isolate, t, "initiv", InitIv);
SetProtoMethod(isolate, t, "update", Update);
SetProtoMethod(isolate, t, "final", Final);
SetProtoMethod(isolate, t, "setAutoPadding", SetAutoPadding);
SetProtoMethodNoSideEffect(isolate, t, "getAuthTag", GetAuthTag);
SetProtoMethod(isolate, t, "setAuthTag", SetAuthTag);
SetProtoMethod(isolate, t, "setAAD", SetAAD);
SetConstructorFunction(context, target, "CipherBase", t);
env->SetMethodNoSideEffect(target, "getSSLCiphers", GetSSLCiphers);
env->SetMethodNoSideEffect(target, "getCiphers", GetCiphers);
SetMethodNoSideEffect(context, target, "getSSLCiphers", GetSSLCiphers);
SetMethodNoSideEffect(context, target, "getCiphers", GetCiphers);
env->SetMethod(target, "publicEncrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
EVP_PKEY_encrypt_init,
EVP_PKEY_encrypt>);
env->SetMethod(target, "privateDecrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
EVP_PKEY_decrypt_init,
EVP_PKEY_decrypt>);
env->SetMethod(target, "privateEncrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
EVP_PKEY_sign_init,
EVP_PKEY_sign>);
env->SetMethod(target, "publicDecrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
EVP_PKEY_verify_recover_init,
EVP_PKEY_verify_recover>);
SetMethod(context,
target,
"publicEncrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
EVP_PKEY_encrypt_init,
EVP_PKEY_encrypt>);
SetMethod(context,
target,
"privateDecrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
EVP_PKEY_decrypt_init,
EVP_PKEY_decrypt>);
SetMethod(context,
target,
"privateEncrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
EVP_PKEY_sign_init,
EVP_PKEY_sign>);
SetMethod(context,
target,
"publicDecrypt",
PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
EVP_PKEY_verify_recover_init,
EVP_PKEY_verify_recover>);
env->SetMethodNoSideEffect(target, "getCipherInfo", GetCipherInfo);
SetMethodNoSideEffect(context, target, "getCipherInfo", GetCipherInfo);
NODE_DEFINE_CONSTANT(target, kWebCryptoCipherEncrypt);
NODE_DEFINE_CONSTANT(target, kWebCryptoCipherDecrypt);

106
src/crypto/crypto_context.cc
View File

@ -31,6 +31,7 @@ using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::PropertyAttribute;
@ -256,51 +257,52 @@ Local<FunctionTemplate> SecureContext::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->secure_context_constructor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, New);
tmpl->InstanceTemplate()->SetInternalFieldCount(
SecureContext::kInternalFieldCount);
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"));
env->SetProtoMethod(tmpl, "init", Init);
env->SetProtoMethod(tmpl, "setKey", SetKey);
env->SetProtoMethod(tmpl, "setCert", SetCert);
env->SetProtoMethod(tmpl, "addCACert", AddCACert);
env->SetProtoMethod(tmpl, "addCRL", AddCRL);
env->SetProtoMethod(tmpl, "addRootCerts", AddRootCerts);
env->SetProtoMethod(tmpl, "setCipherSuites", SetCipherSuites);
env->SetProtoMethod(tmpl, "setCiphers", SetCiphers);
env->SetProtoMethod(tmpl, "setSigalgs", SetSigalgs);
env->SetProtoMethod(tmpl, "setECDHCurve", SetECDHCurve);
env->SetProtoMethod(tmpl, "setDHParam", SetDHParam);
env->SetProtoMethod(tmpl, "setMaxProto", SetMaxProto);
env->SetProtoMethod(tmpl, "setMinProto", SetMinProto);
env->SetProtoMethod(tmpl, "getMaxProto", GetMaxProto);
env->SetProtoMethod(tmpl, "getMinProto", GetMinProto);
env->SetProtoMethod(tmpl, "setOptions", SetOptions);
env->SetProtoMethod(tmpl, "setSessionIdContext", SetSessionIdContext);
env->SetProtoMethod(tmpl, "setSessionTimeout", SetSessionTimeout);
env->SetProtoMethod(tmpl, "close", Close);
env->SetProtoMethod(tmpl, "loadPKCS12", LoadPKCS12);
env->SetProtoMethod(tmpl, "setTicketKeys", SetTicketKeys);
env->SetProtoMethod(tmpl, "setFreeListLength", SetFreeListLength);
env->SetProtoMethod(tmpl, "enableTicketKeyCallback",
EnableTicketKeyCallback);
SetProtoMethod(isolate, tmpl, "init", Init);
SetProtoMethod(isolate, tmpl, "setKey", SetKey);
SetProtoMethod(isolate, tmpl, "setCert", SetCert);
SetProtoMethod(isolate, tmpl, "addCACert", AddCACert);
SetProtoMethod(isolate, tmpl, "addCRL", AddCRL);
SetProtoMethod(isolate, tmpl, "addRootCerts", AddRootCerts);
SetProtoMethod(isolate, tmpl, "setCipherSuites", SetCipherSuites);
SetProtoMethod(isolate, tmpl, "setCiphers", SetCiphers);
SetProtoMethod(isolate, tmpl, "setSigalgs", SetSigalgs);
SetProtoMethod(isolate, tmpl, "setECDHCurve", SetECDHCurve);
SetProtoMethod(isolate, tmpl, "setDHParam", SetDHParam);
SetProtoMethod(isolate, tmpl, "setMaxProto", SetMaxProto);
SetProtoMethod(isolate, tmpl, "setMinProto", SetMinProto);
SetProtoMethod(isolate, tmpl, "getMaxProto", GetMaxProto);
SetProtoMethod(isolate, tmpl, "getMinProto", GetMinProto);
SetProtoMethod(isolate, tmpl, "setOptions", SetOptions);
SetProtoMethod(isolate, tmpl, "setSessionIdContext", SetSessionIdContext);
SetProtoMethod(isolate, tmpl, "setSessionTimeout", SetSessionTimeout);
SetProtoMethod(isolate, tmpl, "close", Close);
SetProtoMethod(isolate, tmpl, "loadPKCS12", LoadPKCS12);
SetProtoMethod(isolate, tmpl, "setTicketKeys", SetTicketKeys);
SetProtoMethod(isolate, tmpl, "setFreeListLength", SetFreeListLength);
SetProtoMethod(
isolate, tmpl, "enableTicketKeyCallback", EnableTicketKeyCallback);
env->SetProtoMethodNoSideEffect(tmpl, "getTicketKeys", GetTicketKeys);
env->SetProtoMethodNoSideEffect(tmpl, "getCertificate",
GetCertificate<true>);
env->SetProtoMethodNoSideEffect(tmpl, "getIssuer",
GetCertificate<false>);
SetProtoMethodNoSideEffect(isolate, tmpl, "getTicketKeys", GetTicketKeys);
SetProtoMethodNoSideEffect(
isolate, tmpl, "getCertificate", GetCertificate<true>);
SetProtoMethodNoSideEffect(
isolate, tmpl, "getIssuer", GetCertificate<false>);
#ifndef OPENSSL_NO_ENGINE
env->SetProtoMethod(tmpl, "setEngineKey", SetEngineKey);
env->SetProtoMethod(tmpl, "setClientCertEngine", SetClientCertEngine);
#endif // !OPENSSL_NO_ENGINE
#ifndef OPENSSL_NO_ENGINE
SetProtoMethod(isolate, tmpl, "setEngineKey", SetEngineKey);
SetProtoMethod(isolate, tmpl, "setClientCertEngine", SetClientCertEngine);
#endif // !OPENSSL_NO_ENGINE
#define SET_INTEGER_CONSTANTS(name, value) \
tmpl->Set(FIXED_ONE_BYTE_STRING(env->isolate(), name), \
Integer::NewFromUnsigned(env->isolate(), value));
#define SET_INTEGER_CONSTANTS(name, value) \
tmpl->Set(FIXED_ONE_BYTE_STRING(isolate, name), \
Integer::NewFromUnsigned(isolate, value));
SET_INTEGER_CONSTANTS("kTicketKeyReturnIndex", kTicketKeyReturnIndex);
SET_INTEGER_CONSTANTS("kTicketKeyHMACIndex", kTicketKeyHMACIndex);
SET_INTEGER_CONSTANTS("kTicketKeyAESIndex", kTicketKeyAESIndex);
@ -308,14 +310,11 @@ Local<FunctionTemplate> SecureContext::GetConstructorTemplate(
SET_INTEGER_CONSTANTS("kTicketKeyIVIndex", kTicketKeyIVIndex);
#undef SET_INTEGER_CONSTANTS
Local<FunctionTemplate> ctx_getter_templ =
FunctionTemplate::New(env->isolate(),
CtxGetter,
Local<Value>(),
Signature::New(env->isolate(), tmpl));
Local<FunctionTemplate> ctx_getter_templ = FunctionTemplate::New(
isolate, CtxGetter, Local<Value>(), Signature::New(isolate, tmpl));
tmpl->PrototypeTemplate()->SetAccessorProperty(
FIXED_ONE_BYTE_STRING(env->isolate(), "_external"),
FIXED_ONE_BYTE_STRING(isolate, "_external"),
ctx_getter_templ,
Local<FunctionTemplate>(),
static_cast<PropertyAttribute>(ReadOnly | DontDelete));
@ -326,17 +325,20 @@ Local<FunctionTemplate> SecureContext::GetConstructorTemplate(
}
void SecureContext::Initialize(Environment* env, Local<Object> target) {
env->SetConstructorFunction(
target,
"SecureContext",
GetConstructorTemplate(env),
Environment::SetConstructorFunctionFlag::NONE);
Local<Context> context = env->context();
SetConstructorFunction(context,
target,
"SecureContext",
GetConstructorTemplate(env),
SetConstructorFunctionFlag::NONE);
env->SetMethodNoSideEffect(target, "getRootCertificates",
GetRootCertificates);
SetMethodNoSideEffect(
context, target, "getRootCertificates", GetRootCertificates);
// Exposed for testing purposes only.
env->SetMethodNoSideEffect(target, "isExtraRootCertsFileLoaded",
IsExtraRootCertsFileLoaded);
SetMethodNoSideEffect(context,
target,
"isExtraRootCertsFileLoaded",
IsExtraRootCertsFileLoaded);
}
void SecureContext::RegisterExternalReferences(

31
src/crypto/crypto_dh.cc
View File

@ -14,12 +14,14 @@ namespace node {
using v8::ArrayBuffer;
using v8::BackingStore;
using v8::ConstructorBehavior;
using v8::Context;
using v8::DontDelete;
using v8::FunctionCallback;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
@ -57,8 +59,10 @@ DiffieHellman::DiffieHellman(Environment* env, Local<Object> wrap)
}
void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
auto make = [&] (Local<String> name, FunctionCallback callback) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(callback);
Isolate* isolate = env->isolate();
Local<Context> context = env->context();
auto make = [&](Local<String> name, FunctionCallback callback) {
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, callback);
const PropertyAttribute attributes =
static_cast<PropertyAttribute>(ReadOnly | DontDelete);
@ -67,17 +71,17 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
DiffieHellman::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "generateKeys", GenerateKeys);
env->SetProtoMethod(t, "computeSecret", ComputeSecret);
env->SetProtoMethodNoSideEffect(t, "getPrime", GetPrime);
env->SetProtoMethodNoSideEffect(t, "getGenerator", GetGenerator);
env->SetProtoMethodNoSideEffect(t, "getPublicKey", GetPublicKey);
env->SetProtoMethodNoSideEffect(t, "getPrivateKey", GetPrivateKey);
env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
SetProtoMethod(isolate, t, "generateKeys", GenerateKeys);
SetProtoMethod(isolate, t, "computeSecret", ComputeSecret);
SetProtoMethodNoSideEffect(isolate, t, "getPrime", GetPrime);
SetProtoMethodNoSideEffect(isolate, t, "getGenerator", GetGenerator);
SetProtoMethodNoSideEffect(isolate, t, "getPublicKey", GetPublicKey);
SetProtoMethodNoSideEffect(isolate, t, "getPrivateKey", GetPrivateKey);
SetProtoMethod(isolate, t, "setPublicKey", SetPublicKey);
SetProtoMethod(isolate, t, "setPrivateKey", SetPrivateKey);
Local<FunctionTemplate> verify_error_getter_templ =
FunctionTemplate::New(env->isolate(),
FunctionTemplate::New(isolate,
DiffieHellman::VerifyErrorGetter,
Local<Value>(),
Signature::New(env->isolate(), t),
@ -91,14 +95,15 @@ void DiffieHellman::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate>(),
attributes);
env->SetConstructorFunction(target, name, t);
SetConstructorFunction(context, target, name, t);
};
make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"), New);
make(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellmanGroup"),
DiffieHellmanGroup);
env->SetMethodNoSideEffect(target, "statelessDH", DiffieHellman::Stateless);
SetMethodNoSideEffect(
context, target, "statelessDH", DiffieHellman::Stateless);
DHKeyPairGenJob::Initialize(env, target);
DHKeyExportJob::Initialize(env, target);
DHBitsJob::Initialize(env, target);

25
src/crypto/crypto_ec.cc
View File

@ -21,9 +21,11 @@ namespace node {
using v8::Array;
using v8::ArrayBuffer;
using v8::BackingStore;
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Int32;
using v8::Isolate;
using v8::Just;
using v8::JustVoid;
using v8::Local;
@ -60,22 +62,25 @@ int GetOKPCurveFromName(const char* name) {
}
void ECDH::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<Context> context = env->context();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->Inherit(BaseObject::GetConstructorTemplate(env));
t->InstanceTemplate()->SetInternalFieldCount(ECDH::kInternalFieldCount);
env->SetProtoMethod(t, "generateKeys", GenerateKeys);
env->SetProtoMethod(t, "computeSecret", ComputeSecret);
env->SetProtoMethodNoSideEffect(t, "getPublicKey", GetPublicKey);
env->SetProtoMethodNoSideEffect(t, "getPrivateKey", GetPrivateKey);
env->SetProtoMethod(t, "setPublicKey", SetPublicKey);
env->SetProtoMethod(t, "setPrivateKey", SetPrivateKey);
SetProtoMethod(isolate, t, "generateKeys", GenerateKeys);
SetProtoMethod(isolate, t, "computeSecret", ComputeSecret);
SetProtoMethodNoSideEffect(isolate, t, "getPublicKey", GetPublicKey);
SetProtoMethodNoSideEffect(isolate, t, "getPrivateKey", GetPrivateKey);
SetProtoMethod(isolate, t, "setPublicKey", SetPublicKey);
SetProtoMethod(isolate, t, "setPrivateKey", SetPrivateKey);
env->SetConstructorFunction(target, "ECDH", t);
SetConstructorFunction(context, target, "ECDH", t);
env->SetMethodNoSideEffect(target, "ECDHConvertKey", ECDH::ConvertKey);
env->SetMethodNoSideEffect(target, "getCurves", ECDH::GetCurves);
SetMethodNoSideEffect(context, target, "ECDHConvertKey", ECDH::ConvertKey);
SetMethodNoSideEffect(context, target, "getCurves", ECDH::GetCurves);
ECDHBitsJob::Initialize(env, target);
ECKeyPairGenJob::Initialize(env, target);

14
src/crypto/crypto_hash.cc
View File

@ -11,8 +11,10 @@
namespace node {
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
@ -51,18 +53,20 @@ void Hash::GetHashes(const FunctionCallbackInfo<Value>& args) {
}
void Hash::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<Context> context = env->context();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
Hash::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "update", HashUpdate);
env->SetProtoMethod(t, "digest", HashDigest);
SetProtoMethod(isolate, t, "update", HashUpdate);
SetProtoMethod(isolate, t, "digest", HashDigest);
env->SetConstructorFunction(target, "Hash", t);
SetConstructorFunction(context, target, "Hash", t);
env->SetMethodNoSideEffect(target, "getHashes", GetHashes);
SetMethodNoSideEffect(context, target, "getHashes", GetHashes);
HashJob::Initialize(env, target);
}

12
src/crypto/crypto_hmac.cc
View File

@ -16,6 +16,7 @@ namespace node {
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
@ -37,17 +38,18 @@ void Hmac::MemoryInfo(MemoryTracker* tracker) const {
}
void Hmac::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
Hmac::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "init", HmacInit);
env->SetProtoMethod(t, "update", HmacUpdate);
env->SetProtoMethod(t, "digest", HmacDigest);
SetProtoMethod(isolate, t, "init", HmacInit);
SetProtoMethod(isolate, t, "update", HmacUpdate);
SetProtoMethod(isolate, t, "digest", HmacDigest);
env->SetConstructorFunction(target, "Hmac", t);
SetConstructorFunction(env->context(), target, "Hmac", t);
HmacJob::Initialize(env, target);
}

38
src/crypto/crypto_keys.cc
View File

@ -24,6 +24,7 @@ using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Int32;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
@ -906,23 +907,24 @@ v8::Local<v8::Function> KeyObjectHandle::Initialize(Environment* env) {
if (!templ.IsEmpty()) {
return templ;
}
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
KeyObjectHandle::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "init", Init);
env->SetProtoMethodNoSideEffect(t, "getSymmetricKeySize",
GetSymmetricKeySize);
env->SetProtoMethodNoSideEffect(t, "getAsymmetricKeyType",
GetAsymmetricKeyType);
env->SetProtoMethod(t, "export", Export);
env->SetProtoMethod(t, "exportJwk", ExportJWK);
env->SetProtoMethod(t, "initECRaw", InitECRaw);
env->SetProtoMethod(t, "initEDRaw", InitEDRaw);
env->SetProtoMethod(t, "initJwk", InitJWK);
env->SetProtoMethod(t, "keyDetail", GetKeyDetail);
env->SetProtoMethod(t, "equals", Equals);
SetProtoMethod(isolate, t, "init", Init);
SetProtoMethodNoSideEffect(
isolate, t, "getSymmetricKeySize", GetSymmetricKeySize);
SetProtoMethodNoSideEffect(
isolate, t, "getAsymmetricKeyType", GetAsymmetricKeyType);
SetProtoMethod(isolate, t, "export", Export);
SetProtoMethod(isolate, t, "exportJwk", ExportJWK);
SetProtoMethod(isolate, t, "initECRaw", InitECRaw);
SetProtoMethod(isolate, t, "initEDRaw", InitEDRaw);
SetProtoMethod(isolate, t, "initJwk", InitJWK);
SetProtoMethod(isolate, t, "keyDetail", GetKeyDetail);
SetProtoMethod(isolate, t, "equals", Equals);
auto function = t->GetFunction(env->context()).ToLocalChecked();
env->set_crypto_key_object_handle_constructor(function);
@ -1317,8 +1319,10 @@ void KeyObjectHandle::ExportJWK(
}
void NativeKeyObject::Initialize(Environment* env, Local<Object> target) {
env->SetMethod(target, "createNativeKeyObjectClass",
NativeKeyObject::CreateNativeKeyObjectClass);
SetMethod(env->context(),
target,
"createNativeKeyObjectClass",
NativeKeyObject::CreateNativeKeyObjectClass);
}
void NativeKeyObject::RegisterExternalReferences(
@ -1338,12 +1342,14 @@ void NativeKeyObject::New(const FunctionCallbackInfo<Value>& args) {
void NativeKeyObject::CreateNativeKeyObjectClass(
const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Isolate* isolate = env->isolate();
CHECK_EQ(args.Length(), 1);
Local<Value> callback = args[0];
CHECK(callback->IsFunction());
Local<FunctionTemplate> t = env->NewFunctionTemplate(NativeKeyObject::New);
Local<FunctionTemplate> t =
NewFunctionTemplate(isolate, NativeKeyObject::New);
t->InstanceTemplate()->SetInternalFieldCount(
KeyObjectHandle::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));

23
src/crypto/crypto_sig.cc
View File

@ -17,6 +17,7 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
@ -325,17 +326,18 @@ Sign::Sign(Environment* env, Local<Object> wrap) : SignBase(env, wrap) {
}
void Sign::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
SignBase::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "init", SignInit);
env->SetProtoMethod(t, "update", SignUpdate);
env->SetProtoMethod(t, "sign", SignFinal);
SetProtoMethod(isolate, t, "init", SignInit);
SetProtoMethod(isolate, t, "update", SignUpdate);
SetProtoMethod(isolate, t, "sign", SignFinal);
env->SetConstructorFunction(target, "Sign", t);
SetConstructorFunction(env->context(), target, "Sign", t);
SignJob::Initialize(env, target);
@ -454,17 +456,18 @@ Verify::Verify(Environment* env, Local<Object> wrap)
}
void Verify::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
SignBase::kInternalFieldCount);
t->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(t, "init", VerifyInit);
env->SetProtoMethod(t, "update", VerifyUpdate);
env->SetProtoMethod(t, "verify", VerifyFinal);
SetProtoMethod(isolate, t, "init", VerifyInit);
SetProtoMethod(isolate, t, "update", VerifyUpdate);
SetProtoMethod(isolate, t, "verify", VerifyFinal);
env->SetConstructorFunction(target, "Verify", t);
SetConstructorFunction(env->context(), target, "Verify", t);
}
void Verify::RegisterExternalReferences(ExternalReferenceRegistry* registry) {

10
src/crypto/crypto_spkac.cc
View File

@ -8,6 +8,7 @@
namespace node {
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::Local;
using v8::Object;
@ -125,9 +126,12 @@ void ExportChallenge(const FunctionCallbackInfo<Value>& args) {
}
void Initialize(Environment* env, Local<Object> target) {
env->SetMethodNoSideEffect(target, "certVerifySpkac", VerifySpkac);
env->SetMethodNoSideEffect(target, "certExportPublicKey", ExportPublicKey);
env->SetMethodNoSideEffect(target, "certExportChallenge", ExportChallenge);
Local<Context> context = env->context();
SetMethodNoSideEffect(context, target, "certVerifySpkac", VerifySpkac);
SetMethodNoSideEffect(
context, target, "certExportPublicKey", ExportPublicKey);
SetMethodNoSideEffect(
context, target, "certExportChallenge", ExportChallenge);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

3
src/crypto/crypto_timing.cc
View File

@ -47,7 +47,8 @@ void TimingSafeEqual(const FunctionCallbackInfo<Value>& args) {
}
void Initialize(Environment* env, Local<Object> target) {
env->SetMethodNoSideEffect(target, "timingSafeEqual", TimingSafeEqual);
SetMethodNoSideEffect(
env->context(), target, "timingSafeEqual", TimingSafeEqual);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
registry->Register(TimingSafeEqual);

89
src/crypto/crypto_tls.cc
View File

@ -2030,8 +2030,9 @@ void TLSWrap::Initialize(
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "wrap", TLSWrap::Wrap);
SetMethod(context, target, "wrap", TLSWrap::Wrap);
NODE_DEFINE_CONSTANT(target, HAVE_SSL_TRACE);
@ -2054,54 +2055,56 @@ void TLSWrap::Initialize(
t->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "certCbDone", CertCbDone);
env->SetProtoMethod(t, "destroySSL", DestroySSL);
env->SetProtoMethod(t, "enableCertCb", EnableCertCb);
env->SetProtoMethod(t, "endParser", EndParser);
env->SetProtoMethod(t, "enableKeylogCallback", EnableKeylogCallback);
env->SetProtoMethod(t, "enableSessionCallbacks", EnableSessionCallbacks);
env->SetProtoMethod(t, "enableTrace", EnableTrace);
env->SetProtoMethod(t, "getServername", GetServername);
env->SetProtoMethod(t, "loadSession", LoadSession);
env->SetProtoMethod(t, "newSessionDone", NewSessionDone);
env->SetProtoMethod(t, "receive", Receive);
env->SetProtoMethod(t, "renegotiate", Renegotiate);
env->SetProtoMethod(t, "requestOCSP", RequestOCSP);
env->SetProtoMethod(t, "setALPNProtocols", SetALPNProtocols);
env->SetProtoMethod(t, "setOCSPResponse", SetOCSPResponse);
env->SetProtoMethod(t, "setServername", SetServername);
env->SetProtoMethod(t, "setSession", SetSession);
env->SetProtoMethod(t, "setVerifyMode", SetVerifyMode);
env->SetProtoMethod(t, "start", Start);
SetProtoMethod(isolate, t, "certCbDone", CertCbDone);
SetProtoMethod(isolate, t, "destroySSL", DestroySSL);
SetProtoMethod(isolate, t, "enableCertCb", EnableCertCb);
SetProtoMethod(isolate, t, "endParser", EndParser);
SetProtoMethod(isolate, t, "enableKeylogCallback", EnableKeylogCallback);
SetProtoMethod(isolate, t, "enableSessionCallbacks", EnableSessionCallbacks);
SetProtoMethod(isolate, t, "enableTrace", EnableTrace);
SetProtoMethod(isolate, t, "getServername", GetServername);
SetProtoMethod(isolate, t, "loadSession", LoadSession);
SetProtoMethod(isolate, t, "newSessionDone", NewSessionDone);
SetProtoMethod(isolate, t, "receive", Receive);
SetProtoMethod(isolate, t, "renegotiate", Renegotiate);
SetProtoMethod(isolate, t, "requestOCSP", RequestOCSP);
SetProtoMethod(isolate, t, "setALPNProtocols", SetALPNProtocols);
SetProtoMethod(isolate, t, "setOCSPResponse", SetOCSPResponse);
SetProtoMethod(isolate, t, "setServername", SetServername);
SetProtoMethod(isolate, t, "setSession", SetSession);
SetProtoMethod(isolate, t, "setVerifyMode", SetVerifyMode);
SetProtoMethod(isolate, t, "start", Start);
env->SetProtoMethodNoSideEffect(t, "exportKeyingMaterial",
ExportKeyingMaterial);
env->SetProtoMethodNoSideEffect(t, "isSessionReused", IsSessionReused);
env->SetProtoMethodNoSideEffect(t, "getALPNNegotiatedProtocol",
GetALPNNegotiatedProto);
env->SetProtoMethodNoSideEffect(t, "getCertificate", GetCertificate);
env->SetProtoMethodNoSideEffect(t, "getX509Certificate", GetX509Certificate);
env->SetProtoMethodNoSideEffect(t, "getCipher", GetCipher);
env->SetProtoMethodNoSideEffect(t, "getEphemeralKeyInfo",
GetEphemeralKeyInfo);
env->SetProtoMethodNoSideEffect(t, "getFinished", GetFinished);
env->SetProtoMethodNoSideEffect(t, "getPeerCertificate", GetPeerCertificate);
env->SetProtoMethodNoSideEffect(t, "getPeerX509Certificate",
GetPeerX509Certificate);
env->SetProtoMethodNoSideEffect(t, "getPeerFinished", GetPeerFinished);
env->SetProtoMethodNoSideEffect(t, "getProtocol", GetProtocol);
env->SetProtoMethodNoSideEffect(t, "getSession", GetSession);
env->SetProtoMethodNoSideEffect(t, "getSharedSigalgs", GetSharedSigalgs);
env->SetProtoMethodNoSideEffect(t, "getTLSTicket", GetTLSTicket);
env->SetProtoMethodNoSideEffect(t, "verifyError", VerifyError);
SetProtoMethodNoSideEffect(
isolate, t, "exportKeyingMaterial", ExportKeyingMaterial);
SetProtoMethodNoSideEffect(isolate, t, "isSessionReused", IsSessionReused);
SetProtoMethodNoSideEffect(
isolate, t, "getALPNNegotiatedProtocol", GetALPNNegotiatedProto);
SetProtoMethodNoSideEffect(isolate, t, "getCertificate", GetCertificate);
SetProtoMethodNoSideEffect(
isolate, t, "getX509Certificate", GetX509Certificate);
SetProtoMethodNoSideEffect(isolate, t, "getCipher", GetCipher);
SetProtoMethodNoSideEffect(
isolate, t, "getEphemeralKeyInfo", GetEphemeralKeyInfo);
SetProtoMethodNoSideEffect(isolate, t, "getFinished", GetFinished);
SetProtoMethodNoSideEffect(
isolate, t, "getPeerCertificate", GetPeerCertificate);
SetProtoMethodNoSideEffect(
isolate, t, "getPeerX509Certificate", GetPeerX509Certificate);
SetProtoMethodNoSideEffect(isolate, t, "getPeerFinished", GetPeerFinished);
SetProtoMethodNoSideEffect(isolate, t, "getProtocol", GetProtocol);
SetProtoMethodNoSideEffect(isolate, t, "getSession", GetSession);
SetProtoMethodNoSideEffect(isolate, t, "getSharedSigalgs", GetSharedSigalgs);
SetProtoMethodNoSideEffect(isolate, t, "getTLSTicket", GetTLSTicket);
SetProtoMethodNoSideEffect(isolate, t, "verifyError", VerifyError);
#ifdef SSL_set_max_send_fragment
env->SetProtoMethod(t, "setMaxSendFragment", SetMaxSendFragment);
SetProtoMethod(isolate, t, "setMaxSendFragment", SetMaxSendFragment);
#endif // SSL_set_max_send_fragment
#ifndef OPENSSL_NO_PSK
env->SetProtoMethod(t, "enablePskCallback", EnablePskCallback);
env->SetProtoMethod(t, "setPskIdentityHint", SetPskIdentityHint);
SetProtoMethod(isolate, t, "enablePskCallback", EnablePskCallback);
SetProtoMethod(isolate, t, "setPskIdentityHint", SetPskIdentityHint);
#endif // !OPENSSL_NO_PSK
StreamBase::AddMethods(env, t);

13
src/crypto/crypto_util.cc
View File

@ -711,19 +711,20 @@ void SecureHeapUsed(const FunctionCallbackInfo<Value>& args) {
namespace Util {
void Initialize(Environment* env, Local<Object> target) {
Local<Context> context = env->context();
#ifndef OPENSSL_NO_ENGINE
env->SetMethod(target, "setEngine", SetEngine);
SetMethod(context, target, "setEngine", SetEngine);
#endif // !OPENSSL_NO_ENGINE
env->SetMethodNoSideEffect(target, "getFipsCrypto", GetFipsCrypto);
env->SetMethod(target, "setFipsCrypto", SetFipsCrypto);
env->SetMethodNoSideEffect(target, "testFipsCrypto", TestFipsCrypto);
SetMethodNoSideEffect(context, target, "getFipsCrypto", GetFipsCrypto);
SetMethod(context, target, "setFipsCrypto", SetFipsCrypto);
SetMethodNoSideEffect(context, target, "testFipsCrypto", TestFipsCrypto);
NODE_DEFINE_CONSTANT(target, kCryptoJobAsync);
NODE_DEFINE_CONSTANT(target, kCryptoJobSync);
env->SetMethod(target, "secureBuffer", SecureBuffer);
env->SetMethod(target, "secureHeapUsed", SecureHeapUsed);
SetMethod(context, target, "secureBuffer", SecureBuffer);
SetMethod(context, target, "secureHeapUsed", SecureHeapUsed);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
#ifndef OPENSSL_NO_ENGINE

9
src/crypto/crypto_util.h
View File

@ -443,12 +443,15 @@ class CryptoJob : public AsyncWrap, public ThreadPoolWork {
v8::FunctionCallback new_fn,
Environment* env,
v8::Local<v8::Object> target) {
v8::Local<v8::FunctionTemplate> job = env->NewFunctionTemplate(new_fn);
v8::Isolate* isolate = env->isolate();
v8::HandleScope scope(isolate);
v8::Local<v8::Context> context = env->context();
v8::Local<v8::FunctionTemplate> job = NewFunctionTemplate(isolate, new_fn);
job->Inherit(AsyncWrap::GetConstructorTemplate(env));
job->InstanceTemplate()->SetInternalFieldCount(
AsyncWrap::kInternalFieldCount);
env->SetProtoMethod(job, "run", Run);
env->SetConstructorFunction(target, CryptoJobTraits::JobName, job);
SetProtoMethod(isolate, job, "run", Run);
SetConstructorFunction(context, target, CryptoJobTraits::JobName, job);
}
static void RegisterExternalReferences(v8::FunctionCallback new_fn,

52
src/crypto/crypto_x509.cc
View File

@ -21,6 +21,7 @@ using v8::EscapableHandleScope;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
@ -54,35 +55,36 @@ Local<FunctionTemplate> X509Certificate::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->x509_constructor_template();
if (tmpl.IsEmpty()) {
tmpl = FunctionTemplate::New(env->isolate());
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, nullptr);
tmpl->InstanceTemplate()->SetInternalFieldCount(
BaseObject::kInternalFieldCount);
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
tmpl->SetClassName(
FIXED_ONE_BYTE_STRING(env->isolate(), "X509Certificate"));
env->SetProtoMethod(tmpl, "subject", Subject);
env->SetProtoMethod(tmpl, "subjectAltName", SubjectAltName);
env->SetProtoMethod(tmpl, "infoAccess", InfoAccess);
env->SetProtoMethod(tmpl, "issuer", Issuer);
env->SetProtoMethod(tmpl, "validTo", ValidTo);
env->SetProtoMethod(tmpl, "validFrom", ValidFrom);
env->SetProtoMethod(tmpl, "fingerprint", Fingerprint);
env->SetProtoMethod(tmpl, "fingerprint256", Fingerprint256);
env->SetProtoMethod(tmpl, "fingerprint512", Fingerprint512);
env->SetProtoMethod(tmpl, "keyUsage", KeyUsage);
env->SetProtoMethod(tmpl, "serialNumber", SerialNumber);
env->SetProtoMethod(tmpl, "pem", Pem);
env->SetProtoMethod(tmpl, "raw", Raw);
env->SetProtoMethod(tmpl, "publicKey", PublicKey);
env->SetProtoMethod(tmpl, "checkCA", CheckCA);
env->SetProtoMethod(tmpl, "checkHost", CheckHost);
env->SetProtoMethod(tmpl, "checkEmail", CheckEmail);
env->SetProtoMethod(tmpl, "checkIP", CheckIP);
env->SetProtoMethod(tmpl, "checkIssued", CheckIssued);
env->SetProtoMethod(tmpl, "checkPrivateKey", CheckPrivateKey);
env->SetProtoMethod(tmpl, "verify", Verify);
env->SetProtoMethod(tmpl, "toLegacy", ToLegacy);
env->SetProtoMethod(tmpl, "getIssuerCert", GetIssuerCert);
SetProtoMethod(isolate, tmpl, "subject", Subject);
SetProtoMethod(isolate, tmpl, "subjectAltName", SubjectAltName);
SetProtoMethod(isolate, tmpl, "infoAccess", InfoAccess);
SetProtoMethod(isolate, tmpl, "issuer", Issuer);
SetProtoMethod(isolate, tmpl, "validTo", ValidTo);
SetProtoMethod(isolate, tmpl, "validFrom", ValidFrom);
SetProtoMethod(isolate, tmpl, "fingerprint", Fingerprint);
SetProtoMethod(isolate, tmpl, "fingerprint256", Fingerprint256);
SetProtoMethod(isolate, tmpl, "fingerprint512", Fingerprint512);
SetProtoMethod(isolate, tmpl, "keyUsage", KeyUsage);
SetProtoMethod(isolate, tmpl, "serialNumber", SerialNumber);
SetProtoMethod(isolate, tmpl, "pem", Pem);
SetProtoMethod(isolate, tmpl, "raw", Raw);
SetProtoMethod(isolate, tmpl, "publicKey", PublicKey);
SetProtoMethod(isolate, tmpl, "checkCA", CheckCA);
SetProtoMethod(isolate, tmpl, "checkHost", CheckHost);
SetProtoMethod(isolate, tmpl, "checkEmail", CheckEmail);
SetProtoMethod(isolate, tmpl, "checkIP", CheckIP);
SetProtoMethod(isolate, tmpl, "checkIssued", CheckIssued);
SetProtoMethod(isolate, tmpl, "checkPrivateKey", CheckPrivateKey);
SetProtoMethod(isolate, tmpl, "verify", Verify);
SetProtoMethod(isolate, tmpl, "toLegacy", ToLegacy);
SetProtoMethod(isolate, tmpl, "getIssuerCert", GetIssuerCert);
env->set_x509_constructor_template(tmpl);
}
return tmpl;
@ -543,7 +545,7 @@ std::unique_ptr<worker::TransferData> X509Certificate::CloneForMessaging()
void X509Certificate::Initialize(Environment* env, Local<Object> target) {
env->SetMethod(target, "parseX509", X509Certificate::Parse);
SetMethod(env->context(), target, "parseX509", X509Certificate::Parse);
NODE_DEFINE_CONSTANT(target, X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT);
NODE_DEFINE_CONSTANT(target, X509_CHECK_FLAG_NEVER_CHECK_SUBJECT);

147
src/env.cc
View File

@ -580,147 +580,6 @@ std::unique_ptr<v8::BackingStore> Environment::release_managed_buffer(
return bs;
}
Local<v8::FunctionTemplate> Environment::NewFunctionTemplate(
v8::FunctionCallback callback,
Local<v8::Signature> signature,
v8::ConstructorBehavior behavior,
v8::SideEffectType side_effect_type,
const v8::CFunction* c_function) {
return v8::FunctionTemplate::New(isolate(),
callback,
Local<v8::Value>(),
signature,
0,
behavior,
side_effect_type,
c_function);
}
void Environment::SetMethod(Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Context> context = isolate()->GetCurrentContext();
Local<v8::Function> function =
NewFunctionTemplate(callback,
Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect)
->GetFunction(context)
.ToLocalChecked();
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
that->Set(context, name_string, function).Check();
function->SetName(name_string); // NODE_SET_METHOD() compatibility.
}
void Environment::SetFastMethod(Local<v8::Object> that,
const char* name,
v8::FunctionCallback slow_callback,
const v8::CFunction* c_function) {
Local<v8::Context> context = isolate()->GetCurrentContext();
Local<v8::Function> function =
NewFunctionTemplate(slow_callback,
Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasNoSideEffect,
c_function)
->GetFunction(context)
.ToLocalChecked();
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
that->Set(context, name_string, function).Check();
}
void Environment::SetMethodNoSideEffect(Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Context> context = isolate()->GetCurrentContext();
Local<v8::Function> function =
NewFunctionTemplate(callback,
Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasNoSideEffect)
->GetFunction(context)
.ToLocalChecked();
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
that->Set(context, name_string, function).Check();
function->SetName(name_string); // NODE_SET_METHOD() compatibility.
}
void Environment::SetProtoMethod(Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
Local<v8::FunctionTemplate> t =
NewFunctionTemplate(callback,
signature,
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect);
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
that->PrototypeTemplate()->Set(name_string, t);
t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility.
}
void Environment::SetProtoMethodNoSideEffect(Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
Local<v8::FunctionTemplate> t =
NewFunctionTemplate(callback,
signature,
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasNoSideEffect);
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
that->PrototypeTemplate()->Set(name_string, t);
t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility.
}
void Environment::SetInstanceMethod(Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Signature> signature = v8::Signature::New(isolate(), that);
Local<v8::FunctionTemplate> t =
NewFunctionTemplate(callback,
signature,
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect);
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate(), name, type).ToLocalChecked();
that->InstanceTemplate()->Set(name_string, t);
t->SetClassName(name_string);
}
void Environment::SetConstructorFunction(Local<v8::Object> that,
const char* name,
Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag) {
SetConstructorFunction(that, OneByteString(isolate(), name), tmpl, flag);
}
void Environment::SetConstructorFunction(Local<v8::Object> that,
Local<v8::String> name,
Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag) {
if (LIKELY(flag == SetConstructorFunctionFlag::SET_CLASS_NAME))
tmpl->SetClassName(name);
that->Set(context(), name, tmpl->GetFunction(context()).ToLocalChecked())
.Check();
}
void Environment::CreateProperties() {
HandleScope handle_scope(isolate_);
Local<Context> ctx = context();
@ -2222,8 +2081,8 @@ void BaseObject::LazilyInitializedJSTemplateConstructor(
Local<FunctionTemplate> BaseObject::MakeLazilyInitializedJSTemplate(
Environment* env) {
Local<FunctionTemplate> t =
env->NewFunctionTemplate(LazilyInitializedJSTemplateConstructor);
Local<FunctionTemplate> t = NewFunctionTemplate(
env->isolate(), LazilyInitializedJSTemplateConstructor);
t->Inherit(BaseObject::GetConstructorTemplate(env));
t->InstanceTemplate()->SetInternalFieldCount(BaseObject::kInternalFieldCount);
return t;
@ -2282,7 +2141,7 @@ bool BaseObject::IsRootNode() const {
Local<FunctionTemplate> BaseObject::GetConstructorTemplate(Environment* env) {
Local<FunctionTemplate> tmpl = env->base_object_ctor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(nullptr);
tmpl = NewFunctionTemplate(env->isolate(), nullptr);
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "BaseObject"));
env->set_base_object_ctor_template(tmpl);
}

50
src/env.h
View File

@ -1292,56 +1292,6 @@ class Environment : public MemoryRetainer {
const char* path = nullptr,
const char* dest = nullptr);
v8::Local<v8::FunctionTemplate> NewFunctionTemplate(
v8::FunctionCallback callback,
v8::Local<v8::Signature> signature = v8::Local<v8::Signature>(),
v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow,
v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect,
const v8::CFunction* c_function = nullptr);
// Convenience methods for NewFunctionTemplate().
void SetMethod(v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback);
void SetFastMethod(v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback slow_callback,
const v8::CFunction* c_function);
void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
void SetInstanceMethod(v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
// Safe variants denote the function has no side effects.
void SetMethodNoSideEffect(v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback);
void SetProtoMethodNoSideEffect(v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
enum class SetConstructorFunctionFlag {
NONE,
SET_CLASS_NAME,
};
void SetConstructorFunction(v8::Local<v8::Object> that,
const char* name,
v8::Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag =
SetConstructorFunctionFlag::SET_CLASS_NAME);
void SetConstructorFunction(v8::Local<v8::Object> that,
v8::Local<v8::String> name,
v8::Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag =
SetConstructorFunctionFlag::SET_CLASS_NAME);
void AtExit(void (*cb)(void* arg), void* arg);
void RunAtExitCallbacks();

8
src/fs_event_wrap.cc
View File

@ -35,6 +35,7 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
@ -95,13 +96,14 @@ void FSEventWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
FSEventWrap::kInternalFieldCount);
t->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "start", Start);
SetProtoMethod(isolate, t, "start", Start);
Local<FunctionTemplate> get_initialized_templ =
FunctionTemplate::New(env->isolate(),
@ -115,7 +117,7 @@ void FSEventWrap::Initialize(Local<Object> target,
Local<FunctionTemplate>(),
static_cast<PropertyAttribute>(ReadOnly | DontDelete | DontEnum));
env->SetConstructorFunction(target, "FSEvent", t);
SetConstructorFunction(context, target, "FSEvent", t);
}
void FSEventWrap::RegisterExternalReferences(

12
src/handle_wrap.cc
View File

@ -31,6 +31,7 @@ using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
@ -157,13 +158,14 @@ void HandleWrap::OnClose(uv_handle_t* handle) {
Local<FunctionTemplate> HandleWrap::GetConstructorTemplate(Environment* env) {
Local<FunctionTemplate> tmpl = env->handle_wrap_ctor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(nullptr);
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, nullptr);
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "HandleWrap"));
tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(tmpl, "close", HandleWrap::Close);
env->SetProtoMethodNoSideEffect(tmpl, "hasRef", HandleWrap::HasRef);
env->SetProtoMethod(tmpl, "ref", HandleWrap::Ref);
env->SetProtoMethod(tmpl, "unref", HandleWrap::Unref);
SetProtoMethod(isolate, tmpl, "close", HandleWrap::Close);
SetProtoMethodNoSideEffect(isolate, tmpl, "hasRef", HandleWrap::HasRef);
SetProtoMethod(isolate, tmpl, "ref", HandleWrap::Ref);
SetProtoMethod(isolate, tmpl, "unref", HandleWrap::Unref);
env->set_handle_wrap_ctor_template(tmpl);
}
return tmpl;

9
src/heap_utils.cc
View File

@ -448,11 +448,10 @@ void Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "buildEmbedderGraph", BuildEmbedderGraph);
env->SetMethod(target, "triggerHeapSnapshot", TriggerHeapSnapshot);
env->SetMethod(target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
SetMethod(context, target, "buildEmbedderGraph", BuildEmbedderGraph);
SetMethod(context, target, "triggerHeapSnapshot", TriggerHeapSnapshot);
SetMethod(
context, target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

90
src/histogram.cc
View File

@ -11,6 +11,7 @@ using v8::BigInt;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Map;
using v8::Number;
@ -280,7 +281,8 @@ Local<FunctionTemplate> HistogramBase::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->histogram_ctor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, New);
Local<String> classname =
FIXED_ONE_BYTE_STRING(env->isolate(), "Histogram");
tmpl->SetClassName(classname);
@ -288,26 +290,27 @@ Local<FunctionTemplate> HistogramBase::GetConstructorTemplate(
tmpl->InstanceTemplate()->SetInternalFieldCount(
HistogramBase::kInternalFieldCount);
env->SetProtoMethodNoSideEffect(tmpl, "count", GetCount);
env->SetProtoMethodNoSideEffect(tmpl, "countBigInt", GetCountBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "exceeds", GetExceeds);
env->SetProtoMethodNoSideEffect(tmpl, "exceedsBigInt", GetExceedsBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "min", GetMin);
env->SetProtoMethodNoSideEffect(tmpl, "minBigInt", GetMinBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "max", GetMax);
env->SetProtoMethodNoSideEffect(tmpl, "maxBigInt", GetMaxBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "mean", GetMean);
env->SetProtoMethodNoSideEffect(tmpl, "stddev", GetStddev);
env->SetProtoMethodNoSideEffect(tmpl, "percentile", GetPercentile);
env->SetProtoMethodNoSideEffect(tmpl, "percentileBigInt",
GetPercentileBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "percentiles", GetPercentiles);
env->SetProtoMethodNoSideEffect(tmpl, "percentilesBigInt",
GetPercentilesBigInt);
env->SetProtoMethod(tmpl, "reset", DoReset);
env->SetProtoMethod(tmpl, "record", Record);
env->SetProtoMethod(tmpl, "recordDelta", RecordDelta);
env->SetProtoMethod(tmpl, "add", Add);
SetProtoMethodNoSideEffect(isolate, tmpl, "count", GetCount);
SetProtoMethodNoSideEffect(isolate, tmpl, "countBigInt", GetCountBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "exceeds", GetExceeds);
SetProtoMethodNoSideEffect(
isolate, tmpl, "exceedsBigInt", GetExceedsBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "min", GetMin);
SetProtoMethodNoSideEffect(isolate, tmpl, "minBigInt", GetMinBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "max", GetMax);
SetProtoMethodNoSideEffect(isolate, tmpl, "maxBigInt", GetMaxBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "mean", GetMean);
SetProtoMethodNoSideEffect(isolate, tmpl, "stddev", GetStddev);
SetProtoMethodNoSideEffect(isolate, tmpl, "percentile", GetPercentile);
SetProtoMethodNoSideEffect(
isolate, tmpl, "percentileBigInt", GetPercentileBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "percentiles", GetPercentiles);
SetProtoMethodNoSideEffect(
isolate, tmpl, "percentilesBigInt", GetPercentilesBigInt);
SetProtoMethod(isolate, tmpl, "reset", DoReset);
SetProtoMethod(isolate, tmpl, "record", Record);
SetProtoMethod(isolate, tmpl, "recordDelta", RecordDelta);
SetProtoMethod(isolate, tmpl, "add", Add);
env->set_histogram_ctor_template(tmpl);
}
return tmpl;
@ -337,7 +340,8 @@ void HistogramBase::RegisterExternalReferences(
}
void HistogramBase::Initialize(Environment* env, Local<Object> target) {
env->SetConstructorFunction(target, "Histogram", GetConstructorTemplate(env));
SetConstructorFunction(
env->context(), target, "Histogram", GetConstructorTemplate(env));
}
BaseObjectPtr<BaseObject> HistogramBase::HistogramTransferData::Deserialize(
@ -360,29 +364,31 @@ Local<FunctionTemplate> IntervalHistogram::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->intervalhistogram_constructor_template();
if (tmpl.IsEmpty()) {
tmpl = FunctionTemplate::New(env->isolate());
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, nullptr);
tmpl->Inherit(HandleWrap::GetConstructorTemplate(env));
tmpl->InstanceTemplate()->SetInternalFieldCount(
HistogramBase::kInternalFieldCount);
env->SetProtoMethodNoSideEffect(tmpl, "count", GetCount);
env->SetProtoMethodNoSideEffect(tmpl, "countBigInt", GetCountBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "exceeds", GetExceeds);
env->SetProtoMethodNoSideEffect(tmpl, "exceedsBigInt", GetExceedsBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "min", GetMin);
env->SetProtoMethodNoSideEffect(tmpl, "minBigInt", GetMinBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "max", GetMax);
env->SetProtoMethodNoSideEffect(tmpl, "maxBigInt", GetMaxBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "mean", GetMean);
env->SetProtoMethodNoSideEffect(tmpl, "stddev", GetStddev);
env->SetProtoMethodNoSideEffect(tmpl, "percentile", GetPercentile);
env->SetProtoMethodNoSideEffect(tmpl, "percentileBigInt",
GetPercentileBigInt);
env->SetProtoMethodNoSideEffect(tmpl, "percentiles", GetPercentiles);
env->SetProtoMethodNoSideEffect(tmpl, "percentilesBigInt",
GetPercentilesBigInt);
env->SetProtoMethod(tmpl, "reset", DoReset);
env->SetProtoMethod(tmpl, "start", Start);
env->SetProtoMethod(tmpl, "stop", Stop);
SetProtoMethodNoSideEffect(isolate, tmpl, "count", GetCount);
SetProtoMethodNoSideEffect(isolate, tmpl, "countBigInt", GetCountBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "exceeds", GetExceeds);
SetProtoMethodNoSideEffect(
isolate, tmpl, "exceedsBigInt", GetExceedsBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "min", GetMin);
SetProtoMethodNoSideEffect(isolate, tmpl, "minBigInt", GetMinBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "max", GetMax);
SetProtoMethodNoSideEffect(isolate, tmpl, "maxBigInt", GetMaxBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "mean", GetMean);
SetProtoMethodNoSideEffect(isolate, tmpl, "stddev", GetStddev);
SetProtoMethodNoSideEffect(isolate, tmpl, "percentile", GetPercentile);
SetProtoMethodNoSideEffect(
isolate, tmpl, "percentileBigInt", GetPercentileBigInt);
SetProtoMethodNoSideEffect(isolate, tmpl, "percentiles", GetPercentiles);
SetProtoMethodNoSideEffect(
isolate, tmpl, "percentilesBigInt", GetPercentilesBigInt);
SetProtoMethod(isolate, tmpl, "reset", DoReset);
SetProtoMethod(isolate, tmpl, "start", Start);
SetProtoMethod(isolate, tmpl, "stop", Stop);
env->set_intervalhistogram_constructor_template(tmpl);
}
return tmpl;

66
src/inspector_js_api.cc
View File

@ -102,17 +102,17 @@ class JSBindingsConnection : public AsyncWrap {
}
static void Bind(Environment* env, Local<Object> target) {
Isolate* isolate = env->isolate();
Local<FunctionTemplate> tmpl =
env->NewFunctionTemplate(JSBindingsConnection::New);
NewFunctionTemplate(isolate, JSBindingsConnection::New);
tmpl->InstanceTemplate()->SetInternalFieldCount(
JSBindingsConnection::kInternalFieldCount);
tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(tmpl, "dispatch", JSBindingsConnection::Dispatch);
env->SetProtoMethod(tmpl, "disconnect", JSBindingsConnection::Disconnect);
env->SetConstructorFunction(
target,
ConnectionType::GetClassName(env),
tmpl);
SetProtoMethod(isolate, tmpl, "dispatch", JSBindingsConnection::Dispatch);
SetProtoMethod(
isolate, tmpl, "disconnect", JSBindingsConnection::Disconnect);
SetConstructorFunction(
env->context(), target, ConnectionType::GetClassName(env), tmpl);
}
static void New(const FunctionCallbackInfo<Value>& info) {
@ -314,37 +314,47 @@ void Url(const FunctionCallbackInfo<Value>& args) {
void Initialize(Local<Object> target, Local<Value> unused,
Local<Context> context, void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
v8::Local<v8::Function> consoleCallFunc =
env->NewFunctionTemplate(InspectorConsoleCall, v8::Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect)
NewFunctionTemplate(isolate,
InspectorConsoleCall,
v8::Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect)
->GetFunction(context)
.ToLocalChecked();
auto name_string = FIXED_ONE_BYTE_STRING(env->isolate(), "consoleCall");
auto name_string = FIXED_ONE_BYTE_STRING(isolate, "consoleCall");
target->Set(context, name_string, consoleCallFunc).Check();
consoleCallFunc->SetName(name_string);
env->SetMethod(
target, "setConsoleExtensionInstaller", SetConsoleExtensionInstaller);
env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart);
env->SetMethod(target, "open", Open);
env->SetMethodNoSideEffect(target, "url", Url);
env->SetMethod(target, "waitForDebugger", WaitForDebugger);
SetMethod(context,
target,
"setConsoleExtensionInstaller",
SetConsoleExtensionInstaller);
SetMethod(context, target, "callAndPauseOnStart", CallAndPauseOnStart);
SetMethod(context, target, "open", Open);
SetMethodNoSideEffect(context, target, "url", Url);
SetMethod(context, target, "waitForDebugger", WaitForDebugger);
env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper);
env->SetMethod(target, "asyncTaskCanceled",
InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>);
env->SetMethod(target, "asyncTaskStarted",
InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>);
env->SetMethod(target, "asyncTaskFinished",
InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);
SetMethod(context, target, "asyncTaskScheduled", AsyncTaskScheduledWrapper);
SetMethod(context,
target,
"asyncTaskCanceled",
InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>);
SetMethod(context,
target,
"asyncTaskStarted",
InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>);
SetMethod(context,
target,
"asyncTaskFinished",
InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);
env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper);
env->SetMethodNoSideEffect(target, "isEnabled", IsEnabled);
SetMethod(context, target, "registerAsyncHook", RegisterAsyncHookWrapper);
SetMethodNoSideEffect(context, target, "isEnabled", IsEnabled);
Local<String> console_string =
FIXED_ONE_BYTE_STRING(env->isolate(), "console");
Local<String> console_string = FIXED_ONE_BYTE_STRING(isolate, "console");
// Grab the console from the binding object and expose those to our binding
// layer.

10
src/inspector_profiler.cc
View File

@ -507,11 +507,11 @@ static void Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "setCoverageDirectory", SetCoverageDirectory);
env->SetMethod(target, "setSourceMapCacheGetter", SetSourceMapCacheGetter);
env->SetMethod(target, "takeCoverage", TakeCoverage);
env->SetMethod(target, "stopCoverage", StopCoverage);
SetMethod(context, target, "setCoverageDirectory", SetCoverageDirectory);
SetMethod(
context, target, "setSourceMapCacheGetter", SetSourceMapCacheGetter);
SetMethod(context, target, "takeCoverage", TakeCoverage);
SetMethod(context, target, "stopCoverage", StopCoverage);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

14
src/js_stream.cc
View File

@ -17,6 +17,7 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
@ -197,19 +198,20 @@ void JSStream::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()
->SetInternalFieldCount(StreamBase::kInternalFieldCount);
t->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "finishWrite", Finish<WriteWrap>);
env->SetProtoMethod(t, "finishShutdown", Finish<ShutdownWrap>);
env->SetProtoMethod(t, "readBuffer", ReadBuffer);
env->SetProtoMethod(t, "emitEOF", EmitEOF);
SetProtoMethod(isolate, t, "finishWrite", Finish<WriteWrap>);
SetProtoMethod(isolate, t, "finishShutdown", Finish<ShutdownWrap>);
SetProtoMethod(isolate, t, "readBuffer", ReadBuffer);
SetProtoMethod(isolate, t, "emitEOF", EmitEOF);
StreamBase::AddMethods(env, t);
env->SetConstructorFunction(target, "JSStream", t);
SetConstructorFunction(context, target, "JSStream", t);
}
} // namespace node

12
src/js_udp_wrap.cc
View File

@ -17,6 +17,7 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
@ -198,18 +199,19 @@ void JSUDPWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()
->SetInternalFieldCount(UDPWrapBase::kUDPWrapBaseField + 1);
t->Inherit(AsyncWrap::GetConstructorTemplate(env));
UDPWrapBase::AddMethods(env, t);
env->SetProtoMethod(t, "emitReceived", EmitReceived);
env->SetProtoMethod(t, "onSendDone", OnSendDone);
env->SetProtoMethod(t, "onAfterBind", OnAfterBind);
SetProtoMethod(isolate, t, "emitReceived", EmitReceived);
SetProtoMethod(isolate, t, "onSendDone", OnSendDone);
SetProtoMethod(isolate, t, "onAfterBind", OnAfterBind);
env->SetConstructorFunction(target, "JSUDPWrap", t);
SetConstructorFunction(context, target, "JSUDPWrap", t);
}

42
src/module_wrap.cc
View File

@ -765,31 +765,37 @@ void ModuleWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> tpl = env->NewFunctionTemplate(New);
Local<FunctionTemplate> tpl = NewFunctionTemplate(isolate, New);
tpl->InstanceTemplate()->SetInternalFieldCount(
ModuleWrap::kInternalFieldCount);
tpl->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(tpl, "link", Link);
env->SetProtoMethod(tpl, "instantiate", Instantiate);
env->SetProtoMethod(tpl, "evaluate", Evaluate);
env->SetProtoMethod(tpl, "setExport", SetSyntheticExport);
env->SetProtoMethodNoSideEffect(tpl, "createCachedData", CreateCachedData);
env->SetProtoMethodNoSideEffect(tpl, "getNamespace", GetNamespace);
env->SetProtoMethodNoSideEffect(tpl, "getStatus", GetStatus);
env->SetProtoMethodNoSideEffect(tpl, "getError", GetError);
env->SetProtoMethodNoSideEffect(tpl, "getStaticDependencySpecifiers",
GetStaticDependencySpecifiers);
SetProtoMethod(isolate, tpl, "link", Link);
SetProtoMethod(isolate, tpl, "instantiate", Instantiate);
SetProtoMethod(isolate, tpl, "evaluate", Evaluate);
SetProtoMethod(isolate, tpl, "setExport", SetSyntheticExport);
SetProtoMethodNoSideEffect(
isolate, tpl, "createCachedData", CreateCachedData);
SetProtoMethodNoSideEffect(isolate, tpl, "getNamespace", GetNamespace);
SetProtoMethodNoSideEffect(isolate, tpl, "getStatus", GetStatus);
SetProtoMethodNoSideEffect(isolate, tpl, "getError", GetError);
SetProtoMethodNoSideEffect(isolate,
tpl,
"getStaticDependencySpecifiers",
GetStaticDependencySpecifiers);
env->SetConstructorFunction(target, "ModuleWrap", tpl);
SetConstructorFunction(context, target, "ModuleWrap", tpl);
env->SetMethod(target,
"setImportModuleDynamicallyCallback",
SetImportModuleDynamicallyCallback);
env->SetMethod(target,
"setInitializeImportMetaObjectCallback",
SetInitializeImportMetaObjectCallback);
SetMethod(context,
target,
"setImportModuleDynamicallyCallback",
SetImportModuleDynamicallyCallback);
SetMethod(context,
target,
"setInitializeImportMetaObjectCallback",
SetInitializeImportMetaObjectCallback);
#define V(name) \
target->Set(context, \

6
src/node.cc
View File

@ -301,10 +301,10 @@ MaybeLocal<Value> Environment::BootstrapInternalLoaders() {
primordials_string()};
std::vector<Local<Value>> loaders_args = {
process_object(),
NewFunctionTemplate(binding::GetLinkedBinding)
NewFunctionTemplate(isolate_, binding::GetLinkedBinding)
->GetFunction(context())
.ToLocalChecked(),
NewFunctionTemplate(binding::GetInternalBinding)
NewFunctionTemplate(isolate_, binding::GetInternalBinding)
->GetFunction(context())
.ToLocalChecked(),
primordials()};
@ -443,7 +443,7 @@ MaybeLocal<Value> StartExecution(Environment* env, const char* main_script_id) {
env->native_module_require(),
env->internal_binding_loader(),
env->primordials(),
env->NewFunctionTemplate(MarkBootstrapComplete)
NewFunctionTemplate(env->isolate(), MarkBootstrapComplete)
->GetFunction(env->context())
.ToLocalChecked()};

23
src/node_blob.cc
View File

@ -22,6 +22,7 @@ using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Number;
@ -42,24 +43,25 @@ void Blob::Initialize(
env->AddBindingData<BlobBindingData>(context, target);
if (binding_data == nullptr) return;
env->SetMethod(target, "createBlob", New);
env->SetMethod(target, "storeDataObject", StoreDataObject);
env->SetMethod(target, "getDataObject", GetDataObject);
env->SetMethod(target, "revokeDataObject", RevokeDataObject);
SetMethod(context, target, "createBlob", New);
SetMethod(context, target, "storeDataObject", StoreDataObject);
SetMethod(context, target, "getDataObject", GetDataObject);
SetMethod(context, target, "revokeDataObject", RevokeDataObject);
FixedSizeBlobCopyJob::Initialize(env, target);
}
Local<FunctionTemplate> Blob::GetConstructorTemplate(Environment* env) {
Local<FunctionTemplate> tmpl = env->blob_constructor_template();
if (tmpl.IsEmpty()) {
tmpl = FunctionTemplate::New(env->isolate());
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, nullptr);
tmpl->InstanceTemplate()->SetInternalFieldCount(
BaseObject::kInternalFieldCount);
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
tmpl->SetClassName(
FIXED_ONE_BYTE_STRING(env->isolate(), "Blob"));
env->SetProtoMethod(tmpl, "toArrayBuffer", ToArrayBuffer);
env->SetProtoMethod(tmpl, "slice", ToSlice);
SetProtoMethod(isolate, tmpl, "toArrayBuffer", ToArrayBuffer);
SetProtoMethod(isolate, tmpl, "slice", ToSlice);
env->set_blob_constructor_template(tmpl);
}
return tmpl;
@ -362,12 +364,13 @@ void FixedSizeBlobCopyJob::MemoryInfo(MemoryTracker* tracker) const {
}
void FixedSizeBlobCopyJob::Initialize(Environment* env, Local<Object> target) {
v8::Local<v8::FunctionTemplate> job = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
v8::Local<v8::FunctionTemplate> job = NewFunctionTemplate(isolate, New);
job->Inherit(AsyncWrap::GetConstructorTemplate(env));
job->InstanceTemplate()->SetInternalFieldCount(
AsyncWrap::kInternalFieldCount);
env->SetProtoMethod(job, "run", Run);
env->SetConstructorFunction(target, "FixedSizeBlobCopyJob", job);
SetProtoMethod(isolate, job, "run", Run);
SetConstructorFunction(env->context(), target, "FixedSizeBlobCopyJob", job);
}
void FixedSizeBlobCopyJob::New(const FunctionCallbackInfo<Value>& args) {

82
src/node_buffer.cc
View File

@ -1275,54 +1275,60 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "setBufferPrototype", SetBufferPrototype);
env->SetMethodNoSideEffect(target, "createFromString", CreateFromString);
SetMethod(context, target, "setBufferPrototype", SetBufferPrototype);
SetMethodNoSideEffect(context, target, "createFromString", CreateFromString);
env->SetMethodNoSideEffect(target, "byteLengthUtf8", ByteLengthUtf8);
env->SetMethod(target, "copy", Copy);
env->SetMethodNoSideEffect(target, "compare", Compare);
env->SetMethodNoSideEffect(target, "compareOffset", CompareOffset);
env->SetMethod(target, "fill", Fill);
env->SetMethodNoSideEffect(target, "indexOfBuffer", IndexOfBuffer);
env->SetMethodNoSideEffect(target, "indexOfNumber", IndexOfNumber);
env->SetMethodNoSideEffect(target, "indexOfString", IndexOfString);
SetMethodNoSideEffect(context, target, "byteLengthUtf8", ByteLengthUtf8);
SetMethod(context, target, "copy", Copy);
SetMethodNoSideEffect(context, target, "compare", Compare);
SetMethodNoSideEffect(context, target, "compareOffset", CompareOffset);
SetMethod(context, target, "fill", Fill);
SetMethodNoSideEffect(context, target, "indexOfBuffer", IndexOfBuffer);
SetMethodNoSideEffect(context, target, "indexOfNumber", IndexOfNumber);
SetMethodNoSideEffect(context, target, "indexOfString", IndexOfString);
env->SetMethod(target, "detachArrayBuffer", DetachArrayBuffer);
env->SetMethod(target, "copyArrayBuffer", CopyArrayBuffer);
SetMethod(context, target, "detachArrayBuffer", DetachArrayBuffer);
SetMethod(context, target, "copyArrayBuffer", CopyArrayBuffer);
env->SetMethod(target, "swap16", Swap16);
env->SetMethod(target, "swap32", Swap32);
env->SetMethod(target, "swap64", Swap64);
SetMethod(context, target, "swap16", Swap16);
SetMethod(context, target, "swap32", Swap32);
SetMethod(context, target, "swap64", Swap64);
env->SetMethod(target, "encodeInto", EncodeInto);
env->SetMethodNoSideEffect(target, "encodeUtf8String", EncodeUtf8String);
SetMethod(context, target, "encodeInto", EncodeInto);
SetMethodNoSideEffect(context, target, "encodeUtf8String", EncodeUtf8String);
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"),
Number::New(env->isolate(), kMaxLength)).Check();
target
->Set(context,
FIXED_ONE_BYTE_STRING(isolate, "kMaxLength"),
Number::New(isolate, kMaxLength))
.Check();
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "kStringMaxLength"),
Integer::New(env->isolate(), String::kMaxLength)).Check();
target
->Set(context,
FIXED_ONE_BYTE_STRING(isolate, "kStringMaxLength"),
Integer::New(isolate, String::kMaxLength))
.Check();
env->SetMethodNoSideEffect(target, "asciiSlice", StringSlice<ASCII>);
env->SetMethodNoSideEffect(target, "base64Slice", StringSlice<BASE64>);
env->SetMethodNoSideEffect(target, "base64urlSlice", StringSlice<BASE64URL>);
env->SetMethodNoSideEffect(target, "latin1Slice", StringSlice<LATIN1>);
env->SetMethodNoSideEffect(target, "hexSlice", StringSlice<HEX>);
env->SetMethodNoSideEffect(target, "ucs2Slice", StringSlice<UCS2>);
env->SetMethodNoSideEffect(target, "utf8Slice", StringSlice<UTF8>);
SetMethodNoSideEffect(context, target, "asciiSlice", StringSlice<ASCII>);
SetMethodNoSideEffect(context, target, "base64Slice", StringSlice<BASE64>);
SetMethodNoSideEffect(
context, target, "base64urlSlice", StringSlice<BASE64URL>);
SetMethodNoSideEffect(context, target, "latin1Slice", StringSlice<LATIN1>);
SetMethodNoSideEffect(context, target, "hexSlice", StringSlice<HEX>);
SetMethodNoSideEffect(context, target, "ucs2Slice", StringSlice<UCS2>);
SetMethodNoSideEffect(context, target, "utf8Slice", StringSlice<UTF8>);
env->SetMethod(target, "asciiWrite", StringWrite<ASCII>);
env->SetMethod(target, "base64Write", StringWrite<BASE64>);
env->SetMethod(target, "base64urlWrite", StringWrite<BASE64URL>);
env->SetMethod(target, "latin1Write", StringWrite<LATIN1>);
env->SetMethod(target, "hexWrite", StringWrite<HEX>);
env->SetMethod(target, "ucs2Write", StringWrite<UCS2>);
env->SetMethod(target, "utf8Write", StringWrite<UTF8>);
SetMethod(context, target, "asciiWrite", StringWrite<ASCII>);
SetMethod(context, target, "base64Write", StringWrite<BASE64>);
SetMethod(context, target, "base64urlWrite", StringWrite<BASE64URL>);
SetMethod(context, target, "latin1Write", StringWrite<LATIN1>);
SetMethod(context, target, "hexWrite", StringWrite<HEX>);
SetMethod(context, target, "ucs2Write", StringWrite<UCS2>);
SetMethod(context, target, "utf8Write", StringWrite<UTF8>);
env->SetMethod(target, "getZeroFillToggle", GetZeroFillToggle);
SetMethod(context, target, "getZeroFillToggle", GetZeroFillToggle);
}
} // anonymous namespace

36
src/node_contextify.cc
View File

@ -255,16 +255,19 @@ MaybeLocal<Context> ContextifyContext::CreateV8Context(
void ContextifyContext::Init(Environment* env, Local<Object> target) {
Isolate* isolate = env->isolate();
Local<Context> context = env->context();
Local<FunctionTemplate> function_template =
FunctionTemplate::New(env->isolate());
NewFunctionTemplate(isolate, nullptr);
function_template->InstanceTemplate()->SetInternalFieldCount(
ContextifyContext::kInternalFieldCount);
env->set_script_data_constructor_function(
function_template->GetFunction(env->context()).ToLocalChecked());
env->SetMethod(target, "makeContext", MakeContext);
env->SetMethod(target, "isContext", IsContext);
env->SetMethod(target, "compileFunction", CompileFunction);
SetMethod(context, target, "makeContext", MakeContext);
SetMethod(context, target, "isContext", IsContext);
SetMethod(context, target, "compileFunction", CompileFunction);
}
void ContextifyContext::RegisterExternalReferences(
@ -657,16 +660,17 @@ void ContextifyContext::IndexedPropertyDeleterCallback(
}
void ContextifyScript::Init(Environment* env, Local<Object> target) {
Isolate* isolate = env->isolate();
HandleScope scope(env->isolate());
Local<String> class_name =
FIXED_ONE_BYTE_STRING(env->isolate(), "ContextifyScript");
Local<FunctionTemplate> script_tmpl = env->NewFunctionTemplate(New);
Local<FunctionTemplate> script_tmpl = NewFunctionTemplate(isolate, New);
script_tmpl->InstanceTemplate()->SetInternalFieldCount(
ContextifyScript::kInternalFieldCount);
script_tmpl->SetClassName(class_name);
env->SetProtoMethod(script_tmpl, "createCachedData", CreateCachedData);
env->SetProtoMethod(script_tmpl, "runInContext", RunInContext);
SetProtoMethod(isolate, script_tmpl, "createCachedData", CreateCachedData);
SetProtoMethod(isolate, script_tmpl, "runInContext", RunInContext);
Local<Context> context = env->context();
@ -1262,12 +1266,14 @@ void MicrotaskQueueWrap::New(const FunctionCallbackInfo<Value>& args) {
}
void MicrotaskQueueWrap::Init(Environment* env, Local<Object> target) {
HandleScope scope(env->isolate());
Local<FunctionTemplate> tmpl = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
HandleScope scope(isolate);
Local<Context> context = env->context();
Local<FunctionTemplate> tmpl = NewFunctionTemplate(isolate, New);
tmpl->InstanceTemplate()->SetInternalFieldCount(
ContextifyScript::kInternalFieldCount);
env->set_microtask_queue_ctor_template(tmpl);
env->SetConstructorFunction(target, "MicrotaskQueue", tmpl);
SetConstructorFunction(context, target, "MicrotaskQueue", tmpl);
}
void MicrotaskQueueWrap::RegisterExternalReferences(
@ -1285,11 +1291,11 @@ void Initialize(Local<Object> target,
ContextifyScript::Init(env, target);
MicrotaskQueueWrap::Init(env, target);
env->SetMethod(target, "startSigintWatchdog", StartSigintWatchdog);
env->SetMethod(target, "stopSigintWatchdog", StopSigintWatchdog);
SetMethod(context, target, "startSigintWatchdog", StartSigintWatchdog);
SetMethod(context, target, "stopSigintWatchdog", StopSigintWatchdog);
// Used in tests.
env->SetMethodNoSideEffect(
target, "watchdogHasPendingSigint", WatchdogHasPendingSigint);
SetMethodNoSideEffect(
context, target, "watchdogHasPendingSigint", WatchdogHasPendingSigint);
{
Local<FunctionTemplate> tpl = FunctionTemplate::New(env->isolate());
@ -1325,7 +1331,7 @@ void Initialize(Local<Object> target,
target->Set(context, env->constants_string(), constants).Check();
env->SetMethod(target, "measureMemory", MeasureMemory);
SetMethod(context, target, "measureMemory", MeasureMemory);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

24
src/node_credentials.cc
View File

@ -448,23 +448,23 @@ static void Initialize(Local<Object> target,
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "safeGetenv", SafeGetenv);
SetMethod(context, target, "safeGetenv", SafeGetenv);
#ifdef NODE_IMPLEMENTS_POSIX_CREDENTIALS
READONLY_TRUE_PROPERTY(target, "implementsPosixCredentials");
env->SetMethodNoSideEffect(target, "getuid", GetUid);
env->SetMethodNoSideEffect(target, "geteuid", GetEUid);
env->SetMethodNoSideEffect(target, "getgid", GetGid);
env->SetMethodNoSideEffect(target, "getegid", GetEGid);
env->SetMethodNoSideEffect(target, "getgroups", GetGroups);
SetMethodNoSideEffect(context, target, "getuid", GetUid);
SetMethodNoSideEffect(context, target, "geteuid", GetEUid);
SetMethodNoSideEffect(context, target, "getgid", GetGid);
SetMethodNoSideEffect(context, target, "getegid", GetEGid);
SetMethodNoSideEffect(context, target, "getgroups", GetGroups);
if (env->owns_process_state()) {
env->SetMethod(target, "initgroups", InitGroups);
env->SetMethod(target, "setegid", SetEGid);
env->SetMethod(target, "seteuid", SetEUid);
env->SetMethod(target, "setgid", SetGid);
env->SetMethod(target, "setuid", SetUid);
env->SetMethod(target, "setgroups", SetGroups);
SetMethod(context, target, "initgroups", InitGroups);
SetMethod(context, target, "setegid", SetEGid);
SetMethod(context, target, "seteuid", SetEUid);
SetMethod(context, target, "setgid", SetGid);
SetMethod(context, target, "setuid", SetUid);
SetMethod(context, target, "setgroups", SetGroups);
}
#endif // NODE_IMPLEMENTS_POSIX_CREDENTIALS
}

11
src/node_dir.cc
View File

@ -351,17 +351,18 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "opendir", OpenDir);
SetMethod(context, target, "opendir", OpenDir);
// Create FunctionTemplate for DirHandle
Local<FunctionTemplate> dir = env->NewFunctionTemplate(DirHandle::New);
Local<FunctionTemplate> dir = NewFunctionTemplate(isolate, DirHandle::New);
dir->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(dir, "read", DirHandle::Read);
env->SetProtoMethod(dir, "close", DirHandle::Close);
SetProtoMethod(isolate, dir, "read", DirHandle::Read);
SetProtoMethod(isolate, dir, "close", DirHandle::Close);
Local<ObjectTemplate> dirt = dir->InstanceTemplate();
dirt->SetInternalFieldCount(DirHandle::kInternalFieldCount);
env->SetConstructorFunction(target, "DirHandle", dir);
SetConstructorFunction(context, target, "DirHandle", dir);
env->set_dir_instance_template(dirt);
}

36
src/node_errors.cc
View File

@ -964,21 +964,27 @@ void Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(
target, "setPrepareStackTraceCallback", SetPrepareStackTraceCallback);
env->SetMethod(
target, "setGetSourceMapErrorSource", SetGetSourceMapErrorSource);
env->SetMethod(target, "setSourceMapsEnabled", SetSourceMapsEnabled);
env->SetMethod(target,
"setMaybeCacheGeneratedSourceMap",
SetMaybeCacheGeneratedSourceMap);
env->SetMethod(target,
"setEnhanceStackForFatalException",
SetEnhanceStackForFatalException);
env->SetMethodNoSideEffect(
target, "noSideEffectsToString", NoSideEffectsToString);
env->SetMethod(target, "triggerUncaughtException", TriggerUncaughtException);
SetMethod(context,
target,
"setPrepareStackTraceCallback",
SetPrepareStackTraceCallback);
SetMethod(context,
target,
"setGetSourceMapErrorSource",
SetGetSourceMapErrorSource);
SetMethod(context, target, "setSourceMapsEnabled", SetSourceMapsEnabled);
SetMethod(context,
target,
"setMaybeCacheGeneratedSourceMap",
SetMaybeCacheGeneratedSourceMap);
SetMethod(context,
target,
"setEnhanceStackForFatalException",
SetEnhanceStackForFatalException);
SetMethodNoSideEffect(
context, target, "noSideEffectsToString", NoSideEffectsToString);
SetMethod(
context, target, "triggerUncaughtException", TriggerUncaughtException);
}
void DecorateErrorStack(Environment* env,

84
src/node_file.cc
View File

@ -2433,46 +2433,46 @@ void Initialize(Local<Object> target,
env->AddBindingData<BindingData>(context, target);
if (binding_data == nullptr) return;
env->SetMethod(target, "access", Access);
env->SetMethod(target, "close", Close);
env->SetMethod(target, "open", Open);
env->SetMethod(target, "openFileHandle", OpenFileHandle);
env->SetMethod(target, "read", Read);
env->SetMethod(target, "readBuffers", ReadBuffers);
env->SetMethod(target, "fdatasync", Fdatasync);
env->SetMethod(target, "fsync", Fsync);
env->SetMethod(target, "rename", Rename);
env->SetMethod(target, "ftruncate", FTruncate);
env->SetMethod(target, "rmdir", RMDir);
env->SetMethod(target, "mkdir", MKDir);
env->SetMethod(target, "readdir", ReadDir);
env->SetMethod(target, "internalModuleReadJSON", InternalModuleReadJSON);
env->SetMethod(target, "internalModuleStat", InternalModuleStat);
env->SetMethod(target, "stat", Stat);
env->SetMethod(target, "lstat", LStat);
env->SetMethod(target, "fstat", FStat);
env->SetMethod(target, "link", Link);
env->SetMethod(target, "symlink", Symlink);
env->SetMethod(target, "readlink", ReadLink);
env->SetMethod(target, "unlink", Unlink);
env->SetMethod(target, "writeBuffer", WriteBuffer);
env->SetMethod(target, "writeBuffers", WriteBuffers);
env->SetMethod(target, "writeString", WriteString);
env->SetMethod(target, "realpath", RealPath);
env->SetMethod(target, "copyFile", CopyFile);
SetMethod(context, target, "access", Access);
SetMethod(context, target, "close", Close);
SetMethod(context, target, "open", Open);
SetMethod(context, target, "openFileHandle", OpenFileHandle);
SetMethod(context, target, "read", Read);
SetMethod(context, target, "readBuffers", ReadBuffers);
SetMethod(context, target, "fdatasync", Fdatasync);
SetMethod(context, target, "fsync", Fsync);
SetMethod(context, target, "rename", Rename);
SetMethod(context, target, "ftruncate", FTruncate);
SetMethod(context, target, "rmdir", RMDir);
SetMethod(context, target, "mkdir", MKDir);
SetMethod(context, target, "readdir", ReadDir);
SetMethod(context, target, "internalModuleReadJSON", InternalModuleReadJSON);
SetMethod(context, target, "internalModuleStat", InternalModuleStat);
SetMethod(context, target, "stat", Stat);
SetMethod(context, target, "lstat", LStat);
SetMethod(context, target, "fstat", FStat);
SetMethod(context, target, "link", Link);
SetMethod(context, target, "symlink", Symlink);
SetMethod(context, target, "readlink", ReadLink);
SetMethod(context, target, "unlink", Unlink);
SetMethod(context, target, "writeBuffer", WriteBuffer);
SetMethod(context, target, "writeBuffers", WriteBuffers);
SetMethod(context, target, "writeString", WriteString);
SetMethod(context, target, "realpath", RealPath);
SetMethod(context, target, "copyFile", CopyFile);
env->SetMethod(target, "chmod", Chmod);
env->SetMethod(target, "fchmod", FChmod);
SetMethod(context, target, "chmod", Chmod);
SetMethod(context, target, "fchmod", FChmod);
env->SetMethod(target, "chown", Chown);
env->SetMethod(target, "fchown", FChown);
env->SetMethod(target, "lchown", LChown);
SetMethod(context, target, "chown", Chown);
SetMethod(context, target, "fchown", FChown);
SetMethod(context, target, "lchown", LChown);
env->SetMethod(target, "utimes", UTimes);
env->SetMethod(target, "futimes", FUTimes);
env->SetMethod(target, "lutimes", LUTimes);
SetMethod(context, target, "utimes", UTimes);
SetMethod(context, target, "futimes", FUTimes);
SetMethod(context, target, "lutimes", LUTimes);
env->SetMethod(target, "mkdtemp", Mkdtemp);
SetMethod(context, target, "mkdtemp", Mkdtemp);
target
->Set(context,
@ -2485,11 +2485,11 @@ void Initialize(Local<Object> target,
StatWatcher::Initialize(env, target);
// Create FunctionTemplate for FSReqCallback
Local<FunctionTemplate> fst = env->NewFunctionTemplate(NewFSReqCallback);
Local<FunctionTemplate> fst = NewFunctionTemplate(isolate, NewFSReqCallback);
fst->InstanceTemplate()->SetInternalFieldCount(
FSReqBase::kInternalFieldCount);
fst->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "FSReqCallback", fst);
SetConstructorFunction(context, target, "FSReqCallback", fst);
// Create FunctionTemplate for FileHandleReadWrap. There’s no need
// to do anything in the constructor, so we only store the instance template.
@ -2514,14 +2514,14 @@ void Initialize(Local<Object> target,
env->set_fsreqpromise_constructor_template(fpo);
// Create FunctionTemplate for FileHandle
Local<FunctionTemplate> fd = env->NewFunctionTemplate(FileHandle::New);
Local<FunctionTemplate> fd = NewFunctionTemplate(isolate, FileHandle::New);
fd->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(fd, "close", FileHandle::Close);
env->SetProtoMethod(fd, "releaseFD", FileHandle::ReleaseFD);
SetProtoMethod(isolate, fd, "close", FileHandle::Close);
SetProtoMethod(isolate, fd, "releaseFD", FileHandle::ReleaseFD);
Local<ObjectTemplate> fdt = fd->InstanceTemplate();
fdt->SetInternalFieldCount(FileHandle::kInternalFieldCount);
StreamBase::AddMethods(env, fd);
env->SetConstructorFunction(target, "FileHandle", fd);
SetConstructorFunction(context, target, "FileHandle", fd);
env->set_fd_constructor_template(fdt);
// Create FunctionTemplate for FileHandle::CloseReq

76
src/node_http2.cc
View File

@ -3201,10 +3201,10 @@ void Initialize(Local<Object> target,
NODE_DEFINE_CONSTANT(target, kSessionHasAltsvcListeners);
// Method to fetch the nghttp2 string description of an nghttp2 error code
env->SetMethod(target, "nghttp2ErrorString", HttpErrorString);
env->SetMethod(target, "refreshDefaultSettings", RefreshDefaultSettings);
env->SetMethod(target, "packSettings", PackSettings);
env->SetMethod(target, "setCallbackFunctions", SetCallbackFunctions);
SetMethod(context, target, "nghttp2ErrorString", HttpErrorString);
SetMethod(context, target, "refreshDefaultSettings", RefreshDefaultSettings);
SetMethod(context, target, "packSettings", PackSettings);
SetMethod(context, target, "setCallbackFunctions", SetCallbackFunctions);
Local<FunctionTemplate> ping = FunctionTemplate::New(env->isolate());
ping->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Http2Ping"));
@ -3220,50 +3220,54 @@ void Initialize(Local<Object> target,
env->set_http2settings_constructor_template(settingt);
Local<FunctionTemplate> stream = FunctionTemplate::New(env->isolate());
env->SetProtoMethod(stream, "id", Http2Stream::GetID);
env->SetProtoMethod(stream, "destroy", Http2Stream::Destroy);
env->SetProtoMethod(stream, "priority", Http2Stream::Priority);
env->SetProtoMethod(stream, "pushPromise", Http2Stream::PushPromise);
env->SetProtoMethod(stream, "info", Http2Stream::Info);
env->SetProtoMethod(stream, "trailers", Http2Stream::Trailers);
env->SetProtoMethod(stream, "respond", Http2Stream::Respond);
env->SetProtoMethod(stream, "rstStream", Http2Stream::RstStream);
env->SetProtoMethod(stream, "refreshState", Http2Stream::RefreshState);
SetProtoMethod(isolate, stream, "id", Http2Stream::GetID);
SetProtoMethod(isolate, stream, "destroy", Http2Stream::Destroy);
SetProtoMethod(isolate, stream, "priority", Http2Stream::Priority);
SetProtoMethod(isolate, stream, "pushPromise", Http2Stream::PushPromise);
SetProtoMethod(isolate, stream, "info", Http2Stream::Info);
SetProtoMethod(isolate, stream, "trailers", Http2Stream::Trailers);
SetProtoMethod(isolate, stream, "respond", Http2Stream::Respond);
SetProtoMethod(isolate, stream, "rstStream", Http2Stream::RstStream);
SetProtoMethod(isolate, stream, "refreshState", Http2Stream::RefreshState);
stream->Inherit(AsyncWrap::GetConstructorTemplate(env));
StreamBase::AddMethods(env, stream);
Local<ObjectTemplate> streamt = stream->InstanceTemplate();
streamt->SetInternalFieldCount(StreamBase::kInternalFieldCount);
env->set_http2stream_constructor_template(streamt);
env->SetConstructorFunction(target, "Http2Stream", stream);
SetConstructorFunction(context, target, "Http2Stream", stream);
Local<FunctionTemplate> session =
env->NewFunctionTemplate(Http2Session::New);
NewFunctionTemplate(isolate, Http2Session::New);
session->InstanceTemplate()->SetInternalFieldCount(
Http2Session::kInternalFieldCount);
session->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(session, "origin", Http2Session::Origin);
env->SetProtoMethod(session, "altsvc", Http2Session::AltSvc);
env->SetProtoMethod(session, "ping", Http2Session::Ping);
env->SetProtoMethod(session, "consume", Http2Session::Consume);
env->SetProtoMethod(session, "receive", Http2Session::Receive);
env->SetProtoMethod(session, "destroy", Http2Session::Destroy);
env->SetProtoMethod(session, "goaway", Http2Session::Goaway);
env->SetProtoMethod(session, "settings", Http2Session::Settings);
env->SetProtoMethod(session, "request", Http2Session::Request);
env->SetProtoMethod(session, "setNextStreamID",
Http2Session::SetNextStreamID);
env->SetProtoMethod(session, "setLocalWindowSize",
Http2Session::SetLocalWindowSize);
env->SetProtoMethod(session, "updateChunksSent",
Http2Session::UpdateChunksSent);
env->SetProtoMethod(session, "refreshState", Http2Session::RefreshState);
env->SetProtoMethod(
session, "localSettings",
SetProtoMethod(isolate, session, "origin", Http2Session::Origin);
SetProtoMethod(isolate, session, "altsvc", Http2Session::AltSvc);
SetProtoMethod(isolate, session, "ping", Http2Session::Ping);
SetProtoMethod(isolate, session, "consume", Http2Session::Consume);
SetProtoMethod(isolate, session, "receive", Http2Session::Receive);
SetProtoMethod(isolate, session, "destroy", Http2Session::Destroy);
SetProtoMethod(isolate, session, "goaway", Http2Session::Goaway);
SetProtoMethod(isolate, session, "settings", Http2Session::Settings);
SetProtoMethod(isolate, session, "request", Http2Session::Request);
SetProtoMethod(
isolate, session, "setNextStreamID", Http2Session::SetNextStreamID);
SetProtoMethod(
isolate, session, "setLocalWindowSize", Http2Session::SetLocalWindowSize);
SetProtoMethod(
isolate, session, "updateChunksSent", Http2Session::UpdateChunksSent);
SetProtoMethod(isolate, session, "refreshState", Http2Session::RefreshState);
SetProtoMethod(
isolate,
session,
"localSettings",
Http2Session::RefreshSettings<nghttp2_session_get_local_settings>);
env->SetProtoMethod(
session, "remoteSettings",
SetProtoMethod(
isolate,
session,
"remoteSettings",
Http2Session::RefreshSettings<nghttp2_session_get_remote_settings>);
env->SetConstructorFunction(target, "Http2Session", session);
SetConstructorFunction(context, target, "Http2Session", session);
Local<Object> constants = Object::New(isolate);

44
src/node_http_parser.cc
View File

@ -1175,11 +1175,12 @@ void InitializeHttpParser(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
BindingData* const binding_data =
env->AddBindingData<BindingData>(context, target);
if (binding_data == nullptr) return;
Local<FunctionTemplate> t = env->NewFunctionTemplate(Parser::New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, Parser::New);
t->InstanceTemplate()->SetInternalFieldCount(Parser::kInternalFieldCount);
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "REQUEST"),
@ -1223,30 +1224,31 @@ void InitializeHttpParser(Local<Object> target,
methods).Check();
t->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "close", Parser::Close);
env->SetProtoMethod(t, "free", Parser::Free);
env->SetProtoMethod(t, "remove", Parser::Remove);
env->SetProtoMethod(t, "execute", Parser::Execute);
env->SetProtoMethod(t, "finish", Parser::Finish);
env->SetProtoMethod(t, "initialize", Parser::Initialize);
env->SetProtoMethod(t, "pause", Parser::Pause<true>);
env->SetProtoMethod(t, "resume", Parser::Pause<false>);
env->SetProtoMethod(t, "consume", Parser::Consume);
env->SetProtoMethod(t, "unconsume", Parser::Unconsume);
env->SetProtoMethod(t, "getCurrentBuffer", Parser::GetCurrentBuffer);
env->SetProtoMethod(t, "duration", Parser::Duration);
env->SetProtoMethod(t, "headersCompleted", Parser::HeadersCompleted);
SetProtoMethod(isolate, t, "close", Parser::Close);
SetProtoMethod(isolate, t, "free", Parser::Free);
SetProtoMethod(isolate, t, "remove", Parser::Remove);
SetProtoMethod(isolate, t, "execute", Parser::Execute);
SetProtoMethod(isolate, t, "finish", Parser::Finish);
SetProtoMethod(isolate, t, "initialize", Parser::Initialize);
SetProtoMethod(isolate, t, "pause", Parser::Pause<true>);
SetProtoMethod(isolate, t, "resume", Parser::Pause<false>);
SetProtoMethod(isolate, t, "consume", Parser::Consume);
SetProtoMethod(isolate, t, "unconsume", Parser::Unconsume);
SetProtoMethod(isolate, t, "getCurrentBuffer", Parser::GetCurrentBuffer);
SetProtoMethod(isolate, t, "duration", Parser::Duration);
SetProtoMethod(isolate, t, "headersCompleted", Parser::HeadersCompleted);
env->SetConstructorFunction(target, "HTTPParser", t);
SetConstructorFunction(context, target, "HTTPParser", t);
Local<FunctionTemplate> c = env->NewFunctionTemplate(ConnectionsList::New);
Local<FunctionTemplate> c =
NewFunctionTemplate(isolate, ConnectionsList::New);
c->InstanceTemplate()
->SetInternalFieldCount(ConnectionsList::kInternalFieldCount);
env->SetProtoMethod(c, "all", ConnectionsList::All);
env->SetProtoMethod(c, "idle", ConnectionsList::Idle);
env->SetProtoMethod(c, "active", ConnectionsList::Active);
env->SetProtoMethod(c, "expired", ConnectionsList::Expired);
env->SetConstructorFunction(target, "ConnectionsList", c);
SetProtoMethod(isolate, c, "all", ConnectionsList::All);
SetProtoMethod(isolate, c, "idle", ConnectionsList::Idle);
SetProtoMethod(isolate, c, "active", ConnectionsList::Active);
SetProtoMethod(isolate, c, "expired", ConnectionsList::Expired);
SetConstructorFunction(context, target, "ConnectionsList", c);
}
} // anonymous namespace

18
src/node_i18n.cc
View File

@ -838,17 +838,17 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "toUnicode", ToUnicode);
env->SetMethod(target, "toASCII", ToASCII);
env->SetMethod(target, "getStringWidth", GetStringWidth);
SetMethod(context, target, "toUnicode", ToUnicode);
SetMethod(context, target, "toASCII", ToASCII);
SetMethod(context, target, "getStringWidth", GetStringWidth);
// One-shot converters
env->SetMethod(target, "icuErrName", ICUErrorName);
env->SetMethod(target, "transcode", Transcode);
SetMethod(context, target, "icuErrName", ICUErrorName);
SetMethod(context, target, "transcode", Transcode);
// ConverterObject
{
Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate());
Local<FunctionTemplate> t = NewFunctionTemplate(env->isolate(), nullptr);
t->Inherit(BaseObject::GetConstructorTemplate(env));
t->InstanceTemplate()->SetInternalFieldCount(
ConverterObject::kInternalFieldCount);
@ -858,9 +858,9 @@ void Initialize(Local<Object> target,
env->set_i18n_converter_template(t->InstanceTemplate());
}
env->SetMethod(target, "getConverter", ConverterObject::Create);
env->SetMethod(target, "decode", ConverterObject::Decode);
env->SetMethod(target, "hasConverter", ConverterObject::Has);
SetMethod(context, target, "getConverter", ConverterObject::Create);
SetMethod(context, target, "decode", ConverterObject::Decode);
SetMethod(context, target, "hasConverter", ConverterObject::Has);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

50
src/node_messaging.cc
View File

@ -1111,14 +1111,15 @@ Local<FunctionTemplate> GetMessagePortConstructorTemplate(Environment* env) {
return templ;
{
Local<FunctionTemplate> m = env->NewFunctionTemplate(MessagePort::New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> m = NewFunctionTemplate(isolate, MessagePort::New);
m->SetClassName(env->message_port_constructor_string());
m->InstanceTemplate()->SetInternalFieldCount(
MessagePort::kInternalFieldCount);
m->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetProtoMethod(m, "postMessage", MessagePort::PostMessage);
env->SetProtoMethod(m, "start", MessagePort::Start);
SetProtoMethod(isolate, m, "postMessage", MessagePort::PostMessage);
SetProtoMethod(isolate, m, "start", MessagePort::Start);
env->set_message_port_constructor_template(m);
}
@ -1451,38 +1452,43 @@ static void InitMessaging(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
{
env->SetConstructorFunction(
target,
"MessageChannel",
env->NewFunctionTemplate(MessageChannel));
SetConstructorFunction(context,
target,
"MessageChannel",
NewFunctionTemplate(isolate, MessageChannel));
}
{
Local<FunctionTemplate> t = env->NewFunctionTemplate(JSTransferable::New);
Local<FunctionTemplate> t =
NewFunctionTemplate(isolate, JSTransferable::New);
t->Inherit(BaseObject::GetConstructorTemplate(env));
t->InstanceTemplate()->SetInternalFieldCount(
JSTransferable::kInternalFieldCount);
env->SetConstructorFunction(target, "JSTransferable", t);
SetConstructorFunction(context, target, "JSTransferable", t);
}
env->SetConstructorFunction(
target,
env->message_port_constructor_string(),
GetMessagePortConstructorTemplate(env));
SetConstructorFunction(context,
target,
env->message_port_constructor_string(),
GetMessagePortConstructorTemplate(env));
// These are not methods on the MessagePort prototype, because
// the browser equivalents do not provide them.
env->SetMethod(target, "stopMessagePort", MessagePort::Stop);
env->SetMethod(target, "checkMessagePort", MessagePort::CheckType);
env->SetMethod(target, "drainMessagePort", MessagePort::Drain);
env->SetMethod(target, "receiveMessageOnPort", MessagePort::ReceiveMessage);
env->SetMethod(target, "moveMessagePortToContext",
MessagePort::MoveToContext);
env->SetMethod(target, "setDeserializerCreateObjectFunction",
SetDeserializerCreateObjectFunction);
env->SetMethod(target, "broadcastChannel", BroadcastChannel);
SetMethod(context, target, "stopMessagePort", MessagePort::Stop);
SetMethod(context, target, "checkMessagePort", MessagePort::CheckType);
SetMethod(context, target, "drainMessagePort", MessagePort::Drain);
SetMethod(
context, target, "receiveMessageOnPort", MessagePort::ReceiveMessage);
SetMethod(
context, target, "moveMessagePortToContext", MessagePort::MoveToContext);
SetMethod(context,
target,
"setDeserializerCreateObjectFunction",
SetDeserializerCreateObjectFunction);
SetMethod(context, target, "broadcastChannel", BroadcastChannel);
{
Local<Function> domexception = GetDOMException(context).ToLocalChecked();

20
src/node_native_module.cc
View File

@ -568,9 +568,10 @@ void NativeModuleLoader::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
target
->SetAccessor(env->context(),
->SetAccessor(context,
env->config_string(),
ConfigStringGetter,
nullptr,
@ -580,8 +581,8 @@ void NativeModuleLoader::Initialize(Local<Object> target,
SideEffectType::kHasNoSideEffect)
.Check();
target
->SetAccessor(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "moduleIds"),
->SetAccessor(context,
FIXED_ONE_BYTE_STRING(isolate, "moduleIds"),
ModuleIdsGetter,
nullptr,
MaybeLocal<Value>(),
@ -591,8 +592,8 @@ void NativeModuleLoader::Initialize(Local<Object> target,
.Check();
target
->SetAccessor(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "moduleCategories"),
->SetAccessor(context,
FIXED_ONE_BYTE_STRING(isolate, "moduleCategories"),
GetModuleCategories,
nullptr,
Local<Value>(),
@ -601,10 +602,11 @@ void NativeModuleLoader::Initialize(Local<Object> target,
SideEffectType::kHasNoSideEffect)
.Check();
env->SetMethod(target, "getCacheUsage", NativeModuleLoader::GetCacheUsage);
env->SetMethod(
target, "compileFunction", NativeModuleLoader::CompileFunction);
env->SetMethod(target, "hasCachedBuiltins", HasCachedBuiltins);
SetMethod(
context, target, "getCacheUsage", NativeModuleLoader::GetCacheUsage);
SetMethod(
context, target, "compileFunction", NativeModuleLoader::CompileFunction);
SetMethod(context, target, "hasCachedBuiltins", HasCachedBuiltins);
// internalBinding('native_module') should be frozen
target->SetIntegrityLevel(context, IntegrityLevel::kFrozen).FromJust();
}

5
src/node_options.cc
View File

@ -1160,8 +1160,9 @@ void Initialize(Local<Object> target,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethodNoSideEffect(target, "getCLIOptions", GetCLIOptions);
env->SetMethodNoSideEffect(target, "getEmbedderOptions", GetEmbedderOptions);
SetMethodNoSideEffect(context, target, "getCLIOptions", GetCLIOptions);
SetMethodNoSideEffect(
context, target, "getEmbedderOptions", GetEmbedderOptions);
Local<Object> env_settings = Object::New(isolate);
NODE_DEFINE_CONSTANT(env_settings, kAllowedInEnvironment);

32
src/node_os.cc
View File

@ -382,21 +382,23 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "getHostname", GetHostname);
env->SetMethod(target, "getLoadAvg", GetLoadAvg);
env->SetMethod(target, "getUptime", GetUptime);
env->SetMethod(target, "getTotalMem", GetTotalMemory);
env->SetMethod(target, "getFreeMem", GetFreeMemory);
env->SetMethod(target, "getCPUs", GetCPUInfo);
env->SetMethod(target, "getInterfaceAddresses", GetInterfaceAddresses);
env->SetMethod(target, "getHomeDirectory", GetHomeDirectory);
env->SetMethod(target, "getUserInfo", GetUserInfo);
env->SetMethod(target, "setPriority", SetPriority);
env->SetMethod(target, "getPriority", GetPriority);
env->SetMethod(target, "getOSInformation", GetOSInformation);
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "isBigEndian"),
Boolean::New(env->isolate(), IsBigEndian())).Check();
SetMethod(context, target, "getHostname", GetHostname);
SetMethod(context, target, "getLoadAvg", GetLoadAvg);
SetMethod(context, target, "getUptime", GetUptime);
SetMethod(context, target, "getTotalMem", GetTotalMemory);
SetMethod(context, target, "getFreeMem", GetFreeMemory);
SetMethod(context, target, "getCPUs", GetCPUInfo);
SetMethod(context, target, "getInterfaceAddresses", GetInterfaceAddresses);
SetMethod(context, target, "getHomeDirectory", GetHomeDirectory);
SetMethod(context, target, "getUserInfo", GetUserInfo);
SetMethod(context, target, "setPriority", SetPriority);
SetMethod(context, target, "getPriority", GetPriority);
SetMethod(context, target, "getOSInformation", GetOSInformation);
target
->Set(context,
FIXED_ONE_BYTE_STRING(env->isolate(), "isBigEndian"),
Boolean::New(env->isolate(), IsBigEndian()))
.Check();
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

28
src/node_perf.cc
View File

@ -291,19 +291,21 @@ void Initialize(Local<Object> target,
target->Set(context, performanceEntryString, fn).Check();
env->set_performance_entry_template(fn);
env->SetMethod(target, "markMilestone", MarkMilestone);
env->SetMethod(target, "setupObservers", SetupPerformanceObservers);
env->SetMethod(target,
"installGarbageCollectionTracking",
InstallGarbageCollectionTracking);
env->SetMethod(target,
"removeGarbageCollectionTracking",
RemoveGarbageCollectionTracking);
env->SetMethod(target, "notify", Notify);
env->SetMethod(target, "loopIdleTime", LoopIdleTime);
env->SetMethod(target, "getTimeOrigin", GetTimeOrigin);
env->SetMethod(target, "getTimeOriginTimestamp", GetTimeOriginTimeStamp);
env->SetMethod(target, "createELDHistogram", CreateELDHistogram);
SetMethod(context, target, "markMilestone", MarkMilestone);
SetMethod(context, target, "setupObservers", SetupPerformanceObservers);
SetMethod(context,
target,
"installGarbageCollectionTracking",
InstallGarbageCollectionTracking);
SetMethod(context,
target,
"removeGarbageCollectionTracking",
RemoveGarbageCollectionTracking);
SetMethod(context, target, "notify", Notify);
SetMethod(context, target, "loopIdleTime", LoopIdleTime);
SetMethod(context, target, "getTimeOrigin", GetTimeOrigin);
SetMethod(context, target, "getTimeOriginTimestamp", GetTimeOriginTimeStamp);
SetMethod(context, target, "createELDHistogram", CreateELDHistogram);
Local<Object> constants = Object::New(isolate);

47
src/node_process_methods.cc
View File

@ -464,8 +464,9 @@ v8::CFunction BindingData::fast_number_(v8::CFunction::Make(FastNumber));
v8::CFunction BindingData::fast_bigint_(v8::CFunction::Make(FastBigInt));
void BindingData::AddMethods() {
env()->SetFastMethod(object(), "hrtime", SlowNumber, &fast_number_);
env()->SetFastMethod(object(), "hrtimeBigInt", SlowBigInt, &fast_bigint_);
Local<Context> ctx = env()->context();
SetFastMethod(ctx, object(), "hrtime", SlowNumber, &fast_number_);
SetFastMethod(ctx, object(), "hrtimeBigInt", SlowBigInt, &fast_bigint_);
}
void BindingData::RegisterExternalReferences(
@ -560,31 +561,31 @@ static void Initialize(Local<Object> target,
// define various internal methods
if (env->owns_process_state()) {
env->SetMethod(target, "_debugProcess", DebugProcess);
env->SetMethod(target, "_debugEnd", DebugEnd);
env->SetMethod(target, "abort", Abort);
env->SetMethod(target, "causeSegfault", CauseSegfault);
env->SetMethod(target, "chdir", Chdir);
SetMethod(context, target, "_debugProcess", DebugProcess);
SetMethod(context, target, "_debugEnd", DebugEnd);
SetMethod(context, target, "abort", Abort);
SetMethod(context, target, "causeSegfault", CauseSegfault);
SetMethod(context, target, "chdir", Chdir);
}
env->SetMethod(target, "umask", Umask);
env->SetMethod(target, "_rawDebug", RawDebug);
env->SetMethod(target, "memoryUsage", MemoryUsage);
env->SetMethod(target, "rss", Rss);
env->SetMethod(target, "cpuUsage", CPUUsage);
env->SetMethod(target, "resourceUsage", ResourceUsage);
SetMethod(context, target, "umask", Umask);
SetMethod(context, target, "_rawDebug", RawDebug);
SetMethod(context, target, "memoryUsage", MemoryUsage);
SetMethod(context, target, "rss", Rss);
SetMethod(context, target, "cpuUsage", CPUUsage);
SetMethod(context, target, "resourceUsage", ResourceUsage);
env->SetMethod(target, "_getActiveRequests", GetActiveRequests);
env->SetMethod(target, "_getActiveRequestsInfo", GetActiveRequestsInfo);
env->SetMethod(target, "_getActiveHandles", GetActiveHandles);
env->SetMethod(target, "_getActiveHandlesInfo", GetActiveHandlesInfo);
env->SetMethod(target, "_kill", Kill);
SetMethod(context, target, "_getActiveRequestsInfo", GetActiveRequestsInfo);
SetMethod(context, target, "_getActiveRequests", GetActiveRequests);
SetMethod(context, target, "_getActiveHandles", GetActiveHandles);
SetMethod(context, target, "_getActiveHandlesInfo", GetActiveHandlesInfo);
SetMethod(context, target, "_kill", Kill);
env->SetMethodNoSideEffect(target, "cwd", Cwd);
env->SetMethod(target, "dlopen", binding::DLOpen);
env->SetMethod(target, "reallyExit", ReallyExit);
env->SetMethodNoSideEffect(target, "uptime", Uptime);
env->SetMethod(target, "patchProcessObject", PatchProcessObject);
SetMethodNoSideEffect(context, target, "cwd", Cwd);
SetMethod(context, target, "dlopen", binding::DLOpen);
SetMethod(context, target, "reallyExit", ReallyExit);
SetMethodNoSideEffect(context, target, "uptime", Uptime);
SetMethod(context, target, "patchProcessObject", PatchProcessObject);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

2
src/node_process_object.cc
View File

@ -144,7 +144,7 @@ MaybeLocal<Object> CreateProcessObject(Environment* env) {
// process._rawDebug: may be overwritten later in JS land, but should be
// available from the beginning for debugging purposes
env->SetMethod(process, "_rawDebug", RawDebug);
SetMethod(context, process, "_rawDebug", RawDebug);
return scope.Escape(process);
}

44
src/node_report_module.cc
View File

@ -18,6 +18,7 @@
namespace report {
using node::Environment;
using node::Mutex;
using node::SetMethod;
using node::Utf8Value;
using v8::Context;
using v8::FunctionCallbackInfo;
@ -175,26 +176,29 @@ static void Initialize(Local<Object> exports,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(exports, "writeReport", WriteReport);
env->SetMethod(exports, "getReport", GetReport);
env->SetMethod(exports, "getCompact", GetCompact);
env->SetMethod(exports, "setCompact", SetCompact);
env->SetMethod(exports, "getDirectory", GetDirectory);
env->SetMethod(exports, "setDirectory", SetDirectory);
env->SetMethod(exports, "getFilename", GetFilename);
env->SetMethod(exports, "setFilename", SetFilename);
env->SetMethod(exports, "getSignal", GetSignal);
env->SetMethod(exports, "setSignal", SetSignal);
env->SetMethod(exports, "shouldReportOnFatalError", ShouldReportOnFatalError);
env->SetMethod(exports, "setReportOnFatalError", SetReportOnFatalError);
env->SetMethod(exports, "shouldReportOnSignal", ShouldReportOnSignal);
env->SetMethod(exports, "setReportOnSignal", SetReportOnSignal);
env->SetMethod(exports, "shouldReportOnUncaughtException",
ShouldReportOnUncaughtException);
env->SetMethod(exports, "setReportOnUncaughtException",
SetReportOnUncaughtException);
SetMethod(context, exports, "writeReport", WriteReport);
SetMethod(context, exports, "getReport", GetReport);
SetMethod(context, exports, "getCompact", GetCompact);
SetMethod(context, exports, "setCompact", SetCompact);
SetMethod(context, exports, "getDirectory", GetDirectory);
SetMethod(context, exports, "setDirectory", SetDirectory);
SetMethod(context, exports, "getFilename", GetFilename);
SetMethod(context, exports, "setFilename", SetFilename);
SetMethod(context, exports, "getSignal", GetSignal);
SetMethod(context, exports, "setSignal", SetSignal);
SetMethod(
context, exports, "shouldReportOnFatalError", ShouldReportOnFatalError);
SetMethod(context, exports, "setReportOnFatalError", SetReportOnFatalError);
SetMethod(context, exports, "shouldReportOnSignal", ShouldReportOnSignal);
SetMethod(context, exports, "setReportOnSignal", SetReportOnSignal);
SetMethod(context,
exports,
"shouldReportOnUncaughtException",
ShouldReportOnUncaughtException);
SetMethod(context,
exports,
"setReportOnUncaughtException",
SetReportOnUncaughtException);
}
void RegisterExternalReferences(node::ExternalReferenceRegistry* registry) {

67
src/node_serdes.cc
View File

@ -455,53 +455,62 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> ser =
env->NewFunctionTemplate(SerializerContext::New);
NewFunctionTemplate(isolate, SerializerContext::New);
ser->InstanceTemplate()->SetInternalFieldCount(
SerializerContext::kInternalFieldCount);
ser->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(ser, "writeHeader", SerializerContext::WriteHeader);
env->SetProtoMethod(ser, "writeValue", SerializerContext::WriteValue);
env->SetProtoMethod(ser, "releaseBuffer", SerializerContext::ReleaseBuffer);
env->SetProtoMethod(ser,
"transferArrayBuffer",
SerializerContext::TransferArrayBuffer);
env->SetProtoMethod(ser, "writeUint32", SerializerContext::WriteUint32);
env->SetProtoMethod(ser, "writeUint64", SerializerContext::WriteUint64);
env->SetProtoMethod(ser, "writeDouble", SerializerContext::WriteDouble);
env->SetProtoMethod(ser, "writeRawBytes", SerializerContext::WriteRawBytes);
env->SetProtoMethod(ser,
"_setTreatArrayBufferViewsAsHostObjects",
SerializerContext::SetTreatArrayBufferViewsAsHostObjects);
SetProtoMethod(isolate, ser, "writeHeader", SerializerContext::WriteHeader);
SetProtoMethod(isolate, ser, "writeValue", SerializerContext::WriteValue);
SetProtoMethod(
isolate, ser, "releaseBuffer", SerializerContext::ReleaseBuffer);
SetProtoMethod(isolate,
ser,
"transferArrayBuffer",
SerializerContext::TransferArrayBuffer);
SetProtoMethod(isolate, ser, "writeUint32", SerializerContext::WriteUint32);
SetProtoMethod(isolate, ser, "writeUint64", SerializerContext::WriteUint64);
SetProtoMethod(isolate, ser, "writeDouble", SerializerContext::WriteDouble);
SetProtoMethod(
isolate, ser, "writeRawBytes", SerializerContext::WriteRawBytes);
SetProtoMethod(isolate,
ser,
"_setTreatArrayBufferViewsAsHostObjects",
SerializerContext::SetTreatArrayBufferViewsAsHostObjects);
ser->ReadOnlyPrototype();
env->SetConstructorFunction(target, "Serializer", ser);
SetConstructorFunction(context, target, "Serializer", ser);
Local<FunctionTemplate> des =
env->NewFunctionTemplate(DeserializerContext::New);
NewFunctionTemplate(isolate, DeserializerContext::New);
des->InstanceTemplate()->SetInternalFieldCount(
DeserializerContext::kInternalFieldCount);
des->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(des, "readHeader", DeserializerContext::ReadHeader);
env->SetProtoMethod(des, "readValue", DeserializerContext::ReadValue);
env->SetProtoMethod(des,
"getWireFormatVersion",
DeserializerContext::GetWireFormatVersion);
env->SetProtoMethod(des,
"transferArrayBuffer",
DeserializerContext::TransferArrayBuffer);
env->SetProtoMethod(des, "readUint32", DeserializerContext::ReadUint32);
env->SetProtoMethod(des, "readUint64", DeserializerContext::ReadUint64);
env->SetProtoMethod(des, "readDouble", DeserializerContext::ReadDouble);
env->SetProtoMethod(des, "_readRawBytes", DeserializerContext::ReadRawBytes);
SetProtoMethod(isolate, des, "readHeader", DeserializerContext::ReadHeader);
SetProtoMethod(isolate, des, "readValue", DeserializerContext::ReadValue);
SetProtoMethod(isolate,
des,
"getWireFormatVersion",
DeserializerContext::GetWireFormatVersion);
SetProtoMethod(isolate,
des,
"transferArrayBuffer",
DeserializerContext::TransferArrayBuffer);
SetProtoMethod(isolate, des, "readUint32", DeserializerContext::ReadUint32);
SetProtoMethod(isolate, des, "readUint64", DeserializerContext::ReadUint64);
SetProtoMethod(isolate, des, "readDouble", DeserializerContext::ReadDouble);
SetProtoMethod(
isolate, des, "_readRawBytes", DeserializerContext::ReadRawBytes);
des->SetLength(1);
des->ReadOnlyPrototype();
env->SetConstructorFunction(target, "Deserializer", des);
SetConstructorFunction(context, target, "Deserializer", des);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

15
src/node_snapshotable.cc
View File

@ -520,13 +520,14 @@ void Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "compileSerializeMain", CompileSerializeMain);
env->SetMethod(target, "markBootstrapComplete", MarkBootstrapComplete);
env->SetMethod(target, "setSerializeCallback", SetSerializeCallback);
env->SetMethod(target, "setDeserializeCallback", SetDeserializeCallback);
env->SetMethod(
target, "setDeserializeMainFunction", SetDeserializeMainFunction);
SetMethod(context, target, "compileSerializeMain", CompileSerializeMain);
SetMethod(context, target, "markBootstrapComplete", MarkBootstrapComplete);
SetMethod(context, target, "setSerializeCallback", SetSerializeCallback);
SetMethod(context, target, "setDeserializeCallback", SetDeserializeCallback);
SetMethod(context,
target,
"setDeserializeMainFunction",
SetDeserializeMainFunction);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

43
src/node_sockaddr.cc
View File

@ -17,6 +17,7 @@ using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Int32;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
@ -697,15 +698,16 @@ Local<FunctionTemplate> SocketAddressBlockListWrap::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->blocklist_constructor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(SocketAddressBlockListWrap::New);
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, SocketAddressBlockListWrap::New);
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "BlockList"));
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
tmpl->InstanceTemplate()->SetInternalFieldCount(kInternalFieldCount);
env->SetProtoMethod(tmpl, "addAddress", AddAddress);
env->SetProtoMethod(tmpl, "addRange", AddRange);
env->SetProtoMethod(tmpl, "addSubnet", AddSubnet);
env->SetProtoMethod(tmpl, "check", Check);
env->SetProtoMethod(tmpl, "getRules", GetRules);
SetProtoMethod(isolate, tmpl, "addAddress", AddAddress);
SetProtoMethod(isolate, tmpl, "addRange", AddRange);
SetProtoMethod(isolate, tmpl, "addSubnet", AddSubnet);
SetProtoMethod(isolate, tmpl, "check", Check);
SetProtoMethod(isolate, tmpl, "getRules", GetRules);
env->set_blocklist_constructor_template(tmpl);
}
return tmpl;
@ -718,11 +720,11 @@ void SocketAddressBlockListWrap::Initialize(
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetConstructorFunction(
target,
"BlockList",
GetConstructorTemplate(env),
Environment::SetConstructorFunctionFlag::NONE);
SetConstructorFunction(context,
target,
"BlockList",
GetConstructorTemplate(env),
SetConstructorFunctionFlag::NONE);
SocketAddressBase::Initialize(env, target);
@ -750,25 +752,26 @@ Local<FunctionTemplate> SocketAddressBase::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->socketaddress_constructor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, New);
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SocketAddress"));
tmpl->InstanceTemplate()->SetInternalFieldCount(
SocketAddressBase::kInternalFieldCount);
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(tmpl, "detail", Detail);
env->SetProtoMethod(tmpl, "legacyDetail", LegacyDetail);
env->SetProtoMethodNoSideEffect(tmpl, "flowlabel", GetFlowLabel);
SetProtoMethod(isolate, tmpl, "detail", Detail);
SetProtoMethod(isolate, tmpl, "legacyDetail", LegacyDetail);
SetProtoMethodNoSideEffect(isolate, tmpl, "flowlabel", GetFlowLabel);
env->set_socketaddress_constructor_template(tmpl);
}
return tmpl;
}
void SocketAddressBase::Initialize(Environment* env, Local<Object> target) {
env->SetConstructorFunction(
target,
"SocketAddress",
GetConstructorTemplate(env),
Environment::SetConstructorFunctionFlag::NONE);
SetConstructorFunction(env->context(),
target,
"SocketAddress",
GetConstructorTemplate(env),
SetConstructorFunctionFlag::NONE);
}
BaseObjectPtr<SocketAddressBase> SocketAddressBase::Create(

9
src/node_stat_watcher.cc
View File

@ -37,23 +37,24 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Uint32;
using v8::Value;
void StatWatcher::Initialize(Environment* env, Local<Object> target) {
Isolate* isolate = env->isolate();
HandleScope scope(env->isolate());
Local<FunctionTemplate> t = env->NewFunctionTemplate(StatWatcher::New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, StatWatcher::New);
t->InstanceTemplate()->SetInternalFieldCount(
StatWatcher::kInternalFieldCount);
t->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "start", StatWatcher::Start);
SetProtoMethod(isolate, t, "start", StatWatcher::Start);
env->SetConstructorFunction(target, "StatWatcher", t);
SetConstructorFunction(env->context(), target, "StatWatcher", t);
}
void StatWatcher::RegisterExternalReferences(

11
src/node_task_queue.cc
View File

@ -196,9 +196,9 @@ static void Initialize(Local<Object> target,
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "enqueueMicrotask", EnqueueMicrotask);
env->SetMethod(target, "setTickCallback", SetTickCallback);
env->SetMethod(target, "runMicrotasks", RunMicrotasks);
SetMethod(context, target, "enqueueMicrotask", EnqueueMicrotask);
SetMethod(context, target, "setTickCallback", SetTickCallback);
SetMethod(context, target, "runMicrotasks", RunMicrotasks);
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(isolate, "tickInfo"),
env->tick_info()->fields().GetJSArray()).Check();
@ -212,9 +212,8 @@ static void Initialize(Local<Object> target,
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),
events).Check();
env->SetMethod(target,
"setPromiseRejectCallback",
SetPromiseRejectCallback);
SetMethod(
context, target, "setPromiseRejectCallback", SetPromiseRejectCallback);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

19
src/node_trace_events.cc
View File

@ -20,6 +20,7 @@ using v8::Context;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Isolate;
using v8::Local;
using v8::NewStringType;
using v8::Object;
@ -124,21 +125,23 @@ void NodeCategorySet::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetMethod(target, "getEnabledCategories", GetEnabledCategories);
env->SetMethod(
target, "setTraceCategoryStateUpdateHandler",
SetTraceCategoryStateUpdateHandler);
SetMethod(context, target, "getEnabledCategories", GetEnabledCategories);
SetMethod(context,
target,
"setTraceCategoryStateUpdateHandler",
SetTraceCategoryStateUpdateHandler);
Local<FunctionTemplate> category_set =
env->NewFunctionTemplate(NodeCategorySet::New);
NewFunctionTemplate(isolate, NodeCategorySet::New);
category_set->InstanceTemplate()->SetInternalFieldCount(
NodeCategorySet::kInternalFieldCount);
category_set->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(category_set, "enable", NodeCategorySet::Enable);
env->SetProtoMethod(category_set, "disable", NodeCategorySet::Disable);
SetProtoMethod(isolate, category_set, "enable", NodeCategorySet::Enable);
SetProtoMethod(isolate, category_set, "disable", NodeCategorySet::Disable);
env->SetConstructorFunction(target, "CategorySet", category_set);
SetConstructorFunction(context, target, "CategorySet", category_set);
Local<String> isTraceCategoryEnabled =
FIXED_ONE_BYTE_STRING(env->isolate(), "isTraceCategoryEnabled");

10
src/node_types.cc
View File

@ -65,16 +65,12 @@ void InitializeTypes(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
#define V(type) env->SetMethodNoSideEffect(target, \
"is" #type, \
Is##type);
#define V(type) SetMethodNoSideEffect(context, target, "is" #type, Is##type);
VALUE_METHOD_MAP(V)
#undef V
env->SetMethodNoSideEffect(target, "isAnyArrayBuffer", IsAnyArrayBuffer);
env->SetMethodNoSideEffect(target, "isBoxedPrimitive", IsBoxedPrimitive);
SetMethodNoSideEffect(context, target, "isAnyArrayBuffer", IsAnyArrayBuffer);
SetMethodNoSideEffect(context, target, "isBoxedPrimitive", IsBoxedPrimitive);
}
} // anonymous namespace

11
src/node_url.cc
View File

@ -1799,12 +1799,11 @@ void Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "parse", Parse);
env->SetMethodNoSideEffect(target, "encodeAuth", EncodeAuthSet);
env->SetMethodNoSideEffect(target, "domainToASCII", DomainToASCII);
env->SetMethodNoSideEffect(target, "domainToUnicode", DomainToUnicode);
env->SetMethod(target, "setURLConstructor", SetURLConstructor);
SetMethod(context, target, "parse", Parse);
SetMethodNoSideEffect(context, target, "encodeAuth", EncodeAuthSet);
SetMethodNoSideEffect(context, target, "domainToASCII", DomainToASCII);
SetMethodNoSideEffect(context, target, "domainToUnicode", DomainToUnicode);
SetMethod(context, target, "setURLConstructor", SetURLConstructor);
#define XX(name, _) NODE_DEFINE_CONSTANT(target, name);
FLAGS(XX)

42
src/node_util.cc
View File

@ -347,6 +347,7 @@ void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
#define V(name, _) \
target->Set(context, \
@ -368,18 +369,21 @@ void Initialize(Local<Object> target,
V(kRejected);
#undef V
env->SetMethodNoSideEffect(target, "getHiddenValue", GetHiddenValue);
env->SetMethod(target, "setHiddenValue", SetHiddenValue);
env->SetMethodNoSideEffect(target, "getPromiseDetails", GetPromiseDetails);
env->SetMethodNoSideEffect(target, "getProxyDetails", GetProxyDetails);
env->SetMethodNoSideEffect(target, "previewEntries", PreviewEntries);
env->SetMethodNoSideEffect(target, "getOwnNonIndexProperties",
GetOwnNonIndexProperties);
env->SetMethodNoSideEffect(target, "getConstructorName", GetConstructorName);
env->SetMethodNoSideEffect(target, "getExternalValue", GetExternalValue);
env->SetMethod(target, "sleep", Sleep);
SetMethodNoSideEffect(context, target, "getHiddenValue", GetHiddenValue);
SetMethod(context, target, "setHiddenValue", SetHiddenValue);
SetMethodNoSideEffect(
context, target, "getPromiseDetails", GetPromiseDetails);
SetMethodNoSideEffect(context, target, "getProxyDetails", GetProxyDetails);
SetMethodNoSideEffect(context, target, "previewEntries", PreviewEntries);
SetMethodNoSideEffect(
context, target, "getOwnNonIndexProperties", GetOwnNonIndexProperties);
SetMethodNoSideEffect(
context, target, "getConstructorName", GetConstructorName);
SetMethodNoSideEffect(context, target, "getExternalValue", GetExternalValue);
SetMethod(context, target, "sleep", Sleep);
env->SetMethod(target, "arrayBufferViewHasBuffer", ArrayBufferViewHasBuffer);
SetMethod(
context, target, "arrayBufferViewHasBuffer", ArrayBufferViewHasBuffer);
Local<Object> constants = Object::New(env->isolate());
NODE_DEFINE_CONSTANT(constants, ALL_PROPERTIES);
NODE_DEFINE_CONSTANT(constants, ONLY_WRITABLE);
@ -394,24 +398,24 @@ void Initialize(Local<Object> target,
Local<String> should_abort_on_uncaught_toggle =
FIXED_ONE_BYTE_STRING(env->isolate(), "shouldAbortOnUncaughtToggle");
CHECK(target
->Set(env->context(),
->Set(context,
should_abort_on_uncaught_toggle,
env->should_abort_on_uncaught_toggle().GetJSArray())
.FromJust());
Local<FunctionTemplate> weak_ref =
env->NewFunctionTemplate(WeakReference::New);
NewFunctionTemplate(isolate, WeakReference::New);
weak_ref->InstanceTemplate()->SetInternalFieldCount(
WeakReference::kInternalFieldCount);
weak_ref->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(weak_ref, "get", WeakReference::Get);
env->SetProtoMethod(weak_ref, "incRef", WeakReference::IncRef);
env->SetProtoMethod(weak_ref, "decRef", WeakReference::DecRef);
env->SetConstructorFunction(target, "WeakReference", weak_ref);
SetProtoMethod(isolate, weak_ref, "get", WeakReference::Get);
SetProtoMethod(isolate, weak_ref, "incRef", WeakReference::IncRef);
SetProtoMethod(isolate, weak_ref, "decRef", WeakReference::DecRef);
SetConstructorFunction(context, target, "WeakReference", weak_ref);
env->SetMethod(target, "guessHandleType", GuessHandleType);
SetMethod(context, target, "guessHandleType", GuessHandleType);
env->SetMethodNoSideEffect(target, "toUSVString", ToUSVString);
SetMethodNoSideEffect(context, target, "toUSVString", ToUSVString);
}
} // namespace util

38
src/node_v8.cc
View File

@ -206,13 +206,17 @@ void Initialize(Local<Object> target,
env->AddBindingData<BindingData>(context, target);
if (binding_data == nullptr) return;
env->SetMethodNoSideEffect(target, "cachedDataVersionTag",
CachedDataVersionTag);
env->SetMethod(
target, "updateHeapStatisticsBuffer", UpdateHeapStatisticsBuffer);
SetMethodNoSideEffect(
context, target, "cachedDataVersionTag", CachedDataVersionTag);
SetMethod(context,
target,
"updateHeapStatisticsBuffer",
UpdateHeapStatisticsBuffer);
env->SetMethod(
target, "updateHeapCodeStatisticsBuffer", UpdateHeapCodeStatisticsBuffer);
SetMethod(context,
target,
"updateHeapCodeStatisticsBuffer",
UpdateHeapCodeStatisticsBuffer);
size_t number_of_heap_spaces = env->isolate()->NumberOfHeapSpaces();
@ -225,19 +229,21 @@ void Initialize(Local<Object> target,
heap_spaces[i] = String::NewFromUtf8(env->isolate(), s.space_name())
.ToLocalChecked();
}
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "kHeapSpaces"),
Array::New(env->isolate(),
heap_spaces.out(),
number_of_heap_spaces)).Check();
target
->Set(
context,
FIXED_ONE_BYTE_STRING(env->isolate(), "kHeapSpaces"),
Array::New(env->isolate(), heap_spaces.out(), number_of_heap_spaces))
.Check();
env->SetMethod(target,
"updateHeapSpaceStatisticsBuffer",
UpdateHeapSpaceStatisticsBuffer);
SetMethod(context,
target,
"updateHeapSpaceStatisticsBuffer",
UpdateHeapSpaceStatisticsBuffer);
#define V(i, _, name) \
target \
->Set(env->context(), \
->Set(context, \
FIXED_ONE_BYTE_STRING(env->isolate(), #name), \
Uint32::NewFromUnsigned(env->isolate(), i)) \
.Check();
@ -248,7 +254,7 @@ void Initialize(Local<Object> target,
#undef V
// Export symbols used by v8.setFlagsFromString()
env->SetMethod(target, "setFlagsFromString", SetFlagsFromString);
SetMethod(context, target, "setFlagsFromString", SetFlagsFromString);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

105
src/node_wasi.cc
View File

@ -1668,62 +1668,67 @@ static void Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> tmpl = env->NewFunctionTemplate(WASI::New);
Local<FunctionTemplate> tmpl = NewFunctionTemplate(isolate, WASI::New);
tmpl->InstanceTemplate()->SetInternalFieldCount(WASI::kInternalFieldCount);
tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
env->SetProtoMethod(tmpl, "args_get", WASI::ArgsGet);
env->SetProtoMethod(tmpl, "args_sizes_get", WASI::ArgsSizesGet);
env->SetProtoMethod(tmpl, "clock_res_get", WASI::ClockResGet);
env->SetProtoMethod(tmpl, "clock_time_get", WASI::ClockTimeGet);
env->SetProtoMethod(tmpl, "environ_get", WASI::EnvironGet);
env->SetProtoMethod(tmpl, "environ_sizes_get", WASI::EnvironSizesGet);
env->SetProtoMethod(tmpl, "fd_advise", WASI::FdAdvise);
env->SetProtoMethod(tmpl, "fd_allocate", WASI::FdAllocate);
env->SetProtoMethod(tmpl, "fd_close", WASI::FdClose);
env->SetProtoMethod(tmpl, "fd_datasync", WASI::FdDatasync);
env->SetProtoMethod(tmpl, "fd_fdstat_get", WASI::FdFdstatGet);
env->SetProtoMethod(tmpl, "fd_fdstat_set_flags", WASI::FdFdstatSetFlags);
env->SetProtoMethod(tmpl, "fd_fdstat_set_rights", WASI::FdFdstatSetRights);
env->SetProtoMethod(tmpl, "fd_filestat_get", WASI::FdFilestatGet);
env->SetProtoMethod(tmpl, "fd_filestat_set_size", WASI::FdFilestatSetSize);
env->SetProtoMethod(tmpl, "fd_filestat_set_times", WASI::FdFilestatSetTimes);
env->SetProtoMethod(tmpl, "fd_pread", WASI::FdPread);
env->SetProtoMethod(tmpl, "fd_prestat_get", WASI::FdPrestatGet);
env->SetProtoMethod(tmpl, "fd_prestat_dir_name", WASI::FdPrestatDirName);
env->SetProtoMethod(tmpl, "fd_pwrite", WASI::FdPwrite);
env->SetProtoMethod(tmpl, "fd_read", WASI::FdRead);
env->SetProtoMethod(tmpl, "fd_readdir", WASI::FdReaddir);
env->SetProtoMethod(tmpl, "fd_renumber", WASI::FdRenumber);
env->SetProtoMethod(tmpl, "fd_seek", WASI::FdSeek);
env->SetProtoMethod(tmpl, "fd_sync", WASI::FdSync);
env->SetProtoMethod(tmpl, "fd_tell", WASI::FdTell);
env->SetProtoMethod(tmpl, "fd_write", WASI::FdWrite);
env->SetProtoMethod(tmpl, "path_create_directory", WASI::PathCreateDirectory);
env->SetProtoMethod(tmpl, "path_filestat_get", WASI::PathFilestatGet);
env->SetProtoMethod(tmpl,
"path_filestat_set_times",
WASI::PathFilestatSetTimes);
env->SetProtoMethod(tmpl, "path_link", WASI::PathLink);
env->SetProtoMethod(tmpl, "path_open", WASI::PathOpen);
env->SetProtoMethod(tmpl, "path_readlink", WASI::PathReadlink);
env->SetProtoMethod(tmpl, "path_remove_directory", WASI::PathRemoveDirectory);
env->SetProtoMethod(tmpl, "path_rename", WASI::PathRename);
env->SetProtoMethod(tmpl, "path_symlink", WASI::PathSymlink);
env->SetProtoMethod(tmpl, "path_unlink_file", WASI::PathUnlinkFile);
env->SetProtoMethod(tmpl, "poll_oneoff", WASI::PollOneoff);
env->SetProtoMethod(tmpl, "proc_exit", WASI::ProcExit);
env->SetProtoMethod(tmpl, "proc_raise", WASI::ProcRaise);
env->SetProtoMethod(tmpl, "random_get", WASI::RandomGet);
env->SetProtoMethod(tmpl, "sched_yield", WASI::SchedYield);
env->SetProtoMethod(tmpl, "sock_recv", WASI::SockRecv);
env->SetProtoMethod(tmpl, "sock_send", WASI::SockSend);
env->SetProtoMethod(tmpl, "sock_shutdown", WASI::SockShutdown);
SetProtoMethod(isolate, tmpl, "args_get", WASI::ArgsGet);
SetProtoMethod(isolate, tmpl, "args_sizes_get", WASI::ArgsSizesGet);
SetProtoMethod(isolate, tmpl, "clock_res_get", WASI::ClockResGet);
SetProtoMethod(isolate, tmpl, "clock_time_get", WASI::ClockTimeGet);
SetProtoMethod(isolate, tmpl, "environ_get", WASI::EnvironGet);
SetProtoMethod(isolate, tmpl, "environ_sizes_get", WASI::EnvironSizesGet);
SetProtoMethod(isolate, tmpl, "fd_advise", WASI::FdAdvise);
SetProtoMethod(isolate, tmpl, "fd_allocate", WASI::FdAllocate);
SetProtoMethod(isolate, tmpl, "fd_close", WASI::FdClose);
SetProtoMethod(isolate, tmpl, "fd_datasync", WASI::FdDatasync);
SetProtoMethod(isolate, tmpl, "fd_fdstat_get", WASI::FdFdstatGet);
SetProtoMethod(isolate, tmpl, "fd_fdstat_set_flags", WASI::FdFdstatSetFlags);
SetProtoMethod(
isolate, tmpl, "fd_fdstat_set_rights", WASI::FdFdstatSetRights);
SetProtoMethod(isolate, tmpl, "fd_filestat_get", WASI::FdFilestatGet);
SetProtoMethod(
isolate, tmpl, "fd_filestat_set_size", WASI::FdFilestatSetSize);
SetProtoMethod(
isolate, tmpl, "fd_filestat_set_times", WASI::FdFilestatSetTimes);
SetProtoMethod(isolate, tmpl, "fd_pread", WASI::FdPread);
SetProtoMethod(isolate, tmpl, "fd_prestat_get", WASI::FdPrestatGet);
SetProtoMethod(isolate, tmpl, "fd_prestat_dir_name", WASI::FdPrestatDirName);
SetProtoMethod(isolate, tmpl, "fd_pwrite", WASI::FdPwrite);
SetProtoMethod(isolate, tmpl, "fd_read", WASI::FdRead);
SetProtoMethod(isolate, tmpl, "fd_readdir", WASI::FdReaddir);
SetProtoMethod(isolate, tmpl, "fd_renumber", WASI::FdRenumber);
SetProtoMethod(isolate, tmpl, "fd_seek", WASI::FdSeek);
SetProtoMethod(isolate, tmpl, "fd_sync", WASI::FdSync);
SetProtoMethod(isolate, tmpl, "fd_tell", WASI::FdTell);
SetProtoMethod(isolate, tmpl, "fd_write", WASI::FdWrite);
SetProtoMethod(
isolate, tmpl, "path_create_directory", WASI::PathCreateDirectory);
SetProtoMethod(isolate, tmpl, "path_filestat_get", WASI::PathFilestatGet);
SetProtoMethod(
isolate, tmpl, "path_filestat_set_times", WASI::PathFilestatSetTimes);
SetProtoMethod(isolate, tmpl, "path_link", WASI::PathLink);
SetProtoMethod(isolate, tmpl, "path_open", WASI::PathOpen);
SetProtoMethod(isolate, tmpl, "path_readlink", WASI::PathReadlink);
SetProtoMethod(
isolate, tmpl, "path_remove_directory", WASI::PathRemoveDirectory);
SetProtoMethod(isolate, tmpl, "path_rename", WASI::PathRename);
SetProtoMethod(isolate, tmpl, "path_symlink", WASI::PathSymlink);
SetProtoMethod(isolate, tmpl, "path_unlink_file", WASI::PathUnlinkFile);
SetProtoMethod(isolate, tmpl, "poll_oneoff", WASI::PollOneoff);
SetProtoMethod(isolate, tmpl, "proc_exit", WASI::ProcExit);
SetProtoMethod(isolate, tmpl, "proc_raise", WASI::ProcRaise);
SetProtoMethod(isolate, tmpl, "random_get", WASI::RandomGet);
SetProtoMethod(isolate, tmpl, "sched_yield", WASI::SchedYield);
SetProtoMethod(isolate, tmpl, "sock_recv", WASI::SockRecv);
SetProtoMethod(isolate, tmpl, "sock_send", WASI::SockSend);
SetProtoMethod(isolate, tmpl, "sock_shutdown", WASI::SockShutdown);
env->SetInstanceMethod(tmpl, "_setMemory", WASI::_SetMemory);
SetInstanceMethod(isolate, tmpl, "_setMemory", WASI::_SetMemory);
env->SetConstructorFunction(target, "WASI", tmpl);
SetConstructorFunction(context, target, "WASI", tmpl);
}

15
src/node_wasm_web_api.cc
View File

@ -13,6 +13,7 @@ using v8::Context;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
@ -25,15 +26,16 @@ Local<Function> WasmStreamingObject::Initialize(Environment* env) {
return templ;
}
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->Inherit(BaseObject::GetConstructorTemplate(env));
t->InstanceTemplate()->SetInternalFieldCount(
WasmStreamingObject::kInternalFieldCount);
env->SetProtoMethod(t, "setURL", SetURL);
env->SetProtoMethod(t, "push", Push);
env->SetProtoMethod(t, "finish", Finish);
env->SetProtoMethod(t, "abort", Abort);
SetProtoMethod(isolate, t, "setURL", SetURL);
SetProtoMethod(isolate, t, "push", Push);
SetProtoMethod(isolate, t, "finish", Finish);
SetProtoMethod(isolate, t, "abort", Abort);
auto function = t->GetFunction(env->context()).ToLocalChecked();
env->set_wasm_streaming_object_constructor(function);
@ -194,8 +196,7 @@ void Initialize(Local<Object> target,
Local<Value>,
Local<Context> context,
void*) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "setImplementation", SetImplementation);
SetMethod(context, target, "setImplementation", SetImplementation);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

11
src/node_watchdog.cc
View File

@ -34,6 +34,7 @@ namespace node {
using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
@ -123,15 +124,17 @@ SignalPropagation SigintWatchdog::HandleSigint() {
}
void TraceSigintWatchdog::Init(Environment* env, Local<Object> target) {
Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> constructor = NewFunctionTemplate(isolate, New);
constructor->InstanceTemplate()->SetInternalFieldCount(
TraceSigintWatchdog::kInternalFieldCount);
constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetProtoMethod(constructor, "start", Start);
env->SetProtoMethod(constructor, "stop", Stop);
SetProtoMethod(isolate, constructor, "start", Start);
SetProtoMethod(isolate, constructor, "stop", Stop);
env->SetConstructorFunction(target, "TraceSigintWatchdog", constructor);
SetConstructorFunction(
env->context(), target, "TraceSigintWatchdog", constructor);
}
void TraceSigintWatchdog::New(const FunctionCallbackInfo<Value>& args) {

43
src/node_worker.cc
View File

@ -839,65 +839,66 @@ void InitWorker(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
{
Local<FunctionTemplate> w = env->NewFunctionTemplate(Worker::New);
Local<FunctionTemplate> w = NewFunctionTemplate(isolate, Worker::New);
w->InstanceTemplate()->SetInternalFieldCount(
Worker::kInternalFieldCount);
w->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(w, "startThread", Worker::StartThread);
env->SetProtoMethod(w, "stopThread", Worker::StopThread);
env->SetProtoMethod(w, "hasRef", Worker::HasRef);
env->SetProtoMethod(w, "ref", Worker::Ref);
env->SetProtoMethod(w, "unref", Worker::Unref);
env->SetProtoMethod(w, "getResourceLimits", Worker::GetResourceLimits);
env->SetProtoMethod(w, "takeHeapSnapshot", Worker::TakeHeapSnapshot);
env->SetProtoMethod(w, "loopIdleTime", Worker::LoopIdleTime);
env->SetProtoMethod(w, "loopStartTime", Worker::LoopStartTime);
SetProtoMethod(isolate, w, "startThread", Worker::StartThread);
SetProtoMethod(isolate, w, "stopThread", Worker::StopThread);
SetProtoMethod(isolate, w, "hasRef", Worker::HasRef);
SetProtoMethod(isolate, w, "ref", Worker::Ref);
SetProtoMethod(isolate, w, "unref", Worker::Unref);
SetProtoMethod(isolate, w, "getResourceLimits", Worker::GetResourceLimits);
SetProtoMethod(isolate, w, "takeHeapSnapshot", Worker::TakeHeapSnapshot);
SetProtoMethod(isolate, w, "loopIdleTime", Worker::LoopIdleTime);
SetProtoMethod(isolate, w, "loopStartTime", Worker::LoopStartTime);
env->SetConstructorFunction(target, "Worker", w);
SetConstructorFunction(context, target, "Worker", w);
}
{
Local<FunctionTemplate> wst = FunctionTemplate::New(env->isolate());
Local<FunctionTemplate> wst = NewFunctionTemplate(isolate, nullptr);
wst->InstanceTemplate()->SetInternalFieldCount(
WorkerHeapSnapshotTaker::kInternalFieldCount);
wst->Inherit(AsyncWrap::GetConstructorTemplate(env));
Local<String> wst_string =
FIXED_ONE_BYTE_STRING(env->isolate(), "WorkerHeapSnapshotTaker");
FIXED_ONE_BYTE_STRING(isolate, "WorkerHeapSnapshotTaker");
wst->SetClassName(wst_string);
env->set_worker_heap_snapshot_taker_template(wst->InstanceTemplate());
}
env->SetMethod(target, "getEnvMessagePort", GetEnvMessagePort);
SetMethod(context, target, "getEnvMessagePort", GetEnvMessagePort);
target
->Set(env->context(),
env->thread_id_string(),
Number::New(env->isolate(), static_cast<double>(env->thread_id())))
Number::New(isolate, static_cast<double>(env->thread_id())))
.Check();
target
->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "isMainThread"),
Boolean::New(env->isolate(), env->is_main_thread()))
FIXED_ONE_BYTE_STRING(isolate, "isMainThread"),
Boolean::New(isolate, env->is_main_thread()))
.Check();
target
->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "ownsProcessState"),
Boolean::New(env->isolate(), env->owns_process_state()))
FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
Boolean::New(isolate, env->owns_process_state()))
.Check();
if (!env->is_main_thread()) {
target
->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "resourceLimits"),
env->worker_context()->GetResourceLimits(env->isolate()))
FIXED_ONE_BYTE_STRING(isolate, "resourceLimits"),
env->worker_context()->GetResourceLimits(isolate))
.Check();
}

18
src/node_zlib.cc
View File

@ -52,6 +52,7 @@ using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Uint32Array;
@ -1256,21 +1257,22 @@ CompressionError BrotliDecoderContext::GetErrorInfo() const {
template <typename Stream>
struct MakeClass {
static void Make(Environment* env, Local<Object> target, const char* name) {
Local<FunctionTemplate> z = env->NewFunctionTemplate(Stream::New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> z = NewFunctionTemplate(isolate, Stream::New);
z->InstanceTemplate()->SetInternalFieldCount(
Stream::kInternalFieldCount);
z->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetProtoMethod(z, "write", Stream::template Write<true>);
env->SetProtoMethod(z, "writeSync", Stream::template Write<false>);
env->SetProtoMethod(z, "close", Stream::Close);
SetProtoMethod(isolate, z, "write", Stream::template Write<true>);
SetProtoMethod(isolate, z, "writeSync", Stream::template Write<false>);
SetProtoMethod(isolate, z, "close", Stream::Close);
env->SetProtoMethod(z, "init", Stream::Init);
env->SetProtoMethod(z, "params", Stream::Params);
env->SetProtoMethod(z, "reset", Stream::Reset);
SetProtoMethod(isolate, z, "init", Stream::Init);
SetProtoMethod(isolate, z, "params", Stream::Params);
SetProtoMethod(isolate, z, "reset", Stream::Reset);
env->SetConstructorFunction(target, name, z);
SetConstructorFunction(env->context(), target, name, z);
}
static void Make(ExternalReferenceRegistry* registry) {

20
src/pipe_wrap.cc
View File

@ -41,6 +41,7 @@ using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Int32;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
@ -67,31 +68,32 @@ void PipeWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()
->SetInternalFieldCount(StreamBase::kInternalFieldCount);
t->Inherit(LibuvStreamWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "bind", Bind);
env->SetProtoMethod(t, "listen", Listen);
env->SetProtoMethod(t, "connect", Connect);
env->SetProtoMethod(t, "open", Open);
SetProtoMethod(isolate, t, "bind", Bind);
SetProtoMethod(isolate, t, "listen", Listen);
SetProtoMethod(isolate, t, "connect", Connect);
SetProtoMethod(isolate, t, "open", Open);
#ifdef _WIN32
env->SetProtoMethod(t, "setPendingInstances", SetPendingInstances);
SetProtoMethod(isolate, t, "setPendingInstances", SetPendingInstances);
#endif
env->SetProtoMethod(t, "fchmod", Fchmod);
SetProtoMethod(isolate, t, "fchmod", Fchmod);
env->SetConstructorFunction(target, "Pipe", t);
SetConstructorFunction(context, target, "Pipe", t);
env->set_pipe_constructor_template(t);
// Create FunctionTemplate for PipeConnectWrap.
auto cwt = BaseObject::MakeLazilyInitializedJSTemplate(env);
cwt->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "PipeConnectWrap", cwt);
SetConstructorFunction(context, target, "PipeConnectWrap", cwt);
// Define constants
Local<Object> constants = Object::New(env->isolate());

10
src/process_wrap.cc
View File

@ -36,6 +36,7 @@ using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Int32;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Number;
using v8::Object;
@ -51,16 +52,17 @@ class ProcessWrap : public HandleWrap {
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> constructor = NewFunctionTemplate(isolate, New);
constructor->InstanceTemplate()->SetInternalFieldCount(
ProcessWrap::kInternalFieldCount);
constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetProtoMethod(constructor, "spawn", Spawn);
env->SetProtoMethod(constructor, "kill", Kill);
SetProtoMethod(isolate, constructor, "spawn", Spawn);
SetProtoMethod(isolate, constructor, "kill", Kill);
env->SetConstructorFunction(target, "Process", constructor);
SetConstructorFunction(context, target, "Process", constructor);
}
SET_NO_MEMORY_INFO()

10
src/signal_wrap.cc
View File

@ -34,6 +34,7 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;
@ -52,15 +53,16 @@ class SignalWrap : public HandleWrap {
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> constructor = NewFunctionTemplate(isolate, New);
constructor->InstanceTemplate()->SetInternalFieldCount(
SignalWrap::kInternalFieldCount);
constructor->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetProtoMethod(constructor, "start", Start);
env->SetProtoMethod(constructor, "stop", Stop);
SetProtoMethod(isolate, constructor, "start", Start);
SetProtoMethod(isolate, constructor, "stop", Stop);
env->SetConstructorFunction(target, "Signal", constructor);
SetConstructorFunction(context, target, "Signal", constructor);
}
static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

3
src/spawn_sync.cc
View File

@ -363,8 +363,7 @@ void SyncProcessRunner::Initialize(Local<Object> target,
Local<Value> unused,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "spawn", Spawn);
SetMethod(context, target, "spawn", Spawn);
}

65
src/stream_base.cc
View File

@ -400,21 +400,24 @@ void StreamBase::AddMethod(Environment* env,
Local<FunctionTemplate> t,
JSMethodFunction* stream_method,
Local<String> string) {
Isolate* isolate = env->isolate();
Local<FunctionTemplate> templ =
env->NewFunctionTemplate(stream_method,
signature,
ConstructorBehavior::kThrow,
SideEffectType::kHasNoSideEffect);
NewFunctionTemplate(isolate,
stream_method,
signature,
ConstructorBehavior::kThrow,
SideEffectType::kHasNoSideEffect);
t->PrototypeTemplate()->SetAccessorProperty(
string, templ, Local<FunctionTemplate>(), attributes);
}
void StreamBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
HandleScope scope(env->isolate());
Isolate* isolate = env->isolate();
HandleScope scope(isolate);
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(ReadOnly | DontDelete | DontEnum);
Local<Signature> sig = Signature::New(env->isolate(), t);
Local<Signature> sig = Signature::New(isolate, t);
AddMethod(env, sig, attributes, t, GetFD, env->fd_string());
AddMethod(
@ -422,32 +425,32 @@ void StreamBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
AddMethod(env, sig, attributes, t, GetBytesRead, env->bytes_read_string());
AddMethod(
env, sig, attributes, t, GetBytesWritten, env->bytes_written_string());
env->SetProtoMethod(t, "readStart", JSMethod<&StreamBase::ReadStartJS>);
env->SetProtoMethod(t, "readStop", JSMethod<&StreamBase::ReadStopJS>);
env->SetProtoMethod(t, "shutdown", JSMethod<&StreamBase::Shutdown>);
env->SetProtoMethod(t,
"useUserBuffer",
JSMethod<&StreamBase::UseUserBuffer>);
env->SetProtoMethod(t, "writev", JSMethod<&StreamBase::Writev>);
env->SetProtoMethod(t, "writeBuffer", JSMethod<&StreamBase::WriteBuffer>);
env->SetProtoMethod(
t, "writeAsciiString", JSMethod<&StreamBase::WriteString<ASCII>>);
env->SetProtoMethod(
t, "writeUtf8String", JSMethod<&StreamBase::WriteString<UTF8>>);
env->SetProtoMethod(
t, "writeUcs2String", JSMethod<&StreamBase::WriteString<UCS2>>);
env->SetProtoMethod(
t, "writeLatin1String", JSMethod<&StreamBase::WriteString<LATIN1>>);
t->PrototypeTemplate()->Set(FIXED_ONE_BYTE_STRING(env->isolate(),
"isStreamBase"),
True(env->isolate()));
SetProtoMethod(isolate, t, "readStart", JSMethod<&StreamBase::ReadStartJS>);
SetProtoMethod(isolate, t, "readStop", JSMethod<&StreamBase::ReadStopJS>);
SetProtoMethod(isolate, t, "shutdown", JSMethod<&StreamBase::Shutdown>);
SetProtoMethod(
isolate, t, "useUserBuffer", JSMethod<&StreamBase::UseUserBuffer>);
SetProtoMethod(isolate, t, "writev", JSMethod<&StreamBase::Writev>);
SetProtoMethod(isolate, t, "writeBuffer", JSMethod<&StreamBase::WriteBuffer>);
SetProtoMethod(isolate,
t,
"writeAsciiString",
JSMethod<&StreamBase::WriteString<ASCII>>);
SetProtoMethod(
isolate, t, "writeUtf8String", JSMethod<&StreamBase::WriteString<UTF8>>);
SetProtoMethod(
isolate, t, "writeUcs2String", JSMethod<&StreamBase::WriteString<UCS2>>);
SetProtoMethod(isolate,
t,
"writeLatin1String",
JSMethod<&StreamBase::WriteString<LATIN1>>);
t->PrototypeTemplate()->Set(FIXED_ONE_BYTE_STRING(isolate, "isStreamBase"),
True(isolate));
t->PrototypeTemplate()->SetAccessor(
FIXED_ONE_BYTE_STRING(env->isolate(), "onread"),
BaseObject::InternalFieldGet<
StreamBase::kOnReadFunctionField>,
BaseObject::InternalFieldSet<
StreamBase::kOnReadFunctionField,
&Value::IsFunction>);
FIXED_ONE_BYTE_STRING(isolate, "onread"),
BaseObject::InternalFieldGet<StreamBase::kOnReadFunctionField>,
BaseObject::InternalFieldSet<StreamBase::kOnReadFunctionField,
&Value::IsFunction>);
}
void StreamBase::RegisterExternalReferences(

14
src/stream_pipe.cc
View File

@ -11,6 +11,7 @@ using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Isolate;
using v8::Just;
using v8::Local;
using v8::Maybe;
@ -313,17 +314,18 @@ void InitializeStreamPipe(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
// Create FunctionTemplate for FileHandle::CloseReq
Local<FunctionTemplate> pipe = env->NewFunctionTemplate(StreamPipe::New);
env->SetProtoMethod(pipe, "unpipe", StreamPipe::Unpipe);
env->SetProtoMethod(pipe, "start", StreamPipe::Start);
env->SetProtoMethod(pipe, "isClosed", StreamPipe::IsClosed);
env->SetProtoMethod(pipe, "pendingWrites", StreamPipe::PendingWrites);
Local<FunctionTemplate> pipe = NewFunctionTemplate(isolate, StreamPipe::New);
SetProtoMethod(isolate, pipe, "unpipe", StreamPipe::Unpipe);
SetProtoMethod(isolate, pipe, "start", StreamPipe::Start);
SetProtoMethod(isolate, pipe, "isClosed", StreamPipe::IsClosed);
SetProtoMethod(isolate, pipe, "pendingWrites", StreamPipe::PendingWrites);
pipe->Inherit(AsyncWrap::GetConstructorTemplate(env));
pipe->InstanceTemplate()->SetInternalFieldCount(
StreamPipe::kInternalFieldCount);
env->SetConstructorFunction(target, "StreamPipe", pipe);
SetConstructorFunction(context, target, "StreamPipe", pipe);
}
} // anonymous namespace

41
src/stream_wrap.cc
View File

@ -46,6 +46,7 @@ using v8::EscapableHandleScope;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::HandleScope;
using v8::Isolate;
using v8::JustVoid;
using v8::Local;
using v8::Maybe;
@ -67,9 +68,10 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> sw =
FunctionTemplate::New(env->isolate(), IsConstructCallCallback);
NewFunctionTemplate(isolate, IsConstructCallCallback);
sw->InstanceTemplate()->SetInternalFieldCount(StreamReq::kInternalFieldCount);
// we need to set handle and callback to null,
@ -79,33 +81,34 @@ void LibuvStreamWrap::Initialize(Local<Object> target,
// - oncomplete
// - callback
// - handle
sw->InstanceTemplate()->Set(
env->oncomplete_string(),
v8::Null(env->isolate()));
sw->InstanceTemplate()->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "callback"),
v8::Null(env->isolate()));
sw->InstanceTemplate()->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "handle"),
v8::Null(env->isolate()));
sw->InstanceTemplate()->Set(env->oncomplete_string(), v8::Null(isolate));
sw->InstanceTemplate()->Set(FIXED_ONE_BYTE_STRING(isolate, "callback"),
v8::Null(isolate));
sw->InstanceTemplate()->Set(FIXED_ONE_BYTE_STRING(isolate, "handle"),
v8::Null(isolate));
sw->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "ShutdownWrap", sw);
SetConstructorFunction(context, target, "ShutdownWrap", sw);
env->set_shutdown_wrap_template(sw->InstanceTemplate());
Local<FunctionTemplate> ww =
FunctionTemplate::New(env->isolate(), IsConstructCallCallback);
FunctionTemplate::New(isolate, IsConstructCallCallback);
ww->InstanceTemplate()->SetInternalFieldCount(
StreamReq::kInternalFieldCount);
ww->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "WriteWrap", ww);
SetConstructorFunction(context, target, "WriteWrap", ww);
env->set_write_wrap_template(ww->InstanceTemplate());
NODE_DEFINE_CONSTANT(target, kReadBytesOrError);
NODE_DEFINE_CONSTANT(target, kArrayBufferOffset);
NODE_DEFINE_CONSTANT(target, kBytesWritten);
NODE_DEFINE_CONSTANT(target, kLastWriteWasAsync);
target->Set(context, FIXED_ONE_BYTE_STRING(env->isolate(), "streamBaseState"),
env->stream_base_state().GetJSArray()).Check();
target
->Set(context,
FIXED_ONE_BYTE_STRING(isolate, "streamBaseState"),
env->stream_base_state().GetJSArray())
.Check();
}
void LibuvStreamWrap::RegisterExternalReferences(
@ -134,23 +137,23 @@ Local<FunctionTemplate> LibuvStreamWrap::GetConstructorTemplate(
Environment* env) {
Local<FunctionTemplate> tmpl = env->libuv_stream_wrap_ctor_template();
if (tmpl.IsEmpty()) {
tmpl = env->NewFunctionTemplate(nullptr);
tmpl->SetClassName(
FIXED_ONE_BYTE_STRING(env->isolate(), "LibuvStreamWrap"));
Isolate* isolate = env->isolate();
tmpl = NewFunctionTemplate(isolate, nullptr);
tmpl->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "LibuvStreamWrap"));
tmpl->Inherit(HandleWrap::GetConstructorTemplate(env));
tmpl->InstanceTemplate()->SetInternalFieldCount(
StreamBase::kInternalFieldCount);
Local<FunctionTemplate> get_write_queue_size =
FunctionTemplate::New(env->isolate(),
FunctionTemplate::New(isolate,
GetWriteQueueSize,
Local<Value>(),
Signature::New(env->isolate(), tmpl));
Signature::New(isolate, tmpl));
tmpl->PrototypeTemplate()->SetAccessorProperty(
env->write_queue_size_string(),
get_write_queue_size,
Local<FunctionTemplate>(),
static_cast<PropertyAttribute>(ReadOnly | DontDelete));
env->SetProtoMethod(tmpl, "setBlocking", SetBlocking);
SetProtoMethod(isolate, tmpl, "setBlocking", SetBlocking);
StreamBase::AddMethods(env, tmpl);
env->set_libuv_stream_wrap_ctor_template(tmpl);
}

4
src/string_decoder.cc
View File

@ -328,8 +328,8 @@ void InitializeStringDecoder(Local<Object> target,
FIXED_ONE_BYTE_STRING(isolate, "kSize"),
Integer::New(isolate, sizeof(StringDecoder))).Check();
env->SetMethod(target, "decode", DecodeData);
env->SetMethod(target, "flush", FlushData);
SetMethod(context, target, "decode", DecodeData);
SetMethod(context, target, "flush", FlushData);
}
} // anonymous namespace

40
src/tcp_wrap.cc
View File

@ -45,6 +45,7 @@ using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Int32;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::Object;
@ -73,8 +74,9 @@ void TCPWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(StreamBase::kInternalFieldCount);
// Init properties
@ -85,32 +87,36 @@ void TCPWrap::Initialize(Local<Object> target,
t->Inherit(LibuvStreamWrap::GetConstructorTemplate(env));
env->SetProtoMethod(t, "open", Open);
env->SetProtoMethod(t, "bind", Bind);
env->SetProtoMethod(t, "listen", Listen);
env->SetProtoMethod(t, "connect", Connect);
env->SetProtoMethod(t, "bind6", Bind6);
env->SetProtoMethod(t, "connect6", Connect6);
env->SetProtoMethod(t, "getsockname",
GetSockOrPeerName<TCPWrap, uv_tcp_getsockname>);
env->SetProtoMethod(t, "getpeername",
GetSockOrPeerName<TCPWrap, uv_tcp_getpeername>);
env->SetProtoMethod(t, "setNoDelay", SetNoDelay);
env->SetProtoMethod(t, "setKeepAlive", SetKeepAlive);
env->SetProtoMethod(t, "reset", Reset);
SetProtoMethod(isolate, t, "open", Open);
SetProtoMethod(isolate, t, "bind", Bind);
SetProtoMethod(isolate, t, "listen", Listen);
SetProtoMethod(isolate, t, "connect", Connect);
SetProtoMethod(isolate, t, "bind6", Bind6);
SetProtoMethod(isolate, t, "connect6", Connect6);
SetProtoMethod(isolate,
t,
"getsockname",
GetSockOrPeerName<TCPWrap, uv_tcp_getsockname>);
SetProtoMethod(isolate,
t,
"getpeername",
GetSockOrPeerName<TCPWrap, uv_tcp_getpeername>);
SetProtoMethod(isolate, t, "setNoDelay", SetNoDelay);
SetProtoMethod(isolate, t, "setKeepAlive", SetKeepAlive);
SetProtoMethod(isolate, t, "reset", Reset);
#ifdef _WIN32
env->SetProtoMethod(t, "setSimultaneousAccepts", SetSimultaneousAccepts);
SetProtoMethod(isolate, t, "setSimultaneousAccepts", SetSimultaneousAccepts);
#endif
env->SetConstructorFunction(target, "TCP", t);
SetConstructorFunction(context, target, "TCP", t);
env->set_tcp_constructor_template(t);
// Create FunctionTemplate for TCPConnectWrap.
Local<FunctionTemplate> cwt =
BaseObject::MakeLazilyInitializedJSTemplate(env);
cwt->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "TCPConnectWrap", cwt);
SetConstructorFunction(context, target, "TCPConnectWrap", cwt);
// Define constants
Local<Object> constants = Object::New(env->isolate());

18
src/timers.cc
View File

@ -48,15 +48,17 @@ void Initialize(Local<Object> target,
void* priv) {
Environment* env = Environment::GetCurrent(context);
env->SetMethod(target, "getLibuvNow", GetLibuvNow);
env->SetMethod(target, "setupTimers", SetupTimers);
env->SetMethod(target, "scheduleTimer", ScheduleTimer);
env->SetMethod(target, "toggleTimerRef", ToggleTimerRef);
env->SetMethod(target, "toggleImmediateRef", ToggleImmediateRef);
SetMethod(context, target, "getLibuvNow", GetLibuvNow);
SetMethod(context, target, "setupTimers", SetupTimers);
SetMethod(context, target, "scheduleTimer", ScheduleTimer);
SetMethod(context, target, "toggleTimerRef", ToggleTimerRef);
SetMethod(context, target, "toggleImmediateRef", ToggleImmediateRef);
target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "immediateInfo"),
env->immediate_info()->fields().GetJSArray()).Check();
target
->Set(context,
FIXED_ONE_BYTE_STRING(env->isolate(), "immediateInfo"),
env->immediate_info()->fields().GetJSArray())
.Check();
}
} // anonymous namespace
void RegisterTimerExternalReferences(ExternalReferenceRegistry* registry) {

15
src/tty_wrap.cc
View File

@ -36,6 +36,7 @@ using v8::Context;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::String;
@ -53,22 +54,24 @@ void TTYWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<String> ttyString = FIXED_ONE_BYTE_STRING(env->isolate(), "TTY");
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->SetClassName(ttyString);
t->InstanceTemplate()->SetInternalFieldCount(StreamBase::kInternalFieldCount);
t->Inherit(LibuvStreamWrap::GetConstructorTemplate(env));
env->SetProtoMethodNoSideEffect(t, "getWindowSize", TTYWrap::GetWindowSize);
env->SetProtoMethod(t, "setRawMode", SetRawMode);
SetProtoMethodNoSideEffect(
isolate, t, "getWindowSize", TTYWrap::GetWindowSize);
SetProtoMethod(isolate, t, "setRawMode", SetRawMode);
env->SetMethodNoSideEffect(target, "isTTY", IsTTY);
SetMethodNoSideEffect(context, target, "isTTY", IsTTY);
Local<Value> func;
if (t->GetFunction(env->context()).ToLocal(&func) &&
target->Set(env->context(), ttyString, func).IsJust()) {
if (t->GetFunction(context).ToLocal(&func) &&
target->Set(context, ttyString, func).IsJust()) {
env->set_tty_constructor_template(t);
}
}

75
src/udp_wrap.cc
View File

@ -110,8 +110,8 @@ UDPWrapBase* UDPWrapBase::FromObject(Local<Object> obj) {
}
void UDPWrapBase::AddMethods(Environment* env, Local<FunctionTemplate> t) {
env->SetProtoMethod(t, "recvStart", RecvStart);
env->SetProtoMethod(t, "recvStop", RecvStop);
SetProtoMethod(env->isolate(), t, "recvStart", RecvStart);
SetProtoMethod(env->isolate(), t, "recvStop", RecvStop);
}
UDPWrap::UDPWrap(Environment* env, Local<Object> object)
@ -134,21 +134,19 @@ void UDPWrap::Initialize(Local<Object> target,
Local<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
Local<FunctionTemplate> t = NewFunctionTemplate(isolate, New);
t->InstanceTemplate()->SetInternalFieldCount(
UDPWrapBase::kInternalFieldCount);
enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(ReadOnly | DontDelete);
Local<Signature> signature = Signature::New(env->isolate(), t);
Local<Signature> signature = Signature::New(isolate, t);
Local<FunctionTemplate> get_fd_templ =
FunctionTemplate::New(env->isolate(),
UDPWrap::GetFD,
Local<Value>(),
signature);
FunctionTemplate::New(isolate, UDPWrap::GetFD, Local<Value>(), signature);
t->PrototypeTemplate()->SetAccessorProperty(env->fd_string(),
get_fd_templ,
@ -156,44 +154,47 @@ void UDPWrap::Initialize(Local<Object> target,
attributes);
UDPWrapBase::AddMethods(env, t);
env->SetProtoMethod(t, "open", Open);
env->SetProtoMethod(t, "bind", Bind);
env->SetProtoMethod(t, "connect", Connect);
env->SetProtoMethod(t, "send", Send);
env->SetProtoMethod(t, "bind6", Bind6);
env->SetProtoMethod(t, "connect6", Connect6);
env->SetProtoMethod(t, "send6", Send6);
env->SetProtoMethod(t, "disconnect", Disconnect);
env->SetProtoMethod(t, "getpeername",
GetSockOrPeerName<UDPWrap, uv_udp_getpeername>);
env->SetProtoMethod(t, "getsockname",
GetSockOrPeerName<UDPWrap, uv_udp_getsockname>);
env->SetProtoMethod(t, "addMembership", AddMembership);
env->SetProtoMethod(t, "dropMembership", DropMembership);
env->SetProtoMethod(t, "addSourceSpecificMembership",
AddSourceSpecificMembership);
env->SetProtoMethod(t, "dropSourceSpecificMembership",
DropSourceSpecificMembership);
env->SetProtoMethod(t, "setMulticastInterface", SetMulticastInterface);
env->SetProtoMethod(t, "setMulticastTTL", SetMulticastTTL);
env->SetProtoMethod(t, "setMulticastLoopback", SetMulticastLoopback);
env->SetProtoMethod(t, "setBroadcast", SetBroadcast);
env->SetProtoMethod(t, "setTTL", SetTTL);
env->SetProtoMethod(t, "bufferSize", BufferSize);
SetProtoMethod(isolate, t, "open", Open);
SetProtoMethod(isolate, t, "bind", Bind);
SetProtoMethod(isolate, t, "connect", Connect);
SetProtoMethod(isolate, t, "send", Send);
SetProtoMethod(isolate, t, "bind6", Bind6);
SetProtoMethod(isolate, t, "connect6", Connect6);
SetProtoMethod(isolate, t, "send6", Send6);
SetProtoMethod(isolate, t, "disconnect", Disconnect);
SetProtoMethod(isolate,
t,
"getpeername",
GetSockOrPeerName<UDPWrap, uv_udp_getpeername>);
SetProtoMethod(isolate,
t,
"getsockname",
GetSockOrPeerName<UDPWrap, uv_udp_getsockname>);
SetProtoMethod(isolate, t, "addMembership", AddMembership);
SetProtoMethod(isolate, t, "dropMembership", DropMembership);
SetProtoMethod(
isolate, t, "addSourceSpecificMembership", AddSourceSpecificMembership);
SetProtoMethod(
isolate, t, "dropSourceSpecificMembership", DropSourceSpecificMembership);
SetProtoMethod(isolate, t, "setMulticastInterface", SetMulticastInterface);
SetProtoMethod(isolate, t, "setMulticastTTL", SetMulticastTTL);
SetProtoMethod(isolate, t, "setMulticastLoopback", SetMulticastLoopback);
SetProtoMethod(isolate, t, "setBroadcast", SetBroadcast);
SetProtoMethod(isolate, t, "setTTL", SetTTL);
SetProtoMethod(isolate, t, "bufferSize", BufferSize);
t->Inherit(HandleWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "UDP", t);
env->set_udp_constructor_function(
t->GetFunction(env->context()).ToLocalChecked());
SetConstructorFunction(context, target, "UDP", t);
env->set_udp_constructor_function(t->GetFunction(context).ToLocalChecked());
// Create FunctionTemplate for SendWrap
Local<FunctionTemplate> swt =
BaseObject::MakeLazilyInitializedJSTemplate(env);
swt->Inherit(AsyncWrap::GetConstructorTemplate(env));
env->SetConstructorFunction(target, "SendWrap", swt);
SetConstructorFunction(context, target, "SendWrap", swt);
Local<Object> constants = Object::New(env->isolate());
Local<Object> constants = Object::New(isolate);
NODE_DEFINE_CONSTANT(constants, UV_UDP_IPV6ONLY);
NODE_DEFINE_CONSTANT(constants, UV_UDP_REUSEADDR);
target->Set(context,

157
src/util.cc
View File

@ -317,4 +317,161 @@ std::string DiagnosticFilename::MakeFilename(
return oss.str();
}
Local<v8::FunctionTemplate> NewFunctionTemplate(
v8::Isolate* isolate,
v8::FunctionCallback callback,
Local<v8::Signature> signature,
v8::ConstructorBehavior behavior,
v8::SideEffectType side_effect_type,
const v8::CFunction* c_function) {
return v8::FunctionTemplate::New(isolate,
callback,
Local<v8::Value>(),
signature,
0,
behavior,
side_effect_type,
c_function);
}
void SetMethod(Local<v8::Context> context,
Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback) {
Isolate* isolate = context->GetIsolate();
Local<v8::Function> function =
NewFunctionTemplate(isolate,
callback,
Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect)
->GetFunction(context)
.ToLocalChecked();
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
that->Set(context, name_string, function).Check();
function->SetName(name_string); // NODE_SET_METHOD() compatibility.
}
void SetFastMethod(Local<v8::Context> context,
Local<v8::Object> that,
const char* name,
v8::FunctionCallback slow_callback,
const v8::CFunction* c_function) {
Isolate* isolate = context->GetIsolate();
Local<v8::Function> function =
NewFunctionTemplate(isolate,
slow_callback,
Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasNoSideEffect,
c_function)
->GetFunction(context)
.ToLocalChecked();
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
that->Set(context, name_string, function).Check();
}
void SetMethodNoSideEffect(Local<v8::Context> context,
Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback) {
Isolate* isolate = context->GetIsolate();
Local<v8::Function> function =
NewFunctionTemplate(isolate,
callback,
Local<v8::Signature>(),
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasNoSideEffect)
->GetFunction(context)
.ToLocalChecked();
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
that->Set(context, name_string, function).Check();
function->SetName(name_string); // NODE_SET_METHOD() compatibility.
}
void SetProtoMethod(v8::Isolate* isolate,
Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Signature> signature = v8::Signature::New(isolate, that);
Local<v8::FunctionTemplate> t =
NewFunctionTemplate(isolate,
callback,
signature,
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect);
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
that->PrototypeTemplate()->Set(name_string, t);
t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility.
}
void SetProtoMethodNoSideEffect(v8::Isolate* isolate,
Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Signature> signature = v8::Signature::New(isolate, that);
Local<v8::FunctionTemplate> t =
NewFunctionTemplate(isolate,
callback,
signature,
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasNoSideEffect);
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
that->PrototypeTemplate()->Set(name_string, t);
t->SetClassName(name_string); // NODE_SET_PROTOTYPE_METHOD() compatibility.
}
void SetInstanceMethod(v8::Isolate* isolate,
Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback) {
Local<v8::Signature> signature = v8::Signature::New(isolate, that);
Local<v8::FunctionTemplate> t =
NewFunctionTemplate(isolate,
callback,
signature,
v8::ConstructorBehavior::kThrow,
v8::SideEffectType::kHasSideEffect);
// kInternalized strings are created in the old space.
const v8::NewStringType type = v8::NewStringType::kInternalized;
Local<v8::String> name_string =
v8::String::NewFromUtf8(isolate, name, type).ToLocalChecked();
that->InstanceTemplate()->Set(name_string, t);
t->SetClassName(name_string);
}
void SetConstructorFunction(Local<v8::Context> context,
Local<v8::Object> that,
const char* name,
Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag) {
Isolate* isolate = context->GetIsolate();
SetConstructorFunction(
context, that, OneByteString(isolate, name), tmpl, flag);
}
void SetConstructorFunction(Local<v8::Context> context,
Local<v8::Object> that,
Local<v8::String> name,
Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag) {
if (LIKELY(flag == SetConstructorFunctionFlag::SET_CLASS_NAME))
tmpl->SetClassName(name);
that->Set(context, name, tmpl->GetFunction(context).ToLocalChecked()).Check();
}
} // namespace node

60
src/util.h
View File

@ -856,6 +856,66 @@ std::unique_ptr<T> static_unique_pointer_cast(std::unique_ptr<U>&& ptr) {
// Returns a non-zero code if it fails to open or read the file,
// aborts if it fails to close the file.
int ReadFileSync(std::string* result, const char* path);
v8::Local<v8::FunctionTemplate> NewFunctionTemplate(
v8::Isolate* isolate,
v8::FunctionCallback callback,
v8::Local<v8::Signature> signature = v8::Local<v8::Signature>(),
v8::ConstructorBehavior behavior = v8::ConstructorBehavior::kAllow,
v8::SideEffectType side_effect = v8::SideEffectType::kHasSideEffect,
const v8::CFunction* c_function = nullptr);
// Convenience methods for NewFunctionTemplate().
void SetMethod(v8::Local<v8::Context> context,
v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback);
void SetFastMethod(v8::Local<v8::Context> context,
v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback slow_callback,
const v8::CFunction* c_function);
void SetProtoMethod(v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
void SetInstanceMethod(v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
// Safe variants denote the function has no side effects.
void SetMethodNoSideEffect(v8::Local<v8::Context> context,
v8::Local<v8::Object> that,
const char* name,
v8::FunctionCallback callback);
void SetProtoMethodNoSideEffect(v8::Isolate* isolate,
v8::Local<v8::FunctionTemplate> that,
const char* name,
v8::FunctionCallback callback);
enum class SetConstructorFunctionFlag {
NONE,
SET_CLASS_NAME,
};
void SetConstructorFunction(v8::Local<v8::Context> context,
v8::Local<v8::Object> that,
const char* name,
v8::Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag =
SetConstructorFunctionFlag::SET_CLASS_NAME);
void SetConstructorFunction(v8::Local<v8::Context> context,
v8::Local<v8::Object> that,
v8::Local<v8::String> name,
v8::Local<v8::FunctionTemplate> tmpl,
SetConstructorFunctionFlag flag =
SetConstructorFunctionFlag::SET_CLASS_NAME);
} // namespace node
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

8
src/uv.cc
View File

@ -109,10 +109,8 @@ void Initialize(Local<Object> target,
void* priv) {
Environment* env = Environment::GetCurrent(context);
Isolate* isolate = env->isolate();
env->SetConstructorFunction(
target,
"errname",
env->NewFunctionTemplate(ErrName));
SetConstructorFunction(
context, target, "errname", NewFunctionTemplate(isolate, ErrName));
// TODO(joyeecheung): This should be deprecated in user land in favor of
// `util.getSystemErrorName(err)`.
@ -128,7 +126,7 @@ void Initialize(Local<Object> target,
target->DefineOwnProperty(context, name, value, attributes).Check();
}
env->SetMethod(target, "getErrorMap", GetErrMap);
SetMethod(context, target, "getErrorMap", GetErrMap);
}
void RegisterExternalReferences(ExternalReferenceRegistry* registry) {

2
test/parallel/test-env-newprotomethod-remove-unnecessary-prototypes.js
View File

@ -3,7 +3,7 @@
require('../common');
// This test ensures that unnecessary prototypes are no longer
// being generated by Environment::NewFunctionTemplate.
// being generated by node::NewFunctionTemplate.
const assert = require('assert');
const { internalBinding } = require('internal/test/binding');