inspector: remove AgentImpl

AgentImpl was introduce so inspector-agent.h does not leak libuv and
inspector implementation details. Inspector had been reworked since and
new classes provide this isolation and AgentImpl became unnecessary
level of indirection. This change removes that class to streamline the
code.
PR-URL: #12576
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>

Author: Eugene Ostroukhov

src/inspector_agent.cc

@@ -44,6 +44,11 @@ std::unique_ptr<StringBuffer> ToProtocolString(Isolate* isolate,
 returnStringBuffer::create(StringView(*buffer, buffer.length()));
 }
 
+// Called from the main thread.
+voidStartInspectorIoThreadAsyncCallback(uv_async_t* handle) {
+static_cast<Agent*>(handle->data)->StartIoThread();
+}
+
 #ifdef __POSIX__
 staticvoidEnableInspectorIOThreadSignalHandler(int signo) {
 uv_sem_post(&inspector_io_thread_semaphore);
@@ -156,61 +161,6 @@ static int RegisterDebugSignalHandler() {
 constintNANOS_PER_MSEC = 1000000;
 constintCONTEXT_GROUP_ID = 1;
 
-classNodeInspectorClient;
-
-classAgentImpl {
-public:
-explicitAgentImpl(node::Environment* env);
-
-boolStart(v8::Platform* platform, constchar* path,
-const DebugOptions& options);
-voidStop();
-boolIsStarted();
-boolIsConnected();
-voidWaitForDisconnect();
-
-voidFatalException(Local<Value> error,
- Local<v8::Message> message);
-
-voidSchedulePauseOnNextStatement(const std::string& reason);
-
-voidConnect(InspectorSessionDelegate* session);
-
- NodeInspectorClient* client() {
-return inspector_.get();
- }
-
-private:
-template <typename Action>
-using MessageQueue =
- std::vector<std::tuple<Action, int, std::unique_ptr<StringBuffer>>>;
-enumclassState { kNew, kAccepting, kConnected, kDone, kError };
-
-staticvoidThreadCbIO(void* agent);
-staticvoidWriteCbIO(uv_async_t* async);
-staticvoidCallAndPauseOnStart(const v8::FunctionCallbackInfo<v8::Value>&);
-
-voidWorkerRunIO();
-voidSetConnected(bool connected);
-voidWaitForFrontendMessage();
-voidNotifyMessageReceived();
-boolStartIoThread();
-staticvoidInspectorWrapConsoleCall(
-const v8::FunctionCallbackInfo<Value>& args);
-staticvoidInspectorConsoleCall(
-const v8::FunctionCallbackInfo<Value>& info);
-staticvoidStartInspectorIoThreadAsyncCallback(uv_async_t* handle);
- State ToState(State state);
-
- node::Environment* parent_env_;
- std::unique_ptr<NodeInspectorClient> inspector_;
- std::unique_ptr<InspectorIo> io_;
- v8::Platform* platform_;
-bool inspector_console_;
- std::string path_;
- DebugOptions debug_options_;
-};
-
 classChannelImplfinal : public v8_inspector::V8Inspector::Channel {
 public:
 explicitChannelImpl(V8Inspector* inspector,
@@ -367,14 +317,18 @@ class NodeInspectorClient : public v8_inspector::V8InspectorClient {
  std::unique_ptr<ChannelImpl> channel_;
 };
 
-AgentImpl::AgentImpl(Environment* env) : parent_env_(env),
- inspector_(nullptr),
- platform_(nullptr),
- inspector_console_(false) {}
+Agent::Agent(Environment* env) : parent_env_(env),
+ inspector_(nullptr),
+ platform_(nullptr),
+ inspector_console_(false) {}
+
+// Header has unique_ptr to some incomplete types - this definition tells
+// the compiler to figure out destruction here, were those types are complete
+Agent::~Agent() {
+}
 
 // static
-voidAgentImpl::InspectorConsoleCall(
-const v8::FunctionCallbackInfo<Value>& info) {
+voidAgent::InspectorConsoleCall(const v8::FunctionCallbackInfo<Value>& info) {
  Isolate* isolate = info.GetIsolate();
  Local<Context> context = isolate->GetCurrentContext();
 
@@ -388,7 +342,7 @@ void AgentImpl::InspectorConsoleCall(
  }
 
  Environment* env = Environment::GetCurrent(isolate);
-if (env->inspector_agent()->impl->inspector_console_) {
+if (env->inspector_agent()->inspector_console_) {
  Local<Value> inspector_method = args->Get(context, 0).ToLocalChecked();
 CHECK(inspector_method->IsFunction());
  Local<Value> config_value = args->Get(context, 2).ToLocalChecked();
@@ -417,33 +371,25 @@ void AgentImpl::InspectorConsoleCall(
 }
 
 // static
-voidAgentImpl::InspectorWrapConsoleCall(
-const FunctionCallbackInfo<Value>& args) {
- Environment* env = Environment::GetCurrent(args);
-
-if (args.Length() != 3 || !args[0]->IsFunction() ||
- !args[1]->IsFunction() || !args[2]->IsObject()) {
+voidAgent::InspectorWrapConsoleCall(const FunctionCallbackInfo<Value>& info) {
+ Environment* env = Environment::GetCurrent(info);
+if (info.Length() != 3 || !info[0]->IsFunction() ||
+ !info[1]->IsFunction() || !info[2]->IsObject()) {
 return env->ThrowError("inspector.wrapConsoleCall takes exactly 3 "
 "arguments: two functions and an object.");
  }
 
- Local<v8::Array> array = v8::Array::New(env->isolate(), args.Length());
-CHECK(array->Set(env->context(), 0, args[0]).FromJust());
-CHECK(array->Set(env->context(), 1, args[1]).FromJust());
-CHECK(array->Set(env->context(), 2, args[2]).FromJust());
-args.GetReturnValue().Set(Function::New(env->context(),
+ Local<v8::Array> array = v8::Array::New(env->isolate(), info.Length());
+CHECK(array->Set(env->context(), 0, info[0]).FromJust());
+CHECK(array->Set(env->context(), 1, info[1]).FromJust());
+CHECK(array->Set(env->context(), 2, info[2]).FromJust());
+info.GetReturnValue().Set(Function::New(env->context(),
  InspectorConsoleCall,
  array).ToLocalChecked());
 }
 
-// Called from the main thread.
-// static
-voidAgentImpl::StartInspectorIoThreadAsyncCallback(uv_async_t* handle) {
-reinterpret_cast<AgentImpl*>(handle->data)->StartIoThread();
-}
-
-boolAgentImpl::Start(v8::Platform* platform, constchar* path,
-const DebugOptions& options) {
+boolAgent::Start(v8::Platform* platform, constchar* path,
+const DebugOptions& options) {
  path_ = path == nullptr ? "" : path;
  debug_options_ = options;
  inspector_console_ = false;
@@ -479,7 +425,7 @@ bool AgentImpl::Start(v8::Platform* platform, const char* path,
  }
 }
 
-boolAgentImpl::StartIoThread() {
+boolAgent::StartIoThread() {
 if (io_ != nullptr)
 returntrue;
 
@@ -517,27 +463,27 @@ bool AgentImpl::StartIoThread() {
 returntrue;
 }
 
-voidAgentImpl::Stop() {
+voidAgent::Stop() {
 if (io_ != nullptr)
  io_->Stop();
 }
 
-voidAgentImpl::Connect(InspectorSessionDelegate* delegate) {
+voidAgent::Connect(InspectorSessionDelegate* delegate) {
  inspector_console_ = true;
  inspector_->connectFrontend(delegate);
 }
 
-boolAgentImpl::IsConnected() {
+boolAgent::IsConnected() {
 return io_ && io_->IsConnected();
 }
 
-boolAgentImpl::IsStarted() {
+boolAgent::IsStarted() {
 return !!inspector_;
 }
 
 // static
-voidAgentImpl::CallAndPauseOnStart(
-const v8::FunctionCallbackInfo<v8::Value>& args) {
+voidAgent::CallAndPauseOnStart(
+const v8::FunctionCallbackInfo<v8::Value>& args) {
  Environment* env = Environment::GetCurrent(args);
 CHECK_GT(args.Length(), 1);
 CHECK(args[0]->IsFunction());
@@ -546,91 +492,41 @@ void AgentImpl::CallAndPauseOnStart(
  call_args.push_back(args[i]);
  }
 
- env->inspector_agent()->SchedulePauseOnNextStatement("Break on start");
+ Agent* agent = env->inspector_agent();
+ agent->inspector_->schedulePauseOnNextStatement("Break on start");
 
  v8::MaybeLocal<v8::Value> retval =
  args[0].As<v8::Function>()->Call(env->context(), args[1],
  call_args.size(), call_args.data());
  args.GetReturnValue().Set(retval.ToLocalChecked());
 }
 
-voidAgentImpl::WaitForDisconnect() {
+voidAgent::WaitForDisconnect() {
 if (io_ != nullptr) {
  io_->WaitForDisconnect();
  }
 }
 
-voidAgentImpl::FatalException(Local<Value> error,
- Local<v8::Message> message) {
+voidAgent::FatalException(Local<Value> error, Local<v8::Message> message) {
 if (!IsStarted())
 return;
  inspector_->FatalException(error, message);
 WaitForDisconnect();
 }
 
-voidAgentImpl::SchedulePauseOnNextStatement(const std::string& reason) {
- inspector_->schedulePauseOnNextStatement(reason);
-}
-
-// Exported class Agent
-Agent::Agent(node::Environment* env) : impl(new AgentImpl(env)) {}
-
-Agent::~Agent() {
-delete impl;
-}
-
-boolAgent::Start(v8::Platform* platform, constchar* path,
-const DebugOptions& options) {
-return impl->Start(platform, path, options);
-}
-
-voidAgent::Stop() {
- impl->Stop();
-}
-
-boolAgent::IsStarted() {
-return impl->IsStarted();
-}
-
-boolAgent::IsConnected() {
-return impl->IsConnected();
-}
-
-voidAgent::WaitForDisconnect() {
- impl->WaitForDisconnect();
-}
-
-voidAgent::FatalException(Local<Value> error,
- Local<v8::Message> message) {
- impl->FatalException(error, message);
-}
-
-voidAgent::SchedulePauseOnNextStatement(const std::string& reason) {
- impl->SchedulePauseOnNextStatement(reason);
-}
-
-voidAgent::Connect(InspectorSessionDelegate* delegate) {
- impl->Connect(delegate);
-}
-
 voidAgent::Dispatch(const StringView& message) {
-CHECK_NE(impl->client(), nullptr);
-impl->client()->dispatchMessageFromFrontend(message);
+CHECK_NE(inspector_, nullptr);
+inspector_->dispatchMessageFromFrontend(message);
 }
 
 voidAgent::Disconnect() {
-CHECK_NE(impl->client(), nullptr);
- impl->client()->disconnectFrontend();
-}
-
-InspectorSessionDelegate* Agent::delegate() {
-CHECK_NE(impl->client(), nullptr);
-return impl->client()->delegate();
+CHECK_NE(inspector_, nullptr);
+ inspector_->disconnectFrontend();
 }
 
 voidAgent::RunMessageLoop() {
-CHECK_NE(impl->client(), nullptr);
-impl->client()->runMessageLoopOnPause(CONTEXT_GROUP_ID);
+CHECK_NE(inspector_, nullptr);
+inspector_->runMessageLoopOnPause(CONTEXT_GROUP_ID);
 }
 
 } // namespace inspector

src/inspector_agent.h

@@ -1,6 +1,8 @@
 #ifndef SRC_INSPECTOR_AGENT_H_
 #defineSRC_INSPECTOR_AGENT_H_
 
+#include<memory>
+
 #include<stddef.h>
 
 #if !HAVE_INSPECTOR
@@ -15,11 +17,13 @@ class Environment;
 } // namespace node
 
 namespacev8 {
-classPlatform;
+template <typename V>
+classFunctionCallbackInfo;
 template<typename T>
 classLocal;
-classValue;
 classMessage;
+classPlatform;
+classValue;
 } // namespace v8
 
 namespacev8_inspector {
@@ -29,37 +33,49 @@ class StringView;
 namespacenode {
 namespaceinspector {
 
-classAgentImpl;
-
 classInspectorSessionDelegate {
 public:
 virtualboolWaitForFrontendMessage() = 0;
 virtualvoidOnMessage(const v8_inspector::StringView& message) = 0;
 };
 
+classInspectorIo;
+classNodeInspectorClient;
+
 classAgent {
 public:
 explicitAgent(node::Environment* env);
 ~Agent();
 
 boolStart(v8::Platform* platform, constchar* path,
 const DebugOptions& options);
+boolStartIoThread();
 voidStop();
 
 boolIsStarted();
 boolIsConnected();
 voidWaitForDisconnect();
 voidFatalException(v8::Local<v8::Value> error,
  v8::Local<v8::Message> message);
-voidSchedulePauseOnNextStatement(const std::string& reason);
 voidConnect(InspectorSessionDelegate* delegate);
 voidDisconnect();
 voidDispatch(const v8_inspector::StringView& message);
- InspectorSessionDelegate* delegate();
 voidRunMessageLoop();
+
 private:
- AgentImpl* impl;
-friendclassAgentImpl;
+staticvoidCallAndPauseOnStart(const v8::FunctionCallbackInfo<v8::Value>&);
+staticvoidInspectorConsoleCall(
+const v8::FunctionCallbackInfo<v8::Value>& info);
+staticvoidInspectorWrapConsoleCall(
+const v8::FunctionCallbackInfo<v8::Value>& info);
+
+ node::Environment* parent_env_;
+ std::unique_ptr<NodeInspectorClient> inspector_;
+ std::unique_ptr<InspectorIo> io_;
+ v8::Platform* platform_;
+bool inspector_console_;
+ std::string path_;
+ DebugOptions debug_options_;
 };
 
 } // namespace inspector