Release handles and revoke callbacks when a GC runtime shuts down

Dart frees handles with a Finalizer, which never runs when an isolate group
shuts down, so on a Flutter hot restart everything the old isolate created
stayed alive: tray icons piled up (leanflutter/tray_manager#106). The core
also kept calling the old isolate's NativeCallables, which died with it, and
crashed on the next event that reached one.

native_handle_finalize(void*) releases any handle for a native finalizer,
always posted to the main thread. native_user_data_revoke(void*) marks a
user_data whose runtime is gone: the generated glue checks revoked() before
every callback call, a revoked async listener casts no vote, and its holder
skips the release. The revocation set is never destroyed, since holders
still let go during static destruction at exit.

Author: lijy91

src/capi/application_c.cpp

@@ -203,6 +203,7 @@ native_listener_id_t native_application_add_listener(native_application_event_ca
   try {
     return static_cast<native_listener_id_t>(nativeapi::Application::GetInstance().AddListener<nativeapi::ApplicationEvent>(
         [callback, holder](const nativeapi::ApplicationEvent& event) {
+          if (holder->revoked()) return;
           native_application_event_t c_event = {};
           if (!to_c_application_event(event, &c_event)) {
             return;
@@ -222,6 +223,7 @@ native_listener_id_t native_application_add_listener_async(native_application_ev
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::ApplicationEvent>(nativeapi::Application::GetInstance(),
         [callback, registration](const nativeapi::ApplicationEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           if (const auto* typed = dynamic_cast<const nativeapi::ApplicationQuitRequestedEvent*>(&event)) request = typed->GetRequest();
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;

src/capi/common_c.cpp

@@ -3,7 +3,9 @@
 
 #include "common_c.h"
 #include "event_delivery.h"
+#include "../foundation/dispatcher.h"
 #include "../foundation/handle_table.h"
+#include "user_data.h"
 
 bool native_event_delivery_is_active(native_event_delivery_t delivery) {
   auto value = nativeapi::HandleTable::GetInstance().Resolve<nativeapi::capi::EventDelivery>(delivery);
@@ -17,3 +19,17 @@ bool native_event_delivery_complete(native_event_delivery_t delivery, bool accep
   table.Release(delivery);
   return true;
 }
+
+void native_handle_finalize(void* handle) {
+  const auto value = static_cast<nativeapi::HandleValue>(
+      reinterpret_cast<uintptr_t>(handle));
+  // Always posted, even from the main thread: destroying a platform object
+  // off it is unsafe, and a runtime shutting down revokes its callbacks in
+  // its other finalizers first, which the destruction may otherwise call.
+  auto release = [value] { nativeapi::HandleTable::GetInstance().Release(value); };
+  if (!nativeapi::RunOnMainThread(release) && !nativeapi::IsMainThreadDispatchSupported()) release();
+}
+
+void native_user_data_revoke(void* user_data) {
+  nativeapi::capi::RevokedUserData::Revoke(user_data);
+}

src/capi/common_c.h

@@ -40,6 +40,19 @@ FFI_PLUGIN_EXPORT bool native_event_delivery_is_active(native_event_delivery_t d
 /// Pass false on failure. Returns false for duplicate, stale or type-confused handles.
 FFI_PLUGIN_EXPORT bool native_event_delivery_complete(native_event_delivery_t delivery, bool accept);
 
+/// Releases a handle of any type for a garbage collector's native finalizer,
+/// such as Dart's NativeFinalizer, which runs it on an arbitrary thread and
+/// also when the runtime shuts down (a Flutter hot restart, for one). `handle`
+/// is the handle's value cast to a pointer; the release itself runs on the
+/// main thread. Stale or invalid handles are ignored.
+FFI_PLUGIN_EXPORT void native_handle_finalize(void* handle);
+
+/// Tells the core a binding's runtime is gone for this user_data, from a
+/// native finalizer like the one above: from now on it calls neither the
+/// callback that travels with it nor its release. Safe from any thread.
+/// A binding must not pass a revoked value again.
+FFI_PLUGIN_EXPORT void native_user_data_revoke(void* user_data);
+
 #ifdef __cplusplus
 }
 #endif

src/capi/display_manager_c.cpp

@@ -72,6 +72,7 @@ native_listener_id_t native_display_manager_add_listener(native_display_event_ca
   try {
     return static_cast<native_listener_id_t>(nativeapi::DisplayManager::GetInstance().AddListener<nativeapi::DisplayEvent>(
         [callback, holder](const nativeapi::DisplayEvent& event) {
+          if (holder->revoked()) return;
           native_display_event_t c_event = {};
           if (!to_c_display_event(event, &c_event)) {
             return;
@@ -91,6 +92,7 @@ native_listener_id_t native_display_manager_add_listener_async(native_display_ev
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::DisplayEvent>(nativeapi::DisplayManager::GetInstance(),
         [callback, registration](const nativeapi::DisplayEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;

src/capi/drag_source_c.cpp

@@ -207,6 +207,7 @@ native_listener_id_t native_drag_source_add_listener(native_drag_source_t drag_s
   try {
     return static_cast<native_listener_id_t>(self->AddListener<nativeapi::DragSourceEvent>(
         [callback, holder](const nativeapi::DragSourceEvent& event) {
+          if (holder->revoked()) return;
           native_drag_source_event_t c_event = {};
           if (!to_c_drag_source_event(event, &c_event)) {
             return;
@@ -230,6 +231,7 @@ native_listener_id_t native_drag_source_add_listener_async(native_drag_source_t
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::DragSourceEvent>(*self,
         [callback, registration](const nativeapi::DragSourceEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;

src/capi/drop_target_c.cpp

@@ -114,6 +114,7 @@ native_listener_id_t native_drop_target_add_listener(native_drop_target_t drop_t
   try {
     return static_cast<native_listener_id_t>(self->AddListener<nativeapi::DropTargetEvent>(
         [callback, holder](const nativeapi::DropTargetEvent& event) {
+          if (holder->revoked()) return;
           native_drop_target_event_t c_event = {};
           if (!to_c_drop_target_event(event, &c_event)) {
             return;
@@ -137,6 +138,7 @@ native_listener_id_t native_drop_target_add_listener_async(native_drop_target_t
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::DropTargetEvent>(*self,
         [callback, registration](const nativeapi::DropTargetEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;

src/capi/keyboard_monitor_c.cpp

@@ -88,6 +88,7 @@ native_listener_id_t native_keyboard_monitor_add_listener(native_keyboard_monito
   try {
     return static_cast<native_listener_id_t>(self->AddListener<nativeapi::KeyboardEvent>(
         [callback, holder](const nativeapi::KeyboardEvent& event) {
+          if (holder->revoked()) return;
           native_keyboard_event_t c_event = {};
           if (!to_c_keyboard_event(event, &c_event)) {
             return;
@@ -111,6 +112,7 @@ native_listener_id_t native_keyboard_monitor_add_listener_async(native_keyboard_
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::KeyboardEvent>(*self,
         [callback, registration](const nativeapi::KeyboardEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;

src/capi/menu_c.cpp

@@ -353,6 +353,7 @@ native_listener_id_t native_menu_item_add_listener(native_menu_item_t menu_item,
   try {
     return static_cast<native_listener_id_t>(self->AddListener<nativeapi::MenuEvent>(
         [callback, holder](const nativeapi::MenuEvent& event) {
+          if (holder->revoked()) return;
           native_menu_event_t c_event = {};
           if (!to_c_menu_event(event, &c_event)) {
             return;
@@ -376,6 +377,7 @@ native_listener_id_t native_menu_item_add_listener_async(native_menu_item_t menu
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::MenuEvent>(*self,
         [callback, registration](const nativeapi::MenuEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;
@@ -711,6 +713,7 @@ native_listener_id_t native_menu_add_listener(native_menu_t menu, native_menu_ev
   try {
     return static_cast<native_listener_id_t>(self->AddListener<nativeapi::MenuEvent>(
         [callback, holder](const nativeapi::MenuEvent& event) {
+          if (holder->revoked()) return;
           native_menu_event_t c_event = {};
           if (!to_c_menu_event(event, &c_event)) {
             return;
@@ -734,6 +737,7 @@ native_listener_id_t native_menu_add_listener_async(native_menu_t menu, native_m
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::MenuEvent>(*self,
         [callback, registration](const nativeapi::MenuEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;

src/capi/notification_manager_c.cpp

@@ -80,6 +80,7 @@ native_listener_id_t native_notification_manager_add_listener(native_notificatio
   try {
     return static_cast<native_listener_id_t>(nativeapi::NotificationManager::GetInstance().AddListener<nativeapi::NotificationEvent>(
         [callback, holder](const nativeapi::NotificationEvent& event) {
+          if (holder->revoked()) return;
           native_notification_event_t c_event = {};
           if (!to_c_notification_event(event, &c_event)) {
             return;
@@ -99,6 +100,7 @@ native_listener_id_t native_notification_manager_add_listener_async(native_notif
     auto registration = std::make_shared<nativeapi::capi::EventDeliveryRegistration>(holder);
     return static_cast<native_listener_id_t>(nativeapi::detail::EventListenerDispatch::AddListener<nativeapi::NotificationEvent>(nativeapi::NotificationManager::GetInstance(),
         [callback, registration](const nativeapi::NotificationEvent& event) {
+          if (registration->context->holder->revoked()) return;
           std::shared_ptr<nativeapi::EventRequest> request;
           auto vote = request && request->IsCancelable() ? request->Defer() : nullptr;
           native_event_delivery_t delivery = 0;

src/capi/shortcut_c.cpp

@@ -42,7 +42,7 @@ native_shortcut_t native_shortcut_create_with_id_and_accelerator_and_callback(na
   try {
     std::function<void()> callback_cpp;
     if (callback) {
-      callback_cpp = [callback, callback_holder]() { callback(callback_holder->get()); };
+      callback_cpp = [callback, callback_holder]() { if (!callback_holder->revoked()) callback(callback_holder->get()); };
     }
     return nativeapi::HandleTable::GetInstance().Insert(
         std::make_shared<nativeapi::Shortcut>(id, std::string(accelerator ? accelerator : ""), callback_cpp));
@@ -168,7 +168,7 @@ void native_shortcut_set_callback(native_shortcut_t shortcut, native_shortcut_se
   try {
     std::function<void()> callback_cpp;
     if (callback) {
-      callback_cpp = [callback, callback_holder]() { callback(callback_holder->get()); };
+      callback_cpp = [callback, callback_holder]() { if (!callback_holder->revoked()) callback(callback_holder->get()); };
     }
     self->SetCallback(callback_cpp);
     return;