From 84bf609fd2dce0343157d2bf8afa323744fd3107 Mon Sep 17 00:00:00 2001
From: Trevor Norris <trev.norris@gmail.com>
Date: Mon, 4 May 2015 15:56:40 -0600
Subject: [PATCH] async-wrap: don't call init callback unnecessarily

Some calls to ReqWrap would get through the initial check and allow the
init callback to run, even though the callback had not been used on the
parent. Fix by explicitly checking if the parent has a queue.

Also change the name of the check, and internal field of AsyncHooks.
Other names were confusing.

PR-URL: https://github.com/iojs/io.js/pull/1614
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
---
 src/async-wrap-inl.h |  8 +++++++-
 src/env-inl.h        | 12 ++++++++----
 src/env.h            |  7 ++++---
 3 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/async-wrap-inl.h b/src/async-wrap-inl.h
index b08f791c2e7635..ba84af19c02d23 100644
--- a/src/async-wrap-inl.h
+++ b/src/async-wrap-inl.h
@@ -21,7 +21,13 @@ inline AsyncWrap::AsyncWrap(Environment* env,
   // Check user controlled flag to see if the init callback should run.
   if (!env->using_asyncwrap())
     return;
-  if (!env->call_async_init_hook() && parent == nullptr)
+
+  // If callback hooks have not been enabled, and there is no parent, return.
+  if (!env->async_wrap_callbacks_enabled() && parent == nullptr)
+    return;
+
+  // If callback hooks have not been enabled and parent has no queue, return.
+  if (!env->async_wrap_callbacks_enabled() && !parent->has_async_queue())
     return;
 
   // TODO(trevnorris): Until it's verified all passed object's are not weak,
diff --git a/src/env-inl.h b/src/env-inl.h
index 237da7159d1ecf..a0815acaccb926 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -66,8 +66,12 @@ inline int Environment::AsyncHooks::fields_count() const {
   return kFieldsCount;
 }
 
-inline bool Environment::AsyncHooks::call_init_hook() {
-  return fields_[kCallInitHook] != 0;
+inline bool Environment::AsyncHooks::callbacks_enabled() {
+  return fields_[kEnableCallbacks] != 0;
+}
+
+inline void Environment::AsyncHooks::set_enable_callbacks(uint32_t flag) {
+  fields_[kEnableCallbacks] = flag;
 }
 
 inline Environment::DomainFlag::DomainFlag() {
@@ -214,9 +218,9 @@ inline v8::Isolate* Environment::isolate() const {
   return isolate_;
 }
 
-inline bool Environment::call_async_init_hook() const {
+inline bool Environment::async_wrap_callbacks_enabled() const {
   // The const_cast is okay, it doesn't violate conceptual const-ness.
-  return const_cast<Environment*>(this)->async_hooks()->call_init_hook();
+  return const_cast<Environment*>(this)->async_hooks()->callbacks_enabled();
 }
 
 inline bool Environment::in_domain() const {
diff --git a/src/env.h b/src/env.h
index 8a926340673c6e..e327786e36b907 100644
--- a/src/env.h
+++ b/src/env.h
@@ -269,7 +269,8 @@ class Environment {
    public:
     inline uint32_t* fields();
     inline int fields_count() const;
-    inline bool call_init_hook();
+    inline bool callbacks_enabled();
+    inline void set_enable_callbacks(uint32_t flag);
 
    private:
     friend class Environment;  // So we can call the constructor.
@@ -277,7 +278,7 @@ class Environment {
 
     enum Fields {
       // Set this to not zero if the init hook should be called.
-      kCallInitHook,
+      kEnableCallbacks,
       kFieldsCount
     };
 
@@ -374,7 +375,7 @@ class Environment {
 
   inline v8::Isolate* isolate() const;
   inline uv_loop_t* event_loop() const;
-  inline bool call_async_init_hook() const;
+  inline bool async_wrap_callbacks_enabled() const;
   inline bool in_domain() const;
   inline uint32_t watched_providers() const;