Currently, UnsafeCallback ref'ing and unref'ing uses a CancelHandle in the UnsafeCallback resource. When an UnsafeCallback gets unref'ed (ref counter goes back to 0), its CancelHandle is triggered to resolve the Future / Promise that keeps the event loop alive and provides a Waker for the CallbackInfo. If the same UnsafeCallback then gets re-ref'ed afterwards the same CancelHandle gets reused and it immediately cancels the Future, leading to Deno's event loop not staying alive and worst of all severing the Waker's tie to the Deno event loop.

There issue is that currently, an UnsafeCallback that is unref'ed (or never ref'ed in the first place) cannot wake the Deno event loop up as it either doesn't have a Waker, or the Waker is no longer tied to the event loop. So eg. this will not work:

const callback = new Deno.UnsafeCallback(...);
lib.symbols.register_callback(callback.pointer); // expect this to be called in a thread-safe manner at some point randomly
setTimeout(() => {}, 100000000000000000)

The timeout finishes in something like a 300 000 years but the callback will never be resolved: Any call to this callback will send Deno's event loop work to do, but the event loop can never be woken up.

Fix

• Added UnsafeCallback.threadSafe() static constructor function that creates a callback and refs it once.
• When a callback is ref'ed, it creates a Promise/Future with a Waker given to the C callback info that can be used to wake up the event loop. The Future is only resolved by cancelling when the callback resource is closed.
• When a callback is unref'ed, the Promise is unref'ed using the core.unrefOp mechanism. ie. The Promise/Future does not get resolved or canceled, it is simply unref'ed.