Keep one window ID on both GTK objects (#65)

WindowManager keys a window by its GdkWindow and stored the ID there alone;
a Window wrapper made afterwards found it there but left the GtkWindow
without one. The close gate and the per-window event subscription check the
ID on the GtkWindow, so a window WindowManager saw first - a Flutter app's,
through GetCurrent() - got no events of its own and its close requests could
not be cancelled: the GNOME close button closed it regardless.

The widget's ID now wins wherever one is found or allocated, and goes on
both objects. tests/window_close_manager_first_linux_test fails without
this (no close request, no property event) and passes with it.

Author: lijy91

src/platform/linux/window_linux.cpp

@@ -932,18 +932,24 @@ Window::Window(void* native_window) {
   }
 
   // Like the other platforms, a wrapped window gets an ID on first sight, stored
-  // on the native objects so every later wrapper and WindowManager agree on it.
+  // on both native objects so every later wrapper and WindowManager agree on it.
+  // The widget's ID wins: it is the identity GetNativeObject() reports, and the
+  // close gate and the per-window events check it there. WindowManager, which
+  // sees windows through their GdkWindow, may have stored one on that alone.
   gpointer existing_id = nullptr;
-  if (gdk_window) {
-    existing_id = g_object_get_data(G_OBJECT(gdk_window), kWindowIdKey);
-  }
-  if (!existing_id && widget) {
+  if (widget) {
     existing_id = g_object_get_data(G_OBJECT(widget), kWindowIdKey);
   }
+  if (!existing_id && gdk_window) {
+    existing_id = g_object_get_data(G_OBJECT(gdk_window), kWindowIdKey);
+  }
   if (existing_id) {
     if (gdk_window) {
       g_object_set_data(G_OBJECT(gdk_window), kWindowIdKey, existing_id);
     }
+    if (widget) {
+      g_object_set_data(G_OBJECT(widget), kWindowIdKey, existing_id);
+    }
   } else if (gdk_window || widget) {
     WindowId id = IdAllocator::Allocate<Window>();
     if (id != IdAllocator::kInvalidId) {

src/platform/linux/window_manager_linux.cpp

@@ -53,9 +53,17 @@ static WindowId GetOrCreateWindowId(GdkWindow* gdk_window) {
     return IdAllocator::kInvalidId;
   }
 
-  // First, try to read ID attached to the GObject
-  gpointer data = g_object_get_data(G_OBJECT(gdk_window), kWindowIdKey);
+  // The owning widget's ID first (see Window(void*)), then the GdkWindow's; an ID
+  // found or allocated here goes on both, or a Window wrapper made later would
+  // not match the widget its close gate and events are keyed on.
+  gpointer owner = nullptr;
+  gdk_window_get_user_data(gdk_window, &owner);
+  GObject* widget = owner && GTK_IS_WIDGET(owner) ? G_OBJECT(owner) : nullptr;
+  gpointer data = widget ? g_object_get_data(widget, kWindowIdKey) : nullptr;
+  if (!data) data = g_object_get_data(G_OBJECT(gdk_window), kWindowIdKey);
   if (data) {
+    g_object_set_data(G_OBJECT(gdk_window), kWindowIdKey, data);
+    if (widget) g_object_set_data(widget, kWindowIdKey, data);
     WindowId id = static_cast<WindowId>(reinterpret_cast<uintptr_t>(data));
     // Cache it in the map for faster lookup next time
     std::lock_guard<std::mutex> lock(g_map_mutex);
@@ -77,6 +85,9 @@ static WindowId GetOrCreateWindowId(GdkWindow* gdk_window) {
   if (new_id != IdAllocator::kInvalidId) {
     g_object_set_data(G_OBJECT(gdk_window), kWindowIdKey,
                       reinterpret_cast<gpointer>(static_cast<uintptr_t>(new_id)));
+    if (widget)
+      g_object_set_data(widget, kWindowIdKey,
+                        reinterpret_cast<gpointer>(static_cast<uintptr_t>(new_id)));
     std::lock_guard<std::mutex> lock(g_map_mutex);
     g_window_id_map[gdk_window] = new_id;
   }

tests/CMakeLists.txt

@@ -391,6 +391,10 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
   target_link_libraries(window_close_linux_test PRIVATE nativeapi Threads::Threads)
   add_test(NAME window_close_linux_test COMMAND window_close_linux_test)
   set_tests_properties(window_close_linux_test PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 10)
+  add_executable(window_close_manager_first_linux_test window_close_manager_first_linux_test.cpp)
+  target_link_libraries(window_close_manager_first_linux_test PRIVATE nativeapi)
+  add_test(NAME window_close_manager_first_linux_test COMMAND window_close_manager_first_linux_test)
+  set_tests_properties(window_close_manager_first_linux_test PROPERTIES SKIP_RETURN_CODE 77 TIMEOUT 10)
 endif()
 
 if(APPLE AND NOT CMAKE_SYSTEM_NAME STREQUAL "iOS")

tests/window_close_manager_first_linux_test.cpp

@@ -0,0 +1,57 @@
+// A window that WindowManager sees before any Window wraps it - the way a
+// Flutter app asks for its window with GetCurrent() - still gets its own
+// events and cancellable close requests. WindowManager keys windows by their
+// GdkWindow; the close gate checks the ID on the GtkWindow, so the two must
+// carry the same one. Private display, no input.
+#include <gtk/gtk.h>
+#include <iostream>
+#include "nativeapi.h"
+namespace {
+int failures = 0;
+void Check(bool ok, const char* label) {
+  std::cout << (ok ? "PASS " : "FAIL ") << label << std::endl;
+  failures += !ok;
+}
+void Drain() {
+  while (g_main_context_pending(nullptr))
+    g_main_context_iteration(nullptr, FALSE);
+}
+}  // namespace
+int main() {
+  if (!gtk_init_check(nullptr, nullptr))
+    return 77;
+  auto* widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  g_object_ref_sink(widget);
+  gtk_widget_realize(widget);  // A real GdkWindow, not shown yet (as a Flutter runner's at start).
+
+  auto current = nativeapi::WindowManager::GetInstance().GetCurrent();
+  Check(current && current->GetNativeObject() == widget, "GetCurrent finds the window");
+  if (!current) return 1;
+  nativeapi::Window wrapper(widget);
+  Check(wrapper.GetId() == current->GetId(), "a wrapper of the widget has the same ID");
+
+  int requested = 0;
+  current->AddListener<nativeapi::WindowCloseRequestedEvent>([&](const auto& event) {
+    ++requested;
+    event.GetRequest()->Cancel();
+  });
+  Drain();  // The subscription is set up on the next main loop turn.
+  gtk_window_close(GTK_WINDOW(widget));
+  Drain();
+  Check(requested == 1, "the close request reaches the window found through WindowManager");
+  Check(!gtk_widget_in_destruction(widget), "and cancelling it keeps the window");
+
+  int titles = 0;
+  current->AddListener<nativeapi::WindowPropertyChangedEvent>([&](const auto& event) {
+    if (event.GetProperty() == nativeapi::WindowProperty::Title) ++titles;
+  });
+  Drain();
+  gtk_window_set_title(GTK_WINDOW(widget), "renamed");
+  Drain();
+  Check(titles == 1, "its own property events arrive too");
+
+  gtk_widget_destroy(widget);
+  g_object_unref(widget);
+  std::cout << (failures ? "FAILED" : "OK") << std::endl;
+  return failures ? 1 : 0;
+}