public:

virtual ~InspectorSession() = default;

virtual void Dispatch(const v8_inspector::StringView& message) = 0;

public:

virtual ~InspectorSessionDelegate() = default;

virtual void SendMessageToFrontend(const v8_inspector::StringView& message)

= 0;

public:

explicit Agent(node::Environment* env);

~Agent();

// Create client_, may create io_ if option enabled

bool Start(const std::string& path,

const DebugOptions& options,

std::shared_ptr<ExclusiveAccess<HostPort>> host_port,

bool is_main);

// Stop and destroy io_

void Stop();

bool IsListening() { return io_ != nullptr; }

// Returns true if the Node inspector is actually in use. It will be true

// if either the user explicitly opted into inspector (e.g. with the

// --inspect command line flag) or if inspector JS API had been used.

bool IsActive();

// Blocks till frontend connects and sends "runIfWaitingForDebugger"

void WaitForConnect();

bool WaitForConnectByOptions();

void StopIfWaitingForConnect();

// Blocks till all the sessions with "WaitForDisconnectOnShutdown" disconnect

void WaitForDisconnect();

void ReportUncaughtException(v8::Local<v8::Value> error,

v8::Local<v8::Message> message);

void EmitProtocolEvent(v8::Local<v8::Context> context,

const v8_inspector::StringView& event,

v8::Local<v8::Object> params);

void SetupNetworkTracking(v8::Local<v8::Function> enable_function,

v8::Local<v8::Function> disable_function);

void EnableNetworkTracking();

void DisableNetworkTracking();

// Async stack traces instrumentation.

void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task,

bool recurring);

void AsyncTaskCanceled(void* task);

void AsyncTaskStarted(void* task);

void AsyncTaskFinished(void* task);

void AllAsyncTasksCanceled();

void RegisterAsyncHook(v8::Isolate* isolate,

v8::Local<v8::Function> enable_function,

v8::Local<v8::Function> disable_function);

void SetAsyncHookTrackingEnabled(bool enabled);

void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);

std::unique_ptr<ParentInspectorHandle> GetParentHandle(uint64_t thread_id,

std::string_view url,

std::string_view name);

// Called to create inspector sessions that can be used from the same thread.

// The inspector responds by using the delegate to send messages back.

std::unique_ptr<InspectorSession> Connect(

std::unique_ptr<InspectorSessionDelegate> delegate,

bool prevent_shutdown);

// Called from the worker to create inspector sessions that is connected

// to the main thread.

// The inspector responds by using the delegate to send messages back.

std::unique_ptr<InspectorSession> ConnectToMainThread(

std::unique_ptr<InspectorSessionDelegate> delegate,

bool prevent_shutdown);

void PauseOnNextJavascriptStatement(const std::string& reason);

std::string GetWsUrl() const;

// Can only be called from the main thread.

bool StartIoThread();

// Calls StartIoThread() from off the main thread. Only valid while the

// Environment owns the inspector and has not started cleanup.

void RequestIoThreadStart();

const DebugOptions& options() { return debug_options_; }

std::shared_ptr<ExclusiveAccess<HostPort>> host_port() { return host_port_; }

void ContextCreated(v8::Local<v8::Context> context, const ContextInfo& info);

// Interface for interacting with inspectors in worker threads

std::shared_ptr<WorkerManager> GetWorkerManager();

inline Environment* env() const { return parent_env_; }

std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager();

private:

void SyncAsyncHookState();

void ToggleNetworkTracking(v8::Isolate* isolate, v8::Local<v8::Function> fn);

node::Environment* parent_env_;

// Encapsulates majority of the Inspector functionality

std::shared_ptr<NodeInspectorClient> client_;

// Interface for transports, e.g. WebSocket server

std::unique_ptr<InspectorIo> io_;

std::unique_ptr<ParentInspectorHandle> parent_handle_;

std::string path_;

// This is a copy of the debug options parsed from CLI in the Environment.

// Do not use the host_port in that, instead manipulate the shared host_port_

// pointer which is meant to store the actual host and port of the inspector

// server.

DebugOptions debug_options_;

std::shared_ptr<ExclusiveAccess<HostPort>> host_port_;

// The state of the async hook used for async stack traces that the protocol

// last requested, and the state JS currently has. SyncAsyncHookState()

// reconciles the two when it is possible and safe to call into JS.

bool async_hook_wanted_ = false;

bool async_hook_enabled_ = false;

bool syncing_async_hook_state_ = false;

// Woken by the SIGUSR1 watchdog; closed by the cleanup hook or ~Agent(),

// whichever runs first, and freed by its close callback.

uv_async_t* start_io_thread_async_ = nullptr;

void StopAcceptingIoThreadStarts();

static void StopAcceptingIoThreadStartsHook(void* agent);

bool network_tracking_enabled_ = false;

bool pending_enable_network_tracking = false;

bool pending_disable_network_tracking = false;

std::shared_ptr<NetworkResourceManager> network_resource_manager_;