◐ Shell
clean mode source ↗

lib,src: make `StatWatcher` a `HandleWrap` · nodejs/node@740d9f1

@@ -31,17 +31,12 @@

3131

namespace node {

32323333

using v8::Context;

34-

using v8::DontDelete;

35-

using v8::DontEnum;

3634

using v8::FunctionCallbackInfo;

3735

using v8::FunctionTemplate;

3836

using v8::HandleScope;

3937

using v8::Integer;

4038

using v8::Local;

4139

using v8::Object;

42-

using v8::PropertyAttribute;

43-

using v8::ReadOnly;

44-

using v8::Signature;

4540

using v8::String;

4641

using v8::Uint32;

4742

using v8::Value;

@@ -58,43 +53,32 @@ void StatWatcher::Initialize(Environment* env, Local<Object> target) {

58535954

AsyncWrap::AddWrapMethods(env, t);

6055

env->SetProtoMethod(t, "start", StatWatcher::Start);

61-

env->SetProtoMethod(t, "stop", StatWatcher::Stop);

62-63-

Local<FunctionTemplate> is_active_templ =

64-

FunctionTemplate::New(env->isolate(),

65-

IsActive,

66-

env->as_external(),

67-

Signature::New(env->isolate(), t));

68-

t->PrototypeTemplate()->SetAccessorProperty(

69-

FIXED_ONE_BYTE_STRING(env->isolate(), "isActive"),

70-

is_active_templ,

71-

Local<FunctionTemplate>(),

72-

static_cast<PropertyAttribute>(ReadOnly | DontDelete | DontEnum));

56+

env->SetProtoMethod(t, "close", HandleWrap::Close);

57+

env->SetProtoMethod(t, "ref", HandleWrap::Ref);

58+

env->SetProtoMethod(t, "unref", HandleWrap::Unref);

59+

env->SetProtoMethod(t, "hasRef", HandleWrap::HasRef);

73607461

target->Set(statWatcherString, t->GetFunction());

7562

}

7663776478-

StatWatcher::StatWatcher(Environment* env, Local<Object> wrap, bool use_bigint)

79-

: AsyncWrap(env, wrap, AsyncWrap::PROVIDER_STATWATCHER),

80-

watcher_(nullptr),

65+

StatWatcher::StatWatcher(Environment* env,

66+

Local<Object> wrap,

67+

bool use_bigint)

68+

: HandleWrap(env,

69+

wrap,

70+

reinterpret_cast<uv_handle_t*>(&watcher_),

71+

AsyncWrap::PROVIDER_STATWATCHER),

8172

use_bigint_(use_bigint) {

82-

MakeWeak();

83-

}

84-85-86-

StatWatcher::~StatWatcher() {

87-

if (IsActive())

88-

Stop();

73+

CHECK_EQ(0, uv_fs_poll_init(env->event_loop(), &watcher_));

8974

}

907591769277

void StatWatcher::Callback(uv_fs_poll_t* handle,

9378

int status,

9479

const uv_stat_t* prev,

9580

const uv_stat_t* curr) {

96-

StatWatcher* wrap = static_cast<StatWatcher*>(handle->data);

97-

CHECK_EQ(wrap->watcher_, handle);

81+

StatWatcher* wrap = ContainerOf(&StatWatcher::watcher_, handle);

9882

Environment* env = wrap->env();

9983

HandleScope handle_scope(env->isolate());

10084

Context::Scope context_scope(env->context());

@@ -118,78 +102,28 @@ void StatWatcher::New(const FunctionCallbackInfo<Value>& args) {

118102

new StatWatcher(env, args.This(), args[0]->IsTrue());

119103

}

120104121-

bool StatWatcher::IsActive() {

122-

return watcher_ != nullptr;

123-

}

124-125-

void StatWatcher::IsActive(const v8::FunctionCallbackInfo<v8::Value>& args) {

126-

StatWatcher* wrap = Unwrap<StatWatcher>(args.This());

127-

CHECK_NOT_NULL(wrap);

128-

args.GetReturnValue().Set(wrap->IsActive());

129-

}

130-131-

// wrap.start(filename, persistent, interval)

105+

// wrap.start(filename, interval)

132106

void StatWatcher::Start(const FunctionCallbackInfo<Value>& args) {

133-

CHECK_EQ(args.Length(), 3);

107+

CHECK_EQ(args.Length(), 2);

134108135-

StatWatcher* wrap = Unwrap<StatWatcher>(args.Holder());

136-

CHECK_NOT_NULL(wrap);

137-

if (wrap->IsActive()) {

138-

return;

139-

}

109+

StatWatcher* wrap;

110+

ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());

111+

CHECK(!uv_is_active(wrap->GetHandle()));

140112141113

const int argc = args.Length();

142-

CHECK_GE(argc, 3);

143114144115

node::Utf8Value path(args.GetIsolate(), args[0]);

145116

CHECK_NOT_NULL(*path);

146117147-

bool persistent = true;

148-

if (args[1]->IsFalse()) {

149-

persistent = false;

150-

}

151-152-

CHECK(args[2]->IsUint32());

153-

const uint32_t interval = args[2].As<Uint32>()->Value();

154-155-

wrap->watcher_ = new uv_fs_poll_t();

156-

CHECK_EQ(0, uv_fs_poll_init(wrap->env()->event_loop(), wrap->watcher_));

157-

wrap->watcher_->data = static_cast<void*>(wrap);

158-

// Safe, uv_ref/uv_unref are idempotent.

159-

if (persistent)

160-

uv_ref(reinterpret_cast<uv_handle_t*>(wrap->watcher_));

161-

else

162-

uv_unref(reinterpret_cast<uv_handle_t*>(wrap->watcher_));

118+

CHECK(args[1]->IsUint32());

119+

const uint32_t interval = args[1].As<Uint32>()->Value();

163120164121

// Note that uv_fs_poll_start does not return ENOENT, we are handling

165122

// mostly memory errors here.

166-

const int err = uv_fs_poll_start(wrap->watcher_, Callback, *path, interval);

123+

const int err = uv_fs_poll_start(&wrap->watcher_, Callback, *path, interval);

167124

if (err != 0) {

168125

args.GetReturnValue().Set(err);

169126

}

170-

wrap->ClearWeak();

171127

}

172128173-174-

void StatWatcher::Stop(const FunctionCallbackInfo<Value>& args) {

175-

StatWatcher* wrap = Unwrap<StatWatcher>(args.Holder());

176-

CHECK_NOT_NULL(wrap);

177-

if (!wrap->IsActive()) {

178-

return;

179-

}

180-181-

Environment* env = wrap->env();

182-

Context::Scope context_scope(env->context());

183-

wrap->MakeCallback(env->onstop_string(), 0, nullptr);

184-

wrap->Stop();

185-

}

186-187-188-

void StatWatcher::Stop() {

189-

env()->CloseHandle(watcher_, [](uv_fs_poll_t* handle) { delete handle; });

190-

watcher_ = nullptr;

191-

MakeWeak();

192-

}

193-194-195129

} // namespace node