Introduce v8::MicrotasksScope.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 57 matching lines @@
 
 
 namespace v8 {
 
 #define LOG_API(isolate, expr) LOG(isolate, ApiEntryCall(expr))
 
 
 #define ENTER_V8(isolate) i::VMState<v8::OTHER> __state__((isolate))
 
 
-#define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name, \
-                                      bailout_value, HandleScopeClass, \
-                                      do_callback)                     \
-  if (IsExecutionTerminatingCheck(isolate)) {                          \
-    return bailout_value;                                              \
-  }                                                                    \
-  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);                \
-  HandleScopeClass handle_scope(isolate);                              \
-  CallDepthScope call_depth_scope(isolate, context, do_callback);      \
-  LOG_API(isolate, function_name);                                     \
-  ENTER_V8(isolate);                                                   \
+#define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name,  \
+                                      bailout_value, HandleScopeClass,  \
+                                      do_callback)                      \
+  if (IsExecutionTerminatingCheck(isolate)) {                           \
+    return bailout_value;                                               \
+  }                                                                     \
+  TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);                 \
+  HandleScopeClass handle_scope(isolate);                               \
+  isolate->IncrementJsCallsFromApiCounter();                            \
+  CallDepthScope call_depth_scope(isolate, context, do_callback, false);\
+  LOG_API(isolate, function_name);                                      \
+  ENTER_V8(isolate);                                                    \
   bool has_pending_exception = false
 
 
 #define PREPARE_FOR_EXECUTION_WITH_CONTEXT(                                  \
     context, function_name, bailout_value, HandleScopeClass, do_callback)    \
   auto isolate = context.IsEmpty()                                           \
                      ? i::Isolate::Current()                                 \
                      : reinterpret_cast<i::Isolate*>(context->GetIsolate()); \
   PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name,             \
                                 bailout_value, HandleScopeClass, do_callback);
@@ skipping 51 matching lines @@
       ->GetCurrentContext();
 }
 
 class InternalEscapableScope : public v8::EscapableHandleScope {
  public:
   explicit inline InternalEscapableScope(i::Isolate* isolate)
       : v8::EscapableHandleScope(reinterpret_cast<v8::Isolate*>(isolate)) {}
 };
 
 
+inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
+  if (isolate->has_scheduled_exception()) {
+    return isolate->scheduled_exception() ==
+        isolate->heap()->termination_exception();
+  }
+  return false;
+}
+
+
 class CallDepthScope {
  public:
-  explicit CallDepthScope(i::Isolate* isolate, Local<Context> context,
-                          bool do_callback)
+  CallDepthScope(i::Isolate* isolate,
+                 Local<Context> context,
+                 bool do_callback_and_microtasks,
+                 bool is_external)
       : isolate_(isolate),
         context_(context),
-        escaped_(false),
-        do_callback_(do_callback) {
-    // TODO(dcarney): remove this when blink stops crashing.
-    DCHECK(!isolate_->external_caught_exception());
-    isolate_->IncrementJsCallsFromApiCounter();
-    isolate_->handle_scope_implementer()->IncrementCallDepth();
+        handle_exception_(!is_external),
+        do_callback_(do_callback_and_microtasks && !is_external) {
+    bool affects_microtasks = is_external ||
+        isolate_->handle_scope_implementer()->microtasks_policy() ==
+            i::kAutoMicrotasksInvocation;
+    run_microtasks_ = affects_microtasks && do_callback_and_microtasks;
+#ifdef V8_ENABLE_CHECKS
+    debug_microtasks_ = affects_microtasks && !do_callback_and_microtasks;
+#endif
+    auto handle_scope_implementer = isolate_->handle_scope_implementer();
+    if (handle_exception_) {
+      // TODO(dcarney): remove this when blink stops crashing.
+      DCHECK(!isolate_->external_caught_exception());
+      handle_scope_implementer->IncrementInternalCallDepth();
+    }
+    if (run_microtasks_) handle_scope_implementer->IncrementCallDepth();
+#ifdef V8_ENABLE_CHECKS
+    if (debug_microtasks_) handle_scope_implementer->IncrementDebugCallDepth();
+#endif
     if (!context_.IsEmpty()) context_->Enter();
     if (do_callback_) isolate_->FireBeforeCallEnteredCallback();
   }
+
   ~CallDepthScope() {
     if (!context_.IsEmpty()) context_->Exit();
-    if (!escaped_) isolate_->handle_scope_implementer()->DecrementCallDepth();
+    auto handle_scope_implementer = isolate_->handle_scope_implementer();
+    if (handle_exception_)
+      handle_scope_implementer->DecrementInternalCallDepth();
     if (do_callback_) isolate_->FireCallCompletedCallback();
+#ifdef V8_ENABLE_CHECKS
+    bool scoped_policy = handle_scope_implementer->microtasks_policy() ==
+        i::kScopedMicrotasksInvocation;
+    DCHECK(!(scoped_policy && do_callback_
+             && !handle_scope_implementer->GetCallDepth()
+             && !handle_scope_implementer->GetDebugCallDepth()));
+#endif
+    if (run_microtasks_) {
+      handle_scope_implementer->DecrementCallDepth();
+      PerformCheckpoint(isolate_);
+    }
+#ifdef V8_ENABLE_CHECKS
+    if (debug_microtasks_) handle_scope_implementer->DecrementDebugCallDepth();
+#endif
   }
 
   void Escape() {
-    DCHECK(!escaped_);
-    escaped_ = true;
+    DCHECK(handle_exception_);
+    handle_exception_ = false;
     auto handle_scope_implementer = isolate_->handle_scope_implementer();
-    handle_scope_implementer->DecrementCallDepth();
-    bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero();
+    handle_scope_implementer->DecrementInternalCallDepth();
+    bool call_depth_is_zero = !handle_scope_implementer->GetInternalCallDepth();
     isolate_->OptionalRescheduleException(call_depth_is_zero);
   }
 
+  static void PerformCheckpoint(i::Isolate* isolate) {
+    if (IsExecutionTerminatingCheck(isolate)) return;
+    if (!isolate->handle_scope_implementer()->GetCallDepth() &&
+        !isolate->handle_scope_implementer()->GetMicrotasksSuppression()) {
+      isolate->RunMicrotasks();
+    }
+  }
+
  private:
   i::Isolate* const isolate_;
   Local<Context> context_;
-  bool escaped_;
+  bool handle_exception_;
   bool do_callback_;
+  bool run_microtasks_;
+  bool debug_microtasks_;
 };
 
 }  // namespace
 
 
 static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,
                                              i::Handle<i::Script> script) {
   TRACE_EVENT_SCOPED_CONTEXT("v8", "Isolate", isolate);
   i::Handle<i::Object> scriptName(i::Script::GetNameOrSourceURL(script));
   i::Handle<i::Object> source_map_url(script->source_mapping_url(), isolate);
@@ skipping 98 matching lines @@
     base::OS::PrintError("\n#\n# Fatal error in %s\n# %s\n#\n\n", location,
                          message);
     base::OS::Abort();
   } else {
     callback(location, message);
   }
   isolate->SignalFatalError();
 }
 
 
-static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {
-  if (isolate->has_scheduled_exception()) {
-    return isolate->scheduled_exception() ==
-        isolate->heap()->termination_exception();
-  }
-  return false;
-}
-
-
 void V8::SetNativesDataBlob(StartupData* natives_blob) {
   i::V8::SetNativesBlob(natives_blob);
 }
 
 
 void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {
   i::V8::SetSnapshotBlob(snapshot_blob);
 }
 
 
@@ skipping 6951 matching lines @@
 
 Isolate::AllowJavascriptExecutionScope::~AllowJavascriptExecutionScope() {
   delete reinterpret_cast<i::AllowJavascriptExecution*>(internal_assert_);
   delete reinterpret_cast<i::NoThrowOnJavascriptExecution*>(internal_throws_);
 }
 
 
 Isolate::SuppressMicrotaskExecutionScope::SuppressMicrotaskExecutionScope(
     Isolate* isolate)
     : isolate_(reinterpret_cast<i::Isolate*>(isolate)) {
-  isolate_->handle_scope_implementer()->IncrementCallDepth();
+  isolate_->handle_scope_implementer()->IncrementMicrotasksSuppression();
 }
 
 
 Isolate::SuppressMicrotaskExecutionScope::~SuppressMicrotaskExecutionScope() {
-  isolate_->handle_scope_implementer()->DecrementCallDepth();
+  isolate_->handle_scope_implementer()->DecrementMicrotasksSuppression();
 }
 
 
 void Isolate::GetHeapStatistics(HeapStatistics* heap_statistics) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   i::Heap* heap = isolate->heap();
   heap_statistics->total_heap_size_ = heap->CommittedMemory();
   heap_statistics->total_heap_size_executable_ =
       heap->CommittedMemoryExecutable();
   heap_statistics->total_physical_size_ = heap->CommittedPhysicalMemory();
