GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: handle_wrap.cc Lines: 80 84 95.2 %
Date: 2022-08-31 04:20:31 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
24819
void HandleWrap::Ref(const FunctionCallbackInfo<Value>& args) {
41
  HandleWrap* wrap;
42
24819
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
43
44
24818
  if (IsAlive(wrap))
45
24817
    uv_ref(wrap->GetHandle());
46
}
47
48
49
63291
void HandleWrap::Unref(const FunctionCallbackInfo<Value>& args) {
50
  HandleWrap* wrap;
51
63291
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
52
53
61413
  if (IsAlive(wrap))
54
61411
    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
29011
void HandleWrap::Close(const FunctionCallbackInfo<Value>& args) {
66
  HandleWrap* wrap;
67
29011
  ASSIGN_OR_RETURN_UNWRAP(&wrap, args.Holder());
68
69
58020
  wrap->Close(args[0]);
70
}
71
72
56276
void HandleWrap::Close(Local<Value> close_callback) {
73
56276
  if (state_ != kInitialized)
74
522
    return;
75
76
55754
  uv_close(handle_, OnClose);
77
55754
  state_ = kClosing;
78
79

97667
  if (!close_callback.IsEmpty() && close_callback->IsFunction() &&
80
13416
      !persistent().IsEmpty()) {
81
13416
    object()->Set(env()->context(),
82
                  env()->handle_onclose_symbol(),
83
40248
                  close_callback).Check();
84
  }
85
}
86
87
88
55631
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
55631
  if (state_ != kClosed) {
95
4
    Close();
96
  } else {
97
55629
    BaseObject::OnGCCollect();
98
  }
99
55631
}
100
101
102
bool HandleWrap::IsNotIndicativeOfMemoryLeakAtExit() const {
103
  return IsWeakOrDetached() ||
104
         !HandleWrap::HasRef(this) ||
105
         !uv_is_active(GetHandle());
106
}
107
108
109
2003
void HandleWrap::MarkAsInitialized() {
110
2003
  env()->handle_wrap_queue()->PushBack(this);
111
2003
  state_ = kInitialized;
112
2003
}
113
114
115
2025
void HandleWrap::MarkAsUninitialized() {
116
2025
  handle_wrap_queue_.Remove();
117
2025
  state_ = kClosed;
118
2025
}
119
120
121
56420
HandleWrap::HandleWrap(Environment* env,
122
                       Local<Object> object,
123
                       uv_handle_t* handle,
124
56420
                       AsyncWrap::ProviderType provider)
125
    : AsyncWrap(env, object, provider),
126
      state_(kInitialized),
127
56420
      handle_(handle) {
128
56420
  handle_->data = this;
129
112840
  HandleScope scope(env->isolate());
130
56420
  CHECK(env->has_run_bootstrapping_code());
131
56420
  env->handle_wrap_queue()->PushBack(this);
132
56420
}
133
134
135
55634
void HandleWrap::OnClose(uv_handle_t* handle) {
136
55634
  CHECK_NOT_NULL(handle->data);
137
111263
  BaseObjectPtr<HandleWrap> wrap { static_cast<HandleWrap*>(handle->data) };
138
55634
  wrap->Detach();
139
140
55634
  Environment* env = wrap->env();
141
111263
  HandleScope scope(env->isolate());
142
55634
  Context::Scope context_scope(env->context());
143
144
55634
  CHECK_EQ(wrap->state_, kClosing);
145
146
55634
  wrap->state_ = kClosed;
147
148
55634
  wrap->OnClose();
149
55634
  wrap->handle_wrap_queue_.Remove();
150
151
111266
  if (!wrap->persistent().IsEmpty() &&
152
166896
      wrap->object()->Has(env->context(), env->handle_onclose_symbol())
153

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