Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/node_task_queue.cc	Lines:	79	81	97.5 %
Date:	2020-11-20 19:51:53	Branches:	32	42	76.2 %


#include "env-inl.h"
#include "node.h"
#include "node_errors.h"
#include "node_external_reference.h"
#include "node_internals.h"
#include "node_process.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::kPromiseHandlerAddedAfterReject;
using v8::kPromiseRejectAfterResolved;
using v8::kPromiseRejectWithNoHandler;
using v8::kPromiseResolveAfterResolved;
using v8::Local;
using v8::MicrotasksScope;
using v8::Number;
using v8::Object;
using v8::Promise;
using v8::PromiseRejectEvent;
using v8::PromiseRejectMessage;
using v8::Value;

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 };

  // 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.
  TryCatchScope try_catch(env);
  USE(callback->Call(
      env->context(), Undefined(isolate), arraysize(args), args));
  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->EnqueueMicrotask(args[0].As<Function>());
}

static void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
  MicrotasksScope::PerformCheckpoint(args.GetIsolate());
}

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 3.4)

Line	Branch	Exec	Source
1			#include "env-inl.h"
2			#include "node.h"
3			#include "node_errors.h"
4			#include "node_external_reference.h"
5			#include "node_internals.h"
6			#include "node_process.h"
7			#include "util-inl.h"
8			#include "v8.h"
9
10			#include <atomic>
11
12			namespace node {
13
14			using errors::TryCatchScope;
15			using v8::Context;
16			using v8::Function;
17			using v8::FunctionCallbackInfo;
18			using v8::Isolate;
19			using v8::kPromiseHandlerAddedAfterReject;
20			using v8::kPromiseRejectAfterResolved;
21			using v8::kPromiseRejectWithNoHandler;
22			using v8::kPromiseResolveAfterResolved;
23			using v8::Local;
24			using v8::MicrotasksScope;
25			using v8::Number;
26			using v8::Object;
27			using v8::Promise;
28			using v8::PromiseRejectEvent;
29			using v8::PromiseRejectMessage;
30			using v8::Value;
31
32		15773	void PromiseRejectCallback(PromiseRejectMessage message) {
33			static std::atomic<uint64_t> unhandledRejections{0};
34			static std::atomic<uint64_t> rejectionsHandledAfter{0};
35
36		15773	Local<Promise> promise = message.GetPromise();
37		15773	Isolate* isolate = promise->GetIsolate();
38		15773	PromiseRejectEvent event = message.GetEvent();
39
40		15773	Environment* env = Environment::GetCurrent(isolate);
41
42	✓✗✓✓ ✓✓	15774	if (env == nullptr \|\| !env->can_call_into_js()) return;
43
44		15772	Local<Function> callback = env->promise_reject_callback();
45			// The promise is rejected before JS land calls SetPromiseRejectCallback
46			// to initializes the promise reject callback during bootstrap.
47	✗✓	15772	CHECK(!callback.IsEmpty());
48
49			Local<Value> value;
50		15772	Local<Value> type = Number::New(env->isolate(), event);
51
52	✓✓	15772	if (event == kPromiseRejectWithNoHandler) {
53		8545	value = message.GetValue();
54		8545	unhandledRejections++;
55	✓✓	8545	TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
56			"rejections",
57			"unhandled", unhandledRejections,
58		138	"handledAfter", rejectionsHandledAfter);
59	✓✓✓✓	24455	} else if (event == kPromiseHandlerAddedAfterReject) {
60		15696	value = Undefined(isolate);
61		7151	rejectionsHandledAfter++;
62		4	TRACE_COUNTER2(TRACING_CATEGORY_NODE2(promises, rejections),
63	✓✓	7155	"rejections",
64			"unhandled", unhandledRejections,
65		119	"handledAfter", rejectionsHandledAfter);
66	✓✓✓✓	14497	} else if (event == kPromiseResolveAfterResolved) {
67		7222	value = message.GetValue();
68	✓✗	5	} else if (event == kPromiseRejectAfterResolved) {
69		7	value = message.GetValue();
70		2	} else {
71			return;
72			}
73
74	✗✓	15772	if (value.IsEmpty()) {
75			value = Undefined(isolate);
76			}
77
78		31544	Local<Value> args[] = { type, promise, value };
79
80			// V8 does not expect this callback to have a scheduled exceptions once it
81			// returns, so we print them out in a best effort to do something about it
82			// without failing silently and without crashing the process.
83		31544	TryCatchScope try_catch(env);
84		31544	USE(callback->Call(
85		78860	env->context(), Undefined(isolate), arraysize(args), args));
86	✓✓✓✗ ✓✓	15772	if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
87		394	fprintf(stderr, "Exception in PromiseRejectCallback:\n");
88		394	PrintCaughtException(isolate, env->context(), try_catch);
89			}
90			}
91			namespace task_queue {
92
93		313	static void EnqueueMicrotask(const FunctionCallbackInfo<Value>& args) {
94		313	Environment* env = Environment::GetCurrent(args);
95		313	Isolate* isolate = env->isolate();
96
97	✗✓	626	CHECK(args[0]->IsFunction());
98
99		626	isolate->EnqueueMicrotask(args[0].As<Function>());
100		313	}
101
102		442372	static void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
103		442372	MicrotasksScope::PerformCheckpoint(args.GetIsolate());
104		442369	}
105
106		438	static void SetTickCallback(const FunctionCallbackInfo<Value>& args) {
107		438	Environment* env = Environment::GetCurrent(args);
108	✗✓	876	CHECK(args[0]->IsFunction());
109		876	env->set_tick_callback_function(args[0].As<Function>());
110		438	}
111
112		438	static void SetPromiseRejectCallback(
113			const FunctionCallbackInfo<Value>& args) {
114		438	Environment* env = Environment::GetCurrent(args);
115
116	✗✓	876	CHECK(args[0]->IsFunction());
117		876	env->set_promise_reject_callback(args[0].As<Function>());
118		438	}
119
120		438	static void Initialize(Local<Object> target,
121			Local<Value> unused,
122			Local<Context> context,
123			void* priv) {
124		438	Environment* env = Environment::GetCurrent(context);
125		438	Isolate* isolate = env->isolate();
126
127		438	env->SetMethod(target, "enqueueMicrotask", EnqueueMicrotask);
128		438	env->SetMethod(target, "setTickCallback", SetTickCallback);
129		438	env->SetMethod(target, "runMicrotasks", RunMicrotasks);
130		876	target->Set(env->context(),
131			FIXED_ONE_BYTE_STRING(isolate, "tickInfo"),
132		2190	env->tick_info()->fields().GetJSArray()).Check();
133
134		438	Local<Object> events = Object::New(isolate);
135		876	NODE_DEFINE_CONSTANT(events, kPromiseRejectWithNoHandler);
136		438	NODE_DEFINE_CONSTANT(events, kPromiseHandlerAddedAfterReject);
137		2190	NODE_DEFINE_CONSTANT(events, kPromiseResolveAfterResolved);
138		2190	NODE_DEFINE_CONSTANT(events, kPromiseRejectAfterResolved);
139		2628
140		3066	target->Set(env->context(),
141		1314	FIXED_ONE_BYTE_STRING(isolate, "promiseRejectEvents"),
142		2628	events).Check();
143			env->SetMethod(target,
144			"setPromiseRejectCallback",
145		438	SetPromiseRejectCallback);
146		438	}
147
148		4601	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
149		4601	registry->Register(EnqueueMicrotask);
150		4601	registry->Register(SetTickCallback);
151		4601	registry->Register(RunMicrotasks);
152		4601	registry->Register(SetPromiseRejectCallback);
153		4601	}
154
155			} // namespace task_queue
156			} // namespace node
157
158		4670	NODE_MODULE_CONTEXT_AWARE_INTERNAL(task_queue, node::task_queue::Initialize)
159	✓✗✓✗	18635	NODE_MODULE_EXTERNAL_REFERENCE(task_queue,
160			node::task_queue::RegisterExternalReferences)