using v8::Array;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::Handle;
static Local<Array> HostentToAddresses(Environment* env, struct hostent* host) {
- HandleScope scope(env->isolate());
- Local<Array> addresses = Array::New();
+ EscapableHandleScope scope(env->isolate());
+ Local<Array> addresses = Array::New(env->isolate());
char ip[INET6_ADDRSTRLEN];
for (uint32_t i = 0; host->h_addr_list[i] != NULL; ++i) {
addresses->Set(i, address);
}
- return scope.Close(addresses);
+ return scope.Escape(addresses);
}
static Local<Array> HostentToNames(Environment* env, struct hostent* host) {
- HandleScope scope(env->isolate());
- Local<Array> names = Array::New();
+ EscapableHandleScope scope(env->isolate());
+ Local<Array> names = Array::New(env->isolate());
for (uint32_t i = 0; host->h_aliases[i] != NULL; ++i) {
Local<String> address = OneByteString(env->isolate(), host->h_aliases[i]);
names->Set(i, address);
}
- return scope.Close(names);
+ return scope.Escape(names);
}
virtual ~QueryWrap() {
assert(!persistent().IsEmpty());
- persistent().Dispose();
+ persistent().Reset();
}
// Subclasses should implement the appropriate Send method.
HandleScope handle_scope(env()->isolate());
Context::Scope context_scope(env()->context());
Local<Value> argv[] = {
- Integer::New(0, env()->isolate()),
+ Integer::New(env()->isolate(), 0),
answer
};
MakeCallback(env()->oncomplete_string(), ARRAY_SIZE(argv), argv);
HandleScope handle_scope(env()->isolate());
Context::Scope context_scope(env()->context());
Local<Value> argv[] = {
- Integer::New(0, env()->isolate()),
+ Integer::New(env()->isolate(), 0),
answer,
family
};
// A cname lookup always returns a single record but we follow the
// common API here.
- Local<Array> result = Array::New(1);
+ Local<Array> result = Array::New(env()->isolate(), 1);
result->Set(0, OneByteString(env()->isolate(), host->h_name));
ares_free_hostent(host);
return;
}
- Local<Array> mx_records = Array::New();
+ Local<Array> mx_records = Array::New(env()->isolate());
Local<String> exchange_symbol = env()->exchange_string();
Local<String> priority_symbol = env()->priority_string();
ares_mx_reply* current = mx_start;
for (uint32_t i = 0; current != NULL; ++i, current = current->next) {
- Local<Object> mx_record = Object::New();
+ Local<Object> mx_record = Object::New(env()->isolate());
mx_record->Set(exchange_symbol,
OneByteString(env()->isolate(), current->host));
mx_record->Set(priority_symbol,
- Integer::New(current->priority, env()->isolate()));
+ Integer::New(env()->isolate(), current->priority));
mx_records->Set(i, mx_record);
}
return;
}
- Local<Array> txt_records = Array::New();
+ Local<Array> txt_records = Array::New(env()->isolate());
ares_txt_reply* current = txt_out;
for (uint32_t i = 0; current != NULL; ++i, current = current->next) {
return;
}
- Local<Array> srv_records = Array::New();
+ Local<Array> srv_records = Array::New(env()->isolate());
Local<String> name_symbol = env()->name_string();
Local<String> port_symbol = env()->port_string();
Local<String> priority_symbol = env()->priority_string();
ares_srv_reply* current = srv_start;
for (uint32_t i = 0; current != NULL; ++i, current = current->next) {
- Local<Object> srv_record = Object::New();
+ Local<Object> srv_record = Object::New(env()->isolate());
srv_record->Set(name_symbol,
OneByteString(env()->isolate(), current->host));
srv_record->Set(port_symbol,
- Integer::New(current->port, env()->isolate()));
+ Integer::New(env()->isolate(), current->port));
srv_record->Set(priority_symbol,
- Integer::New(current->priority, env()->isolate()));
+ Integer::New(env()->isolate(), current->priority));
srv_record->Set(weight_symbol,
- Integer::New(current->weight, env()->isolate()));
+ Integer::New(env()->isolate(), current->weight));
srv_records->Set(i, srv_record);
}
return;
}
- Local<Array> naptr_records = Array::New();
+ Local<Array> naptr_records = Array::New(env()->isolate());
Local<String> flags_symbol = env()->flags_string();
Local<String> service_symbol = env()->service_string();
Local<String> regexp_symbol = env()->regexp_string();
ares_naptr_reply* current = naptr_start;
for (uint32_t i = 0; current != NULL; ++i, current = current->next) {
- Local<Object> naptr_record = Object::New();
+ Local<Object> naptr_record = Object::New(env()->isolate());
naptr_record->Set(flags_symbol,
OneByteString(env()->isolate(), current->flags));
naptr_record->Set(service_symbol,
naptr_record->Set(replacement_symbol,
OneByteString(env()->isolate(), current->replacement));
naptr_record->Set(order_symbol,
- Integer::New(current->order, env()->isolate()));
+ Integer::New(env()->isolate(), current->order));
naptr_record->Set(preference_symbol,
- Integer::New(current->preference, env()->isolate()));
+ Integer::New(env()->isolate(), current->preference));
naptr_records->Set(i, naptr_record);
}
return;
}
- Local<Object> soa_record = Object::New();
+ Local<Object> soa_record = Object::New(env()->isolate());
soa_record->Set(env()->nsname_string(),
OneByteString(env()->isolate(), soa_out->nsname));
soa_record->Set(env()->hostmaster_string(),
OneByteString(env()->isolate(), soa_out->hostmaster));
soa_record->Set(env()->serial_string(),
- Integer::New(soa_out->serial, env()->isolate()));
+ Integer::New(env()->isolate(), soa_out->serial));
soa_record->Set(env()->refresh_string(),
- Integer::New(soa_out->refresh, env()->isolate()));
+ Integer::New(env()->isolate(), soa_out->refresh));
soa_record->Set(env()->retry_string(),
- Integer::New(soa_out->retry, env()->isolate()));
+ Integer::New(env()->isolate(), soa_out->retry));
soa_record->Set(env()->expire_string(),
- Integer::New(soa_out->expire, env()->isolate()));
+ Integer::New(env()->isolate(), soa_out->expire));
soa_record->Set(env()->minttl_string(),
- Integer::New(soa_out->minttl, env()->isolate()));
+ Integer::New(env()->isolate(), soa_out->minttl));
ares_free_data(soa_out);
HandleScope scope(env()->isolate());
Local<Array> addresses = HostentToAddresses(env(), host);
- Local<Integer> family = Integer::New(host->h_addrtype, env()->isolate());
+ Local<Integer> family = Integer::New(env()->isolate(), host->h_addrtype);
this->CallOnComplete(addresses, family);
}
Context::Scope context_scope(env->context());
Local<Value> argv[] = {
- Integer::New(status, env->isolate()),
+ Integer::New(env->isolate(), status),
Null(env->isolate())
};
}
// Create the response array.
- Local<Array> results = Array::New(n);
+ Local<Array> results = Array::New(env->isolate(), n);
char ip[INET6_ADDRSTRLEN];
const char *addr;
Environment* env = Environment::GetCurrent(args.GetIsolate());
HandleScope scope(env->isolate());
- String::AsciiValue ip(args[0]);
+ String::Utf8Value ip(args[0]);
char address_buffer[sizeof(struct in6_addr)];
int rc = 0;
HandleScope handle_scope(args.GetIsolate());
Environment* env = Environment::GetCurrent(args.GetIsolate());
- Local<Array> server_array = Array::New();
+ Local<Array> server_array = Array::New(env->isolate());
ares_addr_node* servers;
NODE_SET_METHOD(target, "setServers", SetServers);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "AF_INET"),
- Integer::New(AF_INET, env->isolate()));
+ Integer::New(env->isolate(), AF_INET));
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "AF_INET6"),
- Integer::New(AF_INET6, env->isolate()));
+ Integer::New(env->isolate(), AF_INET6));
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "AF_UNSPEC"),
- Integer::New(AF_UNSPEC, env->isolate()));
+ Integer::New(env->isolate(), AF_UNSPEC));
}
} // namespace cares_wrap
inline Environment::IsolateData* Environment::IsolateData::Get(
v8::Isolate* isolate) {
- return static_cast<IsolateData*>(isolate->GetData());
+ return static_cast<IsolateData*>(isolate->GetData(kIsolateSlot));
}
inline Environment::IsolateData* Environment::IsolateData::GetOrCreate(
IsolateData* isolate_data = Get(isolate);
if (isolate_data == NULL) {
isolate_data = new IsolateData(isolate);
- isolate->SetData(isolate_data);
+ isolate->SetData(kIsolateSlot, isolate_data);
}
isolate_data->ref_count_ += 1;
return isolate_data;
inline void Environment::IsolateData::Put() {
if (--ref_count_ == 0) {
- isolate()->SetData(NULL);
+ isolate()->SetData(kIsolateSlot, NULL);
delete this;
}
}
// We'll be creating new objects so make sure we've entered the context.
v8::HandleScope handle_scope(isolate());
v8::Context::Scope context_scope(context);
- set_binding_cache_object(v8::Object::New());
- set_module_load_list_array(v8::Array::New());
+ set_binding_cache_object(v8::Object::New(isolate()));
+ set_module_load_list_array(v8::Array::New(isolate()));
RB_INIT(&cares_task_list_);
QUEUE_INIT(&gc_tracker_queue_);
}
v8::HandleScope handle_scope(isolate());
context()->SetAlignedPointerInEmbedderData(kContextEmbedderDataIndex, NULL);
-#define V(PropertyName, TypeName) PropertyName ## _.Dispose();
+#define V(PropertyName, TypeName) PropertyName ## _.Reset();
ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
#undef V
isolate_data()->Put();
#define THROW_ERROR(fun) \
do { \
v8::HandleScope scope(isolate); \
- v8::ThrowException(fun(OneByteString(isolate, errmsg))); \
+ isolate->ThrowException(fun(OneByteString(isolate, errmsg))); \
} \
while (0)
const char* syscall,
const char* message,
const char* path) {
- v8::ThrowException(
+ isolate()->ThrowException(
ErrnoException(isolate(), errorno, syscall, message, path));
}
const char* syscall,
const char* message,
const char* path) {
- v8::ThrowException(
+ isolate()->ThrowException(
UVException(isolate(), errorno, syscall, message, path));
}
#undef V
private:
+ static const int kIsolateSlot = 0;
+
class GCInfo;
class IsolateData;
inline explicit Environment(v8::Local<v8::Context> context);
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(env->fsevent_string());
}
Local<Value> argv[] = {
- Integer::New(status, env->isolate()),
+ Integer::New(env->isolate(), status),
event_string,
Null(env->isolate())
};
}
object->SetAlignedPointerInInternalField(0, NULL);
- wrap->persistent().Dispose();
+ wrap->persistent().Reset();
delete wrap;
}
using v8::ArrayBuffer;
using v8::Boolean;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Exception;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::ObjectTemplate;
using v8::PropertyCallbackInfo;
using v8::String;
-using v8::ThrowException;
using v8::TryCatch;
using v8::Uint32;
using v8::V8;
}
Local<Object> obj = e->ToObject();
- obj->Set(env->errno_string(), Integer::New(errorno, env->isolate()));
+ obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));
obj->Set(env->code_string(), estring);
if (path != NULL) {
Local<Object> obj = e->ToObject();
// TODO(piscisaureus) errno should probably go
- obj->Set(env->errno_string(), Integer::New(errorno, env->isolate()));
+ obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));
obj->Set(env->code_string(), estring);
if (path != NULL) {
}
Local<Object> obj = e->ToObject();
- obj->Set(env->errno_string(), Integer::New(errorno, isolate));
+ obj->Set(env->errno_string(), Integer::New(isolate, errorno));
if (path != NULL) {
obj->Set(env->path_string(), String::NewFromUtf8(isolate, path));
const char* method,
int argc,
Handle<Value> argv[]) {
- HandleScope handle_scope(isolate);
+ EscapableHandleScope handle_scope(isolate);
Local<Context> context = recv->CreationContext();
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
- return handle_scope.Close(MakeCallback(env, recv, method, argc, argv));
+ return handle_scope.Escape(
+ Local<Value>::New(isolate, MakeCallback(env, recv, method, argc, argv)));
}
Handle<String> symbol,
int argc,
Handle<Value> argv[]) {
- HandleScope handle_scope(isolate);
+ EscapableHandleScope handle_scope(isolate);
Local<Context> context = recv->CreationContext();
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
- return handle_scope.Close(MakeCallback(env, recv, symbol, argc, argv));
+ return handle_scope.Escape(
+ Local<Value>::New(isolate, MakeCallback(env, recv, symbol, argc, argv)));
}
Handle<Function> callback,
int argc,
Handle<Value> argv[]) {
- HandleScope handle_scope(isolate);
+ EscapableHandleScope handle_scope(isolate);
Local<Context> context = recv->CreationContext();
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
- return handle_scope.Close(
- MakeCallback(env, recv.As<Value>(), callback, argc, argv));
+ return handle_scope.Escape(Local<Value>::New(
+ isolate,
+ MakeCallback(env, recv.As<Value>(), callback, argc, argv)));
}
Local<Context> context = recv->CreationContext();
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
- HandleScope handle_scope(env->isolate());
- return handle_scope.Close(
- MakeDomainCallback(env, recv, callback, argc, argv));
+ EscapableHandleScope handle_scope(env->isolate());
+ return handle_scope.Escape(Local<Value>::New(
+ env->isolate(),
+ MakeDomainCallback(env, recv, callback, argc, argv)));
}
static Local<Value> ExecuteString(Environment* env,
Handle<String> source,
Handle<Value> filename) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
TryCatch try_catch;
// try_catch must be nonverbose to disable FatalException() handler,
exit(4);
}
- return scope.Close(result);
+ return scope.Escape(result);
}
static void GetActiveRequests(const FunctionCallbackInfo<Value>& args) {
HandleScope scope(args.GetIsolate());
- Local<Array> ary = Array::New();
+ Local<Array> ary = Array::New(args.GetIsolate());
QUEUE* q = NULL;
int i = 0;
Environment* env = Environment::GetCurrent(args.GetIsolate());
HandleScope scope(env->isolate());
- Local<Array> ary = Array::New();
+ Local<Array> ary = Array::New(env->isolate());
QUEUE* q = NULL;
int i = 0;
return env->ThrowErrnoException(errno, "getgroups");
}
- Local<Array> groups_list = Array::New(ngroups);
+ Local<Array> groups_list = Array::New(env->isolate(), ngroups);
bool seen_egid = false;
gid_t egid = getegid();
for (int i = 0; i < ngroups; i++) {
- groups_list->Set(i, Integer::New(groups[i], env->isolate()));
+ groups_list->Set(i, Integer::New(env->isolate(), groups[i]));
if (groups[i] == egid)
seen_egid = true;
}
delete[] groups;
if (seen_egid == false) {
- groups_list->Set(ngroups, Integer::New(egid, env->isolate()));
+ groups_list->Set(ngroups, Integer::New(env->isolate(), egid));
}
args.GetReturnValue().Set(groups_list);
env->isolate()->GetHeapStatistics(&v8_heap_stats);
Local<Integer> heap_total =
- Integer::NewFromUnsigned(v8_heap_stats.total_heap_size(), env->isolate());
+ Integer::NewFromUnsigned(env->isolate(), v8_heap_stats.total_heap_size());
Local<Integer> heap_used =
- Integer::NewFromUnsigned(v8_heap_stats.used_heap_size(), env->isolate());
+ Integer::NewFromUnsigned(env->isolate(), v8_heap_stats.used_heap_size());
- Local<Object> info = Object::New();
+ Local<Object> info = Object::New(env->isolate());
info->Set(env->rss_string(), Number::New(env->isolate(), rss));
info->Set(env->heap_total_string(), heap_total);
info->Set(env->heap_used_string(), heap_used);
t -= (seconds * NANOS_PER_SEC) + nanos;
}
- Local<Array> tuple = Array::New(2);
- tuple->Set(0, Integer::NewFromUnsigned(t / NANOS_PER_SEC, env->isolate()));
- tuple->Set(1, Integer::NewFromUnsigned(t % NANOS_PER_SEC, env->isolate()));
+ Local<Array> tuple = Array::New(env->isolate(), 2);
+ tuple->Set(0, Integer::NewFromUnsigned(env->isolate(), t / NANOS_PER_SEC));
+ tuple->Set(1, Integer::NewFromUnsigned(env->isolate(), t % NANOS_PER_SEC));
args.GetReturnValue().Set(tuple);
}
node_module* mod = get_builtin_module(*module_v);
if (mod != NULL) {
- exports = Object::New();
+ exports = Object::New(env->isolate());
// Internal bindings don't have a "module" object, only exports.
assert(mod->nm_register_func == NULL);
assert(mod->nm_context_register_func != NULL);
env->context(), mod->nm_priv);
cache->Set(module, exports);
} else if (!strcmp(*module_v, "constants")) {
- exports = Object::New();
+ exports = Object::New(env->isolate());
DefineConstants(exports);
cache->Set(module, exports);
} else if (!strcmp(*module_v, "natives")) {
- exports = Object::New();
+ exports = Object::New(env->isolate());
DefineJavaScript(env, exports);
cache->Set(module, exports);
} else {
while (environ[size])
size++;
- Local<Array> envarr = Array::New(size);
+ Local<Array> envarr = Array::New(env->isolate(), size);
for (int i = 0; i < size; ++i) {
const char* var = environ[i];
WCHAR* environment = GetEnvironmentStringsW();
if (environment == NULL)
return; // This should not happen.
- Local<Array> envarr = Array::New();
+ Local<Array> envarr = Array::New(env->isolate());
WCHAR* p = environment;
int i = 0;
while (*p != NULL) {
static Handle<Object> GetFeatures(Environment* env) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
- Local<Object> obj = Object::New();
+ Local<Object> obj = Object::New(env->isolate());
#if defined(DEBUG) && DEBUG
Local<Value> debug = True(env->isolate());
#else
obj->Set(env->tls_sni_string(), tls_sni);
obj->Set(env->tls_string(),
- Boolean::New(get_builtin_module("crypto") != NULL));
+ Boolean::New(env->isolate(), get_builtin_module("crypto") != NULL));
- return scope.Close(obj);
+ return scope.Escape(obj);
}
env->module_load_list_array());
// process.versions
- Local<Object> versions = Object::New();
+ Local<Object> versions = Object::New(env->isolate());
READONLY_PROPERTY(process, "versions", versions);
const char http_parser_version[] = NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR)
OneByteString(env->isolate(), PLATFORM));
// process.argv
- Local<Array> arguments = Array::New(argc);
+ Local<Array> arguments = Array::New(env->isolate(), argc);
for (int i = 0; i < argc; ++i) {
arguments->Set(i, String::NewFromUtf8(env->isolate(), argv[i]));
}
process->Set(env->argv_string(), arguments);
// process.execArgv
- Local<Array> exec_arguments = Array::New(exec_argc);
+ Local<Array> exec_arguments = Array::New(env->isolate(), exec_argc);
for (int i = 0; i < exec_argc; ++i) {
exec_arguments->Set(i, String::NewFromUtf8(env->isolate(), exec_argv[i]));
}
process->Set(env->exec_argv_string(), exec_arguments);
// create process.env
- Local<ObjectTemplate> process_env_template = ObjectTemplate::New();
+ Local<ObjectTemplate> process_env_template =
+ ObjectTemplate::New(env->isolate());
process_env_template->SetNamedPropertyHandler(EnvGetter,
EnvSetter,
EnvQuery,
EnvDeleter,
EnvEnumerator,
- Object::New());
+ Object::New(env->isolate()));
Local<Object> process_env = process_env_template->NewInstance();
process->Set(env->env_string(), process_env);
- READONLY_PROPERTY(process, "pid", Integer::New(getpid(), env->isolate()));
+ READONLY_PROPERTY(process, "pid", Integer::New(env->isolate(), getpid()));
READONLY_PROPERTY(process, "features", GetFeatures(env));
process->SetAccessor(env->need_imm_cb_string(),
NeedImmediateCallbackGetter,
NODE_SET_METHOD(process, "_setupDomainUse", SetupDomainUse);
// values use to cross communicate with processNextTick
- Local<Object> tick_info_obj = Object::New();
+ Local<Object> tick_info_obj = Object::New(env->isolate());
tick_info_obj->SetIndexedPropertiesToExternalArrayData(
env->tick_info()->fields(),
kExternalUnsignedIntArray,
process->Set(env->tick_info_string(), tick_info_obj);
// pre-set _events object for faster emit checks
- process->Set(env->events_string(), Object::New());
+ process->Set(env->events_string(), Object::New(env->isolate()));
}
return; // Still starting up.
Context::Scope context_scope(env->context());
- Local<Object> message = Object::New();
+ Local<Object> message = Object::New(env->isolate());
message->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "cmd"),
FIXED_ONE_BYTE_STRING(env->isolate(), "NODE_DEBUG_ENABLED"));
Local<Value> argv[] = {
Local<Value> args[] = {
env->exit_string(),
- Integer::New(code, env->isolate())
+ Integer::New(env->isolate(), code)
};
MakeCallback(env, process_object, "emit", ARRAY_SIZE(args), args);
StartProfilerIdleNotifier(env);
}
- Local<FunctionTemplate> process_template = FunctionTemplate::New();
+ Local<FunctionTemplate> process_template = FunctionTemplate::New(isolate);
process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
Local<Object> process_object = process_template->GetFunction()->NewInstance();
// environment with Environment::GetCurrentChecked().
// TODO(bnoordhuis) Reorder the debugger initialization logic so it can
// be removed.
- Context::Scope context_scope(env->context());
- bool more;
- do {
- more = uv_run(env->event_loop(), UV_RUN_ONCE);
- if (more == false) {
- EmitBeforeExit(env);
-
- // Emit `beforeExit` if the loop became alive either after emitting
- // event, or after running some callbacks.
- more = uv_loop_alive(env->event_loop());
- if (uv_run(env->event_loop(), UV_RUN_NOWAIT) != 0)
- more = true;
- }
- } while (more == true);
- code = EmitExit(env);
- RunAtExit(env);
+ {
+ Context::Scope context_scope(env->context());
+ bool more;
+ do {
+ more = uv_run(env->event_loop(), UV_RUN_ONCE);
+ if (more == false) {
+ EmitBeforeExit(env);
+
+ // Emit `beforeExit` if the loop became alive either after emitting
+ // event, or after running some callbacks.
+ more = uv_loop_alive(env->event_loop());
+ if (uv_run(env->event_loop(), UV_RUN_NOWAIT) != 0)
+ more = true;
+ }
+ } while (more == true);
+ code = EmitExit(env);
+ RunAtExit(env);
+ }
env->Dispose();
env = NULL;
}
v8::FunctionCallback callback) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handle_scope(isolate);
- v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(callback);
+ v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate,
+ callback);
v8::Local<v8::Function> fn = t->GetFunction();
v8::Local<v8::String> fn_name = v8::String::NewFromUtf8(isolate, name);
fn->SetName(fn_name);
v8::FunctionCallback callback) {
v8::Isolate* isolate = v8::Isolate::GetCurrent();
v8::HandleScope handle_scope(isolate);
- v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(callback);
+ v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate,
+ callback);
recv->PrototypeTemplate()->Set(v8::String::NewFromUtf8(isolate, name),
t->GetFunction());
}
using v8::ArrayBuffer;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
Local<Object> New(Isolate* isolate, Handle<String> string, enum encoding enc) {
- HandleScope scope(isolate);
+ EscapableHandleScope scope(isolate);
size_t length = StringBytes::Size(isolate, string, enc);
char* data = Buffer::Data(buf);
StringBytes::Write(isolate, data, length, string, enc);
- return scope.Close(buf);
+ return scope.Escape(buf);
}
Local<Object> New(Isolate* isolate, size_t length) {
- HandleScope handle_scope(isolate);
+ EscapableHandleScope handle_scope(isolate);
Local<Object> obj = Buffer::New(Environment::GetCurrent(isolate), length);
- return handle_scope.Close(obj);
+ return handle_scope.Escape(obj);
}
// TODO(trevnorris): these have a flaw by needing to call the Buffer inst then
// Alloc. continue to look for a better architecture.
Local<Object> New(Environment* env, size_t length) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
assert(length <= kMaxLength);
- Local<Value> arg = Uint32::NewFromUnsigned(length, env->isolate());
+ Local<Value> arg = Uint32::NewFromUnsigned(env->isolate(), length);
Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
// TODO(trevnorris): done like this to handle HasInstance since only checks
}
smalloc::Alloc(env, obj, data, length);
- return scope.Close(obj);
+ return scope.Escape(obj);
}
Local<Object> New(Isolate* isolate, const char* data, size_t length) {
Environment* env = Environment::GetCurrent(isolate);
- HandleScope handle_scope(env->isolate());
+ EscapableHandleScope handle_scope(env->isolate());
Local<Object> obj = Buffer::New(env, data, length);
- return handle_scope.Close(obj);
+ return handle_scope.Escape(obj);
}
// but for consistency w/ the other should use data. And a copy version renamed
// to something else.
Local<Object> New(Environment* env, const char* data, size_t length) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
assert(length <= kMaxLength);
- Local<Value> arg = Uint32::NewFromUnsigned(length, env->isolate());
+ Local<Value> arg = Uint32::NewFromUnsigned(env->isolate(), length);
Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
// TODO(trevnorris): done like this to handle HasInstance since only checks
smalloc::Alloc(env, obj, new_data, length);
- return scope.Close(obj);
+ return scope.Escape(obj);
}
smalloc::FreeCallback callback,
void* hint) {
Environment* env = Environment::GetCurrent(isolate);
- HandleScope handle_scope(env->isolate());
+ EscapableHandleScope handle_scope(env->isolate());
Local<Object> obj = Buffer::New(env, data, length, callback, hint);
- return handle_scope.Close(obj);
+ return handle_scope.Escape(obj);
}
size_t length,
smalloc::FreeCallback callback,
void* hint) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
assert(length <= kMaxLength);
- Local<Value> arg = Uint32::NewFromUnsigned(length, env->isolate());
+ Local<Value> arg = Uint32::NewFromUnsigned(env->isolate(), length);
Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
smalloc::Alloc(env, obj, data, length, callback, hint);
- return scope.Close(obj);
+ return scope.Escape(obj);
}
Local<Object> Use(Isolate* isolate, char* data, uint32_t length) {
Environment* env = Environment::GetCurrent(isolate);
- HandleScope handle_scope(env->isolate());
+ EscapableHandleScope handle_scope(env->isolate());
Local<Object> obj = Buffer::Use(env, data, length);
- return handle_scope.Close(obj);
+ return handle_scope.Escape(obj);
}
Local<Object> Use(Environment* env, char* data, uint32_t length) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
assert(length <= kMaxLength);
- Local<Value> arg = Uint32::NewFromUnsigned(length, env->isolate());
+ Local<Value> arg = Uint32::NewFromUnsigned(env->isolate(), length);
Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
smalloc::Alloc(env, obj, data, length);
- return scope.Close(obj);
+ return scope.Escape(obj);
}
memcpy(adata, obj_data, obj_length);
- Local<ArrayBuffer> abuf = ArrayBuffer::New(adata, obj_length);
+ Local<ArrayBuffer> abuf = ArrayBuffer::New(env->isolate(), adata, obj_length);
args.GetReturnValue().Set(abuf);
}
// for backwards compatibility
proto->Set(env->offset_string(),
- Uint32::New(0, env->isolate()),
+ Uint32::New(env->isolate(), 0),
v8::ReadOnly);
assert(args[1]->IsObject());
Local<Object> internal = args[1].As<Object>();
internal->Set(env->byte_length_string(),
- FunctionTemplate::New(ByteLength)->GetFunction());
+ FunctionTemplate::New(
+ env->isolate(), ByteLength)->GetFunction());
}
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "setupBufferJS"),
- FunctionTemplate::New(SetupBufferJS)->GetFunction());
+ FunctionTemplate::New(env->isolate(), SetupBufferJS)
+ ->GetFunction());
}
using v8::Array;
using v8::Boolean;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::External;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::TryCatch;
using v8::V8;
using v8::Value;
+using v8::WeakCallbackData;
class ContextifyContext {
- private:
+ protected:
+ enum Kind {
+ kSandbox,
+ kContext,
+ kProxyGlobal
+ };
+
Environment* const env_;
Persistent<Object> sandbox_;
Persistent<Context> context_;
context_(env->isolate(), CreateV8Context(env)),
// Wait for sandbox_, proxy_global_, and context_ to die
references_(0) {
- sandbox_.MakeWeak(this, WeakCallback);
+ sandbox_.SetWeak(this, WeakCallback<Object, kSandbox>);
sandbox_.MarkIndependent();
references_++;
// Allocation failure or maximum call stack size reached
if (context_.IsEmpty())
return;
- context_.MakeWeak(this, WeakCallback);
+ context_.SetWeak(this, WeakCallback<Context, kContext>);
context_.MarkIndependent();
references_++;
proxy_global_.Reset(env->isolate(), context()->Global());
- proxy_global_.MakeWeak(this, WeakCallback);
+ proxy_global_.SetWeak(this, WeakCallback<Object, kProxyGlobal>);
proxy_global_.MarkIndependent();
references_++;
}
~ContextifyContext() {
- context_.Dispose();
- proxy_global_.Dispose();
- sandbox_.Dispose();
+ context_.Reset();
+ proxy_global_.Reset();
+ sandbox_.Reset();
}
// NamedPropertyHandler will store a reference to it forever and keep it
// from getting gc'd.
Local<Value> CreateDataWrapper(Environment* env) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
Local<Object> wrapper =
env->script_data_constructor_function()->NewInstance();
if (wrapper.IsEmpty())
- return scope.Close(Handle<Value>());
+ return scope.Escape(Local<Value>::New(env->isolate(), Handle<Value>()));
Wrap<ContextifyContext>(wrapper, this);
- return scope.Close(wrapper);
+ return scope.Escape(wrapper);
}
Local<Context> CreateV8Context(Environment* env) {
- HandleScope scope(env->isolate());
- Local<FunctionTemplate> function_template = FunctionTemplate::New();
+ EscapableHandleScope scope(env->isolate());
+ Local<FunctionTemplate> function_template =
+ FunctionTemplate::New(env->isolate());
function_template->SetHiddenPrototype(true);
Local<Object> sandbox = PersistentToLocal(env->isolate(), sandbox_);
CreateDataWrapper(env));
object_template->SetAccessCheckCallbacks(GlobalPropertyNamedAccessCheck,
GlobalPropertyIndexedAccessCheck);
- return scope.Close(Context::New(env->isolate(), NULL, object_template));
+ return scope.Escape(Context::New(env->isolate(), NULL, object_template));
}
static void Init(Environment* env, Local<Object> target) {
- Local<FunctionTemplate> function_template = FunctionTemplate::New();
+ Local<FunctionTemplate> function_template =
+ FunctionTemplate::New(env->isolate());
function_template->InstanceTemplate()->SetInternalFieldCount(1);
env->set_script_data_constructor_function(function_template->GetFunction());
if (context->context().IsEmpty())
return;
- Local<External> hidden_context = External::New(context);
+ Local<External> hidden_context = External::New(env->isolate(), context);
sandbox->SetHiddenValue(hidden_name, hidden_context);
}
}
- template <class T>
- static void WeakCallback(Isolate* isolate,
- Persistent<T>* target,
- ContextifyContext* context) {
- target->ClearWeak();
+ template <class T, Kind kind>
+ static void WeakCallback(const WeakCallbackData<T, ContextifyContext>& data) {
+ ContextifyContext* context = data.GetParameter();
+ if (kind == kSandbox)
+ context->sandbox_.ClearWeak();
+ else if (kind == kContext)
+ context->context_.ClearWeak();
+ else
+ context->proxy_global_.ClearWeak();
+
if (--context->references_ == 0)
delete context;
}
Local<String> class_name =
FIXED_ONE_BYTE_STRING(env->isolate(), "ContextifyScript");
- Local<FunctionTemplate> script_tmpl = FunctionTemplate::New(New);
+ Local<FunctionTemplate> script_tmpl = FunctionTemplate::New(env->isolate(),
+ New);
script_tmpl->InstanceTemplate()->SetInternalFieldCount(1);
script_tmpl->SetClassName(class_name);
NODE_SET_PROTOTYPE_METHOD(script_tmpl, "runInContext", RunInContext);
return;
}
- Local<Context> context = Context::GetCurrent();
+ Local<Context> context = env->context();
Context::Scope context_scope(context);
Local<Script> v8_script = Script::New(code, filename);
~ContextifyScript() {
- script_.Dispose();
+ script_.Reset();
}
};
using v8::PropertyAttribute;
using v8::PropertyCallbackInfo;
using v8::String;
-using v8::ThrowException;
using v8::V8;
using v8::Value;
void SecureContext::Initialize(Environment* env, Handle<Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(SecureContext::New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(),
+ SecureContext::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "SecureContext"));
BIO_free_all(bio);
}
- ThrowException(Exception::TypeError(message));
+ args.GetIsolate()->ThrowException(Exception::TypeError(message));
}
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
- Local<Object> hello_obj = Object::New();
+ Local<Object> hello_obj = Object::New(env->isolate());
Local<Object> buff = Buffer::New(
env,
reinterpret_cast<const char*>(hello.session_id()),
hello.servername_size());
hello_obj->Set(env->servername_string(), servername);
}
- hello_obj->Set(env->tls_ticket_string(), Boolean::New(hello.has_ticket()));
+ hello_obj->Set(env->tls_ticket_string(),
+ Boolean::New(env->isolate(), hello.has_ticket()));
Local<Value> argv[] = { hello_obj };
w->MakeCallback(env->onclienthello_string(), ARRAY_SIZE(argv), argv);
ClearErrorOnReturn clear_error_on_return;
(void) &clear_error_on_return; // Silence unused variable warning.
- Local<Object> info = Object::New();
+ Local<Object> info = Object::New(env->isolate());
X509* peer_cert = SSL_get_peer_certificate(w->ssl_);
if (peer_cert != NULL) {
BIO* bio = BIO_new(BIO_s_mem());
STACK_OF(ASN1_OBJECT)* eku = static_cast<STACK_OF(ASN1_OBJECT)*>(
X509_get_ext_d2i(peer_cert, NID_ext_key_usage, NULL, NULL));
if (eku != NULL) {
- Local<Array> ext_key_usage = Array::New();
+ Local<Array> ext_key_usage = Array::New(env->isolate());
char buf[256];
int j = 0;
SSL_SESSION_free(w->next_sess_);
w->next_sess_ = sess;
- Local<Object> info = Object::New();
+ Local<Object> info = Object::New(env->isolate());
#ifndef OPENSSL_NO_TLSEXT
if (sess->tlsext_hostname == NULL) {
info->Set(env->servername_string(), False(args.GetIsolate()));
if (c == NULL)
return;
- Local<Object> info = Object::New();
+ Local<Object> info = Object::New(env->isolate());
const char* cipher_name = SSL_CIPHER_get_name(c);
info->Set(env->name_string(), OneByteString(args.GetIsolate(), cipher_name));
const char* cipher_version = SSL_CIPHER_get_version(c);
Context::Scope context_scope(env->context());
// Release old protocol handler if present
- w->selected_npn_proto_.Dispose();
+ w->selected_npn_proto_.Reset();
if (w->npn_protos_.IsEmpty()) {
// We should at least select one protocol
void Connection::Initialize(Environment* env, Handle<Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(),
+ Connection::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Connection"));
// Call the SNI callback and use its return value as context
if (!conn->sniObject_.IsEmpty()) {
- conn->sniContext_.Dispose();
+ conn->sniContext_.Reset();
Local<Value> arg = PersistentToLocal(env->isolate(), conn->servername_);
Local<Value> ret = conn->MakeCallback(env->onselect_string(), 1, &arg);
return env->ThrowError("Must give a Function as first argument");
}
- Local<Object> obj = Object::New();
+ Local<Object> obj = Object::New(env->isolate());
obj->Set(FIXED_ONE_BYTE_STRING(args.GetIsolate(), "onselect"), args[0]);
conn->sniObject_.Reset(args.GetIsolate(), obj);
}
void CipherBase::Initialize(Environment* env, Handle<Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
void Hmac::Initialize(Environment* env, v8::Handle<v8::Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
void Hash::Initialize(Environment* env, v8::Handle<v8::Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
void Sign::Initialize(Environment* env, v8::Handle<v8::Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
void Verify::Initialize(Environment* env, v8::Handle<v8::Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
void DiffieHellman::Initialize(Environment* env, Handle<Object> target) {
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
static enum PropertyAttribute attributes =
static_cast<PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "DiffieHellman"),
t->GetFunction());
- Local<FunctionTemplate> t2 = FunctionTemplate::New(DiffieHellmanGroup);
+ Local<FunctionTemplate> t2 = FunctionTemplate::New(env->isolate(),
+ DiffieHellmanGroup);
t2->InstanceTemplate()->SetInternalFieldCount(1);
NODE_SET_PROTOTYPE_METHOD(t2, "generateKeys", GenerateKeys);
}
~PBKDF2Request() {
- persistent().Dispose();
+ persistent().Reset();
}
uv_work_t* work_req() {
digest = EVP_sha1();
}
- obj = Object::New();
+ obj = Object::New(env->isolate());
req = new PBKDF2Request(env,
obj,
digest,
EIO_PBKDF2(req);
EIO_PBKDF2After(req, argv);
if (argv[0]->IsObject())
- ThrowException(argv[0]);
+ env->isolate()->ThrowException(argv[0]);
else
args.GetReturnValue().Set(argv[1]);
}
}
~RandomBytesRequest() {
- persistent().Dispose();
+ persistent().Reset();
}
uv_work_t* work_req() {
return env->ThrowTypeError("size > Buffer::kMaxLength");
}
- Local<Object> obj = Object::New();
+ Local<Object> obj = Object::New(env->isolate());
RandomBytesRequest* req = new RandomBytesRequest(env, obj, size);
if (args[1]->IsFunction()) {
delete req;
if (!argv[0]->IsNull())
- ThrowException(argv[0]);
+ env->isolate()->ThrowException(argv[0]);
else
args.GetReturnValue().Set(argv[1]);
}
return env->ThrowError("SSL_new() failed.");
}
- Local<Array> arr = Array::New();
+ Local<Array> arr = Array::New(env->isolate());
STACK_OF(SSL_CIPHER)* ciphers = SSL_get_ciphers(ssl);
for (int i = 0; i < sk_SSL_CIPHER_num(ciphers); ++i) {
class CipherPushContext {
public:
- explicit CipherPushContext(Environment* env) : arr(Array::New()), env_(env) {
+ explicit CipherPushContext(Environment* env)
+ : arr(Array::New(env->isolate())),
+ env_(env) {
}
inline Environment* env() const { return env_; }
void Certificate::Initialize(Environment* env, Handle<Object> target) {
HandleScope scope(env->isolate());
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
}
#ifdef OPENSSL_NPN_NEGOTIATED
- npn_protos_.Dispose();
- selected_npn_proto_.Dispose();
+ npn_protos_.Reset();
+ selected_npn_proto_.Reset();
#endif
}
public:
~Connection() {
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
- sniObject_.Dispose();
- sniContext_.Dispose();
- servername_.Dispose();
+ sniObject_.Reset();
+ sniContext_.Reset();
+ servername_.Reset();
#endif
}
for (unsigned int i = 0; i < ARRAY_SIZE(tab); i++) {
Local<String> key = OneByteString(env->isolate(), tab[i].name);
- Local<Value> val = FunctionTemplate::New(tab[i].func)->GetFunction();
+ Local<Value> val = FunctionTemplate::New(env->isolate(), tab[i].func)
+ ->GetFunction();
target->Set(key, val);
}
using v8::Array;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
void* operator new(size_t size, char* storage) { return storage; }
FSReqWrap(Environment* env, const char* syscall, char* data = NULL)
- : ReqWrap<uv_fs_t>(env, Object::New()),
+ : ReqWrap<uv_fs_t>(env, Object::New(env->isolate())),
syscall_(syscall),
data_(data),
dest_len_(0) {
break;
case UV_FS_OPEN:
- argv[1] = Integer::New(req->result, env->isolate());
+ argv[1] = Integer::New(env->isolate(), req->result);
break;
case UV_FS_WRITE:
- argv[1] = Integer::New(req->result, env->isolate());
+ argv[1] = Integer::New(env->isolate(), req->result);
break;
case UV_FS_STAT:
case UV_FS_READ:
// Buffer interface
- argv[1] = Integer::New(req->result, env->isolate());
+ argv[1] = Integer::New(env->isolate(), req->result);
break;
case UV_FS_READDIR:
char *namebuf = static_cast<char*>(req->ptr);
int nnames = req->result;
- Local<Array> names = Array::New(nnames);
+ Local<Array> names = Array::New(env->isolate(), nnames);
for (int i = 0; i < nnames; i++) {
Local<String> name = String::NewFromUtf8(env->isolate(), namebuf);
// If you hit this assertion, you forgot to enter the v8::Context first.
assert(env->context() == env->isolate()->GetCurrentContext());
- HandleScope handle_scope(env->isolate());
+ EscapableHandleScope handle_scope(env->isolate());
Local<Object> stats = env->stats_constructor_function()->NewInstance();
if (stats.IsEmpty()) {
- return Local<Object>();
+ return handle_scope.Escape(Local<Object>());
}
// The code below is very nasty-looking but it prevents a segmentation fault
// and make sure that we bail out when V8 returns an empty handle.
#define X(name) \
{ \
- Local<Value> val = Integer::New(s->st_##name, env->isolate()); \
+ Local<Value> val = Integer::New(env->isolate(), s->st_##name); \
if (val.IsEmpty()) \
- return Local<Object>(); \
+ return handle_scope.Escape(Local<Object>()); \
stats->Set(env->name ## _string(), val); \
}
X(dev)
#define X(name) \
{ \
- Local<Value> val = Number::New(static_cast<double>(s->st_##name)); \
+ Local<Value> val = Number::New(env->isolate(), \
+ static_cast<double>(s->st_##name)); \
if (val.IsEmpty()) \
- return Local<Object>(); \
+ return handle_scope.Escape(Local<Object>()); \
stats->Set(env->name ## _string(), val); \
}
X(ino)
{ \
double msecs = static_cast<double>(s->st_##rec.tv_sec) * 1000; \
msecs += static_cast<double>(s->st_##rec.tv_nsec / 1000000); \
- Local<Value> val = v8::Date::New(msecs); \
+ Local<Value> val = v8::Date::New(env->isolate(), msecs); \
if (val.IsEmpty()) \
- return Local<Object>(); \
+ return handle_scope.Escape(Local<Object>()); \
stats->Set(env->name ## _string(), val); \
}
X(atime, atim)
X(birthtime, birthtim)
#undef X
- return handle_scope.Close(stats);
+ return handle_scope.Escape(stats);
}
static void Stat(const FunctionCallbackInfo<Value>& args) {
assert(SYNC_REQ.result >= 0);
char* namebuf = static_cast<char*>(SYNC_REQ.ptr);
uint32_t nnames = SYNC_REQ.result;
- Local<Array> names = Array::New(nnames);
+ Local<Array> names = Array::New(env->isolate(), nnames);
for (uint32_t i = 0; i < nnames; ++i) {
names->Set(i, String::NewFromUtf8(env->isolate(), namebuf));
Environment* env = Environment::GetCurrent(context);
// Initialize the stats object
- Local<Function> constructor = FunctionTemplate::New()->GetFunction();
+ Local<Function> constructor =
+ FunctionTemplate::New(env->isolate())->GetFunction();
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "Stats"), constructor);
env->set_stats_constructor_function(constructor);
if (!cb->IsFunction())
return 0;
- Local<Object> message_info = Object::New();
+ Local<Object> message_info = Object::New(env()->isolate());
if (have_flushed_) {
// Slow case, flush remaining headers.
// METHOD
if (parser_.type == HTTP_REQUEST) {
message_info->Set(env()->method_string(),
- Uint32::NewFromUnsigned(parser_.method));
+ Uint32::NewFromUnsigned(env()->isolate(),
+ parser_.method));
}
// STATUS
if (parser_.type == HTTP_RESPONSE) {
message_info->Set(env()->status_code_string(),
- Integer::New(parser_.status_code, env()->isolate()));
+ Integer::New(env()->isolate(), parser_.status_code));
message_info->Set(env()->status_message_string(),
status_message_.ToString(env()));
}
// VERSION
message_info->Set(env()->version_major_string(),
- Integer::New(parser_.http_major, env()->isolate()));
+ Integer::New(env()->isolate(), parser_.http_major));
message_info->Set(env()->version_minor_string(),
- Integer::New(parser_.http_minor, env()->isolate()));
+ Integer::New(env()->isolate(), parser_.http_minor));
message_info->Set(env()->should_keep_alive_string(),
http_should_keep_alive(&parser_) ?
Local<Value> argv[3] = {
current_buffer_,
- Integer::NewFromUnsigned(at - current_buffer_data_, env()->isolate()),
- Integer::NewFromUnsigned(length, env()->isolate())
+ Integer::NewFromUnsigned(env()->isolate(), at - current_buffer_data_),
+ Integer::NewFromUnsigned(env()->isolate(), length)
};
Local<Value> r = cb.As<Function>()->Call(obj, ARRAY_SIZE(argv), argv);
if (parser->got_exception_)
return;
- Local<Integer> nparsed_obj = Integer::New(nparsed, env->isolate());
+ Local<Integer> nparsed_obj = Integer::New(env->isolate(), nparsed);
// If there was a parse error in one of the callbacks
// TODO(bnoordhuis) What if there is an error on EOF?
if (!parser->parser_.upgrade && nparsed != buffer_len) {
Local<Value> e = env->parse_error_string();
Local<Object> obj = e->ToObject();
- obj->Set(env->bytes_parsed_string(), Integer::New(0, env->isolate()));
+ obj->Set(env->bytes_parsed_string(), Integer::New(env->isolate(), 0));
obj->Set(env->code_string(),
OneByteString(env->isolate(), http_errno_name(err)));
Local<Array> CreateHeaders() {
// num_values_ is either -1 or the entry # of the last header
// so num_values_ == 0 means there's a single header
- Local<Array> headers = Array::New(2 * num_values_);
+ Local<Array> headers = Array::New(env()->isolate(), 2 * num_values_);
for (int i = 0; i < num_values_; ++i) {
headers->Set(2 * i, fields_[i].ToString(env()));
Handle<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> t = FunctionTemplate::New(Parser::New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(),
+ Parser::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "HTTPParser"));
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "REQUEST"),
- Integer::New(HTTP_REQUEST, env->isolate()));
+ Integer::New(env->isolate(), HTTP_REQUEST));
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "RESPONSE"),
- Integer::New(HTTP_RESPONSE, env->isolate()));
+ Integer::New(env->isolate(), HTTP_RESPONSE));
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnHeaders"),
- Integer::NewFromUnsigned(kOnHeaders, env->isolate()));
+ Integer::NewFromUnsigned(env->isolate(), kOnHeaders));
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnHeadersComplete"),
- Integer::NewFromUnsigned(kOnHeadersComplete, env->isolate()));
+ Integer::NewFromUnsigned(env->isolate(), kOnHeadersComplete));
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnBody"),
- Integer::NewFromUnsigned(kOnBody, env->isolate()));
+ Integer::NewFromUnsigned(env->isolate(), kOnBody));
t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnMessageComplete"),
- Integer::NewFromUnsigned(kOnMessageComplete, env->isolate()));
+ Integer::NewFromUnsigned(env->isolate(), kOnMessageComplete));
- Local<Array> methods = Array::New();
+ Local<Array> methods = Array::New(env->isolate());
#define V(num, name, string) \
methods->Set(num, FIXED_ONE_BYTE_STRING(env->isolate(), #string));
HTTP_METHOD_MAP(V)
namespace node {
-// If persistent.IsWeak() == false, then do not call persistent.Dispose()
+// If persistent.IsWeak() == false, then do not call persistent.Reset()
// while the returned Local<T> is still in scope, it will destroy the
// reference to the object.
template <class TypeName>
return;
assert(persistent().IsNearDeath());
persistent().ClearWeak();
- persistent().Dispose();
+ persistent().Reset();
}
if (err)
return;
- Local<Array> cpus = Array::New();
+ Local<Array> cpus = Array::New(env->isolate());
for (i = 0; i < count; i++) {
uv_cpu_info_t* ci = cpu_infos + i;
- Local<Object> times_info = Object::New();
+ Local<Object> times_info = Object::New(env->isolate());
times_info->Set(env->user_string(),
Number::New(env->isolate(), ci->cpu_times.user));
times_info->Set(env->nice_string(),
times_info->Set(env->irq_string(),
Number::New(env->isolate(), ci->cpu_times.irq));
- Local<Object> cpu_info = Object::New();
+ Local<Object> cpu_info = Object::New(env->isolate());
cpu_info->Set(env->model_string(),
OneByteString(env->isolate(), ci->model));
cpu_info->Set(env->speed_string(),
HandleScope scope(env->isolate());
double loadavg[3];
uv_loadavg(loadavg);
- Local<Array> loads = Array::New(3);
- loads->Set(0, Number::New(loadavg[0]));
- loads->Set(1, Number::New(loadavg[1]));
- loads->Set(2, Number::New(loadavg[2]));
+ Local<Array> loads = Array::New(env->isolate(), 3);
+ loads->Set(0, Number::New(env->isolate(), loadavg[0]));
+ loads->Set(1, Number::New(env->isolate(), loadavg[1]));
+ loads->Set(2, Number::New(env->isolate(), loadavg[2]));
args.GetReturnValue().Set(loads);
}
int err = uv_interface_addresses(&interfaces, &count);
- ret = Object::New();
+ ret = Object::New(env->isolate());
if (err == UV_ENOSYS) {
args.GetReturnValue().Set(ret);
if (ret->Has(name)) {
ifarr = Local<Array>::Cast(ret->Get(name));
} else {
- ifarr = Array::New();
+ ifarr = Array::New(env->isolate());
ret->Set(name, ifarr);
}
family = env->unknown_string();
}
- o = Object::New();
+ o = Object::New(env->isolate());
o->Set(env->address_string(), OneByteString(env->isolate(), ip));
o->Set(env->netmask_string(), OneByteString(env->isolate(), netmask));
o->Set(env->family_string(), family);
if (interfaces[i].address.address4.sin_family == AF_INET6) {
uint32_t scopeid = interfaces[i].address.address6.sin6_scope_id;
- o->Set(env->scopeid_string(), Integer::NewFromUnsigned(scopeid));
+ o->Set(env->scopeid_string(),
+ Integer::NewFromUnsigned(env->isolate(), scopeid));
}
const bool internal = interfaces[i].is_internal;
void StatWatcher::Initialize(Environment* env, Handle<Object> target) {
HandleScope scope(env->isolate());
- Local<FunctionTemplate> t = FunctionTemplate::New(StatWatcher::New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(),
+ StatWatcher::New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "StatWatcher"));
Local<Value> argv[] = {
BuildStatsObject(env, curr),
BuildStatsObject(env, prev),
- Integer::New(status, env->isolate())
+ Integer::New(env->isolate(), status)
};
wrap->MakeCallback(env->onchange_string(), ARRAY_SIZE(argv), argv);
}
const GCInfo* after) {
HandleScope handle_scope(isolate());
Context::Scope context_scope(context());
- Local<Value> argv[] = { Object::New(), Object::New() };
+ Local<Value> argv[] = { Object::New(isolate()), Object::New(isolate()) };
const GCInfo* infov[] = { before, after };
for (unsigned i = 0; i < ARRAY_SIZE(argv); i += 1) {
Local<Object> obj = argv[i].As<Object>();
default:
UNREACHABLE();
}
- obj->Set(flags_string(), Uint32::NewFromUnsigned(info->flags(), isolate()));
+ obj->Set(flags_string(), Uint32::NewFromUnsigned(isolate(), info->flags()));
obj->Set(timestamp_string(), Number::New(isolate(), info->timestamp()));
// TODO(trevnorris): Setting many object properties in C++ is a significant
// performance hit. Redo this to pass the results to JS and create/set the
#define V(name) \
do { \
obj->Set(name ## _string(), \
- Uint32::NewFromUnsigned(info->stats()->name(), isolate())); \
+ Uint32::NewFromUnsigned(isolate(), info->stats()->name())); \
} while (0)
V(total_heap_size);
V(total_heap_size_executable);
Environment* env = Environment::GetCurrent(isolate);
HeapStatistics s;
isolate->GetHeapStatistics(&s);
- Local<Object> info = Object::New();
+ Local<Object> info = Object::New(isolate);
// TODO(trevnorris): Setting many object properties in C++ is a significant
// performance hit. Redo this to pass the results to JS and create/set the
// properties there.
#define V(name) \
- info->Set(env->name ## _string(), Uint32::NewFromUnsigned(s.name(), isolate))
+ info->Set(env->name ## _string(), Uint32::NewFromUnsigned(isolate, s.name()))
V(total_heap_size);
V(total_heap_size_executable);
V(total_physical_size);
static void AfterSync(ZCtx* ctx, const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args.GetIsolate());
HandleScope scope(env->isolate());
- Local<Integer> avail_out = Integer::New(ctx->strm_.avail_out,
- env->isolate());
- Local<Integer> avail_in = Integer::New(ctx->strm_.avail_in,
- env->isolate());
+ Local<Integer> avail_out = Integer::New(env->isolate(),
+ ctx->strm_.avail_out);
+ Local<Integer> avail_in = Integer::New(env->isolate(),
+ ctx->strm_.avail_in);
ctx->write_in_progress_ = false;
- Local<Array> result = Array::New(2);
+ Local<Array> result = Array::New(env->isolate(), 2);
result->Set(0, avail_in);
result->Set(1, avail_out);
args.GetReturnValue().Set(result);
if (!CheckError(ctx))
return;
- Local<Integer> avail_out = Integer::New(ctx->strm_.avail_out,
- env->isolate());
- Local<Integer> avail_in = Integer::New(ctx->strm_.avail_in,
- env->isolate());
+ Local<Integer> avail_out = Integer::New(env->isolate(),
+ ctx->strm_.avail_out);
+ Local<Integer> avail_in = Integer::New(env->isolate(),
+ ctx->strm_.avail_in);
ctx->write_in_progress_ = false;
HandleScope scope(env->isolate());
Local<Value> args[2] = {
OneByteString(env->isolate(), message),
- Number::New(ctx->err_)
+ Number::New(env->isolate(), ctx->err_)
};
ctx->MakeCallback(env->onerror_string(), ARRAY_SIZE(args), args);
Handle<Context> context,
void* priv) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> z = FunctionTemplate::New(ZCtx::New);
+ Local<FunctionTemplate> z = FunctionTemplate::New(env->isolate(), ZCtx::New);
z->InstanceTemplate()->SetInternalFieldCount(1);
using v8::Boolean;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
Local<Object> PipeWrap::Instantiate(Environment* env) {
- HandleScope handle_scope(env->isolate());
+ EscapableHandleScope handle_scope(env->isolate());
assert(!env->pipe_constructor_template().IsEmpty());
Local<Function> constructor = env->pipe_constructor_template()->GetFunction();
assert(!constructor.IsEmpty());
Local<Object> instance = constructor->NewInstance();
assert(!instance.IsEmpty());
- return handle_scope.Close(instance);
+ return handle_scope.Escape(instance);
}
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Pipe"));
t->InstanceTemplate()->SetInternalFieldCount(1);
PipeWrap* wrap = Unwrap<PipeWrap>(args.This());
- String::AsciiValue name(args[0]);
+ String::Utf8Value name(args[0]);
int err = uv_pipe_bind(&wrap->handle_, *name);
args.GetReturnValue().Set(err);
}
assert(pipe_wrap->persistent().IsEmpty() == false);
Local<Value> argv[] = {
- Integer::New(status, env->isolate()),
- Undefined()
+ Integer::New(env->isolate(), status),
+ Undefined(env->isolate())
};
if (status != 0) {
Local<Object> req_wrap_obj = req_wrap->object();
Local<Value> argv[5] = {
- Integer::New(status, env->isolate()),
+ Integer::New(env->isolate(), status),
wrap->object(),
req_wrap_obj,
- Boolean::New(readable),
- Boolean::New(writable)
+ Boolean::New(env->isolate(), readable),
+ Boolean::New(env->isolate(), writable)
};
req_wrap->MakeCallback(env->oncomplete_string(), ARRAY_SIZE(argv), argv);
int err = uv_pipe_open(&wrap->handle_, fd);
if (err != 0)
- ThrowException(UVException(err, "uv_pipe_open"));
+ env->isolate()->ThrowException(UVException(err, "uv_pipe_open"));
}
assert(args[1]->IsString());
Local<Object> req_wrap_obj = args[0].As<Object>();
- String::AsciiValue name(args[1]);
+ String::Utf8Value name(args[1]);
ConnectWrap* req_wrap = new ConnectWrap(env,
req_wrap_obj,
Handle<Value> unused,
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
+ Local<FunctionTemplate> constructor = FunctionTemplate::New(env->isolate(),
+ New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Process"));
if (err == 0) {
assert(wrap->process_.data == wrap);
wrap->object()->Set(env->pid_string(),
- Integer::New(wrap->process_.pid, env->isolate()));
+ Integer::New(env->isolate(), wrap->process_.pid));
}
if (options.args) {
// Assert that someone has called Dispatched()
assert(req_.data == this);
assert(!persistent().IsEmpty());
- persistent().Dispose();
+ persistent().Reset();
}
// Call this after the req has been dispatched.
Handle<Value> unused,
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
+ Local<FunctionTemplate> constructor = FunctionTemplate::New(env->isolate(),
+ New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Signal"));
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
- Local<Value> arg = Integer::New(signum, env->isolate());
+ Local<Value> arg = Integer::New(env->isolate(), signum);
wrap->MakeCallback(env->onsignal_string(), 1, &arg);
}
using v8::RetainedObjectInfo;
using v8::Uint32;
using v8::Value;
+using v8::WeakCallbackData;
using v8::kExternalUnsignedByteArray;
Persistent<Object> p_obj;
};
-void TargetCallback(Isolate* isolate,
- Persistent<Object>* target,
- char* arg);
+void TargetCallback(const WeakCallbackData<Object, char>& data);
void TargetFreeCallback(Isolate* isolate,
Persistent<Object>* target,
- CallbackInfo* arg);
+ CallbackInfo* cb_info);
+void TargetFreeCallback(const WeakCallbackData<Object, CallbackInfo>& data);
// return size of external array type, or 0 if unrecognized
assert(!obj->HasIndexedPropertiesInExternalArrayData());
Persistent<Object> p_obj(env->isolate(), obj);
env->isolate()->AdjustAmountOfExternalAllocatedMemory(length);
- p_obj.MakeWeak(data, TargetCallback);
+ p_obj.SetWeak(data, TargetCallback);
p_obj.MarkIndependent();
p_obj.SetWrapperClassId(ALLOC_ID);
size_t size = length / ExternalArraySize(type);
}
-void TargetCallback(Isolate* isolate,
- Persistent<Object>* target,
- char* data) {
- HandleScope handle_scope(isolate);
- Local<Object> obj = PersistentToLocal(isolate, *target);
+void TargetCallback(const WeakCallbackData<Object, char>& data) {
+ HandleScope handle_scope(data.GetIsolate());
+ char* info = data.GetParameter();
+
+ Local<Object> obj = data.GetValue();
size_t len = obj->GetIndexedPropertiesExternalArrayDataLength();
enum ExternalArrayType array_type =
obj->GetIndexedPropertiesExternalArrayDataType();
assert(array_size > 0);
assert(array_size * len >= len);
len *= array_size;
- if (data != NULL && len > 0) {
- isolate->AdjustAmountOfExternalAllocatedMemory(-len);
- free(data);
+ if (info != NULL && len > 0) {
+ data.GetIsolate()->AdjustAmountOfExternalAllocatedMemory(-len);
+ free(info);
}
- (*target).Dispose();
+
+ // XXX: Persistent is no longer passed here
+ // persistent.Reset();
}
cb_info->cb = fn;
cb_info->hint = hint;
cb_info->p_obj.Reset(env->isolate(), obj);
- obj->SetHiddenValue(env->smalloc_p_string(), External::New(cb_info));
+ obj->SetHiddenValue(env->smalloc_p_string(),
+ External::New(env->isolate(), cb_info));
env->isolate()->AdjustAmountOfExternalAllocatedMemory(length +
sizeof(*cb_info));
- cb_info->p_obj.MakeWeak(cb_info, TargetFreeCallback);
+ cb_info->p_obj.SetWeak(cb_info, TargetFreeCallback);
cb_info->p_obj.MarkIndependent();
cb_info->p_obj.SetWrapperClassId(ALLOC_ID);
size_t size = length / ExternalArraySize(type);
len *= array_size;
}
isolate->AdjustAmountOfExternalAllocatedMemory(-(len + sizeof(*cb_info)));
- cb_info->p_obj.Dispose();
+ cb_info->p_obj.Reset();
cb_info->cb(data, cb_info->hint);
delete cb_info;
}
+void TargetFreeCallback(const WeakCallbackData<Object, CallbackInfo>& data) {
+ CallbackInfo* cb_info = data.GetParameter();
+ TargetFreeCallback(data.GetIsolate(), &cb_info->p_obj, cb_info);
+}
+
+
void HasExternalData(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args.GetIsolate());
args.GetReturnValue().Set(args[0]->IsObject() &&
NODE_SET_METHOD(exports, "hasExternalData", HasExternalData);
exports->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kMaxLength"),
- Uint32::NewFromUnsigned(kMaxLength, env->isolate()));
+ Uint32::NewFromUnsigned(env->isolate(), kMaxLength));
HeapProfiler* heap_profiler = env->isolate()->GetHeapProfiler();
heap_profiler->SetWrapperClassInfoProvider(ALLOC_ID, WrapperInfo);
using v8::Array;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::FunctionCallbackInfo;
using v8::Handle;
using v8::HandleScope;
Local<Object> SyncProcessRunner::Run(Local<Value> options) {
- HandleScope scope(env()->isolate());
+ EscapableHandleScope scope(env()->isolate());
assert(lifecycle_ == kUninitialized);
Local<Object> result = BuildResultObject();
- return scope.Close(result);
+ return scope.Escape(result);
}
Local<Object> SyncProcessRunner::BuildResultObject() {
- HandleScope scope(env()->isolate());
+ EscapableHandleScope scope(env()->isolate());
- Local<Object> js_result = Object::New();
+ Local<Object> js_result = Object::New(env()->isolate());
- if (GetError() != 0)
- js_result->Set(env()->error_string(), Integer::New(GetError()));
+ if (GetError() != 0) {
+ js_result->Set(env()->error_string(),
+ Integer::New(env()->isolate(), GetError()));
+ }
if (exit_status_ >= 0)
js_result->Set(env()->status_string(),
js_result->Set(env()->signal_string(),
String::NewFromUtf8(env()->isolate(), signo_string(term_signal_)));
else
- js_result->Set(env()->signal_string(), Null());
+ js_result->Set(env()->signal_string(), Null(env()->isolate()));
if (exit_status_ >= 0)
js_result->Set(env()->output_string(), BuildOutputArray());
js_result->Set(env()->pid_string(),
Number::New(env()->isolate(), uv_process_.pid));
- return scope.Close(js_result);
+ return scope.Escape(js_result);
}
assert(lifecycle_ >= kInitialized);
assert(stdio_pipes_ != NULL);
- HandleScope scope(env()->isolate());
- Local<Array> js_output = Array::New(stdio_count_);
+ EscapableHandleScope scope(env()->isolate());
+ Local<Array> js_output = Array::New(env()->isolate(), stdio_count_);
for (uint32_t i = 0; i < stdio_count_; i++) {
SyncProcessStdioPipe* h = stdio_pipes_[i];
if (h != NULL && h->writable())
js_output->Set(i, h->GetOutputAsBuffer());
else
- js_output->Set(i, Null());
+ js_output->Set(i, Null(env()->isolate()));
}
- return scope.Close(js_output);
+ return scope.Escape(js_output);
}
using v8::Array;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::FunctionCallbackInfo;
using v8::Handle;
using v8::HandleScope;
void StreamWrap::UpdateWriteQueueSize() {
HandleScope scope(env()->isolate());
Local<Integer> write_queue_size =
- Integer::NewFromUnsigned(stream()->write_queue_size, env()->isolate());
+ Integer::NewFromUnsigned(env()->isolate(), stream()->write_queue_size);
object()->Set(env()->write_queue_size_string(), write_queue_size);
}
template <class WrapType, class UVType>
static Local<Object> AcceptHandle(Environment* env, uv_stream_t* pipe) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
Local<Object> wrap_obj;
UVType* handle;
if (uv_accept(pipe, reinterpret_cast<uv_stream_t*>(handle)))
abort();
- return scope.Close(wrap_obj);
+ return scope.Escape(wrap_obj);
}
if (msg != NULL)
req_wrap_obj->Set(env->error_string(), OneByteString(env->isolate(), msg));
req_wrap_obj->Set(env->bytes_string(),
- Integer::NewFromUnsigned(length, env->isolate()));
+ Integer::NewFromUnsigned(env->isolate(), length));
args.GetReturnValue().Set(err);
}
if (msg != NULL)
req_wrap_obj->Set(env->error_string(), OneByteString(env->isolate(), msg));
req_wrap_obj->Set(env->bytes_string(),
- Integer::NewFromUnsigned(data_size, env->isolate()));
+ Integer::NewFromUnsigned(env->isolate(), data_size));
args.GetReturnValue().Set(err);
}
wrap->callbacks()->AfterWrite(req_wrap);
Local<Value> argv[] = {
- Integer::New(status, env->isolate()),
+ Integer::New(env->isolate(), status),
wrap->object(),
req_wrap_obj,
- Undefined()
+ Undefined(env->isolate())
};
const char* msg = wrap->callbacks()->Error();
Local<Object> req_wrap_obj = req_wrap->object();
Local<Value> argv[3] = {
- Integer::New(status, env->isolate()),
+ Integer::New(env->isolate(), status),
wrap->object(),
req_wrap_obj
};
Context::Scope context_scope(env->context());
Local<Value> argv[] = {
- Integer::New(nread, env->isolate()),
- Undefined(),
- Undefined()
+ Integer::New(env->isolate(), nread),
+ Undefined(env->isolate()),
+ Undefined(env->isolate())
};
if (nread < 0) {
namespace node {
+using v8::EscapableHandleScope;
using v8::Handle;
using v8::HandleScope;
using v8::Isolate;
static Local<String> NewFromCopy(Isolate* isolate,
const TypeName* data,
size_t length) {
- HandleScope scope(isolate);
+ EscapableHandleScope scope(isolate);
if (length == 0)
- return scope.Close(String::Empty(isolate));
+ return scope.Escape(String::Empty(isolate));
TypeName* new_data = new TypeName[length];
memcpy(new_data, data, length * sizeof(*new_data));
- return scope.Close(ExternString<ResourceType, TypeName>::New(isolate,
- new_data,
- length));
+ return scope.Escape(ExternString<ResourceType, TypeName>::New(isolate,
+ new_data,
+ length));
}
// uses "data" for external resource, and will be free'd on gc
static Local<String> New(Isolate* isolate,
const TypeName* data,
size_t length) {
- HandleScope scope(isolate);
+ EscapableHandleScope scope(isolate);
if (length == 0)
- return scope.Close(String::Empty(isolate));
+ return scope.Escape(String::Empty(isolate));
ExternString* h_str = new ExternString<ResourceType, TypeName>(isolate,
data,
length);
- Local<String> str = String::NewExternal(h_str);
+ Local<String> str = String::NewExternal(isolate, h_str);
isolate->AdjustAmountOfExternalAllocatedMemory(length);
- return scope.Close(str);
+ return scope.Escape(str);
}
inline Isolate* isolate() const { return isolate_; }
const char* buf,
size_t buflen,
enum encoding encoding) {
- HandleScope scope(isolate);
+ EscapableHandleScope scope(isolate);
assert(buflen <= Buffer::kMaxLength);
if (!buflen && encoding != BUFFER)
- return scope.Close(String::Empty(isolate));
+ return scope.Escape(String::Empty(isolate));
Local<String> val;
switch (encoding) {
case BUFFER:
- return scope.Close(Buffer::New(buf, buflen));
+ return scope.Escape(Buffer::New(buf, buflen));
case ASCII:
if (contains_non_ascii(buf, buflen)) {
break;
}
- return scope.Close(val);
+ return scope.Escape(val);
}
} // namespace node
namespace node {
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
Local<Object> TCPWrap::Instantiate(Environment* env) {
- HandleScope handle_scope(env->isolate());
+ EscapableHandleScope handle_scope(env->isolate());
assert(env->tcp_constructor_template().IsEmpty() == false);
Local<Function> constructor = env->tcp_constructor_template()->GetFunction();
assert(constructor.IsEmpty() == false);
Local<Object> instance = constructor->NewInstance();
assert(instance.IsEmpty() == false);
- return handle_scope.Close(instance);
+ return handle_scope.Escape(instance);
}
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TCP"));
t->InstanceTemplate()->SetInternalFieldCount(1);
TCPWrap* wrap = Unwrap<TCPWrap>(args.This());
- String::AsciiValue ip_address(args[0]);
+ String::Utf8Value ip_address(args[0]);
int port = args[1]->Int32Value();
sockaddr_in addr;
TCPWrap* wrap = Unwrap<TCPWrap>(args.This());
- String::AsciiValue ip6_address(args[0]);
+ String::Utf8Value ip6_address(args[0]);
int port = args[1]->Int32Value();
sockaddr_in6 addr;
assert(tcp_wrap->persistent().IsEmpty() == false);
Local<Value> argv[2] = {
- Integer::New(status, env->isolate()),
- Undefined()
+ Integer::New(env->isolate(), status),
+ Undefined(env->isolate())
};
if (status == 0) {
Local<Object> req_wrap_obj = req_wrap->object();
Local<Value> argv[5] = {
- Integer::New(status, env->isolate()),
+ Integer::New(env->isolate(), status),
wrap->object(),
req_wrap_obj,
v8::True(env->isolate()),
assert(args[2]->Uint32Value());
Local<Object> req_wrap_obj = args[0].As<Object>();
- String::AsciiValue ip_address(args[1]);
+ String::Utf8Value ip_address(args[1]);
int port = args[2]->Uint32Value();
sockaddr_in addr;
assert(args[2]->Uint32Value());
Local<Object> req_wrap_obj = args[0].As<Object>();
- String::AsciiValue ip_address(args[1]);
+ String::Utf8Value ip_address(args[1]);
int port = args[2]->Int32Value();
sockaddr_in6 addr;
Local<Object> AddressToJS(Environment* env,
const sockaddr* addr,
Local<Object> info) {
- HandleScope scope(env->isolate());
+ EscapableHandleScope scope(env->isolate());
char ip[INET6_ADDRSTRLEN];
const sockaddr_in *a4;
const sockaddr_in6 *a6;
int port;
if (info.IsEmpty())
- info = Object::New();
+ info = Object::New(env->isolate());
switch (addr->sa_family) {
case AF_INET6:
port = ntohs(a6->sin6_port);
info->Set(env->address_string(), OneByteString(env->isolate(), ip));
info->Set(env->family_string(), env->ipv6_string());
- info->Set(env->port_string(), Integer::New(port, env->isolate()));
+ info->Set(env->port_string(), Integer::New(env->isolate(), port));
break;
case AF_INET:
port = ntohs(a4->sin_port);
info->Set(env->address_string(), OneByteString(env->isolate(), ip));
info->Set(env->family_string(), env->ipv4_string());
- info->Set(env->port_string(), Integer::New(port, env->isolate()));
+ info->Set(env->port_string(), Integer::New(env->isolate(), port));
break;
default:
info->Set(env->address_string(), String::Empty(env->isolate()));
}
- return scope.Close(info);
+ return scope.Escape(info);
}
Handle<Value> unused,
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
+ Local<FunctionTemplate> constructor = FunctionTemplate::New(env->isolate(),
+ New);
constructor->InstanceTemplate()->SetInternalFieldCount(1);
constructor->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "Timer"));
constructor->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnTimeout"),
- Integer::New(kOnTimeout, env->isolate()));
+ Integer::New(env->isolate(), kOnTimeout));
NODE_SET_METHOD(constructor, "now", Now);
Environment* env = wrap->env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
- Local<Value> argv[1] = { Integer::New(status, env->isolate()) };
+ Local<Value> argv[1] = { Integer::New(env->isolate(), status) };
wrap->MakeCallback(kOnTimeout, ARRAY_SIZE(argv), argv);
}
using crypto::SecureContext;
using v8::Boolean;
using v8::Context;
+using v8::EscapableHandleScope;
using v8::Exception;
using v8::Function;
using v8::FunctionCallbackInfo;
clear_in_ = NULL;
sc_ = NULL;
- sc_handle_.Dispose();
- persistent().Dispose();
+ sc_handle_.Reset();
+ persistent().Reset();
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
- sni_context_.Dispose();
+ sni_context_.Reset();
#endif // SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
// Move all writes to pending
Local<Value> TLSCallbacks::GetSSLError(int status, int* err, const char** msg) {
- HandleScope scope(env()->isolate());
+ EscapableHandleScope scope(env()->isolate());
*err = SSL_get_error(ssl_, status);
switch (*err) {
case SSL_ERROR_WANT_WRITE:
break;
case SSL_ERROR_ZERO_RETURN:
- return scope.Close(env()->zero_return_string());
+ return scope.Escape(env()->zero_return_string());
break;
default:
{
*msg = buf;
}
- return scope.Close(exception);
+ return scope.Escape(exception);
}
}
return Local<Value>();
read = SSL_read(ssl_, out, sizeof(out));
if (read > 0) {
Local<Value> argv[] = {
- Integer::New(read, env()->isolate()),
+ Integer::New(env()->isolate(), read),
Buffer::New(env(), out, read)
};
wrap()->MakeCallback(env()->onread_string(), ARRAY_SIZE(argv), argv);
int flags = SSL_get_shutdown(ssl_);
if (!eof_ && flags & SSL_RECEIVED_SHUTDOWN) {
eof_ = true;
- Local<Value> arg = Integer::New(UV_EOF, env()->isolate());
+ Local<Value> arg = Integer::New(env()->isolate(), UV_EOF);
wrap()->MakeCallback(env()->onread_string(), 1, &arg);
}
HandleScope handle_scope(env()->isolate());
Context::Scope context_scope(env()->context());
- Local<Value> arg = Integer::New(nread, env()->isolate());
+ Local<Value> arg = Integer::New(env()->isolate(), nread);
wrap()->MakeCallback(env()->onread_string(), 1, &arg);
return;
}
return SSL_TLSEXT_ERR_NOACK;
}
- p->sni_context_.Dispose();
+ p->sni_context_.Reset();
p->sni_context_.Reset(env->isolate(), ctx);
SecureContext* sc = Unwrap<SecureContext>(ctx.As<Object>());
NODE_SET_METHOD(target, "wrap", TLSCallbacks::Wrap);
- Local<FunctionTemplate> t = FunctionTemplate::New();
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate());
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TLSWrap"));
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "TTY"));
t->InstanceTemplate()->SetInternalFieldCount(1);
if (err == 0) {
Local<v8::Array> a = args[0].As<Array>();
- a->Set(0, Integer::New(width, env->isolate()));
- a->Set(1, Integer::New(height, env->isolate()));
+ a->Set(0, Integer::New(env->isolate(), width));
+ a->Set(1, Integer::New(env->isolate(), height));
}
args.GetReturnValue().Set(err);
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
- Local<FunctionTemplate> t = FunctionTemplate::New(New);
+ Local<FunctionTemplate> t = FunctionTemplate::New(env->isolate(), New);
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "UDP"));
Environment* env = req_wrap->env();
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(env->context());
- Local<Value> arg = Integer::New(status, env->isolate());
+ Local<Value> arg = Integer::New(env->isolate(), status);
req_wrap->MakeCallback(env->oncomplete_string(), 1, &arg);
}
delete req_wrap;
Local<Object> wrap_obj = wrap->object();
Local<Value> argv[] = {
- Integer::New(nread, env->isolate()),
+ Integer::New(env->isolate(), nread),
wrap_obj,
Undefined(env->isolate()),
Undefined(env->isolate())
#define UNREACHABLE() abort()
-// If persistent.IsWeak() == false, then do not call persistent.Dispose()
+// If persistent.IsWeak() == false, then do not call persistent.Reset()
// while the returned Local<T> is still in scope, it will destroy the
// reference to the object.
template <class TypeName>
// Unchecked conversion from a non-weak Persistent<T> to Local<TLocal<T>,
// use with care!
//
-// Do not call persistent.Dispose() while the returned Local<T> is still in
+// Do not call persistent.Reset() while the returned Local<T> is still in
// scope, it will destroy the reference to the object.
template <class TypeName>
inline v8::Local<TypeName> StrongPersistentToLocal(
Handle<Context> context) {
Environment* env = Environment::GetCurrent(context);
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "errname"),
- FunctionTemplate::New(ErrName)->GetFunction());
+ FunctionTemplate::New(env->isolate(), ErrName)->GetFunction());
#define V(name, _) \
target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "UV_" # name), \
- Integer::New(UV_ ## name, env->isolate()));
+ Integer::New(env->isolate(), UV_ ## name));
UV_ERRNO_MAP(V)
#undef V
}
assert.ok(!er.domainBound);
break;
- case 'Cannot call method \'isDirectory\' of undefined':
+ case 'Cannot read property \'isDirectory\' of undefined':
assert.equal(er.domain, d);
assert.ok(!er.domainEmitter);
assert.ok(!er.domainBound);
{ client: client_unix, send: '(function() { "use strict"; var x; delete x; })()',
expect: /^SyntaxError: Delete of an unqualified identifier in strict mode/ },
{ client: client_unix, send: '(function() { "use strict"; eval = 17; })()',
- expect: /^SyntaxError: Assignment to eval or arguments is not allowed in strict mode/ },
+ expect: /^SyntaxError: Unexpected eval or arguments in strict mode/ },
{ client: client_unix, send: '(function() { "use strict"; if (true){ function f() { } } })()',
expect: /^SyntaxError: In strict mode code, functions can only be declared at top level or immediately within another function/ },
// Named functions can be used:
projects / platform / upstream / nodejs.git / commitdiff