src: add can_call_into_js flag

PR-URL: ayojs#82

Author: addaleax

src/async-wrap.cc

@@ -152,6 +152,7 @@ static void DestroyIdsCb(uv_timer_t* handle) {
   do {
     std::vector<double> destroy_ids_list;
     destroy_ids_list.swap(*env->destroy_ids_list());
+    if (!env->can_call_into_js()) return;
     for (auto current_id : destroy_ids_list) {
       // Want each callback to be cleaned up after itself, instead of cleaning
       // them all up after the while() loop completes.
@@ -174,6 +175,9 @@ static void PushBackDestroyId(Environment* env, double id) {
   if (env->async_hooks()->fields()[AsyncHooks::kDestroy] == 0)
     return;
 
+  if (!env->can_call_into_js())
+    return;
+
   if (env->destroy_ids_list()->empty())
     uv_timer_start(env->destroy_ids_timer_handle(), DestroyIdsCb, 0, 0);
 

src/env-inl.h

@@ -504,6 +504,14 @@ inline void Environment::set_fs_stats_field_array(double* fields) {
   fs_stats_field_array_ = fields;
 }
 
+inline bool Environment::can_call_into_js() const {
+  return can_call_into_js_;
+}
+
+inline void Environment::set_can_call_into_js(bool can_call_into_js) {
+  can_call_into_js_ = can_call_into_js;
+}
+
 inline performance::performance_state* Environment::performance_state() {
   return performance_state_;
 }

src/env.h

@@ -609,6 +609,9 @@ class Environment {
   inline performance::performance_state* performance_state();
   inline std::map<std::string, uint64_t>* performance_marks();
 
+  inline bool can_call_into_js() const;
+  inline void set_can_call_into_js(bool can_call_into_js);
+
   inline void ThrowError(const char* errmsg);
   inline void ThrowTypeError(const char* errmsg);
   inline void ThrowRangeError(const char* errmsg);
@@ -706,6 +709,8 @@ class Environment {
   size_t makecallback_cntr_;
   std::vector<double> destroy_ids_list_;
 
+  bool can_call_into_js_ = true;
+
   performance::performance_state* performance_state_ = nullptr;
   std::map<std::string, uint64_t> performance_marks_;
 

src/node.cc

@@ -1386,6 +1386,11 @@ InternalCallbackScope::InternalCallbackScope(Environment* env,
     CHECK(!object.IsEmpty());
   }
 
+  if (!env->can_call_into_js()) {
+    failed_ = true;
+    return;
+  }
+
   HandleScope handle_scope(env->isolate());
   // If you hit this assertion, you forgot to enter the v8::Context first.
   CHECK_EQ(env->context(), env->isolate()->GetCurrentContext());
@@ -1433,6 +1438,7 @@ void InternalCallbackScope::Close() {
 
   Environment::TickInfo* tick_info = env_->tick_info();
 
+  if (!env_->can_call_into_js()) return;
   if (tick_info->length() == 0) {
     env_->isolate()->RunMicrotasks();
   }
@@ -1452,6 +1458,8 @@ void InternalCallbackScope::Close() {
   CHECK_EQ(env_->current_async_id(), 0);
   CHECK_EQ(env_->trigger_id(), 0);
 
+  if (!env_->can_call_into_js()) return;
+
   if (env_->tick_callback_function()->Call(process, 0, nullptr).IsEmpty()) {
     failed_ = true;
   }
@@ -4756,6 +4764,7 @@ inline int Start(Isolate* isolate, IsolateData* isolate_data,
 
   const int exit_code = EmitExit(&env);
 
+  env.set_can_call_into_js(false);
   env.RunCleanup();
   RunAtExit(&env);
   uv_key_delete(&thread_local_env);

src/node_contextify.cc

@@ -986,6 +986,8 @@ class ContextifyScript : public BaseObject {
                           const bool break_on_sigint,
                           const FunctionCallbackInfo<Value>& args,
                           TryCatch* try_catch) {
+    if (!env->can_call_into_js())
+      return false;
     if (!ContextifyScript::InstanceOf(env, args.Holder())) {
       env->ThrowTypeError(
           "Script methods can only be called on script instances.");