HandleScope scope(node_isolate);
Local<Value> key = String::NewSymbol("_errno");
Local<Value> value = String::NewSymbol(AresErrnoString(errorno));
- Local<Object> process = Local<Object>::New(node_isolate, process_p);
+ Local<Object> process = PersistentToLocal(process_p);
process->Set(key, value);
}
}
inline Local<Object> object() {
- return Local<Object>::New(node_isolate, persistent());
+ return PersistentToLocal(persistent());
}
protected:
if (using_domains) return;
HandleScope scope(node_isolate);
using_domains = true;
- Local<Object> process = Local<Object>::New(node_isolate, process_p);
+ Local<Object> process = PersistentToLocal(process_p);
Local<Value> tdc_v = process->Get(String::New("_tickDomainCallback"));
Local<Value> ndt_v = process->Get(String::New("_nextDomainTick"));
if (!tdc_v->IsFunction()) {
}
// process nextTicks after call
- Local<Object> process = Local<Object>::New(node_isolate, process_p);
- Local<Function> fn = Local<Function>::New(node_isolate, process_tickCallback);
+ Local<Object> process = PersistentToLocal(process_p);
+ Local<Function> fn = PersistentToLocal(process_tickCallback);
fn->Call(process, 0, NULL);
if (try_catch.HasCaught()) {
int argc,
Handle<Value> argv[]) {
// TODO Hook for long stack traces to be made here.
- Local<Object> process = Local<Object>::New(node_isolate, process_p);
+ Local<Object> process = PersistentToLocal(process_p);
// lazy load no domain next tick callbacks
if (process_tickCallback.IsEmpty()) {
}
// process nextTicks after call
- Local<Function> fn = Local<Function>::New(node_isolate, process_tickCallback);
+ Local<Function> fn = PersistentToLocal(process_tickCallback);
fn->Call(process, 0, NULL);
if (try_catch.HasCaught()) {
void SetErrno(uv_err_t err) {
HandleScope scope(node_isolate);
- Local<Object> process = Local<Object>::New(node_isolate, process_p);
+ Local<Object> process = PersistentToLocal(process_p);
static Cached<String> errno_symbol;
if (errno_symbol.IsEmpty()) {
if (fatal_exception_symbol.IsEmpty())
fatal_exception_symbol = String::New("_fatalException");
- Local<Object> process = Local<Object>::New(node_isolate, process_p);
+ Local<Object> process = PersistentToLocal(process_p);
Local<Value> fatal_v = process->Get(fatal_exception_symbol);
if (!fatal_v->IsFunction()) {
String::Utf8Value module_v(module);
node_module_struct* modp;
- Local<Object> cache = Local<Object>::New(node_isolate, binding_cache);
+ Local<Object> cache = PersistentToLocal(binding_cache);
Local<Object> exports;
if (cache->Has(module)) {
char buf[1024];
snprintf(buf, 1024, "Binding %s", *module_v);
- Local<Array> modules = Local<Array>::New(node_isolate, module_load_list);
+ Local<Array> modules = PersistentToLocal(module_load_list);
uint32_t l = modules->Length();
modules->Set(l, String::New(buf));
if (!p->sniObject_.IsEmpty()) {
p->sniContext_.Dispose();
- Local<Value> arg = Local<String>::New(node_isolate, p->servername_);
- Local<Value> ret = Local<Value>::New(
- node_isolate, MakeCallback(p->sniObject_, "onselect", 1, &arg));
+ Local<Value> arg = PersistentToLocal(p->servername_);
+ Local<Value> ret = MakeCallback(p->sniObject_, "onselect", 1, &arg);
// If ret is SecureContext
if (HasInstance(secure_context_constructor, ret)) {
assert(status == 0);
pbkdf2_req* req = container_of(work_req, pbkdf2_req, work_req);
HandleScope scope(node_isolate);
- Local<Object> obj = Local<Object>::New(node_isolate, req->obj);
+ Local<Object> obj = PersistentToLocal(req->obj);
req->obj.Dispose();
Local<Value> argv[2];
EIO_PBKDF2After(req, argv);
ctime_symbol = String::New("ctime");
}
- Local<Function> constructor =
- Local<Function>::New(node_isolate, stats_constructor);
-
+ Local<Function> constructor = PersistentToLocal(stats_constructor);
Local<Object> stats = constructor->NewInstance();
if (stats.IsEmpty()) return Local<Object>();
void operator=(v8::Handle<v8::Value> that);
};
+template <class TypeName>
+inline v8::Local<TypeName> PersistentToLocal(
+ const v8::Persistent<TypeName>& persistent);
+
+template <class TypeName>
+inline v8::Local<TypeName> PersistentToLocal(
+ v8::Isolate* isolate,
+ const v8::Persistent<TypeName>& persistent);
+
template <typename TypeName>
v8::Handle<v8::Value> MakeCallback(
const v8::Persistent<v8::Object>& recv,
return true;
}
+template <class TypeName>
+inline v8::Local<TypeName> PersistentToLocal(
+ const v8::Persistent<TypeName>& persistent) {
+ return PersistentToLocal(node_isolate, persistent);
+}
+
+template <class TypeName>
+inline v8::Local<TypeName> PersistentToLocal(
+ v8::Isolate* isolate,
+ const v8::Persistent<TypeName>& persistent) {
+ if (persistent.IsWeak()) {
+ return v8::Local<TypeName>::New(isolate, persistent);
+ } else {
+ return *reinterpret_cast<v8::Local<TypeName>*>(
+ const_cast<v8::Persistent<TypeName>*>(&persistent));
+ }
+}
+
template <typename TypeName>
CachedBase<TypeName>::CachedBase() {
}
template <typename TypeName>
CachedBase<TypeName>::operator v8::Handle<TypeName>() const {
- return v8::Local<TypeName>::New(node_isolate, handle_);
+ return PersistentToLocal(handle_);
}
template <typename TypeName>
const TypeName method,
int argc,
v8::Handle<v8::Value>* argv) {
- v8::Local<v8::Object> recv_obj =
- v8::Local<v8::Object>::New(node_isolate, recv);
+ v8::Local<v8::Object> recv_obj = PersistentToLocal(recv);
return MakeCallback(recv_obj, method, argc, argv);
}
inline bool HasInstance(v8::Persistent<v8::FunctionTemplate>& function_template,
v8::Handle<v8::Value> value) {
v8::Local<v8::FunctionTemplate> function_template_handle =
- v8::Local<v8::FunctionTemplate>::New(node_isolate, function_template);
+ PersistentToLocal(function_template);
return function_template_handle->HasInstance(value);
}
inline v8::Local<v8::Object> NewInstance(v8::Persistent<v8::Function>& ctor,
int argc,
v8::Handle<v8::Value>* argv) {
- v8::Local<v8::Function> constructor_handle =
- v8::Local<v8::Function>::New(node_isolate, ctor);
+ v8::Local<v8::Function> constructor_handle = PersistentToLocal(ctor);
return constructor_handle->NewInstance(argc, argv);
}
inline char* Data(v8::Persistent<TypeName>& val) {
NODE_EXTERN char* Data(v8::Handle<v8::Value>);
NODE_EXTERN char* Data(v8::Handle<v8::Object>);
- return Data(v8::Local<TypeName>::New(node_isolate, val));
+ return Data(PersistentToLocal(val));
}
template <typename TypeName>
inline size_t Length(v8::Persistent<TypeName>& val) {
NODE_EXTERN size_t Length(v8::Handle<v8::Value>);
NODE_EXTERN size_t Length(v8::Handle<v8::Object>);
- return Length(v8::Local<TypeName>::New(node_isolate, val));
+ return Length(PersistentToLocal(val));
}
} // namespace Buffer
Local<Object> WrappedContext::NewInstance() {
Local<FunctionTemplate> constructor_template_handle =
- Local<FunctionTemplate>::New(node_isolate, constructor_template);
+ PersistentToLocal(constructor_template);
return constructor_template_handle->GetFunction()->NewInstance();
}
Local<Context> WrappedContext::GetV8Context() {
- return Local<Context>::New(node_isolate, context_);
+ return PersistentToLocal(context_);
}
"'this' must be a result of previous new Script(code) call.");
}
- script = Local<Script>::New(node_isolate, n_script->script_);
+ script = PersistentToLocal(n_script->script_);
}
if (output_flag == returnResult) {
Persistent<Object>* target,
char* data) {
HandleScope handle_scope(isolate);
- Local<Object> obj = Local<Object>::New(isolate, *target);
+ Local<Object> obj = PersistentToLocal(isolate, *target);
int len = obj->GetIndexedPropertiesExternalArrayDataLength();
if (data != NULL && len > 0) {
isolate->AdjustAmountOfExternalAllocatedMemory(-len);
if (using_alloc_cb && obj->Has(smalloc_sym)) {
Local<External> ext = obj->Get(smalloc_sym).As<External>();
CallbackInfo* cb_info = static_cast<CallbackInfo*>(ext->Value());
- Local<Object> obj = Local<Object>::New(node_isolate, cb_info->p_obj);
+ Local<Object> obj = PersistentToLocal(cb_info->p_obj);
TargetFreeCallback(node_isolate, obj, cb_info);
return;
}
Persistent<Object>* target,
CallbackInfo* cb_info) {
HandleScope handle_scope(isolate);
- Local<Object> obj = Local<Object>::New(isolate, *target);
+ Local<Object> obj = PersistentToLocal(isolate, *target);
TargetFreeCallback(isolate, obj, cb_info);
}
if (object->Has(onsniselect_sym)) {
p->sni_context_.Dispose();
- Local<Value> arg = Local<String>::New(node_isolate, p->servername_);
+ Local<Value> arg = PersistentToLocal(p->servername_);
Handle<Value> ret = MakeCallback(object, onsniselect_sym, 1, &arg);
// If ret is SecureContext