public:

static void Close(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);

static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);

static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);

static inline bool IsAlive(const HandleWrap* wrap) {

return wrap != nullptr &&

wrap->IsDoneInitializing() &&

wrap->state_ != kClosed;

}

static inline bool HasRef(const HandleWrap* wrap) {

return IsAlive(wrap) && uv_has_ref(wrap->GetHandle());

}

inline uv_handle_t* GetHandle() const { return handle_; }

virtual void Close(

v8::Local<v8::Value> close_callback = v8::Local<v8::Value>());

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

IsolateData* isolate_data);

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

Environment* env);

static void RegisterExternalReferences(ExternalReferenceRegistry* registry);

protected:

HandleWrap(Environment* env,

v8::Local<v8::Object> object,

uv_handle_t* handle,

AsyncWrap::ProviderType provider);

virtual void OnClose() {}

void OnGCCollect() final;

bool IsNotIndicativeOfMemoryLeakAtExit() const override;

void MarkAsInitialized();

void MarkAsUninitialized();

inline bool IsHandleClosing() const {

return state_ == kClosing || state_ == kClosed;

}

static void OnClose(uv_handle_t* handle);

enum { kInitialized, kClosing, kClosed } state_;

private:

friend class Environment;

friend void GetActiveHandles(const v8::FunctionCallbackInfo<v8::Value>&);

// handle_wrap_queue_ needs to be at a fixed offset from the start of the

// class because it is used by src/node_postmortem_metadata.cc to calculate

// offsets and generate debug symbols for HandleWrap, which assumes that the

// position of members in memory are predictable. For more information please

// refer to `doc/contributing/node-postmortem-support.md`

friend int GenDebugSymbols();

ListNode<HandleWrap> handle_wrap_queue_;

uv_handle_t* const handle_;