Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/inspector_js_api.cc	Lines:	197	217	90.8 %
Date:	2020-12-12 04:11:07	Branches:	41	86	47.7 %


#include "base_object-inl.h"
#include "inspector_agent.h"
#include "inspector_io.h"
#include "memory_tracker-inl.h"
#include "node_external_reference.h"
#include "util-inl.h"
#include "v8-inspector.h"
#include "v8.h"

#include <memory>

namespace node {
namespace inspector {
namespace {

using v8::Context;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
using v8::Global;
using v8::HandleScope;
using v8::Isolate;
using v8::Local;
using v8::MaybeLocal;
using v8::NewStringType;
using v8::Object;
using v8::String;
using v8::Uint32;
using v8::Value;

using v8_inspector::StringBuffer;
using v8_inspector::StringView;

std::unique_ptr<StringBuffer> ToProtocolString(Isolate* isolate,
                                               Local<Value> value) {
  TwoByteValue buffer(isolate, value);
  return StringBuffer::create(StringView(*buffer, buffer.length()));
}

struct LocalConnection {
  static std::unique_ptr<InspectorSession> Connect(
      Agent* inspector, std::unique_ptr<InspectorSessionDelegate> delegate) {
    return inspector->Connect(std::move(delegate), false);
  }

  static Local<String> GetClassName(Environment* env) {
    return FIXED_ONE_BYTE_STRING(env->isolate(), "Connection");
  }
};

struct MainThreadConnection {
  static std::unique_ptr<InspectorSession> Connect(
      Agent* inspector, std::unique_ptr<InspectorSessionDelegate> delegate) {
    return inspector->ConnectToMainThread(std::move(delegate), true);
  }

  static Local<String> GetClassName(Environment* env) {
    return FIXED_ONE_BYTE_STRING(env->isolate(), "MainThreadConnection");
  }
};

template <typename ConnectionType>
class JSBindingsConnection : public AsyncWrap {
 public:
  class JSBindingsSessionDelegate : public InspectorSessionDelegate {
   public:
    JSBindingsSessionDelegate(Environment* env,
                              JSBindingsConnection* connection)
                              : env_(env),
                                connection_(connection) {
    }

    void SendMessageToFrontend(const v8_inspector::StringView& message)
        override {
      Isolate* isolate = env_->isolate();
      HandleScope handle_scope(isolate);
      Context::Scope context_scope(env_->context());
      MaybeLocal<String> v8string =
          String::NewFromTwoByte(isolate, message.characters16(),
                                 NewStringType::kNormal, message.length());
      Local<Value> argument = v8string.ToLocalChecked().As<Value>();
      connection_->OnMessage(argument);
    }

   private:
    Environment* env_;
    BaseObjectPtr<JSBindingsConnection> connection_;
  };

  JSBindingsConnection(Environment* env,
                       Local<Object> wrap,
                       Local<Function> callback)
                       : AsyncWrap(env, wrap, PROVIDER_INSPECTORJSBINDING),
                         callback_(env->isolate(), callback) {
    Agent* inspector = env->inspector_agent();
    session_ = ConnectionType::Connect(
        inspector, std::make_unique<JSBindingsSessionDelegate>(env, this));
  }

  void OnMessage(Local<Value> value) {
    MakeCallback(callback_.Get(env()->isolate()), 1, &value);
  }

  static void Bind(Environment* env, Local<Object> target) {
    Local<String> class_name = ConnectionType::GetClassName(env);
    Local<FunctionTemplate> tmpl =
        env->NewFunctionTemplate(JSBindingsConnection::New);
    tmpl->InstanceTemplate()->SetInternalFieldCount(
        JSBindingsConnection::kInternalFieldCount);
    tmpl->SetClassName(class_name);
    tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
    env->SetProtoMethod(tmpl, "dispatch", JSBindingsConnection::Dispatch);
    env->SetProtoMethod(tmpl, "disconnect", JSBindingsConnection::Disconnect);
    target->Set(env->context(),
                class_name,
                tmpl->GetFunction(env->context()).ToLocalChecked())
        .ToChecked();
  }

  static void New(const FunctionCallbackInfo<Value>& info) {
    Environment* env = Environment::GetCurrent(info);
    CHECK(info[0]->IsFunction());
    Local<Function> callback = info[0].As<Function>();
    new JSBindingsConnection(env, info.This(), callback);
  }

  void Disconnect() {
    session_.reset();
    delete this;
  }

  static void Disconnect(const FunctionCallbackInfo<Value>& info) {
    JSBindingsConnection* session;
    ASSIGN_OR_RETURN_UNWRAP(&session, info.Holder());
    session->Disconnect();
  }

  static void Dispatch(const FunctionCallbackInfo<Value>& info) {
    Environment* env = Environment::GetCurrent(info);
    JSBindingsConnection* session;
    ASSIGN_OR_RETURN_UNWRAP(&session, info.Holder());
    CHECK(info[0]->IsString());

    if (session->session_) {
      session->session_->Dispatch(
          ToProtocolString(env->isolate(), info[0])->string());
    }
  }

  void MemoryInfo(MemoryTracker* tracker) const override {
    tracker->TrackField("callback", callback_);
    tracker->TrackFieldWithSize(
        "session", sizeof(*session_), "InspectorSession");
  }

  SET_MEMORY_INFO_NAME(JSBindingsConnection)
  SET_SELF_SIZE(JSBindingsConnection)

  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
    return true;  // Binding connections emit events on their own.
  }

 private:
  std::unique_ptr<InspectorSession> session_;
  Global<Function> callback_;
};

static bool InspectorEnabled(Environment* env) {
  Agent* agent = env->inspector_agent();
  return agent->IsActive();
}

void SetConsoleExtensionInstaller(const FunctionCallbackInfo<Value>& info) {
  auto env = Environment::GetCurrent(info);

  CHECK_EQ(info.Length(), 1);
  CHECK(info[0]->IsFunction());

  env->set_inspector_console_extension_installer(info[0].As<Function>());
}

void CallAndPauseOnStart(const FunctionCallbackInfo<v8::Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  CHECK_GT(args.Length(), 1);
  CHECK(args[0]->IsFunction());
  SlicedArguments call_args(args, /* start */ 2);
  env->inspector_agent()->PauseOnNextJavascriptStatement("Break on start");
  v8::MaybeLocal<v8::Value> retval =
      args[0].As<v8::Function>()->Call(env->context(), args[1],
                                       call_args.length(), call_args.out());
  if (!retval.IsEmpty()) {
    args.GetReturnValue().Set(retval.ToLocalChecked());
  }
}

void InspectorConsoleCall(const FunctionCallbackInfo<Value>& info) {
  Environment* env = Environment::GetCurrent(info);
  Isolate* isolate = env->isolate();
  Local<Context> context = isolate->GetCurrentContext();
  CHECK_GE(info.Length(), 2);
  SlicedArguments call_args(info, /* start */ 2);
  if (InspectorEnabled(env)) {
    Local<Value> inspector_method = info[0];
    CHECK(inspector_method->IsFunction());
    if (!env->is_in_inspector_console_call()) {
      env->set_is_in_inspector_console_call(true);
      MaybeLocal<Value> ret =
          inspector_method.As<Function>()->Call(context,
                                                info.Holder(),
                                                call_args.length(),
                                                call_args.out());
      env->set_is_in_inspector_console_call(false);
      if (ret.IsEmpty())
        return;
    }
  }

  Local<Value> node_method = info[1];
  CHECK(node_method->IsFunction());
  node_method.As<Function>()->Call(context,
                                   info.Holder(),
                                   call_args.length(),
                                   call_args.out()).FromMaybe(Local<Value>());
}

static void* GetAsyncTask(int64_t asyncId) {
  // The inspector assumes that when other clients use its asyncTask* API,
  // they use real pointers, or at least something aligned like real pointer.
  // In general it means that our task_id should always be even.
  //
  // On 32bit platforms, the 64bit asyncId would get truncated when converted
  // to a 32bit pointer. However, the javascript part will never enable
  // the async_hook on 32bit platforms, therefore the truncation will never
  // happen in practice.
  return reinterpret_cast<void*>(asyncId << 1);
}

template <void (Agent::*asyncTaskFn)(void*)>
static void InvokeAsyncTaskFnWithId(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  CHECK(args[0]->IsNumber());
  int64_t task_id = args[0]->IntegerValue(env->context()).FromJust();
  (env->inspector_agent()->*asyncTaskFn)(GetAsyncTask(task_id));
}

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

  CHECK(args[0]->IsString());
  Local<String> task_name = args[0].As<String>();
  String::Value task_name_value(args.GetIsolate(), task_name);
  StringView task_name_view(*task_name_value, task_name_value.length());

  CHECK(args[1]->IsNumber());
  int64_t task_id = args[1]->IntegerValue(env->context()).FromJust();
  void* task = GetAsyncTask(task_id);

  CHECK(args[2]->IsBoolean());
  bool recurring = args[2]->BooleanValue(args.GetIsolate());

  env->inspector_agent()->AsyncTaskScheduled(task_name_view, task, recurring);
}

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

  CHECK(args[0]->IsFunction());
  Local<Function> enable_function = args[0].As<Function>();
  CHECK(args[1]->IsFunction());
  Local<Function> disable_function = args[1].As<Function>();
  env->inspector_agent()->RegisterAsyncHook(env->isolate(),
    enable_function, disable_function);
}

void IsEnabled(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  args.GetReturnValue().Set(InspectorEnabled(env));
}

void Open(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Agent* agent = env->inspector_agent();

  if (args.Length() > 0 && args[0]->IsUint32()) {
    uint32_t port = args[0].As<Uint32>()->Value();
    ExclusiveAccess<HostPort>::Scoped host_port(agent->host_port());
    host_port->set_port(static_cast<int>(port));
  }

  if (args.Length() > 1 && args[1]->IsString()) {
    Utf8Value host(env->isolate(), args[1].As<String>());
    ExclusiveAccess<HostPort>::Scoped host_port(agent->host_port());
    host_port->set_host(*host);
  }

  agent->StartIoThread();
}

void WaitForDebugger(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  Agent* agent = env->inspector_agent();
  if (agent->IsActive())
    agent->WaitForConnect();
  args.GetReturnValue().Set(agent->IsActive());
}

void Url(const FunctionCallbackInfo<Value>& args) {
  Environment* env = Environment::GetCurrent(args);
  std::string url = env->inspector_agent()->GetWsUrl();
  if (url.empty()) {
    return;
  }
  args.GetReturnValue().Set(OneByteString(env->isolate(), url.c_str()));
}

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

  v8::Local<v8::Function> consoleCallFunc =
      env->NewFunctionTemplate(InspectorConsoleCall, v8::Local<v8::Signature>(),
                               v8::ConstructorBehavior::kThrow,
                               v8::SideEffectType::kHasSideEffect)
          ->GetFunction(context)
          .ToLocalChecked();
  auto name_string = FIXED_ONE_BYTE_STRING(env->isolate(), "consoleCall");
  target->Set(context, name_string, consoleCallFunc).Check();
  consoleCallFunc->SetName(name_string);

  env->SetMethod(
      target, "setConsoleExtensionInstaller", SetConsoleExtensionInstaller);
  env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart);
  env->SetMethod(target, "open", Open);
  env->SetMethodNoSideEffect(target, "url", Url);
  env->SetMethod(target, "waitForDebugger", WaitForDebugger);

  env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper);
  env->SetMethod(target, "asyncTaskCanceled",
      InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>);
  env->SetMethod(target, "asyncTaskStarted",
      InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>);
  env->SetMethod(target, "asyncTaskFinished",
      InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);

  env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper);
  env->SetMethodNoSideEffect(target, "isEnabled", IsEnabled);

  JSBindingsConnection<LocalConnection>::Bind(env, target);
  JSBindingsConnection<MainThreadConnection>::Bind(env, target);
}

}  // namespace

void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
  registry->Register(InspectorConsoleCall);
  registry->Register(SetConsoleExtensionInstaller);
  registry->Register(CallAndPauseOnStart);
  registry->Register(Open);
  registry->Register(Url);
  registry->Register(WaitForDebugger);

  registry->Register(AsyncTaskScheduledWrapper);
  registry->Register(InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>);
  registry->Register(InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>);
  registry->Register(InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);

  registry->Register(RegisterAsyncHookWrapper);
  registry->Register(IsEnabled);

  registry->Register(JSBindingsConnection<LocalConnection>::New);
  registry->Register(JSBindingsConnection<LocalConnection>::Dispatch);
  registry->Register(JSBindingsConnection<LocalConnection>::Disconnect);
  registry->Register(JSBindingsConnection<MainThreadConnection>::New);
  registry->Register(JSBindingsConnection<MainThreadConnection>::Dispatch);
  registry->Register(JSBindingsConnection<MainThreadConnection>::Disconnect);
}

}  // namespace inspector
}  // namespace node

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


Generated by: GCOVR (Version 3.4)

Line	Branch	Exec	Source
1			#include "base_object-inl.h"
2			#include "inspector_agent.h"
3			#include "inspector_io.h"
4			#include "memory_tracker-inl.h"
5			#include "node_external_reference.h"
6			#include "util-inl.h"
7			#include "v8-inspector.h"
8			#include "v8.h"
9
10			#include <memory>
11
12			namespace node {
13			namespace inspector {
14			namespace {
15
16			using v8::Context;
17			using v8::Function;
18			using v8::FunctionCallbackInfo;
19			using v8::FunctionTemplate;
20			using v8::Global;
21			using v8::HandleScope;
22			using v8::Isolate;
23			using v8::Local;
24			using v8::MaybeLocal;
25			using v8::NewStringType;
26			using v8::Object;
27			using v8::String;
28			using v8::Uint32;
29			using v8::Value;
30
31			using v8_inspector::StringBuffer;
32			using v8_inspector::StringView;
33
34		1027	std::unique_ptr<StringBuffer> ToProtocolString(Isolate* isolate,
35			Local<Value> value) {
36		2054	TwoByteValue buffer(isolate, value);
37		2054	return StringBuffer::create(StringView(*buffer, buffer.length()));
38			}
39
40			struct LocalConnection {
41		768	static std::unique_ptr<InspectorSession> Connect(
42			Agent* inspector, std::unique_ptr<InspectorSessionDelegate> delegate) {
43		768	return inspector->Connect(std::move(delegate), false);
44			}
45
46		444	static Local<String> GetClassName(Environment* env) {
47		444	return FIXED_ONE_BYTE_STRING(env->isolate(), "Connection");
48			}
49			};
50
51			struct MainThreadConnection {
52		2	static std::unique_ptr<InspectorSession> Connect(
53			Agent* inspector, std::unique_ptr<InspectorSessionDelegate> delegate) {
54		2	return inspector->ConnectToMainThread(std::move(delegate), true);
55			}
56
57		444	static Local<String> GetClassName(Environment* env) {
58		444	return FIXED_ONE_BYTE_STRING(env->isolate(), "MainThreadConnection");
59			}
60			};
61
62			template <typename ConnectionType>
63		2307	class JSBindingsConnection : public AsyncWrap {
64			public:
65		1538	class JSBindingsSessionDelegate : public InspectorSessionDelegate {
66			public:
67		770	JSBindingsSessionDelegate(Environment* env,
68			JSBindingsConnection* connection)
69			: env_(env),
70		770	connection_(connection) {
71		770	}
72
73		5630	void SendMessageToFrontend(const v8_inspector::StringView& message)
74			override {
75		5630	Isolate* isolate = env_->isolate();
76		11260	HandleScope handle_scope(isolate);
77		5630	Context::Scope context_scope(env_->context());
78			MaybeLocal<String> v8string =
79		5630	String::NewFromTwoByte(isolate, message.characters16(),
80		11260	NewStringType::kNormal, message.length());
81		11260	Local<Value> argument = v8string.ToLocalChecked().As<Value>();
82		5630	connection_->OnMessage(argument);
83		5630	}
84
85			private:
86			Environment* env_;
87			BaseObjectPtr<JSBindingsConnection> connection_;
88			};
89
90		770	JSBindingsConnection(Environment* env,
91			Local<Object> wrap,
92			Local<Function> callback)
93			: AsyncWrap(env, wrap, PROVIDER_INSPECTORJSBINDING),
94		770	callback_(env->isolate(), callback) {
95		770	Agent* inspector = env->inspector_agent();
96		770	session_ = ConnectionType::Connect(
97			inspector, std::make_unique<JSBindingsSessionDelegate>(env, this));
98		770	}
99
100		5630	void OnMessage(Local<Value> value) {
101		11260	MakeCallback(callback_.Get(env()->isolate()), 1, &value);
102		5630	}
103
104		888	static void Bind(Environment* env, Local<Object> target) {
105		888	Local<String> class_name = ConnectionType::GetClassName(env);
106			Local<FunctionTemplate> tmpl =
107		888	env->NewFunctionTemplate(JSBindingsConnection::New);
108		1776	tmpl->InstanceTemplate()->SetInternalFieldCount(
109			JSBindingsConnection::kInternalFieldCount);
110		888	tmpl->SetClassName(class_name);
111		1776	tmpl->Inherit(AsyncWrap::GetConstructorTemplate(env));
112		888	env->SetProtoMethod(tmpl, "dispatch", JSBindingsConnection::Dispatch);
113		888	env->SetProtoMethod(tmpl, "disconnect", JSBindingsConnection::Disconnect);
114		2664	target->Set(env->context(),
115			class_name,
116		2664	tmpl->GetFunction(env->context()).ToLocalChecked())
117			.ToChecked();
118		888	}
119
120		770	static void New(const FunctionCallbackInfo<Value>& info) {
121		770	Environment* env = Environment::GetCurrent(info);
122	✗✓✗✓	1540	CHECK(info[0]->IsFunction());
123		1540	Local<Function> callback = info[0].As<Function>();
124		770	new JSBindingsConnection(env, info.This(), callback);
125		770	}
126
127		756	void Disconnect() {
128		756	session_.reset();
129	✗✗✓✗	756	delete this;
130		756	}
131
132		756	static void Disconnect(const FunctionCallbackInfo<Value>& info) {
133			JSBindingsConnection* session;
134	✗✗✗✓	756	ASSIGN_OR_RETURN_UNWRAP(&session, info.Holder());
135		756	session->Disconnect();
136			}
137
138		1027	static void Dispatch(const FunctionCallbackInfo<Value>& info) {
139		1027	Environment* env = Environment::GetCurrent(info);
140			JSBindingsConnection* session;
141	✗✓✗✓	1027	ASSIGN_OR_RETURN_UNWRAP(&session, info.Holder());
142	✗✓✗✓	3081	CHECK(info[0]->IsString());
143
144	✓✗✓✗	1027	if (session->session_) {
145		2054	session->session_->Dispatch(
146		2054	ToProtocolString(env->isolate(), info[0])->string());
147			}
148			}
149
150		2	void MemoryInfo(MemoryTracker* tracker) const override {
151		2	tracker->TrackField("callback", callback_);
152		2	tracker->TrackFieldWithSize(
153			"session", sizeof(*session_), "InspectorSession");
154		2	}
155
156		2	SET_MEMORY_INFO_NAME(JSBindingsConnection)
157		2	SET_SELF_SIZE(JSBindingsConnection)
158
159			bool IsNotIndicativeOfMemoryLeakAtExit() const override {
160			return true; // Binding connections emit events on their own.
161			}
162
163			private:
164			std::unique_ptr<InspectorSession> session_;
165			Global<Function> callback_;
166			};
167
168		17463	static bool InspectorEnabled(Environment* env) {
169		17463	Agent* agent = env->inspector_agent();
170		17463	return agent->IsActive();
171			}
172
173		444	void SetConsoleExtensionInstaller(const FunctionCallbackInfo<Value>& info) {
174		444	auto env = Environment::GetCurrent(info);
175
176	✗✓	444	CHECK_EQ(info.Length(), 1);
177	✗✓	888	CHECK(info[0]->IsFunction());
178
179		888	env->set_inspector_console_extension_installer(info[0].As<Function>());
180		444	}
181
182		8	void CallAndPauseOnStart(const FunctionCallbackInfo<v8::Value>& args) {
183		8	Environment* env = Environment::GetCurrent(args);
184	✗✓	8	CHECK_GT(args.Length(), 1);
185	✗✓	16	CHECK(args[0]->IsFunction());
186		14	SlicedArguments call_args(args, /* start */ 2);
187		8	env->inspector_agent()->PauseOnNextJavascriptStatement("Break on start");
188			v8::MaybeLocal<v8::Value> retval =
189		22	args[0].As<v8::Function>()->Call(env->context(), args[1],
190		24	call_args.length(), call_args.out());
191	✓✓	6	if (!retval.IsEmpty()) {
192		10	args.GetReturnValue().Set(retval.ToLocalChecked());
193			}
194		6	}
195
196		17458	void InspectorConsoleCall(const FunctionCallbackInfo<Value>& info) {
197		17458	Environment* env = Environment::GetCurrent(info);
198		17458	Isolate* isolate = env->isolate();
199		17458	Local<Context> context = isolate->GetCurrentContext();
200	✗✓	17458	CHECK_GE(info.Length(), 2);
201		34907	SlicedArguments call_args(info, /* start */ 2);
202	✓✓	17458	if (InspectorEnabled(env)) {
203		17423	Local<Value> inspector_method = info[0];
204	✗✓	17423	CHECK(inspector_method->IsFunction());
205	✓✓	17423	if (!env->is_in_inspector_console_call()) {
206		17422	env->set_is_in_inspector_console_call(true);
207			MaybeLocal<Value> ret =
208		34844	inspector_method.As<Function>()->Call(context,
209			info.Holder(),
210		17422	call_args.length(),
211		69688	call_args.out());
212		17422	env->set_is_in_inspector_console_call(false);
213	✓✓	17422	if (ret.IsEmpty())
214		9	return;
215			}
216			}
217
218		17449	Local<Value> node_method = info[1];
219	✗✓	17449	CHECK(node_method->IsFunction());
220		52347	node_method.As<Function>()->Call(context,
221			info.Holder(),
222		17449	call_args.length(),
223	✓✓	69796	call_args.out()).FromMaybe(Local<Value>());
224			}
225
226		7	static void* GetAsyncTask(int64_t asyncId) {
227			// The inspector assumes that when other clients use its asyncTask* API,
228			// they use real pointers, or at least something aligned like real pointer.
229			// In general it means that our task_id should always be even.
230			//
231			// On 32bit platforms, the 64bit asyncId would get truncated when converted
232			// to a 32bit pointer. However, the javascript part will never enable
233			// the async_hook on 32bit platforms, therefore the truncation will never
234			// happen in practice.
235		7	return reinterpret_cast<void*>(asyncId << 1);
236			}
237
238			template <void (Agent::asyncTaskFn)(void)>
239		6	static void InvokeAsyncTaskFnWithId(const FunctionCallbackInfo<Value>& args) {
240		6	Environment* env = Environment::GetCurrent(args);
241	✗✓✗✓ ✗✓	12	CHECK(args[0]->IsNumber());
242		24	int64_t task_id = args[0]->IntegerValue(env->context()).FromJust();
243		6	(env->inspector_agent()->*asyncTaskFn)(GetAsyncTask(task_id));
244		6	}
245
246		1	static void AsyncTaskScheduledWrapper(const FunctionCallbackInfo<Value>& args) {
247		1	Environment* env = Environment::GetCurrent(args);
248
249	✗✓	3	CHECK(args[0]->IsString());
250		2	Local<String> task_name = args[0].As<String>();
251		2	String::Value task_name_value(args.GetIsolate(), task_name);
252		1	StringView task_name_view(*task_name_value, task_name_value.length());
253
254	✗✓	2	CHECK(args[1]->IsNumber());
255		4	int64_t task_id = args[1]->IntegerValue(env->context()).FromJust();
256		1	void* task = GetAsyncTask(task_id);
257
258	✗✓	2	CHECK(args[2]->IsBoolean());
259		3	bool recurring = args[2]->BooleanValue(args.GetIsolate());
260
261		1	env->inspector_agent()->AsyncTaskScheduled(task_name_view, task, recurring);
262		1	}
263
264		5018	static void RegisterAsyncHookWrapper(const FunctionCallbackInfo<Value>& args) {
265		5018	Environment* env = Environment::GetCurrent(args);
266
267	✗✓	10036	CHECK(args[0]->IsFunction());
268		10036	Local<Function> enable_function = args[0].As<Function>();
269	✗✓	10036	CHECK(args[1]->IsFunction());
270		10036	Local<Function> disable_function = args[1].As<Function>();
271		5018	env->inspector_agent()->RegisterAsyncHook(env->isolate(),
272		5018	enable_function, disable_function);
273		5018	}
274
275		5	void IsEnabled(const FunctionCallbackInfo<Value>& args) {
276		5	Environment* env = Environment::GetCurrent(args);
277		15	args.GetReturnValue().Set(InspectorEnabled(env));
278		5	}
279
280			void Open(const FunctionCallbackInfo<Value>& args) {
281			Environment* env = Environment::GetCurrent(args);
282			Agent* agent = env->inspector_agent();
283
284			if (args.Length() > 0 && args[0]->IsUint32()) {
285			uint32_t port = args[0].As<Uint32>()->Value();
286			ExclusiveAccess<HostPort>::Scoped host_port(agent->host_port());
287			host_port->set_port(static_cast<int>(port));
288			}
289
290			if (args.Length() > 1 && args[1]->IsString()) {
291			Utf8Value host(env->isolate(), args[1].As<String>());
292			ExclusiveAccess<HostPort>::Scoped host_port(agent->host_port());
293			host_port->set_host(*host);
294			}
295
296			agent->StartIoThread();
297			}
298
299			void WaitForDebugger(const FunctionCallbackInfo<Value>& args) {
300			Environment* env = Environment::GetCurrent(args);
301			Agent* agent = env->inspector_agent();
302			if (agent->IsActive())
303			agent->WaitForConnect();
304			args.GetReturnValue().Set(agent->IsActive());
305			}
306
307		6	void Url(const FunctionCallbackInfo<Value>& args) {
308		6	Environment* env = Environment::GetCurrent(args);
309		11	std::string url = env->inspector_agent()->GetWsUrl();
310	✓✓	6	if (url.empty()) {
311		1	return;
312			}
313	✓✓	15	args.GetReturnValue().Set(OneByteString(env->isolate(), url.c_str()));
314			}
315
316		444	void Initialize(Local<Object> target, Local<Value> unused,
317			Local<Context> context, void* priv) {
318		444	Environment* env = Environment::GetCurrent(context);
319
320			v8::Local<v8::Function> consoleCallFunc =
321		888	env->NewFunctionTemplate(InspectorConsoleCall, v8::Local<v8::Signature>(),
322			v8::ConstructorBehavior::kThrow,
323		444	v8::SideEffectType::kHasSideEffect)
324		888	->GetFunction(context)
325		444	.ToLocalChecked();
326		444	auto name_string = FIXED_ONE_BYTE_STRING(env->isolate(), "consoleCall");
327		888	target->Set(context, name_string, consoleCallFunc).Check();
328		444	consoleCallFunc->SetName(name_string);
329
330			env->SetMethod(
331		444	target, "setConsoleExtensionInstaller", SetConsoleExtensionInstaller);
332		444	env->SetMethod(target, "callAndPauseOnStart", CallAndPauseOnStart);
333		444	env->SetMethod(target, "open", Open);
334		444	env->SetMethodNoSideEffect(target, "url", Url);
335		444	env->SetMethod(target, "waitForDebugger", WaitForDebugger);
336
337		444	env->SetMethod(target, "asyncTaskScheduled", AsyncTaskScheduledWrapper);
338			env->SetMethod(target, "asyncTaskCanceled",
339		444	InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>);
340			env->SetMethod(target, "asyncTaskStarted",
341		444	InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>);
342			env->SetMethod(target, "asyncTaskFinished",
343		444	InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);
344
345		444	env->SetMethod(target, "registerAsyncHook", RegisterAsyncHookWrapper);
346		444	env->SetMethodNoSideEffect(target, "isEnabled", IsEnabled);
347
348		444	JSBindingsConnection<LocalConnection>::Bind(env, target);
349		444	JSBindingsConnection<MainThreadConnection>::Bind(env, target);
350		444	}
351
352			} // namespace
353
354		4614	void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
355		4614	registry->Register(InspectorConsoleCall);
356		4614	registry->Register(SetConsoleExtensionInstaller);
357		4614	registry->Register(CallAndPauseOnStart);
358		4614	registry->Register(Open);
359		4614	registry->Register(Url);
360		4614	registry->Register(WaitForDebugger);
361
362		4614	registry->Register(AsyncTaskScheduledWrapper);
363		4614	registry->Register(InvokeAsyncTaskFnWithId<&Agent::AsyncTaskCanceled>);
364		4614	registry->Register(InvokeAsyncTaskFnWithId<&Agent::AsyncTaskStarted>);
365		4614	registry->Register(InvokeAsyncTaskFnWithId<&Agent::AsyncTaskFinished>);
366
367		4614	registry->Register(RegisterAsyncHookWrapper);
368		4614	registry->Register(IsEnabled);
369
370		4614	registry->Register(JSBindingsConnection<LocalConnection>::New);
371		4614	registry->Register(JSBindingsConnection<LocalConnection>::Dispatch);
372		4614	registry->Register(JSBindingsConnection<LocalConnection>::Disconnect);
373		4614	registry->Register(JSBindingsConnection<MainThreadConnection>::New);
374		4614	registry->Register(JSBindingsConnection<MainThreadConnection>::Dispatch);
375		4614	registry->Register(JSBindingsConnection<MainThreadConnection>::Disconnect);
376		4614	}
377
378			} // namespace inspector
379			} // namespace node
380
381		4683	NODE_MODULE_CONTEXT_AWARE_INTERNAL(inspector,
382			node::inspector::Initialize)
383	✓✗✓✗	18687	NODE_MODULE_EXTERNAL_REFERENCE(inspector,
384			node::inspector::RegisterExternalReferences)