Merge branch 146-linux into 146-macos

Bring in the Linux fixes (accessibility location-change grace period,
Ozone/X11 switches, GLib init, sandbox flags) while keeping all macOS-
specific changes (Mach port rendezvous workarounds, use-mock-keychain,
single-process, rpath fix, ARM build fixes).

Conflict resolutions:
- src/cefpython.pyx: use IF UNAME_SYSNAME != "Linux" guard so the
  post-Initialize() message-loop pump is skipped on Linux (where
  gtk_main() drives it) but still runs on macOS/Windows.
- unittests/main_test.py, osr_test.py: keep both the Linux-specific
  switches added by 146-linux (ozone-platform, no-zygote, disable/
  enable-features, password-store) and the macOS if MAC: block from
  146-macos; they guard separate platforms and do not overlap.

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

Author: linesight

.github/workflows/ci-linux.yml

@@ -126,6 +126,9 @@ jobs:
           cp -r build/artifacts/. cefpython3/
           chmod +x cefpython3/subprocess
 
+      - name: Resize /dev/shm for Chromium shared memory
+        run: sudo mount -o remount,size=512m /dev/shm
+
       - name: Run unit tests
         run: xvfb-run python unittests/_test_runner.py
         env:

.github/workflows/ci-windows.yml

@@ -2,7 +2,7 @@ name: CI Windows
 
 on:
   push:
-    branches: [ "github-actions-ci", "master", "146-linux" ]
+    branches: [ "github-actions-ci", "master" ]
   pull_request:
     branches: [ "master" ]
   workflow_dispatch:

cefpython3/__init__.py

@@ -20,6 +20,10 @@
 os.environ["CEFPYTHON3_PATH"] = package_dir
 
 if platform.system() == "Linux":
+    # Force GDK to use X11/XWayland backend before libcef.so loads and
+    # initialises GDK.  Without this, GDK picks the Wayland backend on
+    # GNOME/Wayland sessions, making gdk_x11_window_get_xid() return 0.
+    os.environ.setdefault("GDK_BACKEND", "x11")
     _ld = os.environ.get("LD_LIBRARY_PATH", "")
     os.environ["LD_LIBRARY_PATH"] = (
         package_dir + os.pathsep + _ld if _ld else package_dir

examples/hello_world.py

@@ -8,16 +8,18 @@
 # Setting DPI awareness programmatically via a call to cef.DpiAware.EnableHighDpiSupport
 # is problematic in Python, may not work and can cause display glitches.
 
+import sys
+
 from cefpython3 import cefpython as cef
 import platform
-import sys
 from packaging.version import Version as parse_version
 
 
 def main():
     check_versions()
-    sys.excepthook = cef.ExceptHook  # To shutdown all CEF processes on error
-    cef.Initialize()
+    sys.excepthook = cef.ExceptHook  # shut down all CEF processes on error
+    settings = {}
+    cef.Initialize(settings=settings)
     cef.CreateBrowserSync(url="https://www.google.com/",
                           window_title="Hello World!")
     cef.MessageLoop()
@@ -32,7 +34,8 @@ def check_versions():
     print("[hello_world.py] Python {ver} {arch}".format(
            ver=platform.python_version(),
            arch=platform.architecture()[0]))
-    assert parse_version(cef.__version__) >= parse_version("57.0"), "CEF Python v57.0+ required to run this"
+    assert parse_version(cef.__version__) >= parse_version("57.0"), \
+        "CEF Python v57.0+ required to run this"
 
 
 if __name__ == '__main__':

src/cefpython.pyx

@@ -307,6 +307,11 @@ cdef py_bool g_cef_initialized = False
 cdef py_bool g_context_initialized = False
 cdef list g_pending_browsers = []
 
+IF UNAME_SYSNAME == "Linux":
+    # Keeps ctypes callback objects alive for the duration of gtk_main() and
+    # any pending one-shot GLib timers (Xwayland XReparentWindow scheduling).
+    g_linux_reparent_callbacks = []
+
 cdef dict g_globalClientCallbacks = {}
 
 # -----------------------------------------------------------------------------
@@ -571,14 +576,47 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
         if "use-angle" not in g_commandLineSwitches:
             g_commandLineSwitches["use-angle"] = "gl"
 
+    IF UNAME_SYSNAME == "Linux":
+        # Initialize GTK so GDK has a display connection before CefInitialize.
+        _linux_gtk_init()
+        # Auto-apply switches/settings required for CEF 146 on Linux/Xwayland.
+        # Uses setdefault so user-supplied values are never overwritten.
+        _linux_apply_initialize_defaults(application_settings,
+                                         g_commandLineSwitches)
+        # Pre-seed Chrome profile files to prevent the profile-picker keepalive
+        # from blocking OnContextInitialized (Chrome 146).
+        if application_settings.get("cache_path"):
+            _linux_setup_profile(application_settings["cache_path"])
+
     cdef CefRefPtr[CefApp] cefApp = <CefRefPtr[CefApp]?>new CefPythonApp()
 
     IF UNAME_SYSNAME == "Windows":
         cdef HINSTANCE hInstance = GetModuleHandle(NULL)
         cdef CefMainArgs cefMainArgs = CefMainArgs(hInstance)
     ELIF UNAME_SYSNAME == "Linux":
-        # TODO: use the CefMainArgs(int argc, char** argv) constructor.
-        cdef CefMainArgs cefMainArgs
+        # Build a complete argv so the browser process sees all switches.
+        # OnBeforeChildProcessLaunch only reaches child processes; switches
+        # like --in-process-gpu and --single-process must be in the browser
+        # process's own command line to take effect.
+        _cefMainArgvPyList = [sys.executable.encode('utf-8')]
+        for _cefArgK, _cefArgV in g_commandLineSwitches.items():
+            if _cefArgV:
+                _cefMainArgvPyList.append(
+                    ("--{}={}".format(_cefArgK, _cefArgV)).encode('utf-8'))
+            else:
+                _cefMainArgvPyList.append(
+                    ("--{}".format(_cefArgK)).encode('utf-8'))
+        cdef int _cefMainArgc = len(_cefMainArgvPyList)
+        cdef char** _cefMainArgvC = \
+                <char**>malloc(_cefMainArgc * sizeof(char*))
+        cdef bytes _cefMainArgvItem
+        cdef int _cefMainArgvI
+        for _cefMainArgvI in range(_cefMainArgc):
+            _cefMainArgvItem = _cefMainArgvPyList[_cefMainArgvI]
+            _cefMainArgvC[_cefMainArgvI] = _cefMainArgvItem
+        cdef CefMainArgs cefMainArgs = CefMainArgs(_cefMainArgc, _cefMainArgvC)
+        # _cefMainArgvPyList keeps the bytes alive; freed below after
+        # CefInitialize() has processed the command line.
     ELIF UNAME_SYSNAME == "Darwin":
         # TODO: use the CefMainArgs(int argc, char** argv) constructor.
         cdef CefMainArgs cefMainArgs
@@ -594,8 +632,19 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
         g_applicationSettings[key] = copy.deepcopy(application_settings[key])
 
     cdef CefSettings cefApplicationSettings
-    # No sandboxing for the subprocesses
-    cefApplicationSettings.no_sandbox = 1
+    IF UNAME_SYSNAME == "Linux":
+        # On Linux, leave no_sandbox=0 so Chrome's startup code registers the
+        # Mojo IPC bootstrap fd (GlobalDescriptors key 7) for every subprocess.
+        # Setting no_sandbox=1 would cause BasicStartupComplete() to append
+        # --no-sandbox before fd registration, causing all subprocesses to crash
+        # with "Failed global descriptor lookup: 7". Sandbox behaviour is instead
+        # controlled via --disable-setuid-sandbox / --disable-namespace-sandbox
+        # command-line switches passed by the caller.
+        pass
+    ELSE:
+        # On Windows/macOS the sandbox helper binary is not shipped with
+        # cefpython, so disable sandboxing entirely.
+        cefApplicationSettings.no_sandbox = 1
     SetApplicationSettings(application_settings, &cefApplicationSettings)
 
     # External message pump
@@ -611,6 +660,8 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
     cdef cpp_bool ret
     with nogil:
         ret = CefInitialize(cefMainArgs, cefApplicationSettings, cefApp, NULL)
+    IF UNAME_SYSNAME == "Linux":
+        free(_cefMainArgvC)
 
     global g_cef_initialized
     g_cef_initialized = True
@@ -622,15 +673,22 @@ def Initialize(applicationSettings=None, commandLineSwitches=None, **kwargs):
     # guarantees that CreateBrowserSync() can be called immediately after
     # Initialize() without hitting the deferred-creation path or getting
     # a null browser from CefBrowserHost::CreateBrowserSync().
-    # OnContextInitialized typically fires within the first few iterations;
-    # allow up to 30 seconds for slow CI environments.
+    # Use a generous ceiling (30s) for CI environments where utility
+    # subprocesses (storage service) crash and delay context initialization.
     if ret:
-        for _ in range(3000):
-            with nogil:
-                CefDoMessageLoopWork()
-            if g_context_initialized:
-                break
-            time.sleep(0.01)
+        # On Linux, skip this pump entirely: the Ozone X11 backend needs
+        # gtk_main() (a blocking GLib main loop) running before
+        # OnContextInitialized can fire.  The external caller (hello_world.py,
+        # test harnesses) must enter gtk_main() immediately after Initialize()
+        # and drive the loop via the GLib timer callback.
+        # On Windows/macOS, pump up to 30 s as before.
+        IF UNAME_SYSNAME != "Linux":
+            for _ in range(3000):
+                with nogil:
+                    CefDoMessageLoopWork()
+                if g_context_initialized:
+                    break
+                time.sleep(0.01)
         if not g_context_initialized:
             Debug("CefInitialize() WARNING: OnContextInitialized not received"
                   " within 30 seconds")
@@ -671,8 +729,18 @@ def CreateBrowserSync(windowInfo=None,
     # Defer browser creation until OnContextInitialized fires inside MessageLoop.
     # In CEF 123+, browser creation before OnContextInitialized causes
     # blink.mojom.WidgetHost rejection and renderer shows no content.
-    # Initialize() pumps the loop until OnContextInitialized fires, so this
-    # path is only taken if CreateBrowserSync() is called before Initialize().
+    # Initialize() pumps the loop for up to 30s; if still not initialized
+    # (e.g. slow CI), pump an additional 30s before giving up.
+    if not g_context_initialized:
+        Debug("CreateBrowserSync(): OnContextInitialized not yet received,"
+              " pumping message loop")
+        IF UNAME_SYSNAME != "Linux":
+            for _ in range(3000):
+                with nogil:
+                    CefDoMessageLoopWork()
+                if g_context_initialized:
+                    break
+                time.sleep(0.01)
     if not g_context_initialized:
         Debug("CreateBrowserSync() deferred until OnContextInitialized")
         g_pending_browsers.append({
@@ -730,6 +798,18 @@ def CreateBrowserSync(windowInfo=None,
     elif not isinstance(windowInfo, WindowInfo):
         raise Exception("CreateBrowserSync() failed: windowInfo: invalid object")
 
+    # On Linux, when no parent window is given, auto-create a GTK toplevel
+    # so callers need no GTK-specific code (same API as Windows/Mac).
+    _linux_toplevel_state = None
+    IF UNAME_SYSNAME == "Linux":
+        if windowInfo.windowType == "child" and windowInfo.parentWindowHandle == 0:
+            _linux_toplevel_state = _linux_create_toplevel(
+                    window_title or "CEF Browser")
+            windowInfo.SetAsChild(
+                    _linux_toplevel_state['xid'],
+                    [0, 0, _linux_toplevel_state['width'],
+                           _linux_toplevel_state['height']])
+
     if window_title and windowInfo.parentWindowHandle == 0:
         windowInfo.windowName = window_title
 
@@ -828,6 +908,12 @@ def CreateBrowserSync(windowInfo=None,
             MacSetWindowTitle(cefBrowser,
                               PyStringToChar(windowInfo.windowName))
 
+    IF UNAME_SYSNAME == "Linux":
+        if windowInfo._linux_embed_info:
+            _linux_schedule_xembed(pyBrowser, windowInfo._linux_embed_info)
+        if _linux_toplevel_state is not None:
+            _linux_register_window_callbacks(pyBrowser, _linux_toplevel_state)
+
     return pyBrowser
 
 def MessageLoop():
@@ -837,8 +923,11 @@ def MessageLoop():
         global g_MessageLoop_called
         g_MessageLoop_called = True
 
-    with nogil:
-        CefRunMessageLoop()
+    IF UNAME_SYSNAME == "Linux":
+        _linux_message_loop()
+    ELSE:
+        with nogil:
+            CefRunMessageLoop()
 
 def MessageLoopWork():
     # Perform a single iteration of CEF message loop processing.
@@ -864,6 +953,9 @@ def SingleMessageLoop():
 
 def QuitMessageLoop():
     Debug("QuitMessageLoop()")
+    IF UNAME_SYSNAME == "Linux":
+        import ctypes as _ct
+        _ct.CDLL("libgtk-3.so.0").gtk_main_quit()
     with nogil:
         CefQuitMessageLoop()
 

src/client_handler/x11.cpp

@@ -36,6 +36,7 @@ void SetX11WindowBounds(CefRefPtr<CefBrowser> browser,
                         int x, int y, int width, int height) {
     ::Window xwindow = browser->GetHost()->GetWindowHandle();
     ::Display* xdisplay = cef_get_xdisplay();
+    if (!xdisplay || !xwindow) return;
     XWindowChanges changes = {0};
     changes.x = x;
     changes.y = y;
@@ -48,12 +49,21 @@ void SetX11WindowBounds(CefRefPtr<CefBrowser> browser,
 void SetX11WindowTitle(CefRefPtr<CefBrowser> browser, char* title) {
     ::Window xwindow = browser->GetHost()->GetWindowHandle();
     ::Display* xdisplay = cef_get_xdisplay();
+    if (!xdisplay || !xwindow) return;
     XStoreName(xdisplay, xwindow, title);
 }
 
 GtkWindow* CefBrowser_GetGtkWindow(CefRefPtr<CefBrowser> browser) {
   // TODO: Should return NULL when using the Views framework
   // -- REWRITTEN FOR CEF PYTHON USE CASE --
+  //
+  // WARNING (CEF 146 Ozone X11): gtk_plug_new_for_display() below sends an
+  // XEMBED_EMBEDDED_NOTIFY to the browser's X11 window, which causes GTK to
+  // call XReparentWindow and move the browser window into a new GtkSocket.
+  // This breaks embedded-window positioning.  Only call this function when
+  // showing a transient dialog (file chooser, print dialog) where the browser
+  // window displacement is acceptable or the dialog is temporary.
+  //
   // X11 window handle
   ::Window xwindow = browser->GetHost()->GetWindowHandle();
   // X11 display
@@ -99,7 +109,7 @@ GtkWindow* CefBrowser_GetGtkWindow(CefRefPtr<CefBrowser> browser) {
 XImage* CefBrowser_GetImage(CefRefPtr<CefBrowser> browser) {
     ::Display* display = cef_get_xdisplay();
     if (!display) {
-        LOG(ERROR) << "XOpenDisplay failed in CefBrowser_GetImage";
+        LOG(ERROR) << "cef_get_xdisplay() returned NULL in CefBrowser_GetImage";
         return NULL;
     }
     ::Window browser_window = browser->GetHost()->GetWindowHandle();

src/extern/cef/cef_browser_static.pxd

@@ -4,6 +4,7 @@
 
 include "platform_cimports.pxi"
 
+from libcpp cimport bool as cpp_bool
 from cef_ptr cimport CefRefPtr
 # noinspection PyUnresolvedReferences
 from cef_client cimport CefClient
@@ -18,6 +19,14 @@ from cef_string cimport CefString
 # Specifying namespace allows to import a static method.
 cdef extern from "include/cef_browser.h" namespace "CefBrowserHost":
 
+    cdef cpp_bool CreateBrowser(
+        CefWindowInfo&,
+        CefRefPtr[CefClient],
+        CefString&,
+        CefBrowserSettings&,
+        CefRefPtr[CefDictionaryValue],
+        CefRefPtr[CefRequestContext]) nogil
+
     cdef CefRefPtr[CefBrowser] CreateBrowserSync(
         CefWindowInfo&,
         CefRefPtr[CefClient],

src/extern/cef/cef_command_line.pxd

@@ -9,6 +9,8 @@ include "compile_time_constants.pxi"
 
 from cef_string cimport CefString
 from libcpp cimport bool as cpp_bool
+from libcpp.vector cimport vector as cpp_vector
+from libcpp.map cimport map as cpp_map
 
 cdef extern from "include/cef_command_line.h":
     cdef cppclass CefCommandLine:
@@ -17,3 +19,9 @@ cdef extern from "include/cef_command_line.h":
         CefString GetCommandLineString()
         cpp_bool HasSwitch(const CefString& name)
         CefString GetSwitchValue(const CefString& name)
+        void Reset()
+        CefString GetProgram()
+        void SetProgram(const CefString& program)
+        void GetSwitches(cpp_map[CefString, CefString]& switches)
+        void GetArguments(cpp_vector[CefString]& arguments)
+        void AppendArgument(const CefString& argument)

src/extern/linux.pxd

@@ -6,6 +6,8 @@ cdef extern from "gtk/gtk.h" nogil:
     ctypedef void* GtkWidget
     cdef GtkWidget* gtk_plug_new(unsigned long socket_id)
     cdef void gtk_widget_show(GtkWidget* widget)
+    ctypedef void* GMainContext
+    int g_main_context_iteration(GMainContext* context, int may_block)
 
     ctypedef char* XPointer
     ctypedef struct XImage: