V(onclienthello_string, "onclienthello") \
V(oncomplete_string, "oncomplete") \
V(onconnection_string, "onconnection") \
+ V(ondone_string, "ondone") \
V(onerror_string, "onerror") \
V(onexit_string, "onexit") \
V(onhandshakedone_string, "onhandshakedone") \
V(onmessage_string, "onmessage") \
V(onnewsession_string, "onnewsession") \
V(onread_string, "onread") \
+ V(onselect_string, "onselect") \
V(onsignal_string, "onsignal") \
V(onstop_string, "onstop") \
V(path_string, "path") \
return ThrowError("Must call vm.Script as a constructor.");
}
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
ContextifyScript* contextify_script =
- new ContextifyScript(args.GetIsolate(), args.This());
+ new ContextifyScript(env, args.This());
TryCatch try_catch;
Local<String> code = args[0]->ToString();
}
- ContextifyScript(Isolate* isolate, Local<Object> object)
- : WeakObject(isolate, object) {
+ ContextifyScript(Environment* env, Local<Object> object)
+ : WeakObject(env, object) {
}
HandleScope scope(node_isolate);
Base* w = static_cast<Base*>(SSL_get_app_data(s));
- Environment* env = w->env();
+ Environment* env = w->ssl_env();
if (!w->session_callbacks_)
return 0;
reinterpret_cast<char*>(sess->session_id),
sess->session_id_length);
Local<Value> argv[] = { session, buff };
- MakeCallback(env,
- w->weak_object(node_isolate),
- env->onnewsession_string(),
- ARRAY_SIZE(argv),
- argv);
+ w->MakeCallback(env->onnewsession_string(), ARRAY_SIZE(argv), argv);
return 0;
}
HandleScope scope(node_isolate);
Base* w = static_cast<Base*>(arg);
- Environment* env = w->env();
+ Environment* env = w->ssl_env();
Local<Object> hello_obj = Object::New();
Local<Object> buff = Buffer::New(
hello_obj->Set(env->tls_ticket_string(), Boolean::New(hello.has_ticket()));
Local<Value> argv[] = { hello_obj };
- MakeCallback(env,
- w->weak_object(node_isolate),
- env->onclienthello_string(),
- ARRAY_SIZE(argv),
- argv);
+ w->MakeCallback(env->onclienthello_string(), ARRAY_SIZE(argv), argv);
}
HandleScope scope(node_isolate);
Base* w = Unwrap<Base>(args.This());
- Environment* env = w->env();
+ Environment* env = w->ssl_env();
Local<Object> info = Object::New();
X509* peer_cert = SSL_get_peer_certificate(w->ssl_);
HandleScope scope(node_isolate);
Base* w = Unwrap<Base>(args.This());
- Environment* env = w->env();
+ Environment* env = w->ssl_env();
if (args.Length() >= 1 && Buffer::HasInstance(args[0])) {
ssize_t slen = Buffer::Length(args[0]);
HandleScope scope(node_isolate);
Base* w = Unwrap<Base>(args.This());
- Environment* env = w->env();
+ Environment* env = w->ssl_env();
OPENSSL_CONST SSL_CIPHER* c = SSL_get_current_cipher(w->ssl_);
if (c == NULL)
HandleScope scope(node_isolate);
Local<Value> exception =
Exception::Error(OneByteString(node_isolate, ssl_error_buf));
- weak_object(node_isolate)->Set(
- FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
+ object()->Set(FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
DEBUG_PRINT("[%p] BIO: %s failed: (%d) %s\n",
ssl_,
} else if (err == SSL_ERROR_ZERO_RETURN) {
Local<Value> exception =
Exception::Error(FIXED_ONE_BYTE_STRING(node_isolate, "ZERO_RETURN"));
- weak_object(node_isolate)->Set(
- FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
+ object()->Set(FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
return rv;
} else if (err == SSL_ERROR_SYSCALL && ss == kIgnoreSyscall) {
BIO_get_mem_ptr(bio, &mem);
Local<Value> exception =
Exception::Error(OneByteString(node_isolate, mem->data, mem->length));
- weak_object(node_isolate)->Set(
- FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
+ object()->Set(FIXED_ONE_BYTE_STRING(node_isolate, "error"), exception);
BIO_free_all(bio);
}
// We should clear the error in JS-land
Local<String> error_key = FIXED_ONE_BYTE_STRING(node_isolate, "error");
- Local<Value> error = weak_object(node_isolate)->Get(error_key);
+ Local<Value> error = object()->Get(error_key);
assert(error->BooleanValue() == false);
#endif // NDEBUG
}
if (flags & SSL_SENT_SHUTDOWN) {
Local<String> sent_shutdown_key =
FIXED_ONE_BYTE_STRING(node_isolate, "sentShutdown");
- weak_object(node_isolate)->Set(sent_shutdown_key, True(node_isolate));
+ object()->Set(sent_shutdown_key, True(node_isolate));
}
if (flags & SSL_RECEIVED_SHUTDOWN) {
Local<String> received_shutdown_key =
FIXED_ONE_BYTE_STRING(node_isolate, "receivedShutdown");
- weak_object(node_isolate)->Set(received_shutdown_key, True(node_isolate));
+ object()->Set(received_shutdown_key, True(node_isolate));
}
}
if (!conn->sniObject_.IsEmpty()) {
conn->sniContext_.Dispose();
- Local<Object> sni_object =
- PersistentToLocal(node_isolate, conn->sniObject_);
Local<Value> arg = PersistentToLocal(node_isolate, conn->servername_);
- Local<Value> ret = MakeCallback(env, sni_object, "onselect", 1, &arg);
+ Local<Value> ret = conn->MakeCallback(env->onselect_string(), 1, &arg);
// If ret is SecureContext
Local<FunctionTemplate> secure_context_constructor_template =
HandleScope handle_scope(env->isolate());
if (where & SSL_CB_HANDSHAKE_START) {
- MakeCallback(env,
- conn->weak_object(node_isolate),
- env->onhandshakestart_string());
+ conn->MakeCallback(env->onhandshakestart_string(), 0, NULL);
}
if (where & SSL_CB_HANDSHAKE_DONE) {
- MakeCallback(env,
- conn->weak_object(node_isolate),
- env->onhandshakedone_string());
+ conn->MakeCallback(env->onhandshakedone_string(), 0, NULL);
}
}
void CipherBase::New(const FunctionCallbackInfo<Value>& args) {
assert(args.IsConstructCall() == true);
CipherKind kind = args[0]->IsTrue() ? kCipher : kDecipher;
- new CipherBase(args.GetIsolate(), args.This(), kind);
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ new CipherBase(env, args.This(), kind);
}
void Hmac::New(const FunctionCallbackInfo<Value>& args) {
- new Hmac(args.GetIsolate(), args.This());
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ new Hmac(env, args.This());
}
const String::Utf8Value hash_type(args[0]);
- Hash* hash = new Hash(args.GetIsolate(), args.This());
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ Hash* hash = new Hash(env, args.This());
if (!hash->HashInit(*hash_type)) {
return ThrowError("Digest method not supported");
}
void Sign::New(const FunctionCallbackInfo<Value>& args) {
- new Sign(args.GetIsolate(), args.This());
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ new Sign(env, args.This());
}
void Verify::New(const FunctionCallbackInfo<Value>& args) {
- new Verify(args.GetIsolate(), args.This());
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ new Verify(env, args.This());
}
const FunctionCallbackInfo<Value>& args) {
HandleScope scope(node_isolate);
- DiffieHellman* diffieHellman =
- new DiffieHellman(args.GetIsolate(), args.This());
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ DiffieHellman* diffieHellman = new DiffieHellman(env, args.This());
if (args.Length() != 1 || !args[0]->IsString()) {
return ThrowError("No group name given");
void DiffieHellman::New(const FunctionCallbackInfo<Value>& args) {
HandleScope scope(node_isolate);
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
DiffieHellman* diffieHellman =
- new DiffieHellman(args.GetIsolate(), args.This());
+ new DiffieHellman(env, args.This());
bool initialized = false;
if (args.Length() > 0) {
req->obj.Dispose();
Local<Value> argv[2];
EIO_PBKDF2After(req, argv);
- MakeCallback(env, obj, "ondone", ARRAY_SIZE(argv), argv);
+ MakeCallback(env, obj, env->ondone_string(), ARRAY_SIZE(argv), argv);
}
Local<Value> argv[2];
RandomBytesCheck(req, argv);
Local<Object> obj = PersistentToLocal(node_isolate, req->obj_);
- MakeCallback(env, obj, "ondone", ARRAY_SIZE(argv), argv);
+ MakeCallback(env, obj, env->ondone_string(), ARRAY_SIZE(argv), argv);
delete req;
}
void Certificate::New(const FunctionCallbackInfo<Value>& args) {
- new Certificate(args.GetIsolate(), args.This());
+ Environment* env = Environment::GetCurrent(args.GetIsolate());
+ new Certificate(env, args.This());
}
public:
static void Initialize(Environment* env, v8::Handle<v8::Object> target);
- inline Environment* env() const {
- return env_;
- }
-
X509_STORE* ca_store_;
SSL_CTX* ctx_;
static void SetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
SecureContext(Environment* env, v8::Local<v8::Object> wrap)
- : WeakObject(env->isolate(), wrap),
+ : WeakObject(env, wrap),
ca_store_(NULL),
- ctx_(NULL),
- env_(env) {
+ ctx_(NULL) {
}
void FreeCTXMem() {
~SecureContext() {
FreeCTXMem();
}
-
- private:
- Environment* const env_;
};
template <class Base>
void* arg);
#endif // OPENSSL_NPN_NEGOTIATED
- inline Environment* env() const {
+ inline Environment* ssl_env() const {
return env_;
}
SecureContext* sc,
SSLWrap<Connection>::Kind kind)
: SSLWrap<Connection>(env, sc, kind),
- WeakObject(env->isolate(), wrap),
+ WeakObject(env, wrap),
bio_read_(NULL),
bio_write_(NULL),
hello_offset_(0) {
static void Final(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetAutoPadding(const v8::FunctionCallbackInfo<v8::Value>& args);
- CipherBase(v8::Isolate* isolate,
+ CipherBase(Environment* env,
v8::Local<v8::Object> wrap,
CipherKind kind)
- : WeakObject(isolate, wrap),
+ : WeakObject(env, wrap),
cipher_(NULL),
initialised_(false),
kind_(kind) {
static void HmacUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void HmacDigest(const v8::FunctionCallbackInfo<v8::Value>& args);
- Hmac(v8::Isolate* isolate, v8::Local<v8::Object> wrap)
- : WeakObject(isolate, wrap),
+ Hmac(Environment* env, v8::Local<v8::Object> wrap)
+ : WeakObject(env, wrap),
md_(NULL),
initialised_(false) {
}
static void HashUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void HashDigest(const v8::FunctionCallbackInfo<v8::Value>& args);
- Hash(v8::Isolate* isolate, v8::Local<v8::Object> wrap)
- : WeakObject(isolate, wrap),
+ Hash(Environment* env, v8::Local<v8::Object> wrap)
+ : WeakObject(env, wrap),
md_(NULL),
initialised_(false) {
}
static void SignUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SignFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
- Sign(v8::Isolate* isolate, v8::Local<v8::Object> wrap)
- : WeakObject(isolate, wrap),
+ Sign(Environment* env, v8::Local<v8::Object> wrap)
+ : WeakObject(env, wrap),
md_(NULL),
initialised_(false) {
}
static void VerifyUpdate(const v8::FunctionCallbackInfo<v8::Value>& args);
static void VerifyFinal(const v8::FunctionCallbackInfo<v8::Value>& args);
- Verify(v8::Isolate* isolate, v8::Local<v8::Object> wrap)
- : WeakObject(isolate, wrap),
+ Verify(Environment* env, v8::Local<v8::Object> wrap)
+ : WeakObject(env, wrap),
md_(NULL),
initialised_(false) {
}
static void SetPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
static void SetPrivateKey(const v8::FunctionCallbackInfo<v8::Value>& args);
- DiffieHellman(v8::Isolate* isolate, v8::Local<v8::Object> wrap)
- : WeakObject(isolate, wrap),
+ DiffieHellman(Environment* env, v8::Local<v8::Object> wrap)
+ : WeakObject(env, wrap),
initialised_(false),
dh(NULL) {
}
static void ExportPublicKey(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ExportChallenge(const v8::FunctionCallbackInfo<v8::Value>& args);
- Certificate(v8::Isolate* isolate, v8::Local<v8::Object> wrap)
- : WeakObject(isolate, wrap) {
+ Certificate(Environment* env, v8::Local<v8::Object> wrap)
+ : WeakObject(env, wrap) {
}
};
class Parser : public WeakObject {
public:
Parser(Environment* env, Local<Object> wrap, enum http_parser_type type)
- : WeakObject(env->isolate(), wrap),
- env_(env),
+ : WeakObject(env, wrap),
current_buffer_len_(0),
current_buffer_data_(NULL) {
Init(type);
HTTP_CB(on_headers_complete) {
- Local<Object> obj = weak_object(node_isolate);
+ Local<Object> obj = object();
Local<Value> cb = obj->Get(kOnHeadersComplete);
if (!cb->IsFunction())
HTTP_DATA_CB(on_body) {
HandleScope scope(node_isolate);
- Local<Object> obj = weak_object(node_isolate);
+ Local<Object> obj = object();
Local<Value> cb = obj->Get(kOnBody);
if (!cb->IsFunction())
if (num_fields_)
Flush(); // Flush trailing HTTP headers.
- Local<Object> obj = weak_object(node_isolate);
+ Local<Object> obj = object();
Local<Value> cb = obj->Get(kOnMessageComplete);
if (!cb->IsFunction())
void Flush() {
HandleScope scope(node_isolate);
- Local<Object> obj = weak_object(node_isolate);
+ Local<Object> obj = object();
Local<Value> cb = obj->Get(kOnHeaders);
if (!cb->IsFunction())
}
- inline Environment* env() const {
- return env_;
- }
-
-
- Environment* const env_;
http_parser parser_;
StringPtr fields_[32]; // header fields
StringPtr values_[32]; // header values
StatWatcher::StatWatcher(Environment* env, Local<Object> wrap)
- : WeakObject(env->isolate(), wrap),
- watcher_(new uv_fs_poll_t),
- env_(env) {
+ : WeakObject(env, wrap),
+ watcher_(new uv_fs_poll_t) {
uv_fs_poll_init(env->event_loop(), watcher_);
watcher_->data = static_cast<void*>(this);
}
BuildStatsObject(env, prev),
Integer::New(status, node_isolate)
};
- MakeCallback(env,
- wrap->weak_object(node_isolate),
- env->onchange_string(),
- ARRAY_SIZE(argv),
- argv);
+ wrap->MakeCallback(env->onchange_string(), ARRAY_SIZE(argv), argv);
}
Environment* env = wrap->env();
Context::Scope context_scope(env->context());
HandleScope handle_scope(env->isolate());
- MakeCallback(env, wrap->weak_object(node_isolate), env->onstop_string());
+ wrap->MakeCallback(env->onstop_string(), 0, NULL);
wrap->Stop();
}
class StatWatcher : public WeakObject {
public:
static void Initialize(v8::Handle<v8::Object> target);
- inline Environment* env() const { return env_; }
protected:
StatWatcher(Environment* env, v8::Local<v8::Object> wrap);
void Stop();
uv_fs_poll_t* watcher_;
- Environment* const env_;
};
} // namespace node
public:
ZCtx(Environment* env, Local<Object> wrap, node_zlib_mode mode)
- : WeakObject(env->isolate(), wrap),
+ : WeakObject(env, wrap),
chunk_size_(0),
dictionary_(NULL),
dictionary_len_(0),
- env_(env),
err_(0),
flush_(0),
init_done_(false),
Close();
}
-
- inline Environment* env() const {
- return env_;
- }
-
void Close() {
assert(!write_in_progress_ && "write in progress");
assert(init_done_ && "close before init");
ZCtx::Process,
ZCtx::After);
- args.GetReturnValue().Set(ctx->weak_object(node_isolate));
+ args.GetReturnValue().Set(ctx->object());
}
ctx->write_in_progress_ = false;
// call the write() cb
- Local<Object> handle = ctx->weak_object(node_isolate);
Local<Value> args[2] = { avail_in, avail_out };
- MakeCallback(env, handle, env->callback_string(), ARRAY_SIZE(args), args);
+ ctx->MakeCallback(env->callback_string(), ARRAY_SIZE(args), args);
ctx->Unref();
}
message = ctx->strm_.msg;
}
- Local<Object> handle = ctx->weak_object(node_isolate);
HandleScope scope(node_isolate);
Local<Value> args[2] = {
OneByteString(node_isolate, message),
Number::New(ctx->err_)
};
- MakeCallback(env, handle, env->onerror_string(), ARRAY_SIZE(args), args);
+ ctx->MakeCallback(env->onerror_string(), ARRAY_SIZE(args), args);
// no hope of rescue.
ctx->write_in_progress_ = false;
int chunk_size_;
Bytef* dictionary_;
size_t dictionary_len_;
- Environment* const env_;
int err_;
int flush_;
bool init_done_;
return uv_shutdown(&req_wrap->req_, wrap()->stream(), cb);
}
-
-Handle<Object> StreamWrapCallbacks::Self() {
- return wrap()->object();
-}
-
} // namespace node
uv_handle_type pending);
virtual int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);
- v8::Handle<v8::Object> Self();
-
protected:
inline StreamWrap* wrap() const {
return wrap_;
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#include "tls_wrap.h"
+#include "async-wrap.h"
+#include "async-wrap-inl.h"
#include "node_buffer.h" // Buffer
#include "node_crypto.h" // SecureContext
#include "node_crypto_bio.h" // NodeBIO
StreamWrapCallbacks* old)
: SSLWrap<TLSCallbacks>(env, Unwrap<SecureContext>(sc), kind),
StreamWrapCallbacks(old),
+ AsyncWrap(env, env->tls_wrap_constructor_function()->NewInstance()),
enc_in_(NULL),
enc_out_(NULL),
clear_in_(NULL),
sc_ = Unwrap<SecureContext>(sc);
sc_handle_.Reset(node_isolate, sc);
- Local<Object> object = env->tls_wrap_constructor_function()->NewInstance();
- persistent().Reset(node_isolate, object);
- node::Wrap<TLSCallbacks>(object, this);
+ node::Wrap<TLSCallbacks>(object(), this);
// Initialize queue for clearIn writes
QUEUE_INIT(&write_item_queue_);
// There should be a Context::Scope a few stack frames down.
assert(env->context() == env->isolate()->GetCurrentContext());
HandleScope handle_scope(env->isolate());
- Local<Object> object = c->weak_object(env->isolate());
+ Local<Object> object = c->object();
if (where & SSL_CB_HANDSHAKE_START) {
Local<Value> callback = object->Get(env->onhandshakestart_string());
if (callback->IsFunction()) {
- MakeCallback(env, object, callback.As<Function>());
+ c->MakeCallback(callback.As<Function>(), 0, NULL);
}
}
c->established_ = true;
Local<Value> callback = object->Get(env->onhandshakedone_string());
if (callback->IsFunction()) {
- MakeCallback(env, object, callback.As<Function>());
+ c->MakeCallback(callback.As<Function>(), 0, NULL);
}
}
}
Local<Value> arg = String::Concat(
FIXED_ONE_BYTE_STRING(node_isolate, "write cb error, status: "),
Integer::New(status, node_isolate)->ToString());
- MakeCallback(env,
- callbacks->weak_object(node_isolate),
- env->onerror_string(),
- 1,
- &arg);
+ callbacks->MakeCallback(env->onerror_string(), 1, &arg);
callbacks->InvokeQueued(status);
return;
}
Integer::New(read, node_isolate),
Buffer::New(env(), out, read)
};
- MakeCallback(env(),
- Self(),
- env()->onread_string(),
- ARRAY_SIZE(argv),
- argv);
+ wrap()->MakeCallback(env()->onread_string(), ARRAY_SIZE(argv), argv);
}
} while (read > 0);
Handle<Value> argv = GetSSLError(read, &err);
if (!argv.IsEmpty()) {
- MakeCallback(env(),
- weak_object(node_isolate),
- env()->onerror_string(),
- 1,
- &argv);
+ MakeCallback(env()->onerror_string(), 1, &argv);
}
}
}
int err;
Handle<Value> argv = GetSSLError(written, &err);
if (!argv.IsEmpty()) {
- MakeCallback(env(),
- weak_object(node_isolate),
- env()->onerror_string(),
- 1,
- &argv);
+ MakeCallback(env()->onerror_string(), 1, &argv);
}
return false;
HandleScope handle_scope(env()->isolate());
Handle<Value> argv = GetSSLError(written, &err);
if (!argv.IsEmpty()) {
- MakeCallback(env(),
- weak_object(node_isolate),
- env()->onerror_string(),
- 1,
- &argv);
+ MakeCallback(env()->onerror_string(), 1, &argv);
return -1;
}
Context::Scope context_scope(env()->context());
HandleScope handle_scope(env()->isolate());
Local<Value> arg = Integer::New(nread, node_isolate);
- MakeCallback(env(), Self(), env()->onread_string(), 1, &arg);
+ wrap()->MakeCallback(env()->onread_string(), 1, &arg);
return;
}
if (servername != NULL) {
// Call the SNI callback and use its return value as context
- Local<Object> object = p->weak_object(node_isolate);
+ Local<Object> object = p->object();
Local<Value> ctx = object->Get(env->sni_context_string());
if (!ctx->IsObject())
#include "node.h"
#include "node_crypto.h" // SSLWrap
+#include "async-wrap.h"
#include "env.h"
#include "queue.h"
#include "stream_wrap.h"
}
class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
- public StreamWrapCallbacks {
+ public StreamWrapCallbacks,
+ public AsyncWrap {
public:
static void Initialize(v8::Handle<v8::Object> target,
v8::Handle<v8::Value> unused,
uv_handle_type pending);
int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);
- // Just for compliance with Connection
- inline v8::Local<v8::Object> weak_object(v8::Isolate* isolate) {
- return PersistentToLocal(isolate, persistent());
- }
-
protected:
static const int kClearOutChunkSize = 1024;
static int SelectSNIContextCallback(SSL* s, int* ad, void* arg);
#endif // SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
- inline v8::Persistent<v8::Object>& persistent() {
- return object_;
- }
-
crypto::SecureContext* sc_;
v8::Persistent<v8::Object> sc_handle_;
- v8::Persistent<v8::Object> object_;
BIO* enc_in_;
BIO* enc_out_;
NodeBIO* clear_in_;
#define SRC_WEAK_OBJECT_INL_H_
#include "weak-object.h"
+#include "async-wrap.h"
+#include "async-wrap-inl.h"
#include "util.h"
#include "util-inl.h"
namespace node {
-WeakObject::WeakObject(v8::Isolate* isolate, v8::Local<v8::Object> object)
- : weak_object_(isolate, object) {
- weak_object_.MarkIndependent();
+WeakObject::WeakObject(Environment* env, v8::Local<v8::Object> object)
+ : AsyncWrap(env, object) {
+ persistent().MarkIndependent();
// The pointer is resolved as void*.
Wrap<WeakObject>(object, this);
WeakObject::~WeakObject() {
}
-v8::Local<v8::Object> WeakObject::weak_object(v8::Isolate* isolate) const {
- return v8::Local<v8::Object>::New(isolate, weak_object_);
-}
-
void WeakObject::MakeWeak() {
- weak_object_.MakeWeak(this, WeakCallback);
+ persistent().MakeWeak(this, WeakCallback);
}
void WeakObject::ClearWeak() {
- weak_object_.ClearWeak();
+ persistent().ClearWeak();
}
void WeakObject::WeakCallback(v8::Isolate* isolate,
WeakObject* self) {
// Dispose now instead of in the destructor to avoid child classes that call
// `delete this` in their destructor from blowing up.
- persistent->Dispose();
+ // Dispose the class member instead of the argument or else the IsEmpty()
+ // check in ~AsyncWrap will fail.
+ self->persistent().Dispose();
delete self;
}
#ifndef SRC_WEAK_OBJECT_H_
#define SRC_WEAK_OBJECT_H_
+#include "async-wrap.h"
+#include "env.h"
#include "v8.h"
namespace node {
-class WeakObject {
- public:
- // Returns the wrapped object. Illegal to call in your destructor.
- inline v8::Local<v8::Object> weak_object(v8::Isolate* isolate) const;
+class WeakObject : public AsyncWrap {
protected:
// |object| should be an instance of a v8::ObjectTemplate that has at least
// one internal field reserved with v8::ObjectTemplate::SetInternalFieldCount.
- inline WeakObject(v8::Isolate* isolate, v8::Local<v8::Object> object);
+ inline WeakObject(Environment* env, v8::Local<v8::Object> object);
virtual inline ~WeakObject();
inline void MakeWeak();
inline void ClearWeak();
inline static void WeakCallback(v8::Isolate* isolate,
v8::Persistent<v8::Object>* persistent,
WeakObject* self);
- v8::Persistent<v8::Object> weak_object_;
};
} // namespace node
projects / platform / upstream / nodejs.git / commitdiff