GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: handle_wrap.cc Lines: 80 84 95.2 %
Date: 2022-10-23 04:21:34 Branches: 38 50 76.0 %

Line Branch Exec Source
1
// Copyright Joyent, Inc. and other Node contributors.
2
//
3
// Permission is hereby granted, free of charge, to any person obtaining a
4
// copy of this software and associated documentation files (the
5
// "Software"), to deal in the Software without restriction, including
6
// without limitation the rights to use, copy, modify, merge, publish,
7
// distribute, sublicense, and/or sell copies of the Software, and to permit
8
// persons to whom the Software is furnished to do so, subject to the
9
// following conditions:
10
//
11
// The above copyright notice and this permission notice shall be included
12
// in all copies or substantial portions of the Software.
13
//
14
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20
// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22
#include "handle_wrap.h"
23
#include "async_wrap-inl.h"
24
#include "env-inl.h"
25
#include "node_external_reference.h"
26
#include "util-inl.h"
27
28
namespace node {
29
30
using v8::Context;
31
using v8::FunctionCallbackInfo;
32
using v8::FunctionTemplate;
33
using v8::HandleScope;
34
using v8::Isolate;
35
using v8::Local;
36
using v8::Object;
37
using v8::Value;
38
39
40
24816
void HandleWrap::Ref(const FunctionCallbackInfo<Value>& args) {
41
  HandleWrap* wrap;
42
24816
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
43
44
24815
  if (IsAlive(wrap))
45
24814
    uv_ref(wrap->GetHandle());
46
}
47
48
49
63485
void HandleWrap::Unref(const FunctionCallbackInfo<Value>& args) {
50
  HandleWrap* wrap;
51
63485
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
52
53
61586
  if (IsAlive(wrap))
54
61584
    uv_unref(wrap->GetHandle());
55
}
56
57
58
63
void HandleWrap::HasRef(const FunctionCallbackInfo<Value>& args) {
59
  HandleWrap* wrap;
60
63
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
61
120
  args.GetReturnValue().Set(HasRef(wrap));
62
}
63
64
65
29333
void HandleWrap::Close(const FunctionCallbackInfo<Value>& args) {
66
  HandleWrap* wrap;
67
29333
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
68
69
58664
  wrap->Close(args[0]);
70
}
71
72
56885
void HandleWrap::Close(Local<Value> close_callback) {
73
56885
  if (state_ != kInitialized)
74
546
    return;
75
76
56339
  uv_close(handle_, OnClose);
77
56339
  state_ = kClosing;
78
79

98717
  if (!close_callback.IsEmpty() && close_callback->IsFunction() &&
80
13582
      !persistent().IsEmpty()) {
81
13582
    object()->Set(env()->context(),
82
                  env()->handle_onclose_symbol(),
83
40746
                  close_callback).Check();
84
  }
85
}
86
87
88
56123
void HandleWrap::OnGCCollect() {
89
  // When all references to a HandleWrap are lost and the object is supposed to
90
  // be destroyed, we first call Close() to clean up the underlying libuv
91
  // handle. The OnClose callback then acquires and destroys another reference
92
  // to that object, and when that reference is lost, we perform the default
93
  // action (i.e. destroying `this`).
94
56123
  if (state_ != kClosed) {
95
4
    Close();
96
  } else {
97
56121
    BaseObject::OnGCCollect();
98
  }
99
56123
}
100
101
102
bool HandleWrap::IsNotIndicativeOfMemoryLeakAtExit() const {
103
  return IsWeakOrDetached() ||
104
         !HandleWrap::HasRef(this) ||
105
         !uv_is_active(GetHandle());
106
}
107
108
109
2098
void HandleWrap::MarkAsInitialized() {
110
2098
  env()->handle_wrap_queue()->PushBack(this);
111
2098
  state_ = kInitialized;
112
2098
}
113
114
115
2120
void HandleWrap::MarkAsUninitialized() {
116
2120
  handle_wrap_queue_.Remove();
117
2120
  state_ = kClosed;
118
2120
}
119
120
121
57122
HandleWrap::HandleWrap(Environment* env,
122
                       Local<Object> object,
123
                       uv_handle_t* handle,
124
57122
                       AsyncWrap::ProviderType provider)
125
    : AsyncWrap(env, object, provider),
126
      state_(kInitialized),
127
57122
      handle_(handle) {
128
57122
  handle_->data = this;
129
114244
  HandleScope scope(env->isolate());
130
57122
  CHECK(env->has_run_bootstrapping_code());
131
57122
  env->handle_wrap_queue()->PushBack(this);
132
57122
}
133
134
135
56126
void HandleWrap::OnClose(uv_handle_t* handle) {
136
56126
  CHECK_NOT_NULL(handle->data);
137
112247
  BaseObjectPtr<HandleWrap> wrap { static_cast<HandleWrap*>(handle->data) };
138
56126
  wrap->Detach();
139
140
56126
  Environment* env = wrap->env();
141
112247
  HandleScope scope(env->isolate());
142
56126
  Context::Scope context_scope(env->context());
143
144
56126
  CHECK_EQ(wrap->state_, kClosing);
145
146
56126
  wrap->state_ = kClosed;
147
148
56126
  wrap->OnClose();
149
56126
  wrap->handle_wrap_queue_.Remove();
150
151
112250
  if (!wrap->persistent().IsEmpty() &&
152
168372
      wrap->object()->Has(env->context(), env->handle_onclose_symbol())
153

168374
      .FromMaybe(false)) {
154
48199
    wrap->MakeCallback(env->handle_onclose_symbol(), 0, nullptr);
155
  }
156
56121
}
157
158
18707
Local<FunctionTemplate> HandleWrap::GetConstructorTemplate(Environment* env) {
159
18707
  Local<FunctionTemplate> tmpl = env->handle_wrap_ctor_template();
160
18707
  if (tmpl.IsEmpty()) {
161
788
    Isolate* isolate = env->isolate();
162
788
    tmpl = NewFunctionTemplate(isolate, nullptr);
163
788
    tmpl->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), "HandleWrap"));
164
788
    tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
165
788
    SetProtoMethod(isolate, tmpl, "close", HandleWrap::Close);
166
788
    SetProtoMethodNoSideEffect(isolate, tmpl, "hasRef", HandleWrap::HasRef);
167
788
    SetProtoMethod(isolate, tmpl, "ref", HandleWrap::Ref);
168
788
    SetProtoMethod(isolate, tmpl, "unref", HandleWrap::Unref);
169
788
    env->set_handle_wrap_ctor_template(tmpl);
170
  }
171
18707
  return tmpl;
172
}
173
174
5574
void HandleWrap::RegisterExternalReferences(
175
    ExternalReferenceRegistry* registry) {
176
5574
  registry->Register(HandleWrap::Close);
177
5574
  registry->Register(HandleWrap::HasRef);
178
5574
  registry->Register(HandleWrap::Ref);
179
5574
  registry->Register(HandleWrap::Unref);
180
5574
}
181
182
}  // namespace node
183
184
5574
NODE_MODULE_EXTERNAL_REFERENCE(handle_wrap,
185
                               node::HandleWrap::RegisterExternalReferences)