From ec78a48bd994820a039b6414fd475aa52233c5ac Mon Sep 17 00:00:00 2001 From: yunchan Date: Sun, 11 Oct 2026 15:33:50 +0900 Subject: [PATCH 1/4] linux: add texture lifecycle tests (Kitedesk B212) Standalone C++ tests for the Linux texture, built against the engine of the active Flutter SDK by linux/test/run_tests.sh (optionally with ASan/UBSan). The plugin source is compiled into the test and driven through a real FlMethodChannel on fake engine objects (binary messenger, texture registrar with the reference rules of engine a18df97c, plugin registrar); frame buffers copied with new[] are counted. On 42797e0f eight of the ten tests fail: closing a texture keeps both frame buffers, the GObject has no finalize, and closed textures are never reused, so every session leaves a frame buffer and an engine GL texture behind. Co-Authored-By: Claude Opus 5.5 (1M context) --- linux/test/run_tests.sh | 24 + .../test/texture_rgba_renderer_plugin_test.cc | 836 ++++++++++++++++++ 2 files changed, 860 insertions(+) create mode 100755 linux/test/run_tests.sh create mode 100644 linux/test/texture_rgba_renderer_plugin_test.cc diff --git a/linux/test/run_tests.sh b/linux/test/run_tests.sh new file mode 100755 index 0000000..fc4a1f2 --- /dev/null +++ b/linux/test/run_tests.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash +# Kitedesk fork, 2026: builds and runs linux/test/texture_rgba_renderer_plugin_test.cc +# against the Linux engine of the Flutter SDK on PATH (or FLUTTER_ROOT). +# The test does not open a display or a GL context. +# run_tests.sh -Wall -Werror build, like the plugin in an app build +# run_tests.sh --asan the same with AddressSanitizer and UBSan +# OUT_DIR (default: a new temporary directory) receives the test binary. +set -euo pipefail +here=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +root=${FLUTTER_ROOT:-$(dirname "$(dirname "$(readlink -f "$(command -v flutter)")")")} +engine=$root/bin/cache/artifacts/engine/linux-x64 +[ -f "$engine/libflutter_linux_gtk.so" ] || { echo "no Linux engine in $engine (run flutter precache --linux)" >&2; exit 2; } +out=${OUT_DIR:-$(mktemp -d)} +mkdir -p "$out" +flags=(-std=gnu++14 -Wall -Werror -O1 -g -DFLUTTER_PLUGIN_IMPL) +if [ "${1:-}" = --asan ]; then + flags+=(-fsanitize=address,undefined -fno-omit-frame-pointer -fno-sanitize-recover=undefined) + export ASAN_OPTIONS=${ASAN_OPTIONS:-detect_leaks=0} +fi +# shellcheck disable=SC2046 +"${CXX:-clang++}" "${flags[@]}" -I"$engine" -I"$here/../include" $(pkg-config --cflags gtk+-3.0) \ + "$here/texture_rgba_renderer_plugin_test.cc" -o "$out/texture_rgba_renderer_plugin_test" \ + -L"$engine" -Wl,-rpath,"$engine" -lflutter_linux_gtk $(pkg-config --libs gtk+-3.0) -pthread +"$out/texture_rgba_renderer_plugin_test" diff --git a/linux/test/texture_rgba_renderer_plugin_test.cc b/linux/test/texture_rgba_renderer_plugin_test.cc new file mode 100644 index 0000000..e15baa5 --- /dev/null +++ b/linux/test/texture_rgba_renderer_plugin_test.cc @@ -0,0 +1,836 @@ +// Kitedesk fork, 2026: lifecycle tests for the Linux texture of this plugin +// (Kitedesk backlog B212). Licensed under the Apache License, Version 2.0, +// like the rest of this package. +// +// The plugin source is compiled into this program and driven through a real +// FlMethodChannel on fake engine objects: a binary messenger, a texture +// registrar with the reference rules of the Flutter 3.24 engine, and a plugin +// registrar. Frame buffers that the plugin copies with new[] are counted. +// The engine's GL work (fl_pixel_buffer_texture_populate) is replaced by calls +// to the copy_pixels hook it would make; no GL context is needed. +// +// Build and run: linux/test/run_tests.sh [--asan] + +#include "../texture_rgba_renderer_plugin.cc" + +#include +#include +#include +#include +#include +#include + +namespace { + +constexpr int kWidth = 321; +constexpr int kHeight = 123; +constexpr size_t kFrameBytes = static_cast(kWidth) * kHeight * 4; + +// Live frame buffers: new[] blocks of exactly kFrameBytes (no other code in +// this program allocates that size). +constexpr int kSlots = 4096; +std::atomic_flag g_frames_lock = ATOMIC_FLAG_INIT; +void* g_frames[kSlots]; +int g_live_frames = 0; + +void lock_frames() { + while (g_frames_lock.test_and_set(std::memory_order_acquire)) { + } +} + +void unlock_frames() { g_frames_lock.clear(std::memory_order_release); } + +int live_frames() { + lock_frames(); + int n = g_live_frames; + unlock_frames(); + return n; +} + +} // namespace + +void* operator new[](size_t size) { + void* p = std::malloc(size ? size : 1); + if (p == nullptr) { + throw std::bad_alloc(); + } + if (size == kFrameBytes) { + lock_frames(); + for (int i = 0; i < kSlots; i++) { + if (g_frames[i] == nullptr) { + g_frames[i] = p; + g_live_frames++; + break; + } + } + unlock_frames(); + } + return p; +} + +void operator delete[](void* p) noexcept { + if (p != nullptr) { + lock_frames(); + for (int i = 0; i < kSlots; i++) { + if (g_frames[i] == p) { + g_frames[i] = nullptr; + g_live_frames--; + break; + } + } + unlock_frames(); + } + std::free(p); +} + +void operator delete[](void* p, size_t) noexcept { operator delete[](p); } + +// --------------------------------------------------------------------------- +// Fake texture registrar: register takes a reference and keys the texture by +// its address, unregister drops it (fl_texture_registrar.cc @ engine a18df97c). + +G_DECLARE_FINAL_TYPE(FakeTextureRegistrar, + fake_texture_registrar, + FAKE, + TEXTURE_REGISTRAR, + GObject) + +struct _FakeTextureRegistrar { + GObject parent_instance; + GHashTable* textures; // FlTexture* -> FlTexture* (reference) + GMutex mutex; + gint marks; +}; + +static void fake_texture_registrar_iface_init( + FlTextureRegistrarInterface* iface); + +G_DEFINE_TYPE_WITH_CODE( + FakeTextureRegistrar, + fake_texture_registrar, + G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(fl_texture_registrar_get_type(), + fake_texture_registrar_iface_init)) + +static gboolean ftr_register(FlTextureRegistrar* registrar, + FlTexture* texture) { + FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar); + FL_TEXTURE_GET_IFACE(texture)->set_id(texture, + reinterpret_cast(texture)); + g_mutex_lock(&self->mutex); + g_hash_table_insert(self->textures, texture, g_object_ref(texture)); + g_mutex_unlock(&self->mutex); + return TRUE; +} + +static FlTexture* ftr_lookup(FlTextureRegistrar* registrar, int64_t id) { + FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar); + g_mutex_lock(&self->mutex); + FlTexture* texture = static_cast( + g_hash_table_lookup(self->textures, reinterpret_cast(id))); + g_mutex_unlock(&self->mutex); + return texture; +} + +static gboolean ftr_mark(FlTextureRegistrar* registrar, FlTexture* texture) { + g_atomic_int_inc(&FAKE_TEXTURE_REGISTRAR(registrar)->marks); + return TRUE; +} + +static gboolean ftr_unregister(FlTextureRegistrar* registrar, + FlTexture* texture) { + FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar); + g_mutex_lock(&self->mutex); + gboolean removed = g_hash_table_remove(self->textures, texture); + g_mutex_unlock(&self->mutex); + return removed; +} + +static void ftr_shutdown(FlTextureRegistrar* registrar) { + FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(registrar); + g_mutex_lock(&self->mutex); + g_hash_table_remove_all(self->textures); + g_mutex_unlock(&self->mutex); +} + +static void fake_texture_registrar_iface_init( + FlTextureRegistrarInterface* iface) { + iface->register_texture = ftr_register; + iface->lookup_texture = ftr_lookup; + iface->mark_texture_frame_available = ftr_mark; + iface->unregister_texture = ftr_unregister; + iface->shutdown = ftr_shutdown; +} + +static void fake_texture_registrar_dispose(GObject* object) { + FakeTextureRegistrar* self = FAKE_TEXTURE_REGISTRAR(object); + g_clear_pointer(&self->textures, g_hash_table_unref); + G_OBJECT_CLASS(fake_texture_registrar_parent_class)->dispose(object); +} + +static void fake_texture_registrar_class_init( + FakeTextureRegistrarClass* klass) { + G_OBJECT_CLASS(klass)->dispose = fake_texture_registrar_dispose; +} + +static void fake_texture_registrar_init(FakeTextureRegistrar* self) { + self->textures = g_hash_table_new_full(g_direct_hash, g_direct_equal, + nullptr, g_object_unref); + g_mutex_init(&self->mutex); +} + +static gboolean registered(FakeTextureRegistrar* self, int64_t ptr) { + return ftr_lookup(FL_TEXTURE_REGISTRAR(self), ptr) != nullptr; +} + +// --------------------------------------------------------------------------- +// Fake binary messenger. send_on_channel delivers to the handler registered on +// the peer messenger, like Dart -> engine -> plugin. + +G_DECLARE_FINAL_TYPE(FakeResponseHandle, + fake_response_handle, + FAKE, + RESPONSE_HANDLE, + FlBinaryMessengerResponseHandle) + +struct _FakeResponseHandle { + FlBinaryMessengerResponseHandle parent_instance; + GTask* task; +}; + +G_DEFINE_TYPE(FakeResponseHandle, + fake_response_handle, + fl_binary_messenger_response_handle_get_type()) + +static void fake_response_handle_dispose(GObject* object) { + FakeResponseHandle* self = FAKE_RESPONSE_HANDLE(object); + if (self->task != nullptr) { + g_task_return_new_error(self->task, G_IO_ERROR, G_IO_ERROR_FAILED, + "no response"); + g_clear_object(&self->task); + } + G_OBJECT_CLASS(fake_response_handle_parent_class)->dispose(object); +} + +static void fake_response_handle_class_init(FakeResponseHandleClass* klass) { + G_OBJECT_CLASS(klass)->dispose = fake_response_handle_dispose; +} + +static void fake_response_handle_init(FakeResponseHandle* self) {} + +G_DECLARE_FINAL_TYPE(FakeMessenger, fake_messenger, FAKE, MESSENGER, GObject) + +struct Handler { + FlBinaryMessengerMessageHandler handler; + gpointer user_data; + GDestroyNotify destroy_notify; +}; + +static void handler_free(gpointer data) { + Handler* h = static_cast(data); + if (h->destroy_notify != nullptr) { + h->destroy_notify(h->user_data); + } + g_free(h); +} + +struct _FakeMessenger { + GObject parent_instance; + GHashTable* handlers; // channel -> Handler* + FakeMessenger* peer; // not owned +}; + +static void fake_messenger_iface_init(FlBinaryMessengerInterface* iface); + +G_DEFINE_TYPE_WITH_CODE(FakeMessenger, + fake_messenger, + G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(fl_binary_messenger_get_type(), + fake_messenger_iface_init)) + +static void fm_set_handler(FlBinaryMessenger* messenger, + const gchar* channel, + FlBinaryMessengerMessageHandler handler, + gpointer user_data, + GDestroyNotify destroy_notify) { + FakeMessenger* self = FAKE_MESSENGER(messenger); + if (handler == nullptr) { + g_hash_table_remove(self->handlers, channel); + return; + } + Handler* h = g_new0(Handler, 1); + h->handler = handler; + h->user_data = user_data; + h->destroy_notify = destroy_notify; + g_hash_table_insert(self->handlers, g_strdup(channel), h); +} + +static gboolean fm_send_response(FlBinaryMessenger* messenger, + FlBinaryMessengerResponseHandle* handle, + GBytes* response, + GError** error) { + FakeResponseHandle* h = FAKE_RESPONSE_HANDLE(handle); + if (h->task == nullptr) { + g_set_error(error, G_IO_ERROR, G_IO_ERROR_FAILED, "already responded"); + return FALSE; + } + g_task_return_pointer(h->task, g_bytes_ref(response), + reinterpret_cast(g_bytes_unref)); + g_clear_object(&h->task); + return TRUE; +} + +static void fm_send_on_channel(FlBinaryMessenger* messenger, + const gchar* channel, + GBytes* message, + GCancellable* cancellable, + GAsyncReadyCallback callback, + gpointer user_data) { + FakeMessenger* self = FAKE_MESSENGER(messenger); + // As in FlBinaryMessengerImpl, the reference from g_task_new belongs to + // send_on_channel_finish; the response handle holds its own. + GTask* task = g_task_new(self, cancellable, callback, user_data); + Handler* h = self->peer == nullptr + ? nullptr + : static_cast( + g_hash_table_lookup(self->peer->handlers, channel)); + if (h == nullptr) { + g_task_return_new_error(task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, + "no handler on %s", channel); + return; + } + FakeResponseHandle* handle = FAKE_RESPONSE_HANDLE( + g_object_new(fake_response_handle_get_type(), nullptr)); + handle->task = G_TASK(g_object_ref(task)); + h->handler(FL_BINARY_MESSENGER(self->peer), channel, message, + FL_BINARY_MESSENGER_RESPONSE_HANDLE(handle), h->user_data); + g_object_unref(handle); +} + +static GBytes* fm_send_on_channel_finish(FlBinaryMessenger* messenger, + GAsyncResult* result, + GError** error) { + g_autoptr(GTask) task = G_TASK(result); + return static_cast(g_task_propagate_pointer(task, error)); +} + +static void fm_resize_channel(FlBinaryMessenger* messenger, + const gchar* channel, + int64_t new_size) {} + +static void fm_set_warns(FlBinaryMessenger* messenger, + const gchar* channel, + bool warns) {} + +static void fm_shutdown(FlBinaryMessenger* messenger) { + g_hash_table_remove_all(FAKE_MESSENGER(messenger)->handlers); +} + +static void fake_messenger_iface_init(FlBinaryMessengerInterface* iface) { + iface->set_message_handler_on_channel = fm_set_handler; + iface->send_response = fm_send_response; + iface->send_on_channel = fm_send_on_channel; + iface->send_on_channel_finish = fm_send_on_channel_finish; + iface->resize_channel = fm_resize_channel; + iface->set_warns_on_channel_overflow = fm_set_warns; + iface->shutdown = fm_shutdown; +} + +static void fake_messenger_dispose(GObject* object) { + FakeMessenger* self = FAKE_MESSENGER(object); + g_clear_pointer(&self->handlers, g_hash_table_unref); + G_OBJECT_CLASS(fake_messenger_parent_class)->dispose(object); +} + +static void fake_messenger_class_init(FakeMessengerClass* klass) { + G_OBJECT_CLASS(klass)->dispose = fake_messenger_dispose; +} + +static void fake_messenger_init(FakeMessenger* self) { + self->handlers = + g_hash_table_new_full(g_str_hash, g_str_equal, g_free, handler_free); +} + +// --------------------------------------------------------------------------- +// Fake plugin registrar. + +G_DECLARE_FINAL_TYPE(FakePluginRegistrar, + fake_plugin_registrar, + FAKE, + PLUGIN_REGISTRAR, + GObject) + +struct _FakePluginRegistrar { + GObject parent_instance; + FlBinaryMessenger* messenger; + FlTextureRegistrar* textures; +}; + +static void fake_plugin_registrar_iface_init( + FlPluginRegistrarInterface* iface); + +G_DEFINE_TYPE_WITH_CODE( + FakePluginRegistrar, + fake_plugin_registrar, + G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE(fl_plugin_registrar_get_type(), + fake_plugin_registrar_iface_init)) + +static FlBinaryMessenger* fpr_get_messenger(FlPluginRegistrar* registrar) { + return FAKE_PLUGIN_REGISTRAR(registrar)->messenger; +} + +static FlTextureRegistrar* fpr_get_textures(FlPluginRegistrar* registrar) { + return FAKE_PLUGIN_REGISTRAR(registrar)->textures; +} + +static FlView* fpr_get_view(FlPluginRegistrar* registrar) { + return nullptr; +} + +static void fake_plugin_registrar_iface_init( + FlPluginRegistrarInterface* iface) { + iface->get_messenger = fpr_get_messenger; + iface->get_texture_registrar = fpr_get_textures; + iface->get_view = fpr_get_view; +} + +static void fake_plugin_registrar_dispose(GObject* object) { + FakePluginRegistrar* self = FAKE_PLUGIN_REGISTRAR(object); + g_clear_object(&self->messenger); + g_clear_object(&self->textures); + G_OBJECT_CLASS(fake_plugin_registrar_parent_class)->dispose(object); +} + +static void fake_plugin_registrar_class_init(FakePluginRegistrarClass* klass) { + G_OBJECT_CLASS(klass)->dispose = fake_plugin_registrar_dispose; +} + +static void fake_plugin_registrar_init(FakePluginRegistrar* self) {} + +// --------------------------------------------------------------------------- +// One "engine" (= one Flutter window): the plugin registered on it, plus a Dart +// side channel to call it. + +struct Engine { + FakeMessenger* messenger; + FakeTextureRegistrar* textures; + FakePluginRegistrar* registrar; + FakeMessenger* dart; + FlMethodChannel* channel; +}; + +static Engine* engine_new() { + Engine* e = g_new0(Engine, 1); + e->messenger = + FAKE_MESSENGER(g_object_new(fake_messenger_get_type(), nullptr)); + e->textures = FAKE_TEXTURE_REGISTRAR( + g_object_new(fake_texture_registrar_get_type(), nullptr)); + e->registrar = FAKE_PLUGIN_REGISTRAR( + g_object_new(fake_plugin_registrar_get_type(), nullptr)); + e->registrar->messenger = FL_BINARY_MESSENGER(g_object_ref(e->messenger)); + e->registrar->textures = FL_TEXTURE_REGISTRAR(g_object_ref(e->textures)); + texture_rgba_renderer_plugin_register_with_registrar( + FL_PLUGIN_REGISTRAR(e->registrar)); + e->dart = FAKE_MESSENGER(g_object_new(fake_messenger_get_type(), nullptr)); + e->dart->peer = e->messenger; + g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new(); + e->channel = fl_method_channel_new(FL_BINARY_MESSENGER(e->dart), + "texture_rgba_renderer", + FL_METHOD_CODEC(codec)); + return e; +} + +// What the engine does when its window goes away: the messenger drops its +// handlers (the plugin instance is released with them) and the texture +// registrar drops the textures that are still registered. +static void engine_shutdown(Engine* e) { + fm_shutdown(FL_BINARY_MESSENGER(e->messenger)); + fm_shutdown(FL_BINARY_MESSENGER(e->dart)); + ftr_shutdown(FL_TEXTURE_REGISTRAR(e->textures)); + g_clear_object(&e->channel); + g_clear_object(&e->dart); + g_clear_object(&e->registrar); + g_clear_object(&e->textures); + g_clear_object(&e->messenger); + g_free(e); +} + +struct CallResult { + gboolean done; + FlMethodResponse* response; +}; + +static void call_cb(GObject* object, GAsyncResult* result, gpointer user_data) { + CallResult* r = static_cast(user_data); + r->response = fl_method_channel_invoke_method_finish(FL_METHOD_CHANNEL(object), + result, nullptr); + r->done = TRUE; +} + +// Calls a plugin method like Dart does. Returns the int or bool result, or +// G_MININT64 when the call failed. +static int64_t invoke(Engine* e, const char* method, FlValue* args) { + CallResult r = {FALSE, nullptr}; + fl_method_channel_invoke_method(e->channel, method, args, nullptr, call_cb, + &r); + fl_value_unref(args); + for (int i = 0; i < 10000 && !r.done; i++) { + g_main_context_iteration(nullptr, FALSE); + } + int64_t out = G_MININT64; + if (r.response != nullptr) { + FlValue* value = fl_method_response_get_result(r.response, nullptr); + if (value != nullptr && fl_value_get_type(value) == FL_VALUE_TYPE_INT) { + out = fl_value_get_int(value); + } else if (value != nullptr && + fl_value_get_type(value) == FL_VALUE_TYPE_BOOL) { + out = fl_value_get_bool(value) ? 1 : 0; + } + g_object_unref(r.response); + } + return out; +} + +static FlValue* key_args(int64_t key) { + FlValue* args = fl_value_new_map(); + fl_value_set_string_take(args, "key", fl_value_new_int(key)); + return args; +} + +static int64_t create_texture(Engine* e, int64_t key) { + return invoke(e, "createTexture", key_args(key)); +} + +static int64_t texture_ptr(Engine* e, int64_t key) { + return invoke(e, "getTexturePtr", key_args(key)); +} + +// recycle < 0: no "recycle" argument (callers before the Kitedesk change). +static int64_t close_texture(Engine* e, int64_t key, int recycle) { + FlValue* args = key_args(key); + if (recycle >= 0) { + fl_value_set_string_take(args, "recycle", fl_value_new_bool(recycle != 0)); + } + return invoke(e, "closeTexture", args); +} + +// A decoded frame from the Rust video thread (FlutterRgbaRendererPluginOnRgba). +static void send_frame(int64_t ptr, uint8_t fill) { + static uint8_t frames[256][kFrameBytes]; + static gboolean filled[256]; + if (!filled[fill]) { + memset(frames[fill], fill, kFrameBytes); + filled[fill] = TRUE; + } + FlutterRgbaRendererPluginOnRgba(reinterpret_cast(ptr), frames[fill], + static_cast(kFrameBytes), kWidth, + kHeight, 0); +} + +struct Pulled { + gboolean ok; + const uint8_t* buffer; + uint32_t width; + uint32_t height; +}; + +// What fl_pixel_buffer_texture_populate asks the texture for on a raster +// frame. width/height start as the canvas size, like in the engine. +static Pulled pull_frame(int64_t ptr) { + Pulled p = {FALSE, nullptr, 999, 777}; + FlPixelBufferTexture* texture = + FL_PIXEL_BUFFER_TEXTURE(reinterpret_cast(ptr)); + g_autoptr(GError) error = nullptr; + p.ok = FL_PIXEL_BUFFER_TEXTURE_GET_CLASS(texture)->copy_pixels( + texture, &p.buffer, &p.width, &p.height, &error); + return p; +} + +static void set_flag(gpointer data, GObject* where_the_object_was) { + *static_cast(data) = TRUE; +} + +// --------------------------------------------------------------------------- + +int g_failed_checks = 0; + +#define CHECK(cond) \ + do { \ + if (!(cond)) { \ + std::fprintf(stderr, " check failed at line %d: %s\n", __LINE__, \ + #cond); \ + g_failed_checks++; \ + return; \ + } \ + } while (0) + +// D1: closing a texture frees the frame it shows and the frame still waiting +// for the next raster frame. +static void test_close_frees_frame_buffers() { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t id = create_texture(e, 101); + int64_t ptr = texture_ptr(e, 101); + CHECK(id > 0 && ptr == id); + send_frame(ptr, 1); + Pulled shown = pull_frame(ptr); + CHECK(shown.ok && shown.buffer != nullptr && shown.width == kWidth && + shown.height == kHeight && shown.buffer[0] == 1); + send_frame(ptr, 2); + CHECK(live_frames() == base + 2); + CHECK(close_texture(e, 101, 0) == 1); + CHECK(live_frames() == base); + engine_shutdown(e); +} + +// D1: after close, late frames are dropped and the texture never hands out a +// frame again (it would be a freed buffer). +static void test_closed_texture_ignores_late_frames() { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t ptr = create_texture(e, 111); + send_frame(ptr, 3); + CHECK(close_texture(e, 111, 0) == 1); + send_frame(ptr, 4); + CHECK(live_frames() == base); + Pulled late = pull_frame(ptr); + CHECK(!late.ok); + engine_shutdown(e); +} + +// D1: the GObject frees its frame buffers when it is finalized. +static void test_finalize_frees_frame_buffers() { + const int base = live_frames(); + FakeTextureRegistrar* registrar = FAKE_TEXTURE_REGISTRAR( + g_object_new(fake_texture_registrar_get_type(), nullptr)); + TextureRgba* texture = texture_rgba_new(FL_TEXTURE_REGISTRAR(registrar)); + texture->texture_id = reinterpret_cast(texture); + int64_t ptr = reinterpret_cast(texture); + send_frame(ptr, 5); + CHECK(pull_frame(ptr).ok); + send_frame(ptr, 6); + CHECK(live_frames() == base + 2); + gboolean finalized = FALSE; + g_object_weak_ref(G_OBJECT(texture), set_flag, &finalized); + g_object_unref(texture); + CHECK(finalized); + CHECK(live_frames() == base); + g_object_unref(registrar); +} + +// D2: a texture closed with recycle=true is the one the next createTexture of +// the same window gets back, so the engine's GL texture is reused instead of +// left behind; the object is never released (its GL name belongs to that +// window's context). +static void test_recycled_texture_is_reused_in_same_window() { + const int base = live_frames(); + Engine* e = engine_new(); + std::set seen; + gboolean finalized = FALSE; + for (int i = 0; i < 5; i++) { + int64_t key = 200 + i; + int64_t ptr = create_texture(e, key); + CHECK(ptr > 0 && texture_ptr(e, key) == ptr); + CHECK(registered(e->textures, ptr)); + if (seen.empty()) { + g_object_weak_ref(G_OBJECT(reinterpret_cast(ptr)), set_flag, + &finalized); + } + seen.insert(ptr); + send_frame(ptr, 7); + CHECK(pull_frame(ptr).ok); + send_frame(ptr, 8); + CHECK(close_texture(e, key, 1) == 1); + CHECK(!registered(e->textures, ptr)); + CHECK(live_frames() == base); + } + CHECK(seen.size() == 1); + CHECK(!finalized); + engine_shutdown(e); +} + +// D2, multi-window: windows never get each other's textures back. +static void test_recycling_stays_in_one_window() { + Engine* w1 = engine_new(); + Engine* w2 = engine_new(); + int64_t a = create_texture(w1, 300); + CHECK(close_texture(w1, 300, 1) == 1); + int64_t b = create_texture(w2, 301); + CHECK(b > 0 && b != a); + CHECK(!registered(w2->textures, a) && !registered(w1->textures, a)); + CHECK(close_texture(w2, 301, 1) == 1); + int64_t c = create_texture(w1, 302); + CHECK(c == a && registered(w1->textures, a)); + int64_t d = create_texture(w1, 303); + CHECK(d != b && d != a && registered(w1->textures, d)); + CHECK(!registered(w1->textures, b)); + int64_t f = create_texture(w2, 304); + CHECK(f == b && registered(w2->textures, b)); + engine_shutdown(w1); + engine_shutdown(w2); +} + +// D2: without recycle (old callers, or a tab moving to another window while +// its session keeps the texture pointer), the texture is never handed out +// again and stays a valid, inert object. +static void test_close_without_recycle_never_reuses() { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t a = create_texture(e, 400); + gboolean finalized = FALSE; + g_object_weak_ref(G_OBJECT(reinterpret_cast(a)), set_flag, + &finalized); + CHECK(close_texture(e, 400, -1) == 1); + int64_t b = create_texture(e, 401); + CHECK(b > 0 && b != a); + send_frame(a, 9); + CHECK(live_frames() == base); + CHECK(!pull_frame(a).ok); + CHECK(close_texture(e, 401, 0) == 1); + int64_t c = create_texture(e, 402); + CHECK(c != a && c != b); + CHECK(!finalized); + engine_shutdown(e); +} + +// D2: a reused texture must not show the last frame of its previous session +// before the new session's first frame. While no frame is waiting the texture +// uploads one transparent pixel instead of leaving the old content. +static void test_reused_texture_shows_no_stale_frame() { + Engine* e = engine_new(); + int64_t a = create_texture(e, 500); + send_frame(a, 0xAB); + CHECK(pull_frame(a).ok); + CHECK(close_texture(e, 500, 1) == 1); + int64_t b = create_texture(e, 501); + CHECK(b == a); + Pulled first = pull_frame(b); + CHECK(first.ok && first.buffer != nullptr && first.width == 1 && + first.height == 1); + CHECK(first.buffer[0] == 0 && first.buffer[1] == 0 && first.buffer[2] == 0 && + first.buffer[3] == 0); + send_frame(b, 0xCD); + Pulled next = pull_frame(b); + CHECK(next.ok && next.width == kWidth && next.height == kHeight && + next.buffer[0] == 0xCD); + CHECK(close_texture(e, 501, 1) == 1); + engine_shutdown(e); +} + +// D2: when a window's engine goes away the recycled textures are kept alive: +// releasing them would make the engine delete their GL texture in whatever GL +// context is current (another window's), which is the upstream PR #2 defect. +static void test_engine_shutdown_keeps_recycled_textures() { + Engine* e = engine_new(); + int64_t a = create_texture(e, 600); + int64_t b = create_texture(e, 601); + gboolean a_finalized = FALSE; + gboolean b_finalized = FALSE; + g_object_weak_ref(G_OBJECT(reinterpret_cast(a)), set_flag, + &a_finalized); + g_object_weak_ref(G_OBJECT(reinterpret_cast(b)), set_flag, + &b_finalized); + CHECK(close_texture(e, 600, 1) == 1); + engine_shutdown(e); + CHECK(!a_finalized && !b_finalized); +} + +// D1: frames keep arriving from the video thread while the window closes the +// texture (no recycle: the native side may still hold the pointer). +static void test_frames_racing_close() { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t ptr = create_texture(e, 700); + std::atomic stop{false}; + std::thread video([ptr, &stop]() { + for (int i = 0; i < 200000 && !stop.load(); i++) { + send_frame(ptr, static_cast(10 + i % 2)); + } + }); + for (int i = 0; i < 200; i++) { + pull_frame(ptr); + g_usleep(50); + } + int64_t closed = close_texture(e, 700, 0); + for (int i = 0; i < 200; i++) { + pull_frame(ptr); + g_usleep(50); + } + stop = true; + video.join(); + CHECK(closed == 1); + CHECK(live_frames() == base); + engine_shutdown(e); +} + +// D2, multi-monitor tab: textures of several displays in one window are +// recycled among themselves without touching the ones still on screen. +static void test_multi_display_tab() { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t d0 = create_texture(e, 800); + int64_t d1 = create_texture(e, 801); + CHECK(d0 != d1); + send_frame(d0, 20); + CHECK(pull_frame(d0).ok); + send_frame(d1, 21); + CHECK(pull_frame(d1).ok); + // Show display 0 only. + CHECK(close_texture(e, 801, 1) == 1); + send_frame(d0, 22); + Pulled p0 = pull_frame(d0); + CHECK(p0.ok && p0.buffer[0] == 22 && registered(e->textures, d0)); + // All displays again. + int64_t d1b = create_texture(e, 802); + CHECK(d1b == d1 && registered(e->textures, d1)); + send_frame(d1b, 23); + Pulled p1 = pull_frame(d1b); + CHECK(p1.ok && p1.buffer[0] == 23); + // Close the tab, open another one with two displays. + CHECK(close_texture(e, 800, 1) == 1); + CHECK(close_texture(e, 802, 1) == 1); + CHECK(live_frames() == base); + int64_t n0 = create_texture(e, 803); + int64_t n1 = create_texture(e, 804); + CHECK(std::set({n0, n1}) == std::set({d0, d1})); + CHECK(close_texture(e, 803, 1) == 1); + CHECK(close_texture(e, 804, 1) == 1); + engine_shutdown(e); +} + +int main() { + struct { + const char* name; + void (*run)(); + } tests[] = { + {"close_frees_frame_buffers", test_close_frees_frame_buffers}, + {"closed_texture_ignores_late_frames", + test_closed_texture_ignores_late_frames}, + {"finalize_frees_frame_buffers", test_finalize_frees_frame_buffers}, + {"recycled_texture_is_reused_in_same_window", + test_recycled_texture_is_reused_in_same_window}, + {"recycling_stays_in_one_window", test_recycling_stays_in_one_window}, + {"close_without_recycle_never_reuses", + test_close_without_recycle_never_reuses}, + {"reused_texture_shows_no_stale_frame", + test_reused_texture_shows_no_stale_frame}, + {"engine_shutdown_keeps_recycled_textures", + test_engine_shutdown_keeps_recycled_textures}, + {"frames_racing_close", test_frames_racing_close}, + {"multi_display_tab", test_multi_display_tab}, + }; + int failed = 0; + int count = 0; + for (auto& t : tests) { + int before = g_failed_checks; + t.run(); + bool ok = g_failed_checks == before; + std::printf("%s %s\n", ok ? "PASS" : "FAIL", t.name); + std::fflush(stdout); + failed += ok ? 0 : 1; + count++; + } + std::printf("%d tests, %d passed, %d failed\n", count, count - failed, failed); + return failed == 0 ? 0 : 1; +} From 48fa1d7ddffc0418cfa65215d7be86ba469698de Mon Sep 17 00:00:00 2001 From: yunchan Date: Sun, 11 Oct 2026 15:34:27 +0900 Subject: [PATCH 2/4] linux: free frame buffers on closeTexture and in finalize (Kitedesk B212) closeTexture marked the texture terminated but kept the frame last handed to the engine and any frame still waiting, and TextureRgba had no finalize, so each closed session kept one or two frame-sized buffers forever (2 x width x height x 4 bytes measured per 1080p session). terminate now frees both buffers under the texture mutex: the texture is already unregistered and OnRgba stops copying once terminated is set. A finalize frees them as well. GObject and GL lifetime are unchanged here. Tests: close_frees_frame_buffers, closed_texture_ignores_late_frames, finalize_frees_frame_buffers and frames_racing_close pass (also under ASan); the four recycling tests still fail. Co-Authored-By: Claude Opus 5.5 (1M context) --- .../texture_rgba_renderer.h | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/linux/include/texture_rgba_renderer/texture_rgba_renderer.h b/linux/include/texture_rgba_renderer/texture_rgba_renderer.h index 3bdaae0..f2e17a7 100644 --- a/linux/include/texture_rgba_renderer/texture_rgba_renderer.h +++ b/linux/include/texture_rgba_renderer/texture_rgba_renderer.h @@ -1,3 +1,6 @@ +// Modified by the Kitedesk fork (2026, B212): frame buffers are freed when the +// texture is closed and when the object is finalized. + #ifndef TEXTURE_RGBA_RENDERER_H #define TEXTURE_RGBA_RENDERER_H @@ -40,9 +43,26 @@ G_DEFINE_TYPE(TextureRgba, texture_rgba, TextureRgba)) +// Frees the frame waiting for the next raster frame and the frame last handed +// to the engine. Call with the mutex held, or when no other thread can use the +// texture any more. +static void texture_rgba_free_buffers(TextureRgba* self) { + if (g_atomic_int_get(&self->buffer_ready)) { + // Not handed to the engine yet; prior_buffer is the older frame. + delete[] self->buffer; + } + delete[] self->prior_buffer; + self->buffer = nullptr; + self->prior_buffer = nullptr; + g_atomic_int_set(&self->buffer_ready, FALSE); +} + static void texture_rgba_terminate(TextureRgba* self) { g_mutex_lock(&self->mutex); g_atomic_int_set(&self->terminated, TRUE); + // The texture is unregistered, so the engine reads neither frame again, and + // OnRgba stops copying frames once terminated is set. + texture_rgba_free_buffers(self); g_mutex_unlock(&self->mutex); } @@ -137,8 +157,16 @@ static TextureRgba *texture_rgba_new(FlTextureRegistrar* registrar) return texture; } +static void texture_rgba_finalize(GObject* object) { + TextureRgba* self = TEXTURE_RGBA(object); + texture_rgba_free_buffers(self); + g_mutex_clear(&self->mutex); + G_OBJECT_CLASS(texture_rgba_parent_class)->finalize(object); +} + static void texture_rgba_class_init(TextureRgbaClass *klass) { + G_OBJECT_CLASS(klass)->finalize = texture_rgba_finalize; FL_PIXEL_BUFFER_TEXTURE_CLASS(klass)->copy_pixels = texture_rgba_copy_pixels; } From 8cd34a80ffae73d6e4bb007badf64b8a0a7325ac Mon Sep 17 00:00:00 2001 From: yunchan Date: Sun, 11 Oct 2026 15:38:06 +0900 Subject: [PATCH 3/4] linux: recycle closed textures per engine, closeTexture(recycle:) (Kitedesk B212) Each session created a new TextureRgba and closeTexture never released it, so the engine's FlPixelBufferTexture kept its GL texture (one frame of GPU or, with llvmpipe, process memory per session). Releasing the object is not safe: FlPixelBufferTexture deletes its GL texture in dispose without selecting a GL context, so a release from another window deletes that window's texture of the same name (upstream PR #2 turned the remaining window white). closeTexture(key, recycle: true) now keeps the texture in a list of the plugin instance, i.e. of the engine (window) that created it, and the next createTexture of that engine registers it again. Its GL texture is only ever touched by that engine's populate in its own context, nothing is released, and the GL memory is bounded by the number of textures a window had open at once. When the engine goes away the recycled textures stay referenced for the same reason. Without recycle (old callers, or a tab that moves to another window while its session still holds the pointer) a closed texture stays terminated and is never handed out again. With no frame waiting, copy_pixels hands out one transparent pixel instead of no buffer, so a recycled texture cannot show the last frame of its previous session before the first new frame. Dart: closeTexture(int key, {bool recycle = false}) sends "recycle"; other platforms ignore it. Tests: all ten Linux lifecycle tests pass (clang and gcc, -Wall -Werror, also under ASan/UBSan); Dart 4/4. Co-Authored-By: Claude Opus 5.5 (1M context) --- lib/texture_rgba_renderer.dart | 11 +++++- lib/texture_rgba_renderer_method_channel.dart | 7 ++-- ...ture_rgba_renderer_platform_interface.dart | 3 +- .../texture_rgba_renderer.h | 20 +++++++++- linux/texture_rgba_renderer_plugin.cc | 37 +++++++++++++++++-- ...ure_rgba_renderer_method_channel_test.dart | 17 +++++++++ test/texture_rgba_renderer_test.dart | 23 +++++++++++- 7 files changed, 106 insertions(+), 12 deletions(-) diff --git a/lib/texture_rgba_renderer.dart b/lib/texture_rgba_renderer.dart index 2502177..04ee24a 100644 --- a/lib/texture_rgba_renderer.dart +++ b/lib/texture_rgba_renderer.dart @@ -1,3 +1,4 @@ +// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`. import 'dart:typed_data'; export './texture_rgba_ffi.dart' show Native; @@ -17,9 +18,15 @@ class TextureRgbaRenderer { /// Close a texture with unique identifier [key]. /// + /// Pass [recycle] = true only when nothing calls `onRgba` with the pointer + /// from [getTexturePtr] any more. On Linux the texture is then kept for the + /// next [createTexture] of the same window instead of being leaked + /// (Kitedesk fork, B212); other platforms ignore it. + /// /// @return a boolean to indicate whether the operation is sucessfully executed. - Future closeTexture(int key) { - return TextureRgbaRendererPlatform.instance.closeTexture(key); + Future closeTexture(int key, {bool recycle = false}) { + return TextureRgbaRendererPlatform.instance + .closeTexture(key, recycle: recycle); } /// Provide the rgba data to the texture. diff --git a/lib/texture_rgba_renderer_method_channel.dart b/lib/texture_rgba_renderer_method_channel.dart index 6137a94..ac61506 100644 --- a/lib/texture_rgba_renderer_method_channel.dart +++ b/lib/texture_rgba_renderer_method_channel.dart @@ -1,3 +1,4 @@ +// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`. // ignore: unused_import, unnecessary_import import 'dart:io'; // Compatible with lint in Flutter 3.0.5 @@ -30,9 +31,9 @@ class MethodChannelTextureRgbaRenderer extends TextureRgbaRendererPlatform { } @override - Future closeTexture(int key) async { - return await methodChannel - .invokeMethod('closeTexture', {"key": key}) ?? + Future closeTexture(int key, {bool recycle = false}) async { + return await methodChannel.invokeMethod( + 'closeTexture', {"key": key, "recycle": recycle}) ?? false; } diff --git a/lib/texture_rgba_renderer_platform_interface.dart b/lib/texture_rgba_renderer_platform_interface.dart index fd1d491..f28a650 100644 --- a/lib/texture_rgba_renderer_platform_interface.dart +++ b/lib/texture_rgba_renderer_platform_interface.dart @@ -1,3 +1,4 @@ +// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`. import 'dart:typed_data'; import 'package:flutter/foundation.dart'; @@ -35,7 +36,7 @@ abstract class TextureRgbaRendererPlatform extends PlatformInterface { throw UnimplementedError('createTexture() has not been implemented.'); } - Future closeTexture(int key) { + Future closeTexture(int key, {bool recycle = false}) { throw UnimplementedError('closeTexture() has not been implemented.'); } diff --git a/linux/include/texture_rgba_renderer/texture_rgba_renderer.h b/linux/include/texture_rgba_renderer/texture_rgba_renderer.h index f2e17a7..1a575c6 100644 --- a/linux/include/texture_rgba_renderer/texture_rgba_renderer.h +++ b/linux/include/texture_rgba_renderer/texture_rgba_renderer.h @@ -1,5 +1,7 @@ // Modified by the Kitedesk fork (2026, B212): frame buffers are freed when the -// texture is closed and when the object is finalized. +// texture is closed and when the object is finalized; a closed texture can be +// restarted for reuse; with no frame waiting, one transparent pixel is handed +// out instead of no buffer. #ifndef TEXTURE_RGBA_RENDERER_H #define TEXTURE_RGBA_RENDERER_H @@ -66,6 +68,14 @@ static void texture_rgba_terminate(TextureRgba* self) { g_mutex_unlock(&self->mutex); } +// Makes a texture that was closed for recycling usable again (its frame +// buffers were freed when it was closed). +static void texture_rgba_restart(TextureRgba* self) { + g_mutex_lock(&self->mutex); + g_atomic_int_set(&self->terminated, FALSE); + g_mutex_unlock(&self->mutex); +} + static gboolean texture_rgba_is_terminate(TextureRgba* self) { return g_atomic_int_get(&self->terminated); } @@ -109,6 +119,14 @@ static gboolean texture_rgba_copy_pixels(FlPixelBufferTexture* texture, *error = g_error_new(g_quark_from_static_string("TextureRgba Renderer"), -1, "the texture is already terminated, ignoring."); return FALSE; } else { + // No frame yet (first raster frame, or a recycled texture). Hand out one + // transparent pixel instead of no buffer: the engine would otherwise + // re-specify the GL texture without data and could show its previous + // content, e.g. the last frame of the session that used this texture. + static const uint8_t no_frame[4] = {0, 0, 0, 0}; + *out_buffer = no_frame; + *width = 1; + *height = 1; g_mutex_unlock(&self->mutex); // *error = g_error_new(g_quark_from_static_string("TextureRgba Renderer"), 1, "waiting for new incoming images."); return TRUE; diff --git a/linux/texture_rgba_renderer_plugin.cc b/linux/texture_rgba_renderer_plugin.cc index 1b62124..5037af1 100644 --- a/linux/texture_rgba_renderer_plugin.cc +++ b/linux/texture_rgba_renderer_plugin.cc @@ -1,3 +1,7 @@ +// Modified by the Kitedesk fork (2026, B212): closeTexture with +// "recycle": true keeps the texture for the next createTexture of the same +// engine instead of leaking it. + #include "include/texture_rgba_renderer/texture_rgba_renderer_plugin.h" #include "include/texture_rgba_renderer/texture_rgba_renderer.h" @@ -19,6 +23,10 @@ struct _TextureRgbaRendererPlugin { GObject parent_instance; FlTextureRegistrar *texture_registrar; + // Textures closed with "recycle": true, for the next createTexture of this + // engine (window). Their engine GL texture belongs to this window's GL + // context, so they are never released and never given to another engine. + GPtrArray *recycled; }; G_DEFINE_TYPE(TextureRgbaRendererPlugin, texture_rgba_renderer_plugin, g_object_get_type()) @@ -42,7 +50,13 @@ static void texture_rgba_renderer_plugin_handle_method_call( } else { - TextureRgba* texture_rgba = texture_rgba_new(self->texture_registrar); + TextureRgba* texture_rgba = nullptr; + if (self->recycled->len > 0) { + texture_rgba = TEXTURE_RGBA(g_ptr_array_remove_index_fast(self->recycled, self->recycled->len - 1)); + texture_rgba_restart(texture_rgba); + } else { + texture_rgba = texture_rgba_new(self->texture_registrar); + } auto texture_id = reinterpret_cast(FL_TEXTURE(texture_rgba)); texture_rgba->texture_id = texture_id; g_renderer_map.insert(std::make_pair(key, texture_rgba)); @@ -55,11 +69,19 @@ static void texture_rgba_renderer_plugin_handle_method_call( { auto args = fl_method_call_get_args(method_call); int64_t key = fl_value_get_int(fl_value_lookup_string(args, "key")); + // The caller sets "recycle" only when nothing can call + // FlutterRgbaRendererPluginOnRgba with this texture any more. + FlValue* recycle = fl_value_lookup_string(args, "recycle"); if (g_renderer_map.find(key) != g_renderer_map.end()) { - fl_texture_registrar_unregister_texture(self->texture_registrar, FL_TEXTURE(g_renderer_map[key])); - texture_rgba_terminate(g_renderer_map[key]); + TextureRgba* texture_rgba = g_renderer_map[key]; + fl_texture_registrar_unregister_texture(self->texture_registrar, FL_TEXTURE(texture_rgba)); + texture_rgba_terminate(texture_rgba); g_renderer_map.erase(key); + if (recycle != nullptr && fl_value_get_type(recycle) == FL_VALUE_TYPE_BOOL && fl_value_get_bool(recycle) && + texture_rgba->texture_registrar == self->texture_registrar) { + g_ptr_array_add(self->recycled, texture_rgba); + } } response = FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_bool(true))); } @@ -104,6 +126,11 @@ static void texture_rgba_renderer_plugin_handle_method_call( static void texture_rgba_renderer_plugin_dispose(GObject *object) { + TextureRgbaRendererPlugin *self = TEXTURE_RGBA_RENDERER_PLUGIN(object); + // The engine is going away. The recycled textures keep their references on + // purpose: releasing one makes the engine delete its GL texture in whatever + // GL context is current, which can belong to another window. + g_clear_pointer(&self->recycled, g_ptr_array_unref); G_OBJECT_CLASS(texture_rgba_renderer_plugin_parent_class)->dispose(object); } @@ -112,7 +139,9 @@ static void texture_rgba_renderer_plugin_class_init(TextureRgbaRendererPluginCla G_OBJECT_CLASS(klass)->dispose = texture_rgba_renderer_plugin_dispose; } -static void texture_rgba_renderer_plugin_init(TextureRgbaRendererPlugin *self) {} +static void texture_rgba_renderer_plugin_init(TextureRgbaRendererPlugin *self) { + self->recycled = g_ptr_array_new(); +} static void method_call_cb(FlMethodChannel *channel, FlMethodCall *method_call, gpointer user_data) diff --git a/test/texture_rgba_renderer_method_channel_test.dart b/test/texture_rgba_renderer_method_channel_test.dart index 9702f9a..a281bc4 100644 --- a/test/texture_rgba_renderer_method_channel_test.dart +++ b/test/texture_rgba_renderer_method_channel_test.dart @@ -1,3 +1,4 @@ +// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`. import 'package:flutter/services.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:texture_rgba_renderer/texture_rgba_renderer_method_channel.dart'; @@ -22,4 +23,20 @@ void main() { test('getPlatformVersion', () async { expect(await platform.getPlatformVersion(), '42'); }); + + // Kitedesk fork (B212): closeTexture tells the Linux side whether the + // texture may be recycled. + test('closeTexture sends recycle', () async { + final calls = []; + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger + .setMockMethodCallHandler(channel, (MethodCall methodCall) async { + calls.add(methodCall); + return true; + }); + expect(await platform.closeTexture(7), true); + expect(await platform.closeTexture(8, recycle: true), true); + expect(calls.map((c) => c.method), ['closeTexture', 'closeTexture']); + expect(calls[0].arguments, {'key': 7, 'recycle': false}); + expect(calls[1].arguments, {'key': 8, 'recycle': true}); + }); } diff --git a/test/texture_rgba_renderer_test.dart b/test/texture_rgba_renderer_test.dart index 554c7ea..1493096 100644 --- a/test/texture_rgba_renderer_test.dart +++ b/test/texture_rgba_renderer_test.dart @@ -1,6 +1,8 @@ +// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`. import 'dart:typed_data'; import 'package:flutter_test/flutter_test.dart'; +import 'package:texture_rgba_renderer/texture_rgba_renderer.dart'; import 'package:texture_rgba_renderer/texture_rgba_renderer_platform_interface.dart'; import 'package:texture_rgba_renderer/texture_rgba_renderer_method_channel.dart'; import 'package:plugin_platform_interface/plugin_platform_interface.dart'; @@ -11,8 +13,13 @@ class MockTextureRgbaRendererPlatform @override Future getPlatformVersion() => Future.value('42'); + final closed = >[]; + @override - Future closeTexture(int key) => Future.value(true); + Future closeTexture(int key, {bool recycle = false}) { + closed.add([key, recycle]); + return Future.value(true); + } @override Future createTexture(int key) => Future.value(1); @@ -35,4 +42,18 @@ void main() { test('$MethodChannelTextureRgbaRenderer is the default instance', () { expect(initialPlatform, isInstanceOf()); }); + + // Kitedesk fork (B212). + test('closeTexture forwards recycle', () async { + final fake = MockTextureRgbaRendererPlatform(); + TextureRgbaRendererPlatform.instance = fake; + final renderer = TextureRgbaRenderer(); + expect(await renderer.closeTexture(9), true); + expect(await renderer.closeTexture(10, recycle: true), true); + expect(fake.closed, [ + [9, false], + [10, true], + ]); + TextureRgbaRendererPlatform.instance = initialPlatform; + }); } From 50efc18ec5114aec26b81f49c7fc6cef5b773bcd Mon Sep 17 00:00:00 2001 From: yunchan Date: Thu, 29 Oct 2026 12:13:44 +0900 Subject: [PATCH 4/4] G26: keep Windows textures alive through asynchronous unregister Retain closed raw-pointer identities for late frames, release frame buffers after engine completion, and serialize termination with decoded frame writes. Add native regression controls for held raster buffers, inline completion, failed raster posts, missing registrations, teardown and concurrent closure. B252; Apache-2.0 dependency license and upstream history preserved. --- lib/texture_rgba_renderer.dart | 10 +- windows/test/run_tests.sh | 58 + windows/test/shim/VersionHelpers.h | 3 + windows/test/shim/flutter_windows.h | 63 ++ windows/test/shim/windows.h | 17 + .../test/texture_rgba_renderer_plugin_test.cc | 1002 +++++++++++++++++ windows/texture_rgba.cpp | 33 +- windows/texture_rgba.h | 19 +- windows/texture_rgba_renderer_plugin.cpp | 71 +- windows/texture_rgba_renderer_plugin.h | 6 + 10 files changed, 1268 insertions(+), 14 deletions(-) create mode 100755 windows/test/run_tests.sh create mode 100644 windows/test/shim/VersionHelpers.h create mode 100644 windows/test/shim/flutter_windows.h create mode 100644 windows/test/shim/windows.h create mode 100644 windows/test/texture_rgba_renderer_plugin_test.cc diff --git a/lib/texture_rgba_renderer.dart b/lib/texture_rgba_renderer.dart index 04ee24a..f8d1011 100644 --- a/lib/texture_rgba_renderer.dart +++ b/lib/texture_rgba_renderer.dart @@ -1,4 +1,4 @@ -// Modified by the Kitedesk fork (2026, B212): closeTexture takes `recycle`. +// Modified by the Kitedesk fork (2026, B212/B252): closeTexture ownership. import 'dart:typed_data'; export './texture_rgba_ffi.dart' show Native; @@ -20,8 +20,12 @@ class TextureRgbaRenderer { /// /// Pass [recycle] = true only when nothing calls `onRgba` with the pointer /// from [getTexturePtr] any more. On Linux the texture is then kept for the - /// next [createTexture] of the same window instead of being leaked - /// (Kitedesk fork, B212); other platforms ignore it. + /// next [createTexture] of the same window (Kitedesk fork, B212). + /// On Windows it may be destroyed only after the engine finishes unregistering + /// it. Without [recycle], Windows retains its closed identity for the process + /// lifetime so late raw-pointer frames cannot reach freed or reused memory; + /// its frame buffers are freed after unregistering (Kitedesk fork, B252). + /// Other platforms ignore [recycle]. /// /// @return a boolean to indicate whether the operation is sucessfully executed. Future closeTexture(int key, {bool recycle = false}) { diff --git a/windows/test/run_tests.sh b/windows/test/run_tests.sh new file mode 100755 index 0000000..d66c28c --- /dev/null +++ b/windows/test/run_tests.sh @@ -0,0 +1,58 @@ +#!/usr/bin/env bash +# Kitedesk fork, 2026: builds windows/test/texture_rgba_renderer_plugin_test.cc +# on Linux with the plugin sources and the C++ client wrapper of the Flutter +# Windows engine, and runs each test in its own process. The engine files come +# from FLUTTER_WINDOWS_ENGINE, by default the windows-x64 engine artifacts of the +# Flutter SDK on PATH (or FLUTTER_ROOT) as `flutter precache --windows` leaves +# them: the C headers and cpp_client_wrapper/. No display, GPU or Windows needed. +# run_tests.sh -Wall -Werror build +# run_tests.sh --asan the same with AddressSanitizer and UBSan +# run_tests.sh --tsan the same with ThreadSanitizer +# OUT_DIR (default: a new temporary directory) receives the test binary. +set -euo pipefail +here=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +if [ -z "${FLUTTER_WINDOWS_ENGINE:-}" ]; then + root=${FLUTTER_ROOT:-$(dirname "$(dirname "$(readlink -f "$(command -v flutter)")")")} + FLUTTER_WINDOWS_ENGINE=$root/bin/cache/artifacts/engine/windows-x64 +fi +engine=$FLUTTER_WINDOWS_ENGINE +wrapper=$engine/cpp_client_wrapper +[ -f "$engine/flutter_texture_registrar.h" ] && [ -f "$wrapper/core_implementations.cc" ] || { + echo "no Flutter Windows engine headers and client wrapper in $engine" \ + "(flutter precache --windows, or set FLUTTER_WINDOWS_ENGINE)" >&2 + exit 2 +} +out=${OUT_DIR:-$(mktemp -d)} +mkdir -p "$out" +# The client wrapper headers expect to come with the standard headers, +# as MSVC's do; libstdc++'s do not. +flags=(-std=c++17 -Wall -Werror -O1 -g -pthread -include cstdint -DFLUTTER_PLUGIN_IMPL '-D__declspec(x)=') +case "${1:-}" in + "") ;; + --asan) flags+=('-fsanitize=address,undefined' -fno-omit-frame-pointer -fno-sanitize-recover=undefined) ;; + --tsan) + flags+=(-fsanitize=thread) + export TSAN_OPTIONS=${TSAN_OPTIONS:-halt_on_error=1} + ;; + *) echo "usage: $0 [--asan | --tsan]" >&2; exit 2 ;; +esac +bin=$out/texture_rgba_renderer_plugin_test +"${CXX:-clang++}" "${flags[@]}" -I"$here/shim" -I"$wrapper/include" -I"$engine" \ + "$here/texture_rgba_renderer_plugin_test.cc" \ + "$here/../texture_rgba.cpp" "$here/../texture_rgba_renderer_plugin.cpp" \ + "$here/../texture_rgba_renderer_plugin_c_api.cpp" \ + "$wrapper/core_implementations.cc" "$wrapper/plugin_registrar.cc" "$wrapper/standard_codec.cc" \ + -o "$bin" +count=0 +failed=0 +for test in $("$bin" --list); do + count=$((count + 1)) + if "$bin" "$test"; then + echo "PASS $test" + else + echo "FAIL $test" + failed=$((failed + 1)) + fi +done +echo "$count tests, $((count - failed)) passed, $failed failed" +[ "$failed" -eq 0 ] diff --git a/windows/test/shim/VersionHelpers.h b/windows/test/shim/VersionHelpers.h new file mode 100644 index 0000000..6eaf25f --- /dev/null +++ b/windows/test/shim/VersionHelpers.h @@ -0,0 +1,3 @@ +// Kitedesk fork, 2026: test-only stand-in for (windows/test). +// The plugin includes it but uses nothing from it. Licensed under the Apache +// License, Version 2.0, like the rest of this package. diff --git a/windows/test/shim/flutter_windows.h b/windows/test/shim/flutter_windows.h new file mode 100644 index 0000000..1a05fd8 --- /dev/null +++ b/windows/test/shim/flutter_windows.h @@ -0,0 +1,63 @@ +// Kitedesk fork, 2026: test-only stand-in for flutter_windows.h of the Flutter +// Windows engine (a18df97c) with the declarations that the client wrapper's +// plugin_registrar_windows.h and flutter_view.h use; windows/test defines them. +// Licensed under the Apache License, Version 2.0, like the rest of this +// package. + +#ifndef KD_TEST_SHIM_FLUTTER_WINDOWS_H_ +#define KD_TEST_SHIM_FLUTTER_WINDOWS_H_ + +#include +#include +#include + +#include "flutter_export.h" +#include "flutter_messenger.h" +#include "flutter_plugin_registrar.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +struct IDXGIAdapter; + +struct FlutterDesktopView; +typedef struct FlutterDesktopView* FlutterDesktopViewRef; + +typedef int64_t FlutterDesktopViewId; + +typedef bool (*FlutterDesktopWindowProcCallback)(HWND /* hwnd */, + UINT /* uMsg */, + WPARAM /*wParam*/, + LPARAM /* lParam*/, + void* /* user data */, + LRESULT* result); + +FLUTTER_EXPORT HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view); + +FLUTTER_EXPORT struct IDXGIAdapter* FlutterDesktopViewGetGraphicsAdapter( + FlutterDesktopViewRef view); + +FLUTTER_EXPORT FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView( + FlutterDesktopPluginRegistrarRef registrar); + +FLUTTER_EXPORT FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopViewId view_id); + +FLUTTER_EXPORT void +FlutterDesktopPluginRegistrarRegisterTopLevelWindowProcDelegate( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopWindowProcCallback delegate, + void* user_data); + +FLUTTER_EXPORT void +FlutterDesktopPluginRegistrarUnregisterTopLevelWindowProcDelegate( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopWindowProcCallback delegate); + +#if defined(__cplusplus) +} // extern "C" +#endif + +#endif // KD_TEST_SHIM_FLUTTER_WINDOWS_H_ diff --git a/windows/test/shim/windows.h b/windows/test/shim/windows.h new file mode 100644 index 0000000..3b89c24 --- /dev/null +++ b/windows/test/shim/windows.h @@ -0,0 +1,17 @@ +// Kitedesk fork, 2026: test-only stand-in for , so that the plugin +// and the engine's C++ client wrapper build on Linux for windows/test. It has +// only the types those headers use. Licensed under the Apache License, +// Version 2.0, like the rest of this package. + +#ifndef KD_TEST_SHIM_WINDOWS_H_ +#define KD_TEST_SHIM_WINDOWS_H_ + +#include + +typedef struct HWND__* HWND; +typedef unsigned int UINT; +typedef uintptr_t WPARAM; +typedef intptr_t LPARAM; +typedef intptr_t LRESULT; + +#endif // KD_TEST_SHIM_WINDOWS_H_ diff --git a/windows/test/texture_rgba_renderer_plugin_test.cc b/windows/test/texture_rgba_renderer_plugin_test.cc new file mode 100644 index 0000000..e190ef3 --- /dev/null +++ b/windows/test/texture_rgba_renderer_plugin_test.cc @@ -0,0 +1,1002 @@ +// Kitedesk fork, 2026: lifetime tests for the Windows texture of this plugin +// (Kitedesk backlog B252). Licensed under the Apache License, Version 2.0, +// like the rest of this package. +// +// windows/test/run_tests.sh builds this program on Linux together with the +// plugin sources and the C++ client wrapper of the Flutter Windows engine +// (core_implementations.cc, plugin_registrar.cc, standard_codec.cc); shim/ +// stands in for and flutter_windows.h. The C API of +// flutter_windows.dll is the fake engine below. It follows +// FlutterWindowsTextureRegistrar and FlutterWindowsEngine::Stop of engine +// a18df97c (Flutter 3.24.5): unregistering a texture only queues a task for +// the raster thread, which removes the texture from the engine and then runs +// the callback; until that task has run, the raster thread may still call the +// texture's pixel buffer callback and read the returned buffer (glTexImage2D). +// When a window closes, the registrar is destroyed (and the plugin with it) +// while the engine still runs. The Rust video thread is +// FlutterRgbaRendererPluginOnRgba with the pointer from getTexturePtr. Frame +// buffers the plugin allocates are counted. +// +// Usage: texture_rgba_renderer_plugin_test [--list | ] + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "../include/texture_rgba_renderer/texture_rgba_renderer_plugin_c_api.h" + +#if defined(__has_feature) +#if __has_feature(address_sanitizer) || __has_feature(thread_sanitizer) +#define KD_SANITIZER 1 +#endif +#endif +#if defined(__SANITIZE_ADDRESS__) || defined(__SANITIZE_THREAD__) +#define KD_SANITIZER 1 +#endif + +#ifdef KD_SANITIZER +#include +#endif + +namespace { + +constexpr int kWidth = 321; +constexpr int kHeight = 123; +constexpr size_t kFrameBytes = static_cast(kWidth) * kHeight * 4; + +// Heap accounting: live frame buffers (blocks of exactly kFrameBytes; nothing +// else here allocates that size), live bytes, and whether watched blocks were +// freed. The sanitizer runtimes report every allocation through their hooks; +// otherwise operators new and delete are replaced below. +std::atomic g_live_frames{0}; +std::atomic g_live_bytes{0}; +constexpr int kWatchSlots = 64; +std::atomic g_watched[kWatchSlots]; +std::atomic g_watched_freed[kWatchSlots]; + +void on_allocate(size_t size) { + if (size == kFrameBytes) { + g_live_frames++; + } + g_live_bytes += static_cast(size); +} + +void on_free(const void* ptr, size_t size) { + if (size == kFrameBytes) { + g_live_frames--; + } + g_live_bytes -= static_cast(size); + for (int i = 0; i < kWatchSlots; i++) { + if (g_watched[i].load() == ptr) { + g_watched_freed[i] = true; + } + } +} + +#ifdef KD_SANITIZER + +void malloc_hook(const volatile void* ptr, size_t size) { + on_allocate(size); +} + +void free_hook(const volatile void* ptr) { + on_free(const_cast(ptr), __sanitizer_get_allocated_size(ptr)); +} + +void install_heap_accounting() { + __sanitizer_install_malloc_and_free_hooks(malloc_hook, free_hook); +} + +} // namespace + +#else // KD_SANITIZER + +constexpr size_t kHeader = 16; + +void* allocate(size_t size) noexcept { + char* p = static_cast(std::malloc(size + kHeader)); + if (p == nullptr) { + return nullptr; + } + std::memcpy(p, &size, sizeof(size)); + on_allocate(size); + return p + kHeader; +} + +void deallocate(void* ptr) noexcept { + if (ptr == nullptr) { + return; + } + char* p = static_cast(ptr) - kHeader; + size_t size; + std::memcpy(&size, p, sizeof(size)); + on_free(ptr, size); + std::free(p); +} + +void install_heap_accounting() {} + +} // namespace + +void* operator new(size_t size) { + void* p = allocate(size); + if (p == nullptr) { + throw std::bad_alloc(); + } + return p; +} +void* operator new[](size_t size) { return operator new(size); } +void* operator new(size_t size, const std::nothrow_t&) noexcept { + return allocate(size); +} +void* operator new[](size_t size, const std::nothrow_t&) noexcept { + return allocate(size); +} +void operator delete(void* p) noexcept { deallocate(p); } +void operator delete[](void* p) noexcept { deallocate(p); } +void operator delete(void* p, size_t) noexcept { deallocate(p); } +void operator delete[](void* p, size_t) noexcept { deallocate(p); } +void operator delete(void* p, const std::nothrow_t&) noexcept { deallocate(p); } +void operator delete[](void* p, const std::nothrow_t&) noexcept { + deallocate(p); +} + +#endif // KD_SANITIZER + +// --------------------------------------------------------------------------- +// Fake engine: the C API of flutter_windows.dll that the plugin and the client +// wrapper call. + +constexpr int64_t kMaxTextureIds = 1024; + +struct FlutterDesktopMessenger { + std::mutex lock; + std::map> + handlers; +}; + +struct _FlutterPlatformMessageResponseHandle { + bool replied = false; + std::vector reply; +}; + +struct FlutterDesktopTextureRegistrar { + std::mutex mutex; + int64_t next_id = 1; + // Engine outcomes: normal queued erase, inline completed erase, or stopped + // engine whose PostRasterThreadTask fails and invokes completion inline. + enum class Completion { deferred, immediate, post_failure }; + Completion completion = Completion::deferred; + // The engine's textures: texture id -> what PopulateTexture calls. + std::map textures; + // Tasks posted to the raster thread (PostRasterThreadTask). + std::deque> raster_tasks; + std::array unregisters{}; + std::array marks{}; +}; + +struct FlutterDesktopPluginRegistrar { + FlutterDesktopMessenger messenger; + FlutterDesktopTextureRegistrar textures; + FlutterDesktopOnPluginRegistrarDestroyed on_destroyed = nullptr; +}; + +extern "C" { + +bool FlutterDesktopMessengerSend(FlutterDesktopMessengerRef messenger, + const char* channel, + const uint8_t* message, + const size_t message_size) { + return false; +} + +bool FlutterDesktopMessengerSendWithReply(FlutterDesktopMessengerRef messenger, + const char* channel, + const uint8_t* message, + const size_t message_size, + const FlutterDesktopBinaryReply reply, + void* user_data) { + return false; +} + +void FlutterDesktopMessengerSendResponse( + FlutterDesktopMessengerRef messenger, + const FlutterDesktopMessageResponseHandle* handle, + const uint8_t* data, + size_t data_length) { + auto* h = const_cast(handle); + h->replied = true; + h->reply.assign(data, data + data_length); +} + +void FlutterDesktopMessengerSetCallback(FlutterDesktopMessengerRef messenger, + const char* channel, + FlutterDesktopMessageCallback callback, + void* user_data) { + if (callback == nullptr) { + messenger->handlers.erase(channel); + } else { + messenger->handlers[channel] = {callback, user_data}; + } +} + +FlutterDesktopMessengerRef FlutterDesktopMessengerAddRef( + FlutterDesktopMessengerRef messenger) { + return messenger; +} + +void FlutterDesktopMessengerRelease(FlutterDesktopMessengerRef messenger) {} + +bool FlutterDesktopMessengerIsAvailable(FlutterDesktopMessengerRef messenger) { + return true; +} + +FlutterDesktopMessengerRef FlutterDesktopMessengerLock( + FlutterDesktopMessengerRef messenger) { + messenger->lock.lock(); + return messenger; +} + +void FlutterDesktopMessengerUnlock(FlutterDesktopMessengerRef messenger) { + messenger->lock.unlock(); +} + +int64_t FlutterDesktopTextureRegistrarRegisterExternalTexture( + FlutterDesktopTextureRegistrarRef registrar, + const FlutterDesktopTextureInfo* info) { + if (info->type != kFlutterDesktopPixelBufferTexture || + info->pixel_buffer_config.callback == nullptr) { + return -1; + } + std::lock_guard lock(registrar->mutex); + int64_t id = registrar->next_id++; + if (id >= kMaxTextureIds) { + std::abort(); + } + registrar->textures[id] = info->pixel_buffer_config; + return id; +} + +// FlutterWindowsTextureRegistrar::UnregisterTexture: the engine drops the +// texture on the raster thread, then calls back. +void FlutterDesktopTextureRegistrarUnregisterExternalTexture( + FlutterDesktopTextureRegistrarRef registrar, + int64_t texture_id, + void (*callback)(void* user_data), + void* user_data) { + std::unique_lock lock(registrar->mutex); + if (texture_id > 0 && texture_id < kMaxTextureIds) { + registrar->unregisters[texture_id]++; + } + if (registrar->completion != FlutterDesktopTextureRegistrar::Completion::deferred) { + if (registrar->completion == FlutterDesktopTextureRegistrar::Completion::immediate) { + registrar->textures.erase(texture_id); + } + // Match exact engine a18df97: !posted invokes callback without erasing the + // registrar's external texture. A stopped raster thread never draws it. + // Engine completion is outside map_mutex_, also on post failure. Calling + // it under our fake registry lock would invent an ABBA lock order. + lock.unlock(); + if (callback != nullptr) callback(user_data); + return; + } + registrar->raster_tasks.push_back( + [registrar, texture_id, callback, user_data]() { + { + std::lock_guard lock(registrar->mutex); + registrar->textures.erase(texture_id); + } + if (callback != nullptr) { + callback(user_data); + } + }); +} + +bool FlutterDesktopTextureRegistrarMarkExternalTextureFrameAvailable( + FlutterDesktopTextureRegistrarRef registrar, + int64_t texture_id) { + std::lock_guard lock(registrar->mutex); + if (texture_id > 0 && texture_id < kMaxTextureIds) { + registrar->marks[texture_id]++; + } + return true; +} + +FlutterDesktopMessengerRef FlutterDesktopPluginRegistrarGetMessenger( + FlutterDesktopPluginRegistrarRef registrar) { + return ®istrar->messenger; +} + +FlutterDesktopTextureRegistrarRef FlutterDesktopRegistrarGetTextureRegistrar( + FlutterDesktopPluginRegistrarRef registrar) { + return ®istrar->textures; +} + +void FlutterDesktopPluginRegistrarSetDestructionHandler( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopOnPluginRegistrarDestroyed callback) { + registrar->on_destroyed = callback; +} + +HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view) { + return nullptr; +} + +struct IDXGIAdapter* FlutterDesktopViewGetGraphicsAdapter( + FlutterDesktopViewRef view) { + return nullptr; +} + +FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView( + FlutterDesktopPluginRegistrarRef registrar) { + return nullptr; +} + +FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopViewId view_id) { + return nullptr; +} + +void FlutterDesktopPluginRegistrarRegisterTopLevelWindowProcDelegate( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopWindowProcCallback delegate, + void* user_data) {} + +void FlutterDesktopPluginRegistrarUnregisterTopLevelWindowProcDelegate( + FlutterDesktopPluginRegistrarRef registrar, + FlutterDesktopWindowProcCallback delegate) {} + +} // extern "C" + +namespace { + +// --------------------------------------------------------------------------- +// One engine (= one Flutter window) with the plugin registered on it. + +struct Engine { + FlutterDesktopPluginRegistrar* registrar; +}; + +Engine* engine_new() { + Engine* e = new Engine{new FlutterDesktopPluginRegistrar()}; + TextureRgbaRendererPluginCApiRegisterWithRegistrar(e->registrar); + return e; +} + +FlutterDesktopTextureRegistrar& textures(Engine* e) { + return e->registrar->textures; +} + +// Runs the tasks queued for the raster thread (unregistrations). +void run_raster_tasks(Engine* e) { + for (;;) { + std::function task; + { + std::lock_guard lock(textures(e).mutex); + if (textures(e).raster_tasks.empty()) { + return; + } + task = std::move(textures(e).raster_tasks.front()); + textures(e).raster_tasks.pop_front(); + } + task(); + } +} + +// The window closes. As in FlutterWindowsEngine::Stop, the registrar's +// destruction handler runs first, which destroys the plugin, while the +// engine and its raster thread keep running. +void engine_destroy_plugins(Engine* e) { + e->registrar->on_destroyed(e->registrar); +} + +// Then the engine shuts down: its raster thread runs what was queued and the +// engine's memory is freed. +void engine_free(Engine* e) { + run_raster_tasks(e); + delete e->registrar; + delete e; +} + +void engine_shutdown(Engine* e) { + engine_destroy_plugins(e); + engine_free(e); +} + +constexpr int64_t kNoReply = INT64_MIN; + +// Calls a plugin method like Dart does. Returns the int or bool result, or +// kNoReply when the plugin did not answer. +int64_t invoke(Engine* e, const char* method, flutter::EncodableMap args) { + const auto& codec = flutter::StandardMethodCodec::GetInstance(); + flutter::MethodCall call( + method, std::make_unique(std::move(args))); + std::unique_ptr> message = codec.EncodeMethodCall(call); + _FlutterPlatformMessageResponseHandle handle; + FlutterDesktopMessage m = {sizeof(FlutterDesktopMessage), + "texture_rgba_renderer", message->data(), + message->size(), &handle}; + FlutterDesktopMessenger& messenger = e->registrar->messenger; + auto handler = messenger.handlers.at("texture_rgba_renderer"); + handler.first(&messenger, &m, handler.second); + if (!handle.replied) { + return kNoReply; + } + int64_t out = kNoReply; + flutter::MethodResultFunctions result( + [&out](const flutter::EncodableValue* value) { + if (value == nullptr) { + return; + } + if (auto v = std::get_if(value)) { + out = *v; + } else if (auto v64 = std::get_if(value)) { + out = *v64; + } else if (auto b = std::get_if(value)) { + out = *b ? 1 : 0; + } + }, + nullptr, nullptr); + codec.DecodeAndProcessResponseEnvelope(handle.reply.data(), + handle.reply.size(), &result); + return out; +} + +flutter::EncodableMap key_args(int key) { + return {{flutter::EncodableValue("key"), flutter::EncodableValue(key)}}; +} + +int64_t create_texture(Engine* e, int key) { + return invoke(e, "createTexture", key_args(key)); +} + +int64_t texture_ptr(Engine* e, int key) { + return invoke(e, "getTexturePtr", key_args(key)); +} + +// recycle < 0: no "recycle" argument (callers before the Kitedesk change). +int64_t close_texture(Engine* e, int key, int recycle) { + flutter::EncodableMap args = key_args(key); + if (recycle >= 0) { + args[flutter::EncodableValue("recycle")] = + flutter::EncodableValue(recycle != 0); + } + return invoke(e, "closeTexture", std::move(args)); +} + +// Decoded frames, filled before any test runs (frame i is all bytes i). +constexpr int kFills = 16; +uint8_t g_frames[kFills][kFrameBytes]; + +// A decoded frame from the Rust video thread. +void send_frame(int64_t ptr, uint8_t fill) { + FlutterRgbaRendererPluginOnRgba(reinterpret_cast(ptr), + g_frames[fill % kFills], + static_cast(kFrameBytes), kWidth, + kHeight, 0); +} + +volatile uint8_t g_sink; + +struct Pulled { + bool ok; + uint8_t first; + size_t width; + size_t height; +}; + +// What the raster thread does for a texture on a frame +// (ExternalTexturePixelBuffer::CopyPixelBuffer): ask for the pixel buffer and +// upload it, which reads all of it. +Pulled populate(const FlutterDesktopPixelBufferTextureConfig& config) { + Pulled p = {false, 0, 0, 0}; + const FlutterDesktopPixelBuffer* buffer = + config.callback(1920, 1080, config.user_data); + if (buffer == nullptr || buffer->buffer == nullptr) { + return p; + } + uint8_t x = 0; + for (size_t i = 0; i < buffer->width * buffer->height * 4; i++) { + x ^= buffer->buffer[i]; + } + g_sink = x; + p = {true, buffer->buffer[0], buffer->width, buffer->height}; + if (buffer->release_callback != nullptr) { + buffer->release_callback(buffer->release_context); + } + return p; +} + +Pulled pull(Engine* e, int64_t id) { + FlutterDesktopPixelBufferTextureConfig config; + { + std::lock_guard lock(textures(e).mutex); + auto it = textures(e).textures.find(id); + if (it == textures(e).textures.end()) { + return {false, 0, 0, 0}; + } + config = it->second; + } + return populate(config); +} + +// One raster frame: every texture the engine still has is drawn. +void pull_all(Engine* e) { + std::vector configs; + { + std::lock_guard lock(textures(e).mutex); + for (const auto& entry : textures(e).textures) { + configs.push_back(entry.second); + } + } + for (const auto& config : configs) { + populate(config); + } +} + +bool registered(Engine* e, int64_t id) { + std::lock_guard lock(textures(e).mutex); + return textures(e).textures.count(id) != 0; +} + +int unregisters(Engine* e, int64_t id) { + std::lock_guard lock(textures(e).mutex); + return id > 0 && id < kMaxTextureIds ? textures(e).unregisters[id] : -1; +} + +int marks(Engine* e, int64_t id) { + std::lock_guard lock(textures(e).mutex); + return id > 0 && id < kMaxTextureIds ? textures(e).marks[id] : -1; +} + +int live_frames() { + return g_live_frames.load(); +} + +// Watches the heap block at ptr; freed(slot) tells whether it was freed since. +int watch(int64_t ptr) { + for (int i = 0; i < kWatchSlots; i++) { + if (g_watched[i].load() == nullptr) { + g_watched_freed[i] = false; + g_watched[i] = reinterpret_cast(ptr); + return i; + } + } + std::abort(); +} + +bool freed(int slot) { + return g_watched_freed[slot].load(); +} + +// The Rust session's VideoRenderer (src/flutter.rs): frames go to the +// registered pointer under a read lock, and registerPixelbufferTexture(..., 0) +// clears it under the write lock. +struct Session { + std::shared_mutex lock; + int64_t ptr = 0; + + void set(int64_t p) { + std::unique_lock l(lock); + ptr = p; + } + + void push(uint8_t fill) { + std::shared_lock l(lock); + if (ptr != 0) { + send_frame(ptr, fill); + } + } +}; + +// --------------------------------------------------------------------------- + +int g_failed_checks = 0; + +#define CHECK(cond) \ + do { \ + if (!(cond)) { \ + std::fprintf(stderr, " check failed at line %d: %s\n", __LINE__, \ + #cond); \ + g_failed_checks++; \ + return; \ + } \ + } while (0) + +// N-01, raster thread: closeTexture only queues the engine's unregistration, +// and the engine may draw the texture once more before it is done. The texture +// must stay valid and hand out no frame until the engine calls back; then its +// frame buffers are freed. With "recycle" (nothing pushes to the pointer any +// more) it is destroyed, without it, it is kept. +void test_close_keeps_texture_until_engine_unregisters() { + for (int recycle = 1; recycle >= 0; recycle--) { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t id = create_texture(e, 10); + int64_t ptr = texture_ptr(e, 10); + CHECK(id > 0 && ptr != 0 && ptr != -1 && registered(e, id)); + send_frame(ptr, 1); + Pulled shown = pull(e, id); + CHECK(shown.ok && shown.first == 1 && shown.width == kWidth && + shown.height == kHeight); + send_frame(ptr, 2); + CHECK(live_frames() == base + 2); + const int slot = watch(ptr); + CHECK(close_texture(e, 10, recycle) == 1); + CHECK(registered(e, id)); + Pulled late = pull(e, id); + CHECK(!late.ok); + CHECK(!freed(slot)); + run_raster_tasks(e); + CHECK(!registered(e, id)); + CHECK(live_frames() == base); + CHECK(freed(slot) == (recycle == 1)); + engine_shutdown(e); + } +} + +// N-01, video thread: without "recycle" the session keeps the pointer (a tab +// moving to another window), so frames keep arriving after closeTexture. They +// are dropped without telling the engine, before and after it unregistered the +// texture, and after the engine itself is gone. The closed texture's address +// is never handed out again (ABA: a late frame would show in another session). +void test_late_frames_after_close_are_dropped() { + for (int recycle = 0; recycle >= -1; recycle--) { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t a = create_texture(e, 20); + int64_t pa = texture_ptr(e, 20); + CHECK(a > 0 && pa != 0 && pa != -1); + send_frame(pa, 3); + CHECK(pull(e, a).ok); + CHECK(close_texture(e, 20, recycle) == 1); + const int announced = marks(e, a); + send_frame(pa, 4); + CHECK(marks(e, a) == announced); + run_raster_tasks(e); + CHECK(live_frames() == base); + send_frame(pa, 5); + CHECK(marks(e, a) == announced && live_frames() == base); + std::set ids; + for (int key = 21; key < 53; key++) { + int64_t id = create_texture(e, key); + CHECK(id > 0 && texture_ptr(e, key) != pa); + ids.insert(id); + } + send_frame(pa, 6); + for (int64_t id : ids) { + CHECK(marks(e, id) == 0); + } + engine_shutdown(e); + send_frame(pa, 7); + CHECK(live_frames() == base); + } +} + +// A key that is in use gets -1. Without an answer the Dart future would never +// complete. +void test_duplicate_key_gets_minus_one() { + Engine* e = engine_new(); + int64_t a = create_texture(e, 30); + int64_t pa = texture_ptr(e, 30); + CHECK(a > 0); + CHECK(create_texture(e, 30) == -1); + CHECK(texture_ptr(e, 30) == pa); + CHECK(close_texture(e, 30, 1) == 1); + run_raster_tasks(e); + engine_shutdown(e); +} + +// The texture is unregistered once: by closeTexture, or when the window goes +// away while it is open, not again when the object is destroyed. +void test_texture_is_unregistered_once() { + Engine* e = engine_new(); + int64_t a = create_texture(e, 40); + CHECK(close_texture(e, 40, 1) == 1); + int64_t b = create_texture(e, 41); + CHECK(close_texture(e, 41, 0) == 1); + int64_t c = create_texture(e, 42); + run_raster_tasks(e); + CHECK(unregisters(e, a) == 1 && unregisters(e, b) == 1); + engine_destroy_plugins(e); + run_raster_tasks(e); + CHECK(unregisters(e, c) == 1 && !registered(e, c)); + engine_free(e); +} + +// When the window closes, the textures it still has are unregistered but not +// destroyed: the sessions may still push frames to them, and the raster +// thread may draw them until the engine has dropped them. +void test_engine_shutdown_retires_open_textures() { + const int base = live_frames(); + Engine* e = engine_new(); + int64_t a = create_texture(e, 50); + int64_t pa = texture_ptr(e, 50); + CHECK(a > 0 && pa != 0 && pa != -1); + send_frame(pa, 8); + CHECK(pull(e, a).ok); + send_frame(pa, 9); + engine_destroy_plugins(e); + send_frame(pa, 10); + CHECK(registered(e, a)); + CHECK(!pull(e, a).ok); + engine_free(e); + send_frame(pa, 11); + CHECK(live_frames() == base); +} + +// A texture closed without "recycle" is kept for the rest of the process. It +// keeps no frame buffer once the engine has unregistered it; what it keeps is +// measured here (the retired bound). +void test_retired_textures_keep_no_frame_buffers() { + Engine* e = engine_new(); + auto cycle = [e](int key) { + int64_t id = create_texture(e, key); + int64_t ptr = texture_ptr(e, key); + if (id <= 0 || ptr == 0 || ptr == -1) { + return false; + } + send_frame(ptr, 12); + pull(e, id); + send_frame(ptr, 13); + const bool closed = close_texture(e, key, 0) == 1; + run_raster_tasks(e); + return closed; + }; + CHECK(cycle(60)); + const int base_frames = live_frames(); + const long long base_bytes = g_live_bytes.load(); + constexpr int kRetired = 16; + for (int i = 0; i < kRetired; i++) { + CHECK(cycle(61 + i)); + } + CHECK(live_frames() == base_frames); + const long long per_texture = (g_live_bytes.load() - base_bytes) / kRetired; + std::printf(" retired texture keeps %lld bytes of heap (%d textures)\n", + per_texture, kRetired); + CHECK(per_texture < 1024); + engine_shutdown(e); +} + +// getTexturePtr of a key that is not open (closed meanwhile) answers 0, which +// the session treats as no texture, like on Linux and macOS. +void test_texture_ptr_of_closed_key_is_null() { + Engine* e = engine_new(); + CHECK(texture_ptr(e, 80) == 0); + CHECK(create_texture(e, 81) > 0); + CHECK(close_texture(e, 81, 0) == 1); + CHECK(texture_ptr(e, 81) == 0); + run_raster_tasks(e); + engine_shutdown(e); +} + +// N-01 with threads: the video thread pushes frames and the raster thread draws +// every texture and runs the engine's tasks while the platform thread closes +// textures. With release_first the session first clears its pointer (like +// destroy(true) in Dart) and closes with "recycle"; otherwise it keeps pushing +// to the closed texture. +void racing_close(bool release_first) { + const int base = live_frames(); + Engine* e = engine_new(); + std::atomic stop{false}; + std::thread raster([e, &stop]() { + while (!stop.load()) { + pull_all(e); + run_raster_tasks(e); + } + }); + constexpr int kTextures = 20; + int64_t closed[kTextures] = {}; + bool created = true; + for (int i = 0; i < kTextures && created; i++) { + const int key = 700 + i; + int64_t id = create_texture(e, key); + int64_t ptr = texture_ptr(e, key); + created = id > 0 && ptr != 0 && ptr != -1; + if (!created) { + break; + } + Session session; + session.set(ptr); + std::atomic done{false}; + std::thread video([&session, &done]() { + for (int n = 0; !done.load(); n++) { + session.push(static_cast(1 + n % 2)); + } + }); + std::this_thread::sleep_for(std::chrono::milliseconds(2)); + if (release_first) { + session.set(0); + } + closed[i] = close_texture(e, key, release_first ? 1 : 0); + std::this_thread::sleep_for(std::chrono::milliseconds(2)); + done = true; + video.join(); + } + stop = true; + raster.join(); + run_raster_tasks(e); + CHECK(created); + for (int i = 0; i < kTextures; i++) { + CHECK(closed[i] == 1); + } + CHECK(live_frames() == base); + engine_shutdown(e); +} + +void test_frames_racing_close_without_recycle() { + racing_close(false); +} + +void test_frames_racing_close_with_recycle() { + racing_close(true); +} + + +// The engine reads returned bytes after the PixelBufferTexture callback has +// returned. Pause exactly in that gap, close on the platform thread, and read +// the original bytes before the raster unregister task is allowed to complete. +// An eager buffer/object deletion breaks this with a real ASan UAF. +void test_held_raster_buffer_survives_close() { + for (int recycle : {0, 1}) { + const int base = live_frames(); + Engine* e = engine_new(); + const int64_t id = create_texture(e, 111); + send_frame(texture_ptr(e, 111), 11); + FlutterDesktopPixelBufferTextureConfig config; + { + std::lock_guard lock(textures(e).mutex); + config = textures(e).textures.at(id); + } + const FlutterDesktopPixelBuffer* held = config.callback(kWidth, kHeight, config.user_data); + CHECK(held && held->buffer && held->width == kWidth && held->height == kHeight); + const uint8_t* bytes = held->buffer; + const size_t length = held->width * held->height * 4; + CHECK(close_texture(e, 111, recycle) == 1); + // Actual retained consumer memory, not a new post-close callback or copied + // data. This read must remain safe until unregister completion. + for (size_t i = 0; i < length; ++i) CHECK(bytes[i] == 11); + CHECK(live_frames() == base + 1); + if (held->release_callback) held->release_callback(held->release_context); + run_raster_tasks(e); + CHECK(live_frames() == base); + CHECK(!registered(e, id)); + engine_shutdown(e); + } +} + +void test_inline_unregister_and_failed_raster_post() { + for (auto mode : {FlutterDesktopTextureRegistrar::Completion::immediate, + FlutterDesktopTextureRegistrar::Completion::post_failure}) { + for (int recycle : {0, 1}) { + const int base = live_frames(); + Engine* e = engine_new(); + const int64_t id = create_texture(e, 112); + const int64_t ptr = texture_ptr(e, 112); + send_frame(ptr, 12); + CHECK(pull(e, id).first == 12); + textures(e).completion = mode; + CHECK(close_texture(e, 112, recycle) == 1); + CHECK(unregisters(e, id) == 1); + CHECK(live_frames() == base); + CHECK(close_texture(e, 112, recycle) == 0); + CHECK(texture_ptr(e, 112) == 0); + if (recycle == 0) { + const int count = marks(e, id); + send_frame(ptr, 13); + CHECK(marks(e, id) == count && live_frames() == base); + } + // For post_failure the external texture wrapper can still exist, but + // raster is stopped: don't invent a draw after the completion promise. + CHECK(registered(e, id) == (mode == FlutterDesktopTextureRegistrar::Completion::post_failure)); + engine_shutdown(e); + if (recycle == 0) { send_frame(ptr, 14); CHECK(live_frames() == base); } + } + } +} + +void test_unregister_with_missing_engine_registration() { + for (int recycle : {0, 1}) { + const int base = live_frames(); + Engine* e = engine_new(); + const int64_t id = create_texture(e, 113); + const int64_t ptr = texture_ptr(e, 113); + send_frame(ptr, 1); + CHECK(pull(e, id).ok); + { std::lock_guard lock(textures(e).mutex); textures(e).textures.erase(id); } + CHECK(close_texture(e, 113, recycle) == 1); + CHECK(close_texture(e, 113, recycle) == 0); + run_raster_tasks(e); + CHECK(unregisters(e, id) == 1 && live_frames() == base); + CHECK(texture_ptr(e, 113) == 0); + if (!recycle) send_frame(ptr, 2); + engine_shutdown(e); + if (!recycle) send_frame(ptr, 3); + CHECK(live_frames() == base); + } +} + +struct Test { + const char* name; + void (*run)(); +}; + +const Test kTests[] = { + {"held_raster_buffer_survives_close", test_held_raster_buffer_survives_close}, + {"inline_unregister_and_failed_raster_post", test_inline_unregister_and_failed_raster_post}, + {"unregister_with_missing_engine_registration", test_unregister_with_missing_engine_registration}, + {"close_keeps_texture_until_engine_unregisters", + test_close_keeps_texture_until_engine_unregisters}, + {"late_frames_after_close_are_dropped", + test_late_frames_after_close_are_dropped}, + {"duplicate_key_gets_minus_one", test_duplicate_key_gets_minus_one}, + {"texture_is_unregistered_once", test_texture_is_unregistered_once}, + {"engine_shutdown_retires_open_textures", + test_engine_shutdown_retires_open_textures}, + {"retired_textures_keep_no_frame_buffers", + test_retired_textures_keep_no_frame_buffers}, + {"texture_ptr_of_closed_key_is_null", + test_texture_ptr_of_closed_key_is_null}, + {"frames_racing_close_without_recycle", + test_frames_racing_close_without_recycle}, + {"frames_racing_close_with_recycle", test_frames_racing_close_with_recycle}, +}; + +} // namespace + +int main(int argc, char** argv) { + install_heap_accounting(); + for (int i = 0; i < kFills; i++) { + std::memset(g_frames[i], i, kFrameBytes); + } + if (argc == 2 && std::strcmp(argv[1], "--list") == 0) { + for (const Test& t : kTests) { + std::printf("%s\n", t.name); + } + return 0; + } + int count = 0; + int failed = 0; + for (const Test& t : kTests) { + if (argc == 2 && std::strcmp(argv[1], t.name) != 0) { + continue; + } + const int before = g_failed_checks; + t.run(); + const bool ok = g_failed_checks == before; + if (argc != 2) { + std::printf("%s %s\n", ok ? "PASS" : "FAIL", t.name); + } + std::fflush(stdout); + failed += ok ? 0 : 1; + count++; + } + if (count == 0) { + std::fprintf(stderr, "unknown test %s\n", argv[1]); + return 2; + } + return failed == 0 ? 0 : 1; +} diff --git a/windows/texture_rgba.cpp b/windows/texture_rgba.cpp index 91aaacc..c511dd7 100644 --- a/windows/texture_rgba.cpp +++ b/windows/texture_rgba.cpp @@ -1,3 +1,6 @@ +// Modified by the Kitedesk fork (2026, B252): no UnregisterTexture in the +// destructor; Terminate and FreeBuffers for closeTexture. + #include "texture_rgba.h" #include @@ -11,11 +14,6 @@ TextureRgba::TextureRgba(flutter::TextureRegistrar *texture_registrar) this->texture_id_ = texture_registrar->RegisterTexture(texture_.get()); } -TextureRgba::~TextureRgba() -{ - texture_registrar_->UnregisterTexture(texture_id_); -} - void TextureRgba::MarkVideoFrameAvailable( std::vector &buffer, size_t width, size_t height) { @@ -45,6 +43,11 @@ void TextureRgba::MarkVideoFrameAvailable2(const uint8_t* buffer, const size_t b return; } const std::lock_guard lock(mutex_); + if (terminated_) + { + // Closed while the session still pushes frames to this pointer. + return; + } int bg_index = fg_index_ ^ 1; buffer_tmp_[bg_index].assign(buffer, buffer + buffer_length); width_[bg_index] = width; @@ -61,6 +64,11 @@ void TextureRgba::MarkVideoFrameAvailable2(const uint8_t* buffer, const size_t b inline const FlutterDesktopPixelBuffer *TextureRgba::buffer() { const std::lock_guard lock(mutex_); + if (terminated_) + { + // Closed; the engine may draw the texture until it has unregistered it. + return nullptr; + } if (buff_ready_) { fg_index_ ^= 1; @@ -71,3 +79,18 @@ inline const FlutterDesktopPixelBuffer *TextureRgba::buffer() } return &this->flutter_pixel_buffer_; } + +void TextureRgba::Terminate() +{ + const std::lock_guard lock(mutex_); + terminated_ = true; +} + +void TextureRgba::FreeBuffers() +{ + const std::lock_guard lock(mutex_); + std::vector().swap(buffer_tmp_[0]); + std::vector().swap(buffer_tmp_[1]); + flutter_pixel_buffer_.buffer = nullptr; + buff_ready_ = false; +} diff --git a/windows/texture_rgba.h b/windows/texture_rgba.h index 8273039..04a9000 100644 --- a/windows/texture_rgba.h +++ b/windows/texture_rgba.h @@ -1,7 +1,14 @@ +// Modified by the Kitedesk fork (2026, B252): the texture no longer +// unregisters itself when destroyed (closeTexture does, and the plugin keeps +// the object alive until the engine is done with it); a closed texture drops +// pushed frames, hands the engine no buffer, and frees its frame buffers once +// the engine has unregistered it. + #ifndef TEXTURE_RGBA_H_ #define TEXTURE_RGBA_H_ #include +#include #include #include @@ -9,7 +16,6 @@ class TextureRgba { public: TextureRgba(flutter::TextureRegistrar* texture_registrar); - ~TextureRgba(); void MarkVideoFrameAvailable(std::vector& buffer, size_t width, size_t height); @@ -19,12 +25,23 @@ public: const FlutterDesktopPixelBuffer* buffer(); + // Closes the texture: frames pushed from now on are dropped without + // touching the texture registrar, and the engine gets no buffer any more. + void Terminate(); + + // Frees the frame buffers. Call after Terminate, once the engine has + // unregistered the texture and so no longer reads them. + void FreeBuffers(); + private: FlutterDesktopPixelBuffer flutter_pixel_buffer_{}; flutter::TextureRegistrar* texture_registrar_ = nullptr; std::unique_ptr texture_ = nullptr; int64_t texture_id_; std::mutex mutex_; + // Set and read with mutex_ held, so that no frame is copied or announced + // to the engine after Terminate returns. + std::atomic terminated_{false}; int fg_index_ = 0; bool buff_ready_ = false; size_t width_[2]; diff --git a/windows/texture_rgba_renderer_plugin.cpp b/windows/texture_rgba_renderer_plugin.cpp index a5186bf..b3b13fe 100644 --- a/windows/texture_rgba_renderer_plugin.cpp +++ b/windows/texture_rgba_renderer_plugin.cpp @@ -1,3 +1,9 @@ +// Modified by the Kitedesk fork (2026, B252): closeTexture no longer destroys +// the texture before the engine is done with it, and keeps it for good unless +// "recycle" is set; the textures of a closing engine are kept the same way; +// createTexture of a key in use answers -1; getTexturePtr of a key that is not +// open answers 0. + #include "texture_rgba_renderer_plugin.h" // This must be included before many other Windows headers. @@ -11,10 +17,32 @@ #include #include +#include #include +#include namespace texture_rgba_renderer { +namespace { + +// Textures closed while frames may still be pushed to the pointer from +// getTexturePtr: closeTexture without "recycle" (a tab moving to another +// window keeps its session's pointer), or an engine going away first. They are +// never destroyed, so such a push finds a closed texture and not freed memory, +// and their address is never handed out again for another texture (ABA). Their +// lifetime is the process; each one keeps the object, not its frame buffers. +struct Retired { + std::mutex mutex; + std::vector> textures; +}; + +Retired& retired() { + static Retired* instance = new Retired(); + return *instance; +} + +} // namespace + // static void TextureRgbaRendererPlugin::RegisterWithRegistrar( flutter::PluginRegistrarWindows *registrar) { @@ -38,7 +66,28 @@ TextureRgbaRendererPlugin::TextureRgbaRendererPlugin() { this->texture_registrar = nullptr; } -TextureRgbaRendererPlugin::~TextureRgbaRendererPlugin() {} +TextureRgbaRendererPlugin::~TextureRgbaRendererPlugin() { + // The engine is going away (its texture registrar outlives the plugins), and + // sessions may still push frames to these textures. + for (auto &entry : textures_) { + CloseTexture(std::move(entry.second), false); + } +} + +void TextureRgbaRendererPlugin::CloseTexture( + std::unique_ptr texture, bool recycle) { + std::shared_ptr closed = std::move(texture); + closed->Terminate(); + if (!recycle) { + std::lock_guard lock(retired().mutex); + retired().textures.push_back(closed); + } + // The engine removes the texture on its raster thread, which may draw it + // until then, and calls back there. Only then are the frame buffers freed, + // and a recycled texture is destroyed with the last reference. + this->texture_registrar->UnregisterTexture(closed->texture_id(), + [closed] { closed->FreeBuffers(); }); +} void TextureRgbaRendererPlugin::HandleMethodCall( const flutter::MethodCall &method_call, @@ -52,16 +101,27 @@ void TextureRgbaRendererPlugin::HandleMethodCall( it->second = std::make_unique(this->texture_registrar); result->Success(flutter::EncodableValue(it->second->texture_id())); } + else { + // The key is in use. Without an answer the Dart future never completes. + result->Success(flutter::EncodableValue(int64_t(-1))); + } } else if (method_call.method_name().compare("closeTexture") == 0) { auto args = std::get(*method_call.arguments()); auto key = std::get(args.at(flutter::EncodableValue("key"))); - if (textures_.find(key) == textures_.end()) { + auto it = textures_.find(key); + if (it == textures_.end()) { result->Success(flutter::EncodableValue(false)); } else { - this->texture_registrar->UnregisterTexture(textures_[key]->texture_id()); - textures_.erase(key); + // "recycle": true promises that nothing pushes frames to the pointer + // from getTexturePtr any more, so the texture may be destroyed. + auto recycle = args.find(flutter::EncodableValue("recycle")); + const bool* recycle_value = recycle == args.end() + ? nullptr : std::get_if(&recycle->second); + CloseTexture(std::move(it->second), + recycle_value != nullptr && *recycle_value); + textures_.erase(it); result->Success(flutter::EncodableValue(true)); } } @@ -83,7 +143,8 @@ void TextureRgbaRendererPlugin::HandleMethodCall( auto args = std::get(*method_call.arguments()); auto key = std::get(args.at(flutter::EncodableValue("key"))); if (textures_.find(key) == textures_.end()) { - result->Success(flutter::EncodableValue(-1)); + // Not open (e.g. closed meanwhile): no pointer for the session. + result->Success(flutter::EncodableValue(0)); } else { // Return an address. diff --git a/windows/texture_rgba_renderer_plugin.h b/windows/texture_rgba_renderer_plugin.h index a87c3b0..0cb67bf 100644 --- a/windows/texture_rgba_renderer_plugin.h +++ b/windows/texture_rgba_renderer_plugin.h @@ -1,3 +1,7 @@ +// Modified by the Kitedesk fork (2026, B252): closeTexture keeps the texture +// alive until the engine has unregistered it, and for good unless "recycle" +// says that nothing pushes frames to its pointer any more. + #ifndef FLUTTER_PLUGIN_TEXTURE_RGBA_RENDERER_PLUGIN_H_ #define FLUTTER_PLUGIN_TEXTURE_RGBA_RENDERER_PLUGIN_H_ @@ -31,6 +35,8 @@ class TextureRgbaRendererPlugin : public flutter::Plugin { void HandleMethodCall( const flutter::MethodCall &method_call, std::unique_ptr> result); + + void CloseTexture(std::unique_ptr texture, bool recycle); }; } // namespace texture_rgba_renderer