Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	node_task_queue.cc	Lines:	104	113	92.0 %
Date:	2022-05-23 04:15:47	Branches:	50	74	67.6 %


#include "async_wrap.h"
#include "env-inl.h"
#include "node.h"
#include "node_errors.h"
#include "node_external_reference.h"
#include "node_internals.h"
#include "node_process-inl.h"
#include "util-inl.h"
#include "v8.h"

#include <atomic>

namespace node {

using errors::TryCatchScope;
using v8::Context;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::Isolate;
using v8::Just;
using v8::kPromiseHandlerAddedAfterReject;
using v8::kPromiseRejectAfterResolved;
using v8::kPromiseRejectWithNoHandler;
using v8::kPromiseResolveAfterResolved;
using v8::Local;
using v8::Maybe;
using v8::Number;
using v8::Object;
using v8::Promise;
using v8::PromiseRejectEvent;
using v8::PromiseRejectMessage;
using v8::Value;

static Maybe<double> GetAssignedPromiseAsyncId(Environment* env,
                                               Local<Promise> promise,
                                               Local<Value> id_symbol) {
  Local<Value> maybe_async_id;
  if (!promise->Get(env->context(), id_symbol).ToLocal(&maybe_async_id)) {
    return v8::Just(AsyncWrap::kInvalidAsyncId);
  }
  return maybe_async_id->IsNumber()
      ? maybe_async_id->NumberValue(env->context())
      : v8::Just(AsyncWrap::kInvalidAsyncId);
}

static Maybe<double> GetAssignedPromiseWrapAsyncId(Environment* env,
                                                   Local<Promise> promise,
                                                   Local<Value> id_symbol) {
  // This check is imperfect. If the internal field is set, it should
  // be an object. If it's not, we just ignore it. Ideally v8 would
  // have had GetInternalField returning a MaybeLocal but this works
  // for now.
  Local<Value> promiseWrap = promise->GetInternalField(0);
  if (promiseWrap->IsObject()) {
        Local<Value> maybe_async_id;
    if (!promiseWrap.As<Object>()->Get(env->context(), id_symbol)
        .ToLocal(&maybe_async_id)) {
      return v8::Just(AsyncWrap::kInvalidAsyncId);
    }
    return maybe_async_id->IsNumber()
        ? maybe_async_id->NumberValue(env->context())
        : v8::Just(AsyncWrap::kInvalidAsyncId);
  } else {
      return v8::Just(AsyncWrap::kInvalidAsyncId);
  }
}

void PromiseRejectCallback(PromiseRejectMessage message) {
  static std::atomic<uint64_t> unhandledRejections{0};
  static std::atomic<uint64_t> rejectionsHandledAfter{0};

  Local<Promise> promise = message.GetPromise();
  Isolate* isolate = promise->GetIsolate();
  PromiseRejectEvent event = message.GetEvent();

  Environment* env = Environment::GetCurrent(isolate);

  if (env == nullptr || !env->can_call_into_js()) return;

  Local<Function> callback = env->promise_reject_callback();
  // The promise is rejected before JS land calls SetPromiseRejectCallback
  // to initializes the promise reject callback during bootstrap.
  CHECK(!callback.IsEmpty());

  Local<Value> value;
  Local<Value> type = Number::New(env->isolate(), event);

  if (event == kPromiseRejectWithNoHandler) {
    value = message.GetValue();
    unhandledRejections++;
    TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
                  "rejections",
                  "unhandled", unhandledRejections,
                  "handledAfter", rejectionsHandledAfter);
  } else if (event == kPromiseHandlerAddedAfterReject) {
    value = Undefined(isolate);
    rejectionsHandledAfter++;
    TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
                  "rejections",
                  "unhandled", unhandledRejections,
                  "handledAfter", rejectionsHandledAfter);
  } else if (event == kPromiseResolveAfterResolved) {
    value = message.GetValue();
  } else if (event == kPromiseRejectAfterResolved) {
    value = message.GetValue();
  } else {
    return;
  }

  if (value.IsEmpty()) {
    value = Undefined(isolate);
  }

  Local<Value> args[] = { type, promise, value };

  double async_id = AsyncWrap::kInvalidAsyncId;
  double trigger_async_id = AsyncWrap::kInvalidAsyncId;
  TryCatchScope try_catch(env);

  if (!GetAssignedPromiseAsyncId(env, promise, env->async_id_symbol())
          .To(&async_id)) return;
  if (!GetAssignedPromiseAsyncId(env, promise, env->trigger_async_id_symbol())
          .To(&trigger_async_id)) return;

  if (async_id == AsyncWrap::kInvalidAsyncId &&
      trigger_async_id == AsyncWrap::kInvalidAsyncId) {
    // That means that promise might be a PromiseWrap, so we'll
    // check there as well.
    if (!GetAssignedPromiseWrapAsyncId(env, promise, env->async_id_symbol())
              .To(&async_id)) return;
    if (!GetAssignedPromiseWrapAsyncId(
          env, promise, env->trigger_async_id_symbol())
              .To(&trigger_async_id)) return;
  }

  if (async_id != AsyncWrap::kInvalidAsyncId &&
      trigger_async_id != AsyncWrap::kInvalidAsyncId) {
    env->async_hooks()->push_async_context(
        async_id, trigger_async_id, promise);
  }

  USE(callback->Call(
      env->context(), Undefined(isolate), arraysize(args), args));

  if (async_id != AsyncWrap::kInvalidAsyncId &&
      trigger_async_id != AsyncWrap::kInvalidAsyncId &&
      env->execution_async_id() == async_id) {
    // This condition might not be true if async_hooks was enabled during
    // the promise callback execution.
    env->async_hooks()->pop_async_context(async_id);
  }

  // V8 does not expect this callback to have a scheduled exceptions once it
  // returns, so we print them out in a best effort to do something about it
  // without failing silently and without crashing the process.
  if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
    fprintf(stderr, "Exception in PromiseRejectCallback:\n");
    PrintCaughtException(isolate, env->context(), try_catch);
  }
}
namespace task_queue {

static void EnqueueMicrotask(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Isolate* isolate = env->isolate();

  CHECK(args[0]->IsFunction());

  isolate->GetCurrentContext()->GetMicrotaskQueue()
      ->EnqueueMicrotask(isolate, args[0].As<Function>());
}

static void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  env->context()->GetMicrotaskQueue()->PerformCheckpoint(env->isolate());
}

static void SetTickCallback(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  CHECK(args[0]->IsFunction());
  env->set_tick_callback_function(args[0].As<Function>());
}

static void SetPromiseRejectCallback(
    const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);

  CHECK(args[0]->IsFunction());
  env->set_promise_reject_callback(args[0].As<Function>());
}

static void Initialize(Local<Object> target,
                       Local<Value> unused,
                       Local<Context> context,
                       void* priv) {
  Environment* env = Environment::GetCurrent(context);
  Isolate* isolate = env->isolate();

  env->SetMethod(target, "enqueueMicrotask", EnqueueMicrotask);
  env->SetMethod(target, "setTickCallback", SetTickCallback);
  env->SetMethod(target, "runMicrotasks", RunMicrotasks);
  target->Set(env->context(),
              FIXED_ONE_BYTE_STRING(isolate, "tickInfo"),
              env->tick_info()->fields().GetJSArray()).Check();

  Local<Object> events = Object::New(isolate);
  NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler);
  NODE_DEFINE_CONSTANT(events, kPromiseHandlerAddedAfterReject);
  NODE_DEFINE_CONSTANT(events, kPromiseResolveAfterResolved);
  NODE_DEFINE_CONSTANT(events, kPromiseRejectAfterResolved);

  target->Set(env->context(),
              FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),
              events).Check();
  env->SetMethod(target,
                 "setPromiseRejectCallback",
                 SetPromiseRejectCallback);
}

void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(EnqueueMicrotask);
  registry->Register(SetTickCallback);
  registry->Register(RunMicrotasks);
  registry->Register(SetPromiseRejectCallback);
}

}  // namespace task_queue
}  // namespace node

NODE_MODULE_CONTEXT_AWARE_INTERNAL(task_queue, node::task_queue::Initialize)
NODE_MODULE_EXTERNAL_REFERENCE(task_queue,
                               node::task_queue::RegisterExternalReferences)


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			#include "async_wrap.h"
2			#include "env-inl.h"
3			#include "node.h"
4			#include "node_errors.h"
5			#include "node_external_reference.h"
6			#include "node_internals.h"
7			#include "node_process-inl.h"
8			#include "util-inl.h"
9			#include "v8.h"
10
11			#include <atomic>
12
13			namespace node {
14
15			using errors::TryCatchScope;
16			using v8::Context;
17			using v8::Function;
18			using v8::FunctionCallbackInfo;
19			using v8::Isolate;
20			using v8::Just;
21			using v8::kPromiseHandlerAddedAfterReject;
22			using v8::kPromiseRejectAfterResolved;
23			using v8::kPromiseRejectWithNoHandler;
24			using v8::kPromiseResolveAfterResolved;
25			using v8::Local;
26			using v8::Maybe;
27			using v8::Number;
28			using v8::Object;
29			using v8::Promise;
30			using v8::PromiseRejectEvent;
31			using v8::PromiseRejectMessage;
32			using v8::Value;
33
34		64948	static Maybe<double> GetAssignedPromiseAsyncId(Environment* env,
35			Local<Promise> promise,
36			Local<Value> id_symbol) {
37			Local<Value> maybe_async_id;
38	✗✓	129896	if (!promise->Get(env->context(), id_symbol).ToLocal(&maybe_async_id)) {
39			return v8::Just(AsyncWrap::kInvalidAsyncId);
40			}
41		64948	return maybe_async_id->IsNumber()
42		52	? maybe_async_id->NumberValue(env->context())
43	✓✓	65000	: v8::Just(AsyncWrap::kInvalidAsyncId);
44			}
45
46		64896	static Maybe<double> GetAssignedPromiseWrapAsyncId(Environment* env,
47			Local<Promise> promise,
48			Local<Value> id_symbol) {
49			// This check is imperfect. If the internal field is set, it should
50			// be an object. If it's not, we just ignore it. Ideally v8 would
51			// have had GetInternalField returning a MaybeLocal but this works
52			// for now.
53		129792	Local<Value> promiseWrap = promise->GetInternalField(0);
54	✗✓	64896	if (promiseWrap->IsObject()) {
55			Local<Value> maybe_async_id;
56			if (!promiseWrap.As<Object>()->Get(env->context(), id_symbol)
57			.ToLocal(&maybe_async_id)) {
58			return v8::Just(AsyncWrap::kInvalidAsyncId);
59			}
60			return maybe_async_id->IsNumber()
61			? maybe_async_id->NumberValue(env->context())
62			: v8::Just(AsyncWrap::kInvalidAsyncId);
63			} else {
64		64896	return v8::Just(AsyncWrap::kInvalidAsyncId);
65			}
66			}
67
68		32475	void PromiseRejectCallback(PromiseRejectMessage message) {
69			static std::atomic<uint64_t> unhandledRejections{0};
70			static std::atomic<uint64_t> rejectionsHandledAfter{0};
71
72		32475	Local<Promise> promise = message.GetPromise();
73		32475	Isolate* isolate = promise->GetIsolate();
74		32475	PromiseRejectEvent event = message.GetEvent();
75
76		32475	Environment* env = Environment::GetCurrent(isolate);
77
78	✓✗✓✓ ✓✓	32475	if (env == nullptr \|\| !env->can_call_into_js()) return;
79
80		32474	Local<Function> callback = env->promise_reject_callback();
81			// The promise is rejected before JS land calls SetPromiseRejectCallback
82			// to initializes the promise reject callback during bootstrap.
83	✗✓	32474	CHECK(!callback.IsEmpty());
84
85			Local<Value> value;
86		32474	Local<Value> type = Number::New(env->isolate(), event);
87
88	✓✓	32474	if (event == kPromiseRejectWithNoHandler) {
89		13149	value = message.GetValue();
90		13149	unhandledRejections++;
91	✓✓✓✓	13386	TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
92			"rejections",
93			"unhandled", unhandledRejections,
94			"handledAfter", rejectionsHandledAfter);
95	✓✓	19325	} else if (event == kPromiseHandlerAddedAfterReject) {
96		11629	value = Undefined(isolate);
97		11629	rejectionsHandledAfter++;
98	✓✓✗✓	11828	TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
99			"rejections",
100			"unhandled", unhandledRejections,
101			"handledAfter", rejectionsHandledAfter);
102	✓✓	7696	} else if (event == kPromiseResolveAfterResolved) {
103		80	value = message.GetValue();
104	✓✗	7616	} else if (event == kPromiseRejectAfterResolved) {
105		7616	value = message.GetValue();
106			} else {
107			return;
108			}
109
110	✗✓	32474	if (value.IsEmpty()) {
111			value = Undefined(isolate);
112			}
113
114		32474	Local<Value> args[] = { type, promise, value };
115
116		32474	double async_id = AsyncWrap::kInvalidAsyncId;
117		32474	double trigger_async_id = AsyncWrap::kInvalidAsyncId;
118		32474	TryCatchScope try_catch(env);
119
120		64948	if (!GetAssignedPromiseAsyncId(env, promise, env->async_id_symbol())
121	✗✓	32474	.To(&async_id)) return;
122		64948	if (!GetAssignedPromiseAsyncId(env, promise, env->trigger_async_id_symbol())
123	✗✓	32474	.To(&trigger_async_id)) return;
124
125	✓✓	32474	if (async_id == AsyncWrap::kInvalidAsyncId &&
126	✓✗	32448	trigger_async_id == AsyncWrap::kInvalidAsyncId) {
127			// That means that promise might be a PromiseWrap, so we'll
128			// check there as well.
129		64896	if (!GetAssignedPromiseWrapAsyncId(env, promise, env->async_id_symbol())
130	✗✓	32448	.To(&async_id)) return;
131		64896	if (!GetAssignedPromiseWrapAsyncId(
132		64896	env, promise, env->trigger_async_id_symbol())
133	✗✓	32448	.To(&trigger_async_id)) return;
134			}
135
136	✓✓	32474	if (async_id != AsyncWrap::kInvalidAsyncId &&
137	✓✗	26	trigger_async_id != AsyncWrap::kInvalidAsyncId) {
138		52	env->async_hooks()->push_async_context(
139			async_id, trigger_async_id, promise);
140			}
141
142		32474	USE(callback->Call(
143		64948	env->context(), Undefined(isolate), arraysize(args), args));
144
145		64974	if (async_id != AsyncWrap::kInvalidAsyncId &&
146	✓✓✓✗ ✓✓	32500	trigger_async_id != AsyncWrap::kInvalidAsyncId &&
147	✓✗	26	env->execution_async_id() == async_id) {
148			// This condition might not be true if async_hooks was enabled during
149			// the promise callback execution.
150		26	env->async_hooks()->pop_async_context(async_id);
151			}
152
153			// V8 does not expect this callback to have a scheduled exceptions once it
154			// returns, so we print them out in a best effort to do something about it
155			// without failing silently and without crashing the process.
156	✓✓✓✗ ✓✓	32474	if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
157		423	fprintf(stderr, "Exception in PromiseRejectCallback:\n");
158		423	PrintCaughtException(isolate, env->context(), try_catch);
159			}
160			}
161			namespace task_queue {
162
163		708	static void EnqueueMicrotask(const FunctionCallbackInfo<Value>& args) {
164		708	Environment* env = Environment::GetCurrent(args);
165		708	Isolate* isolate = env->isolate();
166
167	✗✓	708	CHECK(args[0]->IsFunction());
168
169		1416	isolate->GetCurrentContext()->GetMicrotaskQueue()
170	✓✗	2124	->EnqueueMicrotask(isolate, args[0].As<Function>());
171		708	}
172
173		230338	static void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
174		230338	Environment* env = Environment::GetCurrent(args);
175		460676	env->context()->GetMicrotaskQueue()->PerformCheckpoint(env->isolate());
176		230336	}
177
178		847	static void SetTickCallback(const FunctionCallbackInfo<Value>& args) {
179		847	Environment* env = Environment::GetCurrent(args);
180	✗✓	847	CHECK(args[0]->IsFunction());
181		1694	env->set_tick_callback_function(args[0].As<Function>());
182		847	}
183
184		847	static void SetPromiseRejectCallback(
185			const FunctionCallbackInfo<Value>& args) {
186		847	Environment* env = Environment::GetCurrent(args);
187
188	✗✓	847	CHECK(args[0]->IsFunction());
189		1694	env->set_promise_reject_callback(args[0].As<Function>());
190		847	}
191
192		847	static void Initialize(Local<Object> target,
193			Local<Value> unused,
194			Local<Context> context,
195			void* priv) {
196		847	Environment* env = Environment::GetCurrent(context);
197		847	Isolate* isolate = env->isolate();
198
199		847	env->SetMethod(target, "enqueueMicrotask", EnqueueMicrotask);
200		847	env->SetMethod(target, "setTickCallback", SetTickCallback);
201		847	env->SetMethod(target, "runMicrotasks", RunMicrotasks);
202		847	target->Set(env->context(),
203			FIXED_ONE_BYTE_STRING(isolate, "tickInfo"),
204		2541	env->tick_info()->fields().GetJSArray()).Check();
205
206		847	Local<Object> events = Object::New(isolate);
207		2541	NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler);
208		2541	NODE_DEFINE_CONSTANT(events, kPromiseHandlerAddedAfterReject);
209		2541	NODE_DEFINE_CONSTANT(events, kPromiseResolveAfterResolved);
210		2541	NODE_DEFINE_CONSTANT(events, kPromiseRejectAfterResolved);
211
212		847	target->Set(env->context(),
213			FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),
214		1694	events).Check();
215		847	env->SetMethod(target,
216			"setPromiseRejectCallback",
217			SetPromiseRejectCallback);
218		847	}
219
220		5187	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
221		5187	registry->Register(EnqueueMicrotask);
222		5187	registry->Register(SetTickCallback);
223		5187	registry->Register(RunMicrotasks);
224		5187	registry->Register(SetPromiseRejectCallback);
225		5187	}
226
227			} // namespace task_queue
228			} // namespace node
229
230		5255	NODE_MODULE_CONTEXT_AWARE_INTERNAL(task_queue, node::task_queue::Initialize)
231		5187	NODE_MODULE_EXTERNAL_REFERENCE(task_queue,
232			node::task_queue::RegisterExternalReferences)