unittests: run with default config; remove CI switch hacks; fix flaky OSR test

Reviewer feedback on cztomczak#691: the unit tests must run with the default cefpython
configuration on a normal development machine, not with Chromium switches added
only to make CI pass.

_common.py: revert to base. Drop the Linux Initialize monkey-patch, init_gtk(),
the dead _linux_needs_no_sandbox() helper, the off-screen OnBeforePopup hack and
CloseBrowser(False). The library already applies the needed Linux defaults
(ozone-platform=x11, windowless_rendering_enabled, no-sandbox, GDK display) in
window_utils_linux.pyx, and the windowed popup-close no longer crashes, so these
test-side hacks are unnecessary.

main_test.py: remove the per-platform CI switch block. Keep only
disable-popup-blocking, a functional requirement of the popup sub-test (Chrome
blocks gesture-less window.open) rather than a CI workaround.

osr_test.py: remove the Linux/macOS CI switch blocks (keep the OSR switches from
Issue cztomczak#240/cztomczak#463). Fix the intermittent OnTextSelectionChanged failure: post the
selection click after OnLoadEnd instead of from the first paint, let the body
fill the viewport so a fixed center click reliably hits it, and drive the test
with cef.MessageLoop()/QuitMessageLoop() plus a watchdog task instead of looping
for a fixed duration.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: linesight

unittests/_common.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 CEF Python, see the Authors file.
+# Copyright (c) 2018 CEF Python, see the Authors file.
 # All rights reserved. Licensed under BSD 3-clause license.
 # Project website: https://github.com/cztomczak/cefpython
 
@@ -29,71 +29,6 @@
 g_on_load_end_callbacks = []
 
 
-if LINUX:
-    # Ensure windowless_rendering_enabled=True on Linux so that JS-created
-    # popup browsers can be configured as off-screen (see LoadHandler.
-    # OnBeforePopup).  Off-screen browsers are destroyed immediately when
-    # DoClose returns False — no X11/GLib delete_event dispatch is needed,
-    # avoiding the main browser's GTK window receiving the close notification.
-    _orig_cef_initialize = cef.Initialize
-    def _cef_initialize_linux(settings=None, switches=None, **kw):
-        if settings is None:
-            settings = {}
-        settings.setdefault("windowless_rendering_enabled", True)
-        return _orig_cef_initialize(settings, switches=switches, **kw)
-    cef.Initialize = _cef_initialize_linux
-
-
-def init_gtk():
-    """Open a GDK/X11 display connection before CEF initialises.
-
-    On a desktop GNOME/Wayland session gdk_display_get_default() returns NULL
-    unless a GTK application has already opened a display.  Calling
-    gtk_init(NULL, NULL) here ensures the display is available so that the
-    browser window becomes visible.  On CI (xvfb) this is a no-op.
-    GTK is safe to initialise multiple times.
-    """
-    if LINUX:
-        try:
-            import ctypes
-            gtk = ctypes.CDLL("libgtk-3.so.0")
-            gtk.gtk_init(None, None)
-        except Exception as e:
-            print("WARNING: gtk_init failed: %s" % e)
-
-
-def _linux_needs_no_sandbox():
-    """Return True if unprivileged user namespaces are not available.
-
-    Chrome's namespace sandbox requires clone(CLONE_NEWUSER).  Two sysctls
-    can block it:
-      * apparmor_restrict_unprivileged_userns=1  (Ubuntu 23.10+)
-      * unprivileged_userns_clone=0              (older Debian/Ubuntu)
-
-    When namespaces are unavailable and no SUID sandbox binary is present,
-    Chrome FATALs with "No usable sandbox!" unless --no-sandbox is passed.
-
-    Note: do NOT pass --no-sandbox at all. It causes Chrome to skip
-    GlobalDescriptors key 7 registration while still encoding it in
-    --pseudonymization-salt-handle, causing a CHECK-crash in subprocesses.
-    """
-    if not LINUX:
-        return False
-    try:
-        with open("/proc/sys/kernel/apparmor_restrict_unprivileged_userns") as f:
-            if f.read().strip() == "1":
-                return True
-    except OSError:
-        pass
-    try:
-        with open("/proc/sys/kernel/unprivileged_userns_clone") as f:
-            if f.read().strip() == "0":
-                return True
-    except OSError:
-        pass
-    return False
-
-
 def subtest_message(message):
     global g_subtests_ran
     g_subtests_ran += 1
@@ -185,10 +120,7 @@ def OnConsoleMessage(self, message, **_):
 
 
 def close_popup(global_handler, browser):
-    # The popup was created as off-screen on Linux (see LoadHandler.OnBeforePopup).
-    # For off-screen browsers DoClose returning False causes immediate destruction
-    # without any GLib/X11 event dispatch, so CloseBrowser(False) works cleanly.
-    browser.CloseBrowser(False)
+    browser.CloseBrowser()
     global_handler.PopupClosed_True = True
 
     # Test developer tools popup
@@ -261,20 +193,6 @@ def __init__(self, test_case, datauri):
         # self.OnLoadingStateChange_Start_True = False # FAILS
         self.OnLoadingStateChange_End_True = False
 
-    def OnBeforePopup(self, browser, frame, target_url, target_frame_name,
-                      target_disposition, user_gesture, popup_features,
-                      window_info_out, client, browser_settings_out,
-                      no_javascript_access_out, **_):
-        if LINUX:
-            # Configure JS-created popups as off-screen so they can be closed
-            # without GLib/X11 event dispatch.  For off-screen browsers CEF
-            # destroys the browser immediately when DoClose returns False,
-            # without sending delete_event to any parent GTK window.
-            winfo = cef.WindowInfo()
-            winfo.SetAsOffscreen(0)
-            window_info_out.append(winfo)
-        return False  # Allow the popup
-
     def OnLoadStart(self, browser, frame, **_):
         self.test_case.assertFalse(self.OnLoadStart_True)
         self.OnLoadStart_True = True

unittests/main_test.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2016 CEF Python, see the Authors file.
+# Copyright (c) 2016 CEF Python, see the Authors file.
 # All rights reserved. Licensed under BSD 3-clause license.
 # Project website: https://github.com/cztomczak/cefpython
 
@@ -141,68 +141,11 @@ def test_main(self):
         if "--debug-warning" in sys.argv:
             settings["debug"] = True
             settings["log_severity"] = cef.LOGSEVERITY_WARNING
-        # Chrome 130+ blocks window.open() called without a user gesture.
+        # The popup sub-test opens a window via window.open() during page
+        # load, i.e. without a user gesture, which Chrome blocks by default.
+        # This is a functional requirement of the test itself (not a CI
+        # workaround), so it applies on every platform.
         switches = {"disable-popup-blocking": ""}
-        if LINUX:
-            # Open a GDK/X11 display connection before CEF initialises so
-            # that gdk_display_get_default() returns a valid display.  On a
-            # desktop session this is required for the browser window to be
-            # visible; on xvfb (CI) it is a no-op.
-            init_gtk()
-            # cefpython does not ship a chrome-sandbox (setuid) binary.
-            # Disable SUID/namespace sandboxes; Chrome falls back to seccomp-BPF
-            # which keeps GlobalDescriptors key 7 registered for subprocesses.
-            # Do NOT pass --no-sandbox: it skips key 7 registration but encodes
-            # it in --pseudonymization-salt-handle, causing a CHECK-crash.
-            switches["disable-setuid-sandbox"] = ""
-                    # /dev/shm is too small in CI containers.
-            switches["disable-dev-shm-usage"] = ""
-            # GPU acceleration is not available under xvfb.
-            switches["disable-gpu"] = ""
-            switches["disable-gpu-compositing"] = ""
-            # Run GPU process inside the browser process so it is not
-            # spawned during CefInitialize() where it would fail.
-            switches["in-process-gpu"] = ""
-            switches["no-zygote"] = ""
-            # Force X11 rendering via XWayland.  On Ubuntu 24 GNOME/Wayland
-            # Chrome 130+ defaults to the Wayland Ozone backend when
-            # WAYLAND_DISPLAY is set; cefpython uses raw X11 APIs so the
-            # window would never appear.  On CI (xvfb) this is a no-op.
-            switches["ozone-platform"] = "x11"
-            # Run the network service in-process so no utility subprocess
-            # needs to be spawned (reduces spawn overhead on CI).
-            # The feature string in Chrome 130+ is "NetworkServiceInProcess2".
-            switches["enable-features"] = "NetworkServiceInProcess2"
-            # Suppress the GNOME Keyring unlock prompt on desktop sessions.
-            switches["password-store"] = "basic"
-        if MAC:
-            # cefpython does not ship a chrome-sandbox binary.
-            switches["no-sandbox"] = ""
-            # No real GPU available on macOS CI runners.
-            switches["disable-gpu"] = ""
-            switches["disable-gpu-compositing"] = ""
-            switches["in-process-gpu"] = ""
-            # Prevent macOS keychain authorization prompts during init
-            # (matches CEF's own test infrastructure on macOS).
-            switches["use-mock-keychain"] = ""
-            # Chrome 130+ MachPortRendezvousServer registers via
-            # bootstrap_check_in; renderer subprocesses look up the service
-            # via bootstrap_look_up, which fails on unsigned CI processes
-            # because Chrome gives them a restricted bootstrap namespace.
-            # --in-process-renderer was removed from Chrome 130+.
-            # --single-process runs the renderer in the browser process,
-            # eliminating renderer subprocess bootstrap_look_up failures.
-            switches["single-process"] = ""
-            # --single-process puts the renderer's V8 in the browser process,
-            # which requires a large contiguous CodeRange for JIT code.
-            # On constrained CI runner images this reservation fails with an
-            # OOM error.  --jitless disables all V8 JIT compilers, eliminating
-            # the CodeRange requirement entirely.
-            switches["js-flags"] = "--jitless"
-            # Run network service in-process to avoid Mach port rendezvous
-            # failures for utility subprocesses on macOS CI runners.
-            # The feature string in Chrome 130+ is "NetworkServiceInProcess2".
-            switches["enable-features"] = "NetworkServiceInProcess2"
         cef.Initialize(settings, switches=switches)
         subtest_message("cef.Initialize() ok")
 

unittests/osr_test.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018 CEF Python, see the Authors file.
+# Copyright (c) 2018 CEF Python, see the Authors file.
 # All rights reserved. Licensed under BSD 3-clause license.
 # Project website: https://github.com/cztomczak/cefpython
 
@@ -18,7 +18,11 @@
 <html>
 <head>
     <style type="text/css">
-    body,html {
+    html, body {
+        height: 100%;
+        margin: 0;
+    }
+    body {
         font-family: Arial;
         font-size: 11pt;
     }
@@ -115,49 +119,6 @@ def test_osr(self):
             # switches (which disable it) must not be passed there.
             switches["enable-begin-frame-scheduling"] = ""
             switches["disable-surfaces"] = ""  # Required for PDF ext to work
-        if LINUX:
-            # Open a GDK/X11 display connection before CEF initialises.
-            init_gtk()
-            # cefpython does not ship a chrome-sandbox (setuid) binary.
-            # Disable SUID/namespace sandboxes; Chrome falls back to seccomp-BPF
-            # which keeps GlobalDescriptors key 7 registered for subprocesses.
-            # Do NOT pass --no-sandbox: it skips key 7 registration but encodes
-            # it in --pseudonymization-salt-handle, causing a CHECK-crash.
-            switches["disable-setuid-sandbox"] = ""
-                    # /dev/shm is too small in CI containers.
-            switches["disable-dev-shm-usage"] = ""
-            # Run GPU process inside the browser process so it is not
-            # spawned during CefInitialize() where it would fail.
-            switches["in-process-gpu"] = ""
-            switches["no-zygote"] = ""
-            # Force X11 rendering via XWayland (see main_test.py for details).
-            switches["ozone-platform"] = "x11"
-            # Run the network service in-process so no utility subprocess
-            # needs to be spawned (reduces spawn overhead on CI).
-            # The feature string in Chrome 130+ is "NetworkServiceInProcess2".
-            switches["enable-features"] = "NetworkServiceInProcess2"
-        if MAC:
-            # Prevent macOS keychain authorization prompts during init.
-            # CEF's own test infrastructure (client_app_browser.cc) does
-            # the same on macOS.
-            switches["use-mock-keychain"] = ""
-            # Chrome 130+ MachPortRendezvousServer registers its bootstrap
-            # service as BaseBundleID()+".MachPortRendezvousServer."+pid.
-            # Python processes with only ad-hoc code signing receive a
-            # restricted bootstrap namespace from macOS, so renderer
-            # subprocesses cannot bootstrap_look_up the service.
-            # --single-process runs the renderer inside the browser process,
-            # eliminating the subprocess bootstrap_look_up entirely.
-            # (--in-process-renderer was removed in Chrome 130+.)
-            switches["single-process"] = ""
-            # --single-process puts the renderer's V8 in the browser process,
-            # which requires a large contiguous CodeRange for JIT code.
-            # --jitless disables V8 JIT, removing that requirement.
-            switches["js-flags"] = "--jitless"
-            # Run the network service in-process to avoid Mach port rendezvous
-            # failures for the network utility subprocess on macOS.
-            # (Feature name in Chrome 130+: "NetworkServiceInProcess2".)
-            switches["enable-features"] = "NetworkServiceInProcess2"
         browser_settings = {
             # Tweaking OSR performance (Issue #240)
             "windowless_frame_rate": 30,  # Default frame rate in CEF is 30
@@ -208,8 +169,20 @@ def test_osr(self):
         browser.SetFocus(True)
         browser.WasResized()
 
-        # Message loop
-        run_message_loop()
+        # Trigger the text-selection sub-test once the page has fully
+        # loaded (registered here, executed from LoadHandler.OnLoadEnd).
+        on_load_end(_select_h1_after_load, browser)
+
+        # Message loop.
+        # The test is event-driven: RenderHandler.OnTextSelectionChanged
+        # calls QuitMessageLoop() as soon as the <h1> selection is reported,
+        # so the loop ends exactly when the work is done rather than after a
+        # fixed delay (which raced the selection round-trip and made this
+        # test flaky on CI). The watchdog task quits the loop if that event
+        # never arrives, turning a would-be hang into a clean assert failure.
+        cef.PostDelayedTask(cef.TID_UI, 15000, cef.QuitMessageLoop)
+        cef.MessageLoop()
+        subtest_message("cef.MessageLoop() ok")
 
         # Close browser and clean reference
         browser.CloseBrowser(True)
@@ -265,8 +238,18 @@ def _OnAccessibilityLocationChange(self, **_):
         pass
 
 
+def _select_h1_after_load(browser):
+    """Register the selection click after the page has finished loading.
+
+    Runs from LoadHandler.OnLoadEnd, i.e. the document (and its onclick
+    handler) is ready. The click itself is posted with a small delay so
+    layout has been flushed to the compositor and hit-testing is reliable.
+    """
+    cef.PostDelayedTask(cef.TID_UI, 250, _click_h1_to_select, browser)
+
+
 def _click_h1_to_select(browser):
-    """Send a real click anywhere in the viewport after layout is complete.
+    """Send a real click at the center of the viewport.
 
     Chrome 130+ requires the Selection API to run inside a real user-gesture
     event handler for OnTextSelectionChanged to fire. The body has an onclick
@@ -293,6 +276,10 @@ def __init__(self, test_case):
         self.GetViewRect_True = False
         self.OnPaint_True = False
         self.OnTextSelectionChanged_True = False
+        # Set once the non-empty <h1> selection has been reported. Used as
+        # the message-loop termination condition so the test does not rely
+        # on a fixed-duration loop (which was the source of CI flakiness).
+        self.OnTextSelectionChanged_h1_True = False
 
     def GetViewRect(self, rect_out, **_):
         """Called to retrieve the view rectangle which is relative
@@ -311,10 +298,6 @@ def OnPaint(self, browser, element_type, paint_buffer, **_):
             if not self.OnPaint_True:
                 self.OnPaint_True = True
                 subtest_message("RenderHandler.OnPaint: viewport ok")
-                # Layout is now complete. Post the click so it isn't
-                # re-entrant with OnPaint and hit-testing is reliable.
-                cef.PostDelayedTask(cef.TID_UI, 100, _click_h1_to_select,
-                                    browser)
         else:
             raise Exception("Unsupported element_type in OnPaint")
 
@@ -324,6 +307,11 @@ def OnTextSelectionChanged(self, selected_text, selected_range, **_):
             # Verify the h1 text is selected when a non-empty selection fires.
             self.test_case.assertEqual(selected_text,
                                        "Off-screen rendering test")
+            self.OnTextSelectionChanged_h1_True = True
+            # Selection round-trip complete — stop the message loop. Safe to
+            # call from this callback (unlike closing the browser, which must
+            # be deferred out of OnPaint/OnLoadingStateChange).
+            cef.QuitMessageLoop()
 
 
 if __name__ == "__main__":