lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

src: fixup strings, reduce duplication 

PR-URL: https://github.com/nodejs/node/pull/14937
Reviewed-By: Anna Henningsen <anna@addaleax.net>
canary-base
James M Snell 8 years ago
parent
0ce54a7ec9
commit
771a03dfe3
18 changed files with 104 additions and 73 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 32
      src/cares_wrap.cc
  2. 8
      src/js_stream.cc
  3. 2
      src/node_config.cc
  4. 7
      src/node_crypto.cc
  5. 7
      src/node_file.cc
  6. 3
      src/node_http2.cc
  7. 12
      src/node_serdes.cc
  8. 8
      src/node_stat_watcher.cc
  9. 6
      src/node_zlib.cc
  10. 13
      src/pipe_wrap.cc
  11. 7
      src/process_wrap.cc
  12. 8
      src/signal_wrap.cc
  13. 14
      src/stream_wrap.cc
  14. 14
      src/tcp_wrap.cc
  15. 7
      src/timer_wrap.cc
  16. 9
      src/tls_wrap.cc
  17. 7
      src/tty_wrap.cc
  18. 13
      src/udp_wrap.cc

32
src/cares_wrap.cc
View File

@ -2190,28 +2190,28 @@ void Initialize(Local<Object> target,
FunctionTemplate::New(env->isolate(), is_construct_call_callback); FunctionTemplate::New(env->isolate(), is_construct_call_callback);
aiw->InstanceTemplate()->SetInternalFieldCount(1); aiw->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(aiw, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(aiw, "getAsyncId", AsyncWrap::GetAsyncId);
aiw->SetClassName( Local<String> addrInfoWrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "GetAddrInfoReqWrap")); FIXED_ONE_BYTE_STRING(env->isolate(), "GetAddrInfoReqWrap");
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "GetAddrInfoReqWrap"), aiw->SetClassName(addrInfoWrapString);
aiw->GetFunction()); target->Set(addrInfoWrapString, aiw->GetFunction());
Local<FunctionTemplate> niw = Local<FunctionTemplate> niw =
FunctionTemplate::New(env->isolate(), is_construct_call_callback); FunctionTemplate::New(env->isolate(), is_construct_call_callback);
niw->InstanceTemplate()->SetInternalFieldCount(1); niw->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(niw, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(niw, "getAsyncId", AsyncWrap::GetAsyncId);
niw->SetClassName( Local<String> nameInfoWrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "GetNameInfoReqWrap")); FIXED_ONE_BYTE_STRING(env->isolate(), "GetNameInfoReqWrap");
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "GetNameInfoReqWrap"), niw->SetClassName(nameInfoWrapString);
niw->GetFunction()); target->Set(nameInfoWrapString, niw->GetFunction());
Local<FunctionTemplate> qrw = Local<FunctionTemplate> qrw =
FunctionTemplate::New(env->isolate(), is_construct_call_callback); FunctionTemplate::New(env->isolate(), is_construct_call_callback);
qrw->InstanceTemplate()->SetInternalFieldCount(1); qrw->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(qrw, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(qrw, "getAsyncId", AsyncWrap::GetAsyncId);
qrw->SetClassName( Local<String> queryWrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "QueryReqWrap")); FIXED_ONE_BYTE_STRING(env->isolate(), "QueryReqWrap");
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "QueryReqWrap"), qrw->SetClassName(queryWrapString);
qrw->GetFunction()); target->Set(queryWrapString, qrw->GetFunction());
Local<FunctionTemplate> channel_wrap = Local<FunctionTemplate> channel_wrap =
env->NewFunctionTemplate(ChannelWrap::New); env->NewFunctionTemplate(ChannelWrap::New);
@ -2235,10 +2235,10 @@ void Initialize(Local<Object> target,
env->SetProtoMethod(channel_wrap, "setServers", SetServers); env->SetProtoMethod(channel_wrap, "setServers", SetServers);
env->SetProtoMethod(channel_wrap, "cancel", Cancel); env->SetProtoMethod(channel_wrap, "cancel", Cancel);
channel_wrap->SetClassName( Local<String> channelWrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap")); FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap");
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ChannelWrap"), channel_wrap->SetClassName(channelWrapString);
channel_wrap->GetFunction()); target->Set(channelWrapString, channel_wrap->GetFunction());
} }
} // anonymous namespace } // anonymous namespace

8
src/js_stream.cc
View File

@ -18,6 +18,7 @@ using v8::HandleScope;
using v8::Local; using v8::Local;
using v8::MaybeLocal; using v8::MaybeLocal;
using v8::Object; using v8::Object;
using v8::String;
using v8::Value; using v8::Value;
@ -212,7 +213,9 @@ void JSStream::Initialize(Local<Object> target,
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> t = env->NewFunctionTemplate(New); Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "JSStream")); Local<String> jsStreamString =
FIXED_ONE_BYTE_STRING(env->isolate(), "JSStream");
t->SetClassName(jsStreamString);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId);
@ -226,8 +229,7 @@ void JSStream::Initialize(Local<Object> target,
env->SetProtoMethod(t, "emitEOF", EmitEOF); env->SetProtoMethod(t, "emitEOF", EmitEOF);
StreamBase::AddMethods<JSStream>(env, t, StreamBase::kFlagHasWritev); StreamBase::AddMethods<JSStream>(env, t, StreamBase::kFlagHasWritev);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "JSStream"), target->Set(jsStreamString, t->GetFunction());
t->GetFunction());
env->set_jsstream_constructor_template(t); env->set_jsstream_constructor_template(t);
} }

2
src/node_config.cc
View File

@ -105,7 +105,7 @@ static void InitConfig(Local<Object> target,
debugOptions->DefineOwnProperty( debugOptions->DefineOwnProperty(
context, context,
FIXED_ONE_BYTE_STRING(isolate, "port"), env->port_string(),
Integer::New(isolate, debug_options.port()), Integer::New(isolate, debug_options.port()),
ReadOnly).FromJust(); ReadOnly).FromJust();

7
src/node_crypto.cc
View File

@ -312,7 +312,9 @@ bool EntropySource(unsigned char* buffer, size_t length) {
void SecureContext::Initialize(Environment* env, Local<Object> target) { void SecureContext::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(SecureContext::New); Local<FunctionTemplate> t = env->NewFunctionTemplate(SecureContext::New);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext")); Local<String> secureContextString =
FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext");
t->SetClassName(secureContextString);
env->SetProtoMethod(t, "init", SecureContext::Init); env->SetProtoMethod(t, "init", SecureContext::Init);
env->SetProtoMethod(t, "setKey", SecureContext::SetKey); env->SetProtoMethod(t, "setKey", SecureContext::SetKey);
@ -359,8 +361,7 @@ void SecureContext::Initialize(Environment* env, Local<Object> target) {
static_cast<PropertyAttribute>(ReadOnly | DontDelete), static_cast<PropertyAttribute>(ReadOnly | DontDelete),
AccessorSignature::New(env->isolate(), t)); AccessorSignature::New(env->isolate(), t));
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"), target->Set(secureContextString, t->GetFunction());
t->GetFunction());
env->set_secure_context_constructor_template(t); env->set_secure_context_constructor_template(t);
} }

7
src/node_file.cc
View File

@ -1484,9 +1484,10 @@ void InitFs(Local<Object> target,
FunctionTemplate::New(env->isolate(), NewFSReqWrap); FunctionTemplate::New(env->isolate(), NewFSReqWrap);
fst->InstanceTemplate()->SetInternalFieldCount(1); fst->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(fst, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(fst, "getAsyncId", AsyncWrap::GetAsyncId);
fst->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "FSReqWrap")); Local<String> wrapString =
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "FSReqWrap"), FIXED_ONE_BYTE_STRING(env->isolate(), "FSReqWrap");
fst->GetFunction()); fst->SetClassName(wrapString);
target->Set(wrapString, fst->GetFunction());
} }
} // end namespace node } // end namespace node

3
src/node_http2.cc
View File

@ -1206,8 +1206,7 @@ void Initialize(Local<Object> target,
env->SetMethod(target, "nghttp2ErrorString", HttpErrorString); env->SetMethod(target, "nghttp2ErrorString", HttpErrorString);
Local<String> http2SessionClassName = Local<String> http2SessionClassName =
String::NewFromUtf8(isolate, "Http2Session", FIXED_ONE_BYTE_STRING(isolate, "Http2Session");
v8::NewStringType::kInternalized).ToLocalChecked();
Local<FunctionTemplate> session = Local<FunctionTemplate> session =
env->NewFunctionTemplate(Http2Session::New); env->NewFunctionTemplate(Http2Session::New);

12
src/node_serdes.cc
View File

@ -451,9 +451,11 @@ void InitializeSerdesBindings(Local<Object> target,
"_setTreatArrayBufferViewsAsHostObjects", "_setTreatArrayBufferViewsAsHostObjects",
SerializerContext::SetTreatArrayBufferViewsAsHostObjects); SerializerContext::SetTreatArrayBufferViewsAsHostObjects);
ser->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Serializer")); Local<String> serializerString =
FIXED_ONE_BYTE_STRING(env->isolate(), "Serializer");
ser->SetClassName(serializerString);
target->Set(env->context(), target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "Serializer"), serializerString,
ser->GetFunction(env->context()).ToLocalChecked()).FromJust(); ser->GetFunction(env->context()).ToLocalChecked()).FromJust();
Local<FunctionTemplate> des = Local<FunctionTemplate> des =
@ -474,9 +476,11 @@ void InitializeSerdesBindings(Local<Object> target,
env->SetProtoMethod(des, "readDouble", DeserializerContext::ReadDouble); env->SetProtoMethod(des, "readDouble", DeserializerContext::ReadDouble);
env->SetProtoMethod(des, "_readRawBytes", DeserializerContext::ReadRawBytes); env->SetProtoMethod(des, "_readRawBytes", DeserializerContext::ReadRawBytes);
des->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Deserializer")); Local<String> deserializerString =
FIXED_ONE_BYTE_STRING(env->isolate(), "Deserializer");
des->SetClassName(deserializerString);
target->Set(env->context(), target->Set(env->context(),
FIXED_ONE_BYTE_STRING(env->isolate(), "Deserializer"), deserializerString,
des->GetFunction(env->context()).ToLocalChecked()).FromJust(); des->GetFunction(env->context()).ToLocalChecked()).FromJust();
} }

8
src/node_stat_watcher.cc
View File

@ -39,6 +39,7 @@ using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::String;
using v8::Value; using v8::Value;
@ -47,14 +48,15 @@ void StatWatcher::Initialize(Environment* env, Local<Object> target) {
Local<FunctionTemplate> t = env->NewFunctionTemplate(StatWatcher::New); Local<FunctionTemplate> t = env->NewFunctionTemplate(StatWatcher::New);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher")); Local<String> statWatcherString =
FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher");
t->SetClassName(statWatcherString);
env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId);
env->SetProtoMethod(t, "start", StatWatcher::Start); env->SetProtoMethod(t, "start", StatWatcher::Start);
env->SetProtoMethod(t, "stop", StatWatcher::Stop); env->SetProtoMethod(t, "stop", StatWatcher::Stop);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher"), target->Set(statWatcherString, t->GetFunction());
t->GetFunction());
} }

6
src/node_zlib.cc
View File

@ -50,6 +50,7 @@ using v8::Local;
using v8::Number; using v8::Number;
using v8::Object; using v8::Object;
using v8::Persistent; using v8::Persistent;
using v8::String;
using v8::Uint32Array; using v8::Uint32Array;
using v8::Value; using v8::Value;
@ -693,8 +694,9 @@ void InitZlib(Local<Object> target,
env->SetProtoMethod(z, "params", ZCtx::Params); env->SetProtoMethod(z, "params", ZCtx::Params);
env->SetProtoMethod(z, "reset", ZCtx::Reset); env->SetProtoMethod(z, "reset", ZCtx::Reset);
z->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Zlib")); Local<String> zlibString = FIXED_ONE_BYTE_STRING(env->isolate(), "Zlib");
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Zlib"), z->GetFunction()); z->SetClassName(zlibString);
target->Set(zlibString, z->GetFunction());
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ZLIB_VERSION"), target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ZLIB_VERSION"),
FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION)); FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION));

13
src/pipe_wrap.cc
View File

@ -44,6 +44,7 @@ using v8::FunctionTemplate;
using v8::HandleScope; using v8::HandleScope;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::String;
using v8::Value; using v8::Value;
using AsyncHooks = Environment::AsyncHooks; using AsyncHooks = Environment::AsyncHooks;
@ -67,7 +68,8 @@ void PipeWrap::Initialize(Local<Object> target,
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> t = env->NewFunctionTemplate(New); Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Pipe")); Local<String> pipeString = FIXED_ONE_BYTE_STRING(env->isolate(), "Pipe");
t->SetClassName(pipeString);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId);
@ -92,7 +94,7 @@ void PipeWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "setPendingInstances", SetPendingInstances); env->SetProtoMethod(t, "setPendingInstances", SetPendingInstances);
#endif #endif
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Pipe"), t->GetFunction()); target->Set(pipeString, t->GetFunction());
env->set_pipe_constructor_template(t); env->set_pipe_constructor_template(t);
// Create FunctionTemplate for PipeConnectWrap. // Create FunctionTemplate for PipeConnectWrap.
@ -103,9 +105,10 @@ void PipeWrap::Initialize(Local<Object> target,
auto cwt = FunctionTemplate::New(env->isolate(), constructor); auto cwt = FunctionTemplate::New(env->isolate(), constructor);
cwt->InstanceTemplate()->SetInternalFieldCount(1); cwt->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(cwt, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(cwt, "getAsyncId", AsyncWrap::GetAsyncId);
cwt->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "PipeConnectWrap")); Local<String> wrapString =
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "PipeConnectWrap"), FIXED_ONE_BYTE_STRING(env->isolate(), "PipeConnectWrap");
cwt->GetFunction()); cwt->SetClassName(wrapString);
target->Set(wrapString, cwt->GetFunction());
} }

7
src/process_wrap.cc
View File

@ -53,7 +53,9 @@ class ProcessWrap : public HandleWrap {
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New); Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
constructor->InstanceTemplate()->SetInternalFieldCount(1); constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Process")); Local<String> processString =
FIXED_ONE_BYTE_STRING(env->isolate(), "Process");
constructor->SetClassName(processString);
env->SetProtoMethod(constructor, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(constructor, "getAsyncId", AsyncWrap::GetAsyncId);
@ -66,8 +68,7 @@ class ProcessWrap : public HandleWrap {
env->SetProtoMethod(constructor, "unref", HandleWrap::Unref); env->SetProtoMethod(constructor, "unref", HandleWrap::Unref);
env->SetProtoMethod(constructor, "hasRef", HandleWrap::HasRef); env->SetProtoMethod(constructor, "hasRef", HandleWrap::HasRef);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Process"), target->Set(processString, constructor->GetFunction());
constructor->GetFunction());
} }
size_t self_size() const override { return sizeof(*this); } size_t self_size() const override { return sizeof(*this); }

8
src/signal_wrap.cc
View File

@ -37,6 +37,7 @@ using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::String;
using v8::Value; using v8::Value;
namespace { namespace {
@ -49,7 +50,9 @@ class SignalWrap : public HandleWrap {
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New); Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
constructor->InstanceTemplate()->SetInternalFieldCount(1); constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Signal")); Local<String> signalString =
FIXED_ONE_BYTE_STRING(env->isolate(), "Signal");
constructor->SetClassName(signalString);
env->SetProtoMethod(constructor, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(constructor, "getAsyncId", AsyncWrap::GetAsyncId);
env->SetProtoMethod(constructor, "close", HandleWrap::Close); env->SetProtoMethod(constructor, "close", HandleWrap::Close);
@ -59,8 +62,7 @@ class SignalWrap : public HandleWrap {
env->SetProtoMethod(constructor, "start", Start); env->SetProtoMethod(constructor, "start", Start);
env->SetProtoMethod(constructor, "stop", Stop); env->SetProtoMethod(constructor, "stop", Stop);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Signal"), target->Set(signalString, constructor->GetFunction());
constructor->GetFunction());
} }
size_t self_size() const override { return sizeof(*this); } size_t self_size() const override { return sizeof(*this); }

14
src/stream_wrap.cc
View File

@ -67,18 +67,20 @@ void StreamWrap::Initialize(Local<Object> target,
Local<FunctionTemplate> sw = Local<FunctionTemplate> sw =
FunctionTemplate::New(env->isolate(), is_construct_call_callback); FunctionTemplate::New(env->isolate(), is_construct_call_callback);
sw->InstanceTemplate()->SetInternalFieldCount(1); sw->InstanceTemplate()->SetInternalFieldCount(1);
sw->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "ShutdownWrap")); Local<String> wrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "ShutdownWrap");
sw->SetClassName(wrapString);
env->SetProtoMethod(sw, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(sw, "getAsyncId", AsyncWrap::GetAsyncId);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "ShutdownWrap"), target->Set(wrapString, sw->GetFunction());
sw->GetFunction());
Local<FunctionTemplate> ww = Local<FunctionTemplate> ww =
FunctionTemplate::New(env->isolate(), is_construct_call_callback); FunctionTemplate::New(env->isolate(), is_construct_call_callback);
ww->InstanceTemplate()->SetInternalFieldCount(1); ww->InstanceTemplate()->SetInternalFieldCount(1);
ww->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "WriteWrap")); Local<String> writeWrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "WriteWrap");
ww->SetClassName(writeWrapString);
env->SetProtoMethod(ww, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(ww, "getAsyncId", AsyncWrap::GetAsyncId);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "WriteWrap"), target->Set(writeWrapString, ww->GetFunction());
ww->GetFunction());
env->set_write_wrap_constructor_function(ww->GetFunction()); env->set_write_wrap_constructor_function(ww->GetFunction());
} }

14
src/tcp_wrap.cc
View File

@ -71,11 +71,12 @@ void TCPWrap::Initialize(Local<Object> target,
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> t = env->NewFunctionTemplate(New); Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TCP")); Local<String> tcpString = FIXED_ONE_BYTE_STRING(env->isolate(), "TCP");
t->SetClassName(tcpString);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
// Init properties // Init properties
t->InstanceTemplate()->Set(String::NewFromUtf8(env->isolate(), "reading"), t->InstanceTemplate()->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "reading"),
Boolean::New(env->isolate(), false)); Boolean::New(env->isolate(), false));
t->InstanceTemplate()->Set(env->owner_string(), Null(env->isolate())); t->InstanceTemplate()->Set(env->owner_string(), Null(env->isolate()));
t->InstanceTemplate()->Set(env->onread_string(), Null(env->isolate())); t->InstanceTemplate()->Set(env->onread_string(), Null(env->isolate()));
@ -109,7 +110,7 @@ void TCPWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "setSimultaneousAccepts", SetSimultaneousAccepts); env->SetProtoMethod(t, "setSimultaneousAccepts", SetSimultaneousAccepts);
#endif #endif
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "TCP"), t->GetFunction()); target->Set(tcpString, t->GetFunction());
env->set_tcp_constructor_template(t); env->set_tcp_constructor_template(t);
// Create FunctionTemplate for TCPConnectWrap. // Create FunctionTemplate for TCPConnectWrap.
@ -120,9 +121,10 @@ void TCPWrap::Initialize(Local<Object> target,
auto cwt = FunctionTemplate::New(env->isolate(), constructor); auto cwt = FunctionTemplate::New(env->isolate(), constructor);
cwt->InstanceTemplate()->SetInternalFieldCount(1); cwt->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(cwt, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(cwt, "getAsyncId", AsyncWrap::GetAsyncId);
cwt->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TCPConnectWrap")); Local<String> wrapString =
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "TCPConnectWrap"), FIXED_ONE_BYTE_STRING(env->isolate(), "TCPConnectWrap");
cwt->GetFunction()); cwt->SetClassName(wrapString);
target->Set(wrapString, cwt->GetFunction());
} }

7
src/timer_wrap.cc
View File

@ -39,6 +39,7 @@ using v8::HandleScope;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::String;
using v8::Value; using v8::Value;
const uint32_t kOnTimeout = 0; const uint32_t kOnTimeout = 0;
@ -50,8 +51,9 @@ class TimerWrap : public HandleWrap {
Local<Context> context) { Local<Context> context) {
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New); Local<FunctionTemplate> constructor = env->NewFunctionTemplate(New);
Local<String> timerString = FIXED_ONE_BYTE_STRING(env->isolate(), "Timer");
constructor->InstanceTemplate()->SetInternalFieldCount(1); constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Timer")); constructor->SetClassName(timerString);
constructor->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnTimeout"), constructor->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnTimeout"),
Integer::New(env->isolate(), kOnTimeout)); Integer::New(env->isolate(), kOnTimeout));
@ -67,8 +69,7 @@ class TimerWrap : public HandleWrap {
env->SetProtoMethod(constructor, "start", Start); env->SetProtoMethod(constructor, "start", Start);
env->SetProtoMethod(constructor, "stop", Stop); env->SetProtoMethod(constructor, "stop", Stop);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Timer"), target->Set(timerString, constructor->GetFunction());
constructor->GetFunction());
} }
size_t self_size() const override { return sizeof(*this); } size_t self_size() const override { return sizeof(*this); }

9
src/tls_wrap.cc
View File

@ -938,9 +938,13 @@ void TLSWrap::Initialize(Local<Object> target,
CHECK(args.IsConstructCall()); CHECK(args.IsConstructCall());
args.This()->SetAlignedPointerInInternalField(0, nullptr); args.This()->SetAlignedPointerInInternalField(0, nullptr);
}; };
Local<String> tlsWrapString =
FIXED_ONE_BYTE_STRING(env->isolate(), "TLSWrap");
auto t = env->NewFunctionTemplate(constructor); auto t = env->NewFunctionTemplate(constructor);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TLSWrap")); t->SetClassName(tlsWrapString);
env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId);
env->SetProtoMethod(t, "asyncReset", AsyncWrap::AsyncReset); env->SetProtoMethod(t, "asyncReset", AsyncWrap::AsyncReset);
@ -962,8 +966,7 @@ void TLSWrap::Initialize(Local<Object> target,
env->set_tls_wrap_constructor_template(t); env->set_tls_wrap_constructor_template(t);
env->set_tls_wrap_constructor_function(t->GetFunction()); env->set_tls_wrap_constructor_function(t->GetFunction());
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "TLSWrap"), target->Set(tlsWrapString, t->GetFunction());
t->GetFunction());
} }
} // namespace node } // namespace node

7
src/tty_wrap.cc
View File

@ -41,6 +41,7 @@ using v8::FunctionTemplate;
using v8::Integer; using v8::Integer;
using v8::Local; using v8::Local;
using v8::Object; using v8::Object;
using v8::String;
using v8::Value; using v8::Value;
@ -49,8 +50,10 @@ void TTYWrap::Initialize(Local<Object> target,
Local<Context> context) { Local<Context> context) {
Environment* env = Environment::GetCurrent(context); Environment* env = Environment::GetCurrent(context);
Local<String> ttyString = FIXED_ONE_BYTE_STRING(env->isolate(), "TTY");
Local<FunctionTemplate> t = env->NewFunctionTemplate(New); Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TTY")); t->SetClassName(ttyString);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId);
@ -68,7 +71,7 @@ void TTYWrap::Initialize(Local<Object> target,
env->SetMethod(target, "isTTY", IsTTY); env->SetMethod(target, "isTTY", IsTTY);
env->SetMethod(target, "guessHandleType", GuessHandleType); env->SetMethod(target, "guessHandleType", GuessHandleType);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "TTY"), t->GetFunction()); target->Set(ttyString, t->GetFunction());
env->set_tty_constructor_template(t); env->set_tty_constructor_template(t);
} }

13
src/udp_wrap.cc
View File

@ -106,7 +106,9 @@ void UDPWrap::Initialize(Local<Object> target,
Local<FunctionTemplate> t = env->NewFunctionTemplate(New); Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
t->InstanceTemplate()->SetInternalFieldCount(1); t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "UDP")); Local<String> udpString =
FIXED_ONE_BYTE_STRING(env->isolate(), "UDP");
t->SetClassName(udpString);
enum PropertyAttribute attributes = enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete); static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
@ -139,7 +141,7 @@ void UDPWrap::Initialize(Local<Object> target,
env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(t, "getAsyncId", AsyncWrap::GetAsyncId);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "UDP"), t->GetFunction()); target->Set(udpString, t->GetFunction());
env->set_udp_constructor_function(t->GetFunction()); env->set_udp_constructor_function(t->GetFunction());
// Create FunctionTemplate for SendWrap // Create FunctionTemplate for SendWrap
@ -147,9 +149,10 @@ void UDPWrap::Initialize(Local<Object> target,
FunctionTemplate::New(env->isolate(), NewSendWrap); FunctionTemplate::New(env->isolate(), NewSendWrap);
swt->InstanceTemplate()->SetInternalFieldCount(1); swt->InstanceTemplate()->SetInternalFieldCount(1);
env->SetProtoMethod(swt, "getAsyncId", AsyncWrap::GetAsyncId); env->SetProtoMethod(swt, "getAsyncId", AsyncWrap::GetAsyncId);
swt->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SendWrap")); Local<String> sendWrapString =
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "SendWrap"), FIXED_ONE_BYTE_STRING(env->isolate(), "SendWrap");
swt->GetFunction()); swt->SetClassName(sendWrapString);
target->Set(sendWrapString, swt->GetFunction());
} }

Write Preview
Loading…
Cancel
Save