public TracingController::TraceStateObserver {

public:

void OnTraceEnabled() override {

char name_buffer[512];

if (uv_get_process_title(name_buffer, sizeof(name_buffer)) == 0) {

// Only emit the metadata event if the title can be retrieved

// successfully. Ignore it otherwise.

TRACE_EVENT_METADATA1("__metadata", "process_name",

"name", TRACE_STR_COPY(name_buffer));

}

TRACE_EVENT_METADATA1("__metadata", "version",

"node", NODE_VERSION_STRING);

TRACE_EVENT_METADATA1("__metadata", "thread_name",

"name", "JavaScriptMainThread");

auto trace_process = tracing::TracedValue::Create();

trace_process->BeginDictionary("versions");

#define V(key) \

trace_process->SetString(#key, per_process::metadata.versions.key.c_str());

NODE_VERSIONS_KEYS(V)

#undef V

trace_process->EndDictionary();

trace_process->SetString("arch", NODE_ARCH);

trace_process->SetString("platform", NODE_PLATFORM);

trace_process->BeginDictionary("release");

trace_process->SetString("name", NODE_RELEASE);

#if NODE_VERSION_IS_LTS

trace_process->SetString("lts", NODE_VERSION_LTS_CODENAME);

#endif

trace_process->EndDictionary();

TRACE_EVENT_METADATA1("__metadata", "node",

"process", std::move(trace_process));

// This only runs the first time tracing is enabled

controller_->RemoveTraceStateObserver(this);

delete this;

}

void OnTraceDisabled() override {

// Do nothing here. This should never be called because the

// observer removes itself when OnTraceEnabled() is called.

UNREACHABLE();

}

explicit NodeTraceStateObserver(TracingController* controller) :

controller_(controller) {}

~NodeTraceStateObserver() override {}

private:

TracingController* controller_;

tracing_agent_.reset(new tracing::Agent());

node::tracing::TraceEventHelper::SetAgent(tracing_agent_.get());

auto controller = tracing_agent_->GetTracingController();

controller->AddTraceStateObserver(new NodeTraceStateObserver(controller));

StartTracingAgent();

// Tracing must be initialized before platform threads are created.

platform_ = new NodePlatform(thread_pool_size, controller);

V8::InitializePlatform(platform_);

platform_->Shutdown();

delete platform_;

platform_ = nullptr;

// Destroy tracing after the platform (and platform threads) have been

// stopped.

tracing_agent_.reset(nullptr);

// Inspector agent can't fail to start, but if it was configured to listen

// right away on the websocket port and fails to bind/etc, this will return

// false.

return env->inspector_agent()->Start(

script_path == nullptr ? "" : script_path,

env->options()->debug_options(),

env->inspector_host_port(),

true);

if (per_process_opts->trace_event_categories.empty()) {

tracing_file_writer_ = tracing_agent_->DefaultHandle();

} else {

tracing_file_writer_ = tracing_agent_->AddClient(

ParseCommaSeparatedSet(per_process_opts->trace_event_categories),

std::unique_ptr<tracing::AsyncTraceWriter>(

new tracing::NodeTraceWriter(

per_process_opts->trace_event_file_pattern)),

tracing::Agent::kUseDefaultCategories);

}

if (!trace_enabled_categories.empty()) {

fprintf(stderr, "Node compiled with NODE_USE_V8_PLATFORM=0, "

"so event tracing is not available.\n");

}

HandleScope scope(isolate);

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

return env != nullptr &&

env->should_abort_on_uncaught_toggle()[0] &&

!env->inside_should_not_abort_on_uncaught_scope();

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

CHECK_NOT_NULL(env);

env->AddPromiseHook(fn, arg);

void (*fun)(void* arg),

void* arg) {

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

CHECK_NOT_NULL(env);

env->AddCleanupHook(fun, arg);

void (*fun)(void* arg),

void* arg) {

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

CHECK_NOT_NULL(env);

env->RemoveCleanupHook(fun, arg);

Local<Object> recv,

const Local<Function> callback,

int argc,

Local<Value> argv[],

async_context asyncContext) {

CHECK(!recv.IsEmpty());

InternalCallbackScope scope(env, recv, asyncContext);

if (scope.Failed()) {

return MaybeLocal<Value>();

}

Local<Function> domain_cb = env->domain_callback();

MaybeLocal<Value> ret;

if (asyncContext.async_id != 0 || domain_cb.IsEmpty() || recv.IsEmpty()) {

ret = callback->Call(env->context(), recv, argc, argv);

} else {

std::vector<Local<Value>> args(1 + argc);

args[0] = callback;

std::copy(&argv[0], &argv[argc], args.begin() + 1);

ret = domain_cb->Call(env->context(), recv, args.size(), &args[0]);

}

if (ret.IsEmpty()) {

scope.MarkAsFailed();

return MaybeLocal<Value>();

}

scope.Close();

if (scope.Failed()) {

return MaybeLocal<Value>();

}

return ret;

Local<Object> recv,

const char* method,

int argc,

Local<Value> argv[],

async_context asyncContext) {

Local<String> method_string =

String::NewFromUtf8(isolate, method, NewStringType::kNormal)

.ToLocalChecked();

return MakeCallback(isolate, recv, method_string, argc, argv, asyncContext);

Local<Object> recv,

Local<String> symbol,

int argc,

Local<Value> argv[],

async_context asyncContext) {

Local<Value> callback_v = recv->Get(isolate->GetCurrentContext(),

symbol).ToLocalChecked();

if (callback_v.IsEmpty()) return Local<Value>();

if (!callback_v->IsFunction()) return Local<Value>();

Local<Function> callback = callback_v.As<Function>();

return MakeCallback(isolate, recv, callback, argc, argv, asyncContext);

Local<Object> recv,

Local<Function> callback,

int argc,

Local<Value> argv[],

async_context asyncContext) {

// Observe the following two subtleties:

//

// 1. The environment is retrieved from the callback function's context.

// 2. The context to enter is retrieved from the environment.

//

// Because of the AssignToContext() call in src/node_contextify.cc,

// the two contexts need not be the same.

Environment* env = Environment::GetCurrent(callback->CreationContext());

CHECK_NOT_NULL(env);

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

MaybeLocal<Value> ret = InternalMakeCallback(env, recv, callback,

argc, argv, asyncContext);

if (ret.IsEmpty() && env->makecallback_depth() == 0) {

// This is only for legacy compatiblity and we may want to look into

// removing/adjusting it.

return Undefined(env->isolate());

}

return ret;

Local<Object> recv,

const char* method,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, method, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

Local<Object> recv,

Local<String> symbol,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, symbol, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

Local<Object> recv,

Local<Function> callback,

int argc,

Local<Value>* argv) {

EscapableHandleScope handle_scope(isolate);

return handle_scope.Escape(

MakeCallback(isolate, recv, callback, argc, argv, {0, 0})

.FromMaybe(Local<Value>()));

#if HAVE_INSPECTOR

if (env->inspector_agent()->IsActive()) {

// Restore signal dispositions, the app is done and is no longer

// capable of handling signals.

#if defined(__POSIX__) && !defined(NODE_SHARED_MODE)

struct sigaction act;

memset(&act, 0, sizeof(act));

for (unsigned nr = 1; nr < kMaxSignal; nr += 1) {

if (nr == SIGKILL || nr == SIGSTOP || nr == SIGPROF)

continue;

act.sa_handler = (nr == SIGPIPE) ? SIG_IGN : SIG_DFL;

CHECK_EQ(0, sigaction(nr, &act, nullptr));

}

#endif

env->inspector_agent()->WaitForDisconnect();

}

#endif

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

WaitForInspectorDisconnect(env);

v8_platform.StopTracingAgent();

int code = args[0]->Int32Value(env->context()).FromMaybe(0);

env->Exit(code);

const char* warning,

const char* type = nullptr,

const char* code = nullptr) {

HandleScope handle_scope(env->isolate());

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

Local<Object> process = env->process_object();

Local<Value> emit_warning;

if (!process->Get(env->context(),

env->emit_warning_string()).ToLocal(&emit_warning)) {

return Nothing<bool>();

}

if (!emit_warning->IsFunction()) return Just(false);

int argc = 0;

Local<Value> args[3]; // warning, type, code

// The caller has to be able to handle a failure anyway, so we might as well

// do proper error checking for string creation.

if (!String::NewFromUtf8(env->isolate(),

warning,

NewStringType::kNormal).ToLocal(&args[argc++])) {

return Nothing<bool>();

}

if (type != nullptr) {

if (!String::NewFromOneByte(env->isolate(),

reinterpret_cast<const uint8_t*>(type),

NewStringType::kNormal)

.ToLocal(&args[argc++])) {

return Nothing<bool>();

}

if (code != nullptr &&

!String::NewFromOneByte(env->isolate(),

reinterpret_cast<const uint8_t*>(code),

NewStringType::kNormal)

.ToLocal(&args[argc++])) {

return Nothing<bool>();

}

}

// MakeCallback() unneeded because emitWarning is internal code, it calls

// process.emit('warning', ...), but does so on the nextTick.

if (emit_warning.As<Function>()->Call(env->context(),

process,

argc,

args).IsEmpty()) {

return Nothing<bool>();

}

return Just(true);

char warning[1024];

va_list ap;

va_start(ap, fmt);

vsnprintf(warning, sizeof(warning), fmt, ap);

va_end(ap);

return ProcessEmitWarningGeneric(env, warning);

const char* warning,

const char* deprecation_code) {

return ProcessEmitWarningGeneric(env,

warning,

"DeprecationWarning",

deprecation_code);

Isolate* isolate = message->GetIsolate();

switch (message->ErrorLevel()) {

case Isolate::MessageErrorLevel::kMessageWarning: {

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

if (!env) {

break;

}

Utf8Value filename(isolate,

message->GetScriptOrigin().ResourceName());

// (filename):(line) (message)

std::stringstream warning;

warning << *filename;

warning << ":";

warning << message->GetLineNumber(env->context()).FromMaybe(-1);

warning << " ";

v8::String::Utf8Value msg(isolate, message->Get());

warning << *msg;

USE(ProcessEmitWarningGeneric(env, warning.str().c_str(), "V8"));

break;

}

case Isolate::MessageErrorLevel::kMessageError:

FatalException(isolate, error, message);

break;

}

EscapableHandleScope scope(env->isolate());

Local<Object> obj = Object::New(env->isolate());

#if defined(DEBUG) && DEBUG

Local<Value> debug = True(env->isolate());

#else

Local<Value> debug = False(env->isolate());

#endif // defined(DEBUG) && DEBUG

obj->Set(env->context(),

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

debug).FromJust();

obj->Set(env->context(),

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

True(env->isolate())).FromJust();

// TODO(bnoordhuis) ping libuv

obj->Set(env->context(),

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

True(env->isolate())).FromJust();

#ifdef HAVE_OPENSSL

Local<Boolean> have_openssl = True(env->isolate());

#else

Local<Boolean> have_openssl = False(env->isolate());

#endif

obj->Set(env->context(),

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

have_openssl).FromJust();

obj->Set(env->context(),

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

have_openssl).FromJust();

obj->Set(env->context(),

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

have_openssl).FromJust();

obj->Set(env->context(),

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

have_openssl).FromJust();

return scope.Escape(obj);

const std::vector<std::string>& args,

const std::vector<std::string>& exec_args) {

Isolate* isolate = env->isolate();

HandleScope scope(isolate);

Local<Context> context = env->context();

Local<Object> process = env->process_object();

auto title_string = FIXED_ONE_BYTE_STRING(env->isolate(), "title");

CHECK(process->SetAccessor(

env->context(),

title_string,

ProcessTitleGetter,

env->is_main_thread() ? ProcessTitleSetter : nullptr,

env->as_external(),

DEFAULT,

None,

SideEffectType::kHasNoSideEffect).FromJust());

// process.version

READONLY_PROPERTY(process,

"version",

FIXED_ONE_BYTE_STRING(env->isolate(), NODE_VERSION));

// process.versions

Local<Object> versions = Object::New(env->isolate());

READONLY_PROPERTY(process, "versions", versions);

#define V(key) \

if (!per_process::metadata.versions.key.empty()) { \

READONLY_STRING_PROPERTY( \

versions, #key, per_process::metadata.versions.key); \

}

NODE_VERSIONS_KEYS(V)

#undef V

// process.arch

READONLY_PROPERTY(process, "arch", OneByteString(env->isolate(), NODE_ARCH));

// process.platform

READONLY_PROPERTY(process,

"platform",

OneByteString(env->isolate(), NODE_PLATFORM));

// process.release

Local<Object> release = Object::New(env->isolate());

READONLY_PROPERTY(process, "release", release);

READONLY_PROPERTY(release, "name",

OneByteString(env->isolate(), NODE_RELEASE));

#if NODE_VERSION_IS_LTS

READONLY_PROPERTY(release, "lts",

OneByteString(env->isolate(), NODE_VERSION_LTS_CODENAME));

#endif

#ifndef NODE_RELEASE_URLBASE

# if NODE_VERSION_IS_RELEASE

# define NODE_RELEASE_URLBASE "https://nodejs.org/download/release/"

# endif

#endif

#if defined(NODE_RELEASE_URLBASE)

# define NODE_RELEASE_URLPFX NODE_RELEASE_URLBASE "v" NODE_VERSION_STRING "/"

# define NODE_RELEASE_URLFPFX NODE_RELEASE_URLPFX "node-v" NODE_VERSION_STRING

READONLY_PROPERTY(release,

"sourceUrl",

OneByteString(env->isolate(),

NODE_RELEASE_URLFPFX ".tar.gz"));

READONLY_PROPERTY(release,

"headersUrl",

OneByteString(env->isolate(),

NODE_RELEASE_URLFPFX "-headers.tar.gz"));

# ifdef _WIN32

READONLY_PROPERTY(release,

"libUrl",

OneByteString(env->isolate(),

strcmp(NODE_ARCH, "ia32") ? NODE_RELEASE_URLPFX "win-"

NODE_ARCH "/node.lib"

: NODE_RELEASE_URLPFX

"win-x86/node.lib"));

# endif

#endif

// process.argv

Local<Array> arguments = Array::New(env->isolate(), args.size());

for (size_t i = 0; i < args.size(); ++i) {

arguments->Set(env->context(), i,

String::NewFromUtf8(env->isolate(), args[i].c_str(),

NewStringType::kNormal).ToLocalChecked())

.FromJust();

}

process->Set(env->context(),

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

arguments).FromJust();

// process.execArgv

Local<Array> exec_arguments = Array::New(env->isolate(), exec_args.size());

for (size_t i = 0; i < exec_args.size(); ++i) {

exec_arguments->Set(env->context(), i,

String::NewFromUtf8(env->isolate(), exec_args[i].c_str(),

NewStringType::kNormal).ToLocalChecked())

.FromJust();

}

process->Set(env->context(),

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

exec_arguments).FromJust();

// create process.env

process

->Set(env->context(),

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

CreateEnvVarProxy(context, isolate, env->as_external()))

.FromJust();

READONLY_PROPERTY(process, "pid",

Integer::New(env->isolate(), uv_os_getpid()));

READONLY_PROPERTY(process, "features", GetFeatures(env));

CHECK(process->SetAccessor(env->context(),

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

GetParentProcessId).FromJust());

// -e, --eval

// TODO(addaleax): Remove this.

if (env->options()->has_eval_string) {

READONLY_PROPERTY(process,

"_eval",

String::NewFromUtf8(

env->isolate(),

env->options()->eval_string.c_str(),

NewStringType::kNormal).ToLocalChecked());

}

// -p, --print

// TODO(addaleax): Remove this.

if (env->options()->print_eval) {

READONLY_PROPERTY(process, "_print_eval", True(env->isolate()));

}

// -c, --check

// TODO(addaleax): Remove this.

if (env->options()->syntax_check_only) {

READONLY_PROPERTY(process, "_syntax_check_only", True(env->isolate()));

}

// -i, --interactive

// TODO(addaleax): Remove this.

if (env->options()->force_repl) {

READONLY_PROPERTY(process, "_forceRepl", True(env->isolate()));

}