linux: fix window-close hang, popup lifecycle, PDF frame crash

Three independent fixes for the CEF 146 Linux embedding path:

1. window_utils_linux: _on_configure — replace XResizeWindow+XSync with
   NotifyMoveOrResizeStarted()+SetBounds().  XSync() blocks the Python GIL
   on every GTK configure-event; when the GIL is held the GLib event loop
   stalls, the window manager marks the window as unresponsive, and sends a
   spurious WM_DELETE_WINDOW that closes the browser unexpectedly.
   SetBounds() already calls XConfigureWindow+XFlush internally, so the
   explicit XResizeWindow was redundant.  NotifyMoveOrResizeStarted() is
   required before SetBounds() so the CEF compositor can prepare.

2. window_utils_linux: _on_delete / QuitMessageLoop — two related fixes:
   a. Add _linux_close_popup_browsers() called from _on_delete so that any
      JS-created popup browsers are queued for close in the same drain pass
      as the main browser, avoiding Shutdown()'s emergency force-close path.
   b. Always call gtk_main_quit() in _on_delete.  When _on_delete returns
      False, GTK destroys the X11 parent window which also destroys CEF's
      embedded child window via the X11 parent-child relationship.  CEF does
      not fire OnBeforeClose through its normal path after that, so
      QuitMessageLoop() would never be called and the GLib timer would spin
      MessageLoopWork() at 100% CPU indefinitely.  The drain loop in
      _linux_message_loop() handles remaining cleanup after gtk_main()
      returns.
   c. Guard QuitMessageLoop()'s gtk_main_quit() with gtk_main_level() > 0
      to suppress the "assertion 'main_loops != NULL' failed" GTK warning
      that fires when QuitMessageLoop() runs during the post-gtk_main() drain
      after _on_delete has already called gtk_main_quit().

3. frame: GetPyFrame — replace the blanket assert on frameId/browserId with
   a targeted Exception for browserId==0 only.  CEF 146 fires OnLoadStart
   with an empty frameId for internal frames created before the renderer
   frame is ready (e.g. the PDF-viewer extension frame).  The assert was
   incorrectly blocking the frameId.empty() handling that already existed
   below it, causing an AssertionError → ExceptHook → abort when loading
   any PDF URL.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: linesight

src/cefpython.pyx

@@ -959,7 +959,13 @@ def QuitMessageLoop():
     Debug("QuitMessageLoop()")
     IF UNAME_SYSNAME == "Linux":
         import ctypes as _ct
-        _ct.CDLL("libgtk-3.so.0").gtk_main_quit()
+        _gtk = _ct.CDLL("libgtk-3.so.0")
+        # Only call gtk_main_quit() when a GTK main loop is actually running.
+        # _on_delete() may have already called it (via gtk_main_quit directly),
+        # and calling it a second time during the drain would generate a
+        # spurious "assertion 'main_loops != NULL' failed" warning.
+        if _gtk.gtk_main_level() > 0:
+            _gtk.gtk_main_quit()
     with nogil:
         CefQuitMessageLoop()
 

src/frame.pyx

@@ -29,7 +29,12 @@ cdef PyFrame GetPyFrame(CefRefPtr[CefFrame] cefFrame):
     cdef PyFrame pyFrame
     cdef CefString frameId = cefFrame.get().GetIdentifier()
     cdef int browserId = cefFrame.get().GetBrowser().get().GetIdentifier()
-    assert (not frameId.empty() and browserId), "frameId or browserId empty"
+    if not browserId:
+        raise Exception("GetPyFrame(): browserId is 0 (browser not yet initialised)")
+    # frameId may be empty for internal frames that CEF creates before the
+    # underlying renderer frame is ready (e.g. the PDF-viewer internal frame
+    # on the first OnLoadStart).  The code below already creates an incomplete
+    # PyFrame for this case, so do not assert here.
     cdef str uniqueFrameId = GetUniqueFrameId(browserId, CefToPyString(frameId))
 
     if frameId.empty():

src/window_utils_linux.pyx

@@ -258,6 +258,25 @@ def _linux_create_toplevel(title, width=800, height=600):
     }
 
 
+def _linux_close_popup_browsers(main_id):
+    """Queue CloseBrowser(True) for every tracked browser except main_id.
+
+    Called when the main GTK window delete-event fires so that popup browsers
+    are shut down in the same event-loop pass.  Without this, cef.Shutdown()
+    can be called while popups are still alive, hitting the emergency
+    force-close path in Shutdown() and producing a spurious gtk_main_quit()
+    assertion warning when QuitMessageLoop fires later.
+    """
+    for bid in list(g_pyBrowsers.keys()):
+        if bid != main_id:
+            pb = GetPyBrowserById(bid)
+            if pb:
+                try:
+                    pb.CloseBrowser(True)
+                except Exception:
+                    pass
+
+
 def _linux_register_window_callbacks(browser, ws):
     """Register resize and close callbacks for a standalone GTK toplevel.
 
@@ -285,9 +304,13 @@ def _linux_register_window_callbacks(browser, ws):
             if _b:
                 _chrome_xid = _b.GetWindowHandle()
                 if _chrome_xid:
-                    _x11.XResizeWindow(_xdisp, _ct.c_ulong(_chrome_xid),
-                                       _ct.c_uint(nw), _ct.c_uint(nh))
-                    _x11.XSync(_xdisp, _ct.c_int(0))
+                    # Notify CEF of the incoming resize before applying it so
+                    # the compositor can prepare (avoids blank frames).
+                    # SetBounds calls XConfigureWindow + XFlush internally;
+                    # the redundant XResizeWindow+XSync was removed because
+                    # XSync blocks the GIL and can make the WM consider the
+                    # window unresponsive (triggering spurious WM_DELETE_WINDOW).
+                    _b.NotifyMoveOrResizeStarted()
                     _b.SetBounds(0, 0, nw, nh)
         return False
     _conf_cb = _ConfigureCb(_on_configure)
@@ -301,7 +324,19 @@ def _linux_register_window_callbacks(browser, ws):
     def _on_delete(_w, _ev, _ud):
         _b = _browser_ref[0]
         if _b:
+            # Close any open popup browsers so the drain loop in
+            # _linux_message_loop() can clean them up without hitting the
+            # emergency force-close path in Shutdown().
+            _linux_close_popup_browsers(_b.GetIdentifier())
             _b.CloseBrowser(True)
+        # Always call gtk_main_quit() here.  When _on_delete returns False,
+        # GTK destroys the X11 parent window, which also destroys CEF's
+        # embedded child window via X11's parent-child relationship.  CEF
+        # does not fire OnBeforeClose through its normal path after the X11
+        # window is destroyed externally, so QuitMessageLoop() would never be
+        # called and the GTK main loop would spin at 100% CPU.  The drain
+        # loop in _linux_message_loop() handles remaining CEF cleanup after
+        # gtk_main() returns.
         _gtk.gtk_main_quit()
         return False
     _del_cb = _DeleteCb(_on_delete)