I completely forgot. Developers need to reenter JS from C++ after an asynchronous call though the `MakeCallback` API. So instead the call should look like:
```c++
Handle<Value> ret = node::MakeCallback(Context::GetCurrent()->Global(),
                                       asyncData->callback,
                                       2,
                                       argv);
```
(You may not need the `Handle<Value> ret` if you're not returning a value, but I put it there for demonstration.)

This is extremely important as the `nextTickQueue` won't drain unless `MakeCallback` is called. Which means any callbacks queued though `process.nextTick` won't be processed.

It's also important in the use of domains. Called like this either the `domain` module won't be able to track where things were happening, or you'll have an incorrect domain because there's one currently on the global context that shouldn't be attached to the callback.

Though that means you'll need to do something like (the string stuff is not optimal):
```c++
Handle<Value> domain = Context::GetCurrent()
                       ->Global()
                       ->Get(String::New("domain"));
Persistent<Object> p_obj;
if (!domain->IsNull()) {
  p_obj = Persistent<Object>::New(Object::New());
  p_obj->Set(String::New("domain"), domain);
}
```
Then `p_obj` will be passed with the request. Which you pass on `->Call()`. You can check `IsEmpty()` right before the callback is run to see if it was set. if not then pass `Object::New()` (or just stash an empty `Persistent` somewhere you can reuse, that would be faster). Something like this:
```c++
node::MakeCallback(asyncData->p_obj.IsEmpty() ? p_empty_obj : asyncData->p_obj,
                   asyncData->callback,
                   2,
                   argv);
```
Then don't forget to `Dispose` of `p_obj` during cleanup.

You'll probably need to rerun the benchmarks again, but shouldn't slow you down too much if you're not using domains.