Move microtask queueing logic from JavaScript to C++

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 2214 matching lines @@
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     if (callback == call_completed_callbacks_.at(i)) {
       call_completed_callbacks_.Remove(i);
     }
   }
 }
 
 
 void Isolate::FireCallCompletedCallback() {
   bool has_call_completed_callbacks = !call_completed_callbacks_.is_empty();
-  bool run_microtasks = autorun_microtasks() && microtask_pending();
+  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();
-  if (run_microtasks) Execution::RunMicrotasks(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(1);

[dcarney, 2014/05/17 06:54:09]

1 might be a little conservative here, maybe 4, 8 or whatever - depending on
what you see in the wild

[adamk, 2014/05/19 07:47:58]

Let's go with 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() {
-  if (!microtask_pending())
-    return;
-
   ASSERT(handle_scope_implementer()->CallDepthIsZero());
 
   // Increase call depth to prevent recursive callbacks.
   handle_scope_implementer()->IncrementCallDepth();
-  Execution::RunMicrotasks(this);
+
+  HandleScope scope(this);
+  while (pending_microtask_count() > 0) {

[dcarney, 2014/05/16 17:41:51]

put handlescope here

[adamk, 2014/05/19 07:47:58]

Done.

+    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++) {

[dcarney, 2014/05/16 17:41:51]

and here maybe

[adamk, 2014/05/19 07:47:58]

Done.

+      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_scope_implementer()->DecrementCallDepth();
 }
 
 
 } }  // namespace v8::internal