@@ skipping 120 matching lines @@
 
 
 void Isolate::SetPromiseRejectCallback(PromiseRejectCallback callback) {
   if (callback == NULL) return;
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   isolate->SetPromiseRejectCallback(callback);
 }
 
 
 void Isolate::RunMicrotasks() {
+  DCHECK_EQ(Isolate::kExplicitMicrotasksInvocation, GetMicrotasksPolicy());
   reinterpret_cast<i::Isolate*>(this)->RunMicrotasks();
 }
 
 
 void Isolate::EnqueueMicrotask(Local<Function> microtask) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   isolate->EnqueueMicrotask(Utils::OpenHandle(*microtask));
 }
 
 
 void Isolate::EnqueueMicrotask(MicrotaskCallback microtask, void* data) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   i::HandleScope scope(isolate);
   i::Handle<i::CallHandlerInfo> callback_info =
       i::Handle<i::CallHandlerInfo>::cast(
           isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE));
   SET_FIELD_WRAPPED(callback_info, set_callback, microtask);
   SET_FIELD_WRAPPED(callback_info, set_data, data);
   isolate->EnqueueMicrotask(callback_info);
 }
 
 
 void Isolate::SetAutorunMicrotasks(bool autorun) {
-  reinterpret_cast<i::Isolate*>(this)->set_autorun_microtasks(autorun);
+  SetMicrotasksPolicy(kAutoMicrotasksInvocation);
 }
 
 
 bool Isolate::WillAutorunMicrotasks() const {
-  return reinterpret_cast<const i::Isolate*>(this)->autorun_microtasks();
+  return GetMicrotasksPolicy() == kAutoMicrotasksInvocation;
 }
 
 
+void Isolate::SetMicrotasksPolicy(MicrotasksPolicy policy) {
+  reinterpret_cast<i::Isolate*>(this)->handle_scope_implementer()->
+      set_microtasks_policy(static_cast<i::MicrotasksPolicy>(policy));
+}
+
+
+Isolate::MicrotasksPolicy Isolate::GetMicrotasksPolicy() const {
+  return static_cast<MicrotasksPolicy>(
+      reinterpret_cast<i::Isolate*>(const_cast<Isolate*>(this))->
+          handle_scope_implementer()->microtasks_policy());
+}
+
+
 void Isolate::AddMicrotasksCompletedCallback(
     MicrotasksCompletedCallback callback) {
   DCHECK(callback);
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   isolate->AddMicrotasksCompletedCallback(callback);
 }
 
 
 void Isolate::RemoveMicrotasksCompletedCallback(
     MicrotasksCompletedCallback callback) {
@@ skipping 215 matching lines @@
 
 void Isolate::VisitWeakHandles(PersistentHandleVisitor* visitor) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   i::DisallowHeapAllocation no_allocation;
   VisitorAdapter visitor_adapter(visitor);
   isolate->global_handles()->IterateWeakRootsInNewSpaceWithClassIds(
       &visitor_adapter);
 }
 
 
+MicrotasksScope::MicrotasksScope(Isolate* isolate, MicrotasksScope::Type type) {
+  DCHECK_EQ(Isolate::kScopedMicrotasksInvocation,
+            isolate->GetMicrotasksPolicy());
+  internal_ = reinterpret_cast<void*>(new CallDepthScope(

[adamk, 2016/03/01 19:10:34]

I'm a little bit worried about the added heap allocation here. I'm wondering if
it'd be worth moving CallDepthScope's declaration into the "internal" block in
v8.h?

[dgozman, 2016/03/03 01:22:06]

I think this patch would be easier to understand with separate scopes, so I
decided to not merge them. This means heap allocation is gone.

+      reinterpret_cast<i::Isolate*>(isolate),
+      Local<Context>(),
+      type == MicrotasksScope::kRunMicrotasks,
+      true));
+}
+
+
+MicrotasksScope::~MicrotasksScope() {
+  delete reinterpret_cast<CallDepthScope*>(internal_);
+}
+
+
+void MicrotasksScope::PerformCheckpoint(Isolate* isolate) {
+  CallDepthScope::PerformCheckpoint(reinterpret_cast<i::Isolate*>(isolate));
+}
+
+
+int MicrotasksScope::GetRecursionLevel(Isolate* isolate) {
+  return reinterpret_cast<i::Isolate*>(isolate)->handle_scope_implementer()->
+      GetCallDepth();
+}
+
+
 String::Utf8Value::Utf8Value(v8::Local<v8::Value> obj)
     : str_(NULL), length_(0) {
   if (obj.IsEmpty()) return;
   i::Isolate* isolate = i::Isolate::Current();
   Isolate* v8_isolate = reinterpret_cast<Isolate*>(isolate);
   ENTER_V8(isolate);
   i::HandleScope scope(isolate);
   Local<Context> context = v8_isolate->GetCurrentContext();
   TryCatch try_catch(v8_isolate);
   Local<String> str;
@@ skipping 898 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8