Allow microtasks to throw exceptions and handle them gracefully

src/isolate.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 <stdlib.h>
 
 #include "v8.h"
 
 #include "ast.h"
 #include "bootstrapper.h"
@@ skipping 2216 matching lines @@
 
 
 void Isolate::FireCallCompletedCallback() {
   bool has_call_completed_callbacks = !call_completed_callbacks_.is_empty();
   bool run_microtasks = autorun_microtasks() && pending_microtask_count();
   if (!has_call_completed_callbacks && !run_microtasks) return;
 
   if (!handle_scope_implementer()->CallDepthIsZero()) return;
   if (run_microtasks) RunMicrotasks();
   // Fire callbacks.  Increase call depth to prevent recursive callbacks.
-  handle_scope_implementer()->IncrementCallDepth();
+  v8::Isolate::SuppressMicrotaskExecutionScope suppress(
+      reinterpret_cast<v8::Isolate*>(this));
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     call_completed_callbacks_.at(i)();
   }
-  handle_scope_implementer()->DecrementCallDepth();
 }
 
 
 void Isolate::EnqueueMicrotask(Handle<JSFunction> microtask) {
   Handle<FixedArray> queue(heap()->microtask_queue(), this);
   int num_tasks = pending_microtask_count();
   ASSERT(num_tasks <= queue->length());
   if (num_tasks == 0) {
     queue = factory()->NewFixedArray(8);
     heap()->set_microtask_queue(*queue);
   } else if (num_tasks == queue->length()) {
     queue = FixedArray::CopySize(queue, num_tasks * 2);
     heap()->set_microtask_queue(*queue);
   }
   ASSERT(queue->get(num_tasks)->IsUndefined());
   queue->set(num_tasks, *microtask);
   set_pending_microtask_count(num_tasks + 1);
 }
 
 
 void Isolate::RunMicrotasks() {
   // TODO(adamk): This ASSERT triggers in mjsunit tests which
   // call the %RunMicrotasks runtime function. But it should
   // never happen outside of tests, so it would be nice to
   // uncomment it.
   //
   // ASSERT(handle_scope_implementer()->CallDepthIsZero());
 
   // Increase call depth to prevent recursive callbacks.
-  handle_scope_implementer()->IncrementCallDepth();
+  v8::Isolate::SuppressMicrotaskExecutionScope suppress(
+      reinterpret_cast<v8::Isolate*>(this));
 
   while (pending_microtask_count() > 0) {
     HandleScope scope(this);
     int num_tasks = pending_microtask_count();
     Handle<FixedArray> queue(heap()->microtask_queue(), this);
     ASSERT(num_tasks <= queue->length());
     set_pending_microtask_count(0);
     heap()->set_microtask_queue(heap()->empty_fixed_array());
 
     for (int i = 0; i < num_tasks; i++) {
       HandleScope scope(this);
       Handle<JSFunction> microtask(JSFunction::cast(queue->get(i)), this);
-      // TODO(adamk): This should ignore/clear exceptions instead of Checking.
-      Execution::Call(this, microtask, factory()->undefined_value(),
-                      0, NULL).Check();
+      Handle<Object> exception;
+      MaybeHandle<Object> result = Execution::TryCall(
+          microtask, factory()->undefined_value(), 0, NULL, &exception);
+      // If execution is terminating, just bail out.
+      if (result.is_null() &&
+          !exception.is_null() &&
+          *exception == heap()->termination_exception()) {
+        // Clear out any remaining callbacks in the queue.
+        heap()->set_microtask_queue(heap()->empty_fixed_array());
+        set_pending_microtask_count(0);
+        return;
+      }
     }
   }
-
-  handle_scope_implementer()->DecrementCallDepth();
 }
 
 
 } }  // namespace v8::internal