Add API support for passing a C++ function as a microtask callback

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index ca552fc60f6ba44140461666f730411a92de0fe4..f966177c6fd6d76f3d764bfeb3bab1b8bdf2d2c2 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -6664,6 +6664,18 @@ void Isolate::EnqueueMicrotask(Handle<Function> 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 =

[dcarney, 2014/06/02 07:22:10]

if you're going to reuse the CallHandlerInfo struct, the second field must be a
Handle<Value>.
the embedder can use External::New if needed.  this requires no context

[adamk, 2014/06/02 16:41:50]

I'm guessing this might be the source of my try job failure...but could you
explain what's enforcing this requirement?

Also, it seems a bit weird to me to make an External part of this API, given
that otherwise it's C++-type-based, not V8-type-based. Would you be OK with the
External::New call happening internally?

As for re-using CallHandlerInfo: I at first started to write a new Struct for
this, but CallHandlerInfo seemed so close to what I needed that it seemed like a
lot of useless code. If you think it's weird to re-use it here, I can easily add
a new struct for this case.

+      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);
 }