[bug][cef][linux] Keyboard input fails at startup or after switching back to the app #16251

fn main() {
    tauri_build::build();
}

use cef::{ImplBrowser, ImplBrowserHost};
use tauri_runtime_cef::{Cef, CefRuntime, RemoteDebugging};
mod native_focus;

#[tauri_runtime_cef::cef_entry_point]
fn main() {
    let manual_window = std::env::var_os("CEF_REPRO_MANUAL_WINDOW").is_some();
    let forward_focus = std::env::var_os("CEF_REPRO_FORWARD_FOCUS").is_some();
    let native_focus = std::env::var_os("CEF_REPRO_NATIVE_FOCUS").is_some();
    let cef = Cef::default().remote_debugging(RemoteDebugging::Port {
        port: 4001,
        allowed_origins: Vec::new(),
    });
    #[cfg(target_os = "linux")]
    let cef = if std::env::var_os("CEF_REPRO_VULKAN").is_some() {
        cef.enable_features(["Vulkan", "VulkanFromANGLE"])
            .command_line_args([
                ("--enable-unsafe-webgpu", None),
                ("use-angle", Some("vulkan")),
                ("--ozone-platform", Some("x11")),
            ])
    } else {
        cef
    };

    tauri::Builder::<CefRuntime>::new()
        .runtime(cef)
        .on_window_event(move |window, event| {
            if forward_focus {
                if let tauri::WindowEvent::Focused(focused) = event {
                    let focused = *focused;
                    for webview in window.webviews() {
                        let _ = webview.with_webview(move |platform| {
                            if let Some(host) = platform.browser().host() {
                                host.set_focus(i32::from(focused));
                                if native_focus && focused {
                                    native_focus::focus_browser(host.window_handle() as _);
                                }
                            }
                        });
                    }
                }
            }
        })
        .setup(move |app| {
            if manual_window {
                let config = app
                    .config()
                    .app
                    .windows
                    .iter()
                    .find(|window| window.label == "main")
                    .expect("the main window config is required");
                let window = tauri::WebviewWindowBuilder::from_config(app, config)?.build()?;
                if std::env::var_os("CEF_REPRO_MAXIMIZE_BEFORE_SHOW").is_some() {
                    window.maximize()?;
                }
                window.show()?;
                if std::env::var_os("CEF_REPRO_SKIP_WINDOW_FOCUS").is_none() {
                    window.set_focus()?;
                }
            }
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("failed to run the CEF keyboard reproduction");
}

use std::mem::MaybeUninit;
use x11_dl::xlib;

// This experiment runs only inside with_webview's CEF UI-thread callback.
pub fn focus_browser(window: std::os::raw::c_ulong) {
    if window == 0 {
        return;
    }
    let Ok(x) = xlib::Xlib::open() else {
        return;
    };
    unsafe {
        // CEF owns this display; keep the borrow inside its UI-thread callback.
        let display = cef::get_xdisplay().cast::<xlib::Display>();
        if display.is_null() {
            return;
        }
        let mut attributes = MaybeUninit::<xlib::XWindowAttributes>::uninit();
        if (x.XGetWindowAttributes)(display, window, attributes.as_mut_ptr()) != 0
            && attributes.assume_init().map_state == xlib::IsViewable
        {
            (x.XSetInputFocus)(display, window, xlib::RevertToParent, xlib::CurrentTime);
            (x.XFlush)(display);
        }
    }
}