[squash] address AndreasMadsen comment

Author: addaleax

src/async-wrap.cc

@@ -283,8 +283,8 @@ bool AsyncWrap::EmitAfter(Environment* env, double async_id) {
 
 class PromiseWrap : public AsyncWrap {
  public:
-  PromiseWrap(Environment* env, Local<Object> object)
-    : AsyncWrap(env, object, PROVIDER_PROMISE) {}
+  PromiseWrap(Environment* env, Local<Object> object, bool silent)
+    : AsyncWrap(env, object, PROVIDER_PROMISE, silent) {}
   size_t self_size() const override { return sizeof(*this); }
 };
 
@@ -294,19 +294,10 @@ static void PromiseHook(PromiseHookType type, Local<Promise> promise,
   Local<Context> context = promise->CreationContext();
   Environment* env = Environment::GetCurrent(context);
   PromiseWrap* wrap = Unwrap<PromiseWrap>(promise);
-  if (type == PromiseHookType::kInit ||
-      wrap == nullptr) {
-    uint32_t stored_init_field;
-    if (type != PromiseHookType::kInit) {
-      // Do not emit an init event.
-      stored_init_field = env->async_hooks()->fields()[AsyncHooks::kInit];
-      env->async_hooks()->fields()[AsyncHooks::kInit] = 0;
-    }
-    wrap = new PromiseWrap(env, promise);
+  if (type == PromiseHookType::kInit || wrap == nullptr) {
+    bool silent = type != PromiseHookType::kInit;
+    wrap = new PromiseWrap(env, promise, silent);
     wrap->MakeWeak(wrap);
-    if (type != PromiseHookType::kInit) {
-      env->async_hooks()->fields()[AsyncHooks::kInit] = stored_init_field;
-    }
   } else if (type == PromiseHookType::kResolve) {
     // TODO(matthewloring): need to expose this through the async hooks api.
   }
@@ -501,7 +492,8 @@ void LoadAsyncWrapperInfo(Environment* env) {
 
 AsyncWrap::AsyncWrap(Environment* env,
                      Local<Object> object,
-                     ProviderType provider)
+                     ProviderType provider,
+                     bool silent)
     : BaseObject(env, object),
       provider_type_(provider) {
   CHECK_NE(provider, PROVIDER_NONE);
@@ -511,7 +503,7 @@ AsyncWrap::AsyncWrap(Environment* env,
   persistent().SetWrapperClassId(NODE_ASYNC_ID_OFFSET + provider);
 
   // Use AsyncReset() call to execute the init() callbacks.
-  AsyncReset();
+  AsyncReset(silent);
 }
 
 
@@ -523,10 +515,13 @@ AsyncWrap::~AsyncWrap() {
 // Generalized call for both the constructor and for handles that are pooled
 // and reused over their lifetime. This way a new uid can be assigned when
 // the resource is pulled out of the pool and put back into use.
-void AsyncWrap::AsyncReset() {
+void AsyncWrap::AsyncReset(bool silent) {
+  AsyncHooks* async_hooks = env()->async_hooks();
   async_id_ = env()->new_async_id();
   trigger_id_ = env()->get_init_trigger_id();
 
+  if (silent) return;
+
   EmitAsyncInit(env(), object(),
                 env()->async_hooks()->provider_string(provider_type()),
                 async_id_, trigger_id_);

src/async-wrap.h

@@ -86,7 +86,8 @@ class AsyncWrap : public BaseObject {
 
   AsyncWrap(Environment* env,
             v8::Local<v8::Object> object,
-            ProviderType provider);
+            ProviderType provider,
+            bool silent = false);
 
   virtual ~AsyncWrap();
 
@@ -116,7 +117,7 @@ class AsyncWrap : public BaseObject {
 
   inline double get_trigger_id() const;
 
-  void AsyncReset();
+  void AsyncReset(bool silent = false);
 
   // Only call these within a valid HandleScope.
   // TODO(trevnorris): These should return a MaybeLocal.