JBR-9893 Closed and disposed windows leak through WLGraphicsDevice.toplevels

Author: mkartashev

src/java.desktop/unix/classes/sun/awt/wl/WLGraphicsDevice.java

@@ -35,7 +35,10 @@
 import java.awt.Insets;
 import java.awt.Rectangle;
 import java.awt.Window;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -119,7 +122,7 @@ public class WLGraphicsDevice extends GraphicsDevice {
      * Top-level window peers that consider this device as their primary one
      * and get their graphics configuration from it
      */
-    private final Set<WLComponentPeer> toplevels = new HashSet<>(); // guarded by 'this'
+    private final Set<WeakReference<WLComponentPeer>> toplevels = new HashSet<>(); // guarded by 'this'
 
     private WLGraphicsDevice(int id,
                              String name,
@@ -205,9 +208,14 @@ void updateConfiguration(String name,
     }
 
     private void notifyToplevels() {
-        Set<WLComponentPeer> toplevelsCopy = new HashSet<>(toplevels.size());
+        List<WLComponentPeer> toplevelsCopy = new ArrayList<>(toplevels.size());
         synchronized (this) {
-            toplevelsCopy.addAll(toplevels);
+            for (var toplevel: toplevels) {
+                WLComponentPeer peer = toplevel.get();
+                if (peer != null) {
+                    toplevelsCopy.add(peer);
+                }
+            }
         }
         toplevelsCopy.forEach(WLComponentPeer::checkIfOnNewScreen);
     }
@@ -369,13 +377,16 @@ private void exitFullScreenExclusive(Window w) {
 
     public void addWindow(WLComponentPeer peer) {
         synchronized (this) {
-            toplevels.add(peer);
+            toplevels.add(new WeakReference<>(peer));
         }
     }
 
     public void removeWindow(WLComponentPeer peer) {
         synchronized (this) {
-            toplevels.remove(peer);
+            toplevels.removeIf(ref -> {
+                WLComponentPeer p = ref.get();
+                return p == null || p == peer;
+            });
         }
     }
 

src/java.desktop/unix/classes/sun/awt/wl/WLKeyboardFocusManagerPeer.java

@@ -6,11 +6,12 @@
 
 import java.awt.Component;
 import java.awt.Window;
+import java.lang.ref.WeakReference;
 
 public class WLKeyboardFocusManagerPeer extends KeyboardFocusManagerPeerImpl {
     private static final PlatformLogger focusLog = PlatformLogger.getLogger("sun.awt.wl.focus.WLKeyboardFocusManagerPeer");
 
-    private Window currentFocusedWindow;
+    private WeakReference<Window> currentFocusedWindow = new WeakReference<>(null);
     private static final WLKeyboardFocusManagerPeer instance = new WLKeyboardFocusManagerPeer();
 
     public static WLKeyboardFocusManagerPeer getInstance() {
@@ -23,14 +24,14 @@ public void setCurrentFocusedWindow(Window win) {
             if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
                 focusLog.finer("Current focused window -> " + win);
             }
-            currentFocusedWindow = win;
+            currentFocusedWindow = new WeakReference<>(win);
         }
     }
 
     @Override
     public Window getCurrentFocusedWindow() {
         synchronized (this) {
-            return currentFocusedWindow;
+            return currentFocusedWindow.get();
         }
     }
 
@@ -61,7 +62,7 @@ public void setCurrentFocusOwner(Component comp) {
     @Override
     public Component getCurrentFocusOwner() {
         synchronized (this) {
-            return currentFocusedWindow;
+            return currentFocusedWindow.get();
         }
     }
 }

src/java.desktop/unix/classes/sun/awt/wl/WLToolkit.java

@@ -85,7 +85,6 @@
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -471,12 +470,13 @@ private static void dispatchKeyboardLeaveEvent(long serial, long surfacePtr) {
 
         keyboard.onLostFocus();
 
+        WLKeyboardFocusManagerPeer.getInstance().setCurrentFocusedWindow(null);
+        WLKeyboardFocusManagerPeer.getInstance().setCurrentFocusOwner(null);
+
         final WLInputState newInputState = inputState.updatedFromKeyboardLeaveEvent(serial, surfacePtr);
         final WLWindowPeer peer = peerFromSurface(surfacePtr);
         if (peer != null && peer.getTarget() instanceof Window window) {
             final WindowEvent winLostFocusEvent = new WindowEvent(window, WindowEvent.WINDOW_LOST_FOCUS);
-            WLKeyboardFocusManagerPeer.getInstance().setCurrentFocusedWindow(null);
-            WLKeyboardFocusManagerPeer.getInstance().setCurrentFocusOwner(null);
             postPriorityEvent(winLostFocusEvent);
         }
         inputState = newInputState;
@@ -1116,6 +1116,19 @@ public static boolean isSSDAvailable() {
 
     protected static void targetDisposedPeer(Object target, Object peer) {
         SunToolkit.targetDisposedPeer(target, peer);
+        if (target instanceof Window window) {
+            // When a window is disposed, we may not get the keyboard leave event that
+            // normally posts WINDOW_LOST_FOCUS, so we need to post it manually to maintain
+            // a correct state of the keyboard focus manager.
+            final WindowEvent winLostFocusEvent = new WindowEvent(window, WindowEvent.WINDOW_LOST_FOCUS);
+            postPriorityEvent(winLostFocusEvent);
+
+            var gc = window.getGraphicsConfiguration();
+            if (gc != null && peer instanceof WLWindowPeer windowPeer) {
+                WLGraphicsDevice gd = (WLGraphicsDevice) gc.getDevice();
+                gd.removeWindow(windowPeer);
+            }
+        }
     }
 
     static void postEvent(AWTEvent event) {

test/jdk/jb/java/awt/wayland/WLWindowsLeak.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2026 JetBrains s.r.o.
+ * Copyright (c) 2026, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @key headful
+ * @summary Tests that nothing prevents windows from being removed from the global list
+ *          after they have been disposed
+ * @library /javax/swing/regtesthelpers
+ * @modules java.desktop/sun.awt
+ *          java.desktop/sun.java2d
+ * @build Util
+ * @run main/othervm -Xms32M -Xmx32M WLWindowsLeak
+ */
+
+import java.awt.Color;
+import java.awt.Frame;
+import java.awt.Robot;
+import java.awt.Window;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+import com.sun.management.HotSpotDiagnosticMXBean;
+import sun.awt.AppContext;
+import sun.java2d.Disposer;
+
+public class WLWindowsLeak {
+
+    public static final int WINDOWS_COUNT = 100;
+    private static volatile boolean disposerPhantomComplete;
+
+    public static void main(String[] args) throws Exception {
+        spawnWindows();
+
+        Disposer.addRecord(new Object(), () -> disposerPhantomComplete = true);
+
+        while (!disposerPhantomComplete) {
+            Util.generateOOME();
+        }
+
+        Vector<WeakReference<Window>> windowList =
+                (Vector<WeakReference<Window>>) AppContext.getAppContext().get(Window.class);
+
+        if (windowList != null && !windowList.isEmpty()) {
+            dumpHeap("heap_dump_live_windows.hprof");
+            System.out.println("Live window list:");
+            windowList.forEach(ref -> System.out.println(ref.get()));
+            throw new RuntimeException("Test FAILED: Window list is not empty: " + windowList.size());
+        }
+
+        System.out.println("Test PASSED");
+    }
+
+    private static void dumpHeap(String filePath) {
+        try {
+            HotSpotDiagnosticMXBean mxBean = ManagementFactory
+                    .getPlatformMXBean(HotSpotDiagnosticMXBean.class);
+            mxBean.dumpHeap(filePath, true); // true = live objects only
+            System.out.println("Heap dump created at: " + filePath);
+        } catch (IOException e) {
+            System.err.println("Failed to dump heap: " + e.getMessage());
+        }
+    }
+
+    private static void spawnWindows() throws Exception {
+        List<WeakReference<Frame>> frameList = new ArrayList<>();
+        Robot r = new Robot();
+
+        for (int i = 0; i < WINDOWS_COUNT; i++) {
+            Frame f = new Frame(String.format("Frame %d", i));
+            f.setBackground(Color.WHITE);
+            f.setSize(100, 100);
+            f.setVisible(true);
+            frameList.add(new WeakReference<>(f));
+            Thread.sleep(42);
+        }
+        r.waitForIdle();
+
+        frameList.forEach(ref -> {
+            ref.get().setVisible(false);
+        });
+        r.waitForIdle();
+
+        frameList.forEach(ref -> {
+            var f = ref.get();
+            if (f != null) f.dispose();
+        });
+        frameList.clear();
+        r.waitForIdle(); // to make sure no events hold a reference to frames
+        System.gc();
+    }
+}