inspector: move inspector async hooks to environment

Since async hooks are per-environment and putting them in the environment allows us to serialize them for the snapshot automatically. PR-URL: #39112 Refs: #38905 Refs: #35711 Reviewed-By: Anna Henningsen <anna@addaleax.net>
nodejs · Sep 4, 2021 · 8a2ce5d · 8a2ce5d
1 parent 3ecfe9d
commit 8a2ce5d
Show file tree

Hide file tree

Showing 3 changed files with 15 additions and 14 deletions.
diff --git a/src/env.h b/src/env.h
@@ -479,6 +479,8 @@ constexpr size_t kFsStatsBufferLength =
   V(internal_binding_loader, v8::Function)                                     \
   V(immediate_callback_function, v8::Function)                                 \
   V(inspector_console_extension_installer, v8::Function)                       \
+  V(inspector_disable_async_hooks, v8::Function)                               \
+  V(inspector_enable_async_hooks, v8::Function)                                \
   V(messaging_deserialize_create_object, v8::Function)                         \
   V(message_port, v8::Object)                                                  \
   V(native_module_require, v8::Function)                                       \

diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
@@ -40,7 +40,6 @@ using node::FatalError;
 
 using v8::Context;
 using v8::Function;
-using v8::Global;
 using v8::HandleScope;
 using v8::Isolate;
 using v8::Local;
@@ -804,8 +803,8 @@ void Agent::PauseOnNextJavascriptStatement(const std::string& reason) {
 void Agent::RegisterAsyncHook(Isolate* isolate,
                               Local<Function> enable_function,
                               Local<Function> disable_function) {
-  enable_async_hook_function_.Reset(isolate, enable_function);
-  disable_async_hook_function_.Reset(isolate, disable_function);
+  parent_env_->set_inspector_enable_async_hooks(enable_function);
+  parent_env_->set_inspector_disable_async_hooks(disable_function);
   if (pending_enable_async_hook_) {
     CHECK(!pending_disable_async_hook_);
     pending_enable_async_hook_ = false;
@@ -818,8 +817,10 @@ void Agent::RegisterAsyncHook(Isolate* isolate,
 }
 
 void Agent::EnableAsyncHook() {
-  if (!enable_async_hook_function_.IsEmpty()) {
-    ToggleAsyncHook(parent_env_->isolate(), enable_async_hook_function_);
+  HandleScope scope(parent_env_->isolate());
+  Local<Function> enable = parent_env_->inspector_enable_async_hooks();
+  if (!enable.IsEmpty()) {
+    ToggleAsyncHook(parent_env_->isolate(), enable);
   } else if (pending_disable_async_hook_) {
     CHECK(!pending_enable_async_hook_);
     pending_disable_async_hook_ = false;
@@ -829,8 +830,10 @@ void Agent::EnableAsyncHook() {
 }
 
 void Agent::DisableAsyncHook() {
-  if (!disable_async_hook_function_.IsEmpty()) {
-    ToggleAsyncHook(parent_env_->isolate(), disable_async_hook_function_);
+  HandleScope scope(parent_env_->isolate());
+  Local<Function> disable = parent_env_->inspector_enable_async_hooks();
+  if (!disable.IsEmpty()) {
+    ToggleAsyncHook(parent_env_->isolate(), disable);
   } else if (pending_enable_async_hook_) {
     CHECK(!pending_disable_async_hook_);
     pending_enable_async_hook_ = false;
@@ -839,8 +842,7 @@ void Agent::DisableAsyncHook() {
   }
 }
 
-void Agent::ToggleAsyncHook(Isolate* isolate,
-                            const Global<Function>& fn) {
+void Agent::ToggleAsyncHook(Isolate* isolate, Local<Function> fn) {
   // Guard against running this during cleanup -- no async events will be
   // emitted anyway at that point anymore, and calling into JS is not possible.
   // This should probably not be something we're attempting in the first place,
@@ -851,7 +853,7 @@ void Agent::ToggleAsyncHook(Isolate* isolate,
   CHECK(!fn.IsEmpty());
   auto context = parent_env_->context();
   v8::TryCatch try_catch(isolate);
-  USE(fn.Get(isolate)->Call(context, Undefined(isolate), 0, nullptr));
+  USE(fn->Call(context, Undefined(isolate), 0, nullptr));
   if (try_catch.HasCaught() && !try_catch.HasTerminated()) {
     PrintCaughtException(isolate, context, try_catch);
     FatalError("\nnode::inspector::Agent::ToggleAsyncHook",

diff --git a/src/inspector_agent.h b/src/inspector_agent.h
@@ -117,8 +117,7 @@ class Agent {
   inline Environment* env() const { return parent_env_; }
 
  private:
-  void ToggleAsyncHook(v8::Isolate* isolate,
-                       const v8::Global<v8::Function>& fn);
+  void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
 
   node::Environment* parent_env_;
   // Encapsulates majority of the Inspector functionality
@@ -137,8 +136,6 @@ class Agent {
 
   bool pending_enable_async_hook_ = false;
   bool pending_disable_async_hook_ = false;
-  v8::Global<v8::Function> enable_async_hook_function_;
-  v8::Global<v8::Function> disable_async_hook_function_;
 };
 
 }  // namespace inspector