//! What CEF calls back: per process, and per browser. use std::{ collections::HashMap, sync::{Arc, Mutex, OnceLock}, }; use cef::{ wrapper::message_router::{ BrowserSideCallback, BrowserSideHandler, BrowserSideRouter, MessageRouterBrowserSide, MessageRouterBrowserSideHandlerCallbacks, MessageRouterConfig, MessageRouterRendererSide, MessageRouterRendererSideHandlerCallbacks, RendererSideRouter, }, *, }; use crate::{fence::Requests, surface::Shared}; /// The page calls `window.elyQuery({request, onSuccess, onFailure})`. fn config() -> MessageRouterConfig { MessageRouterConfig { js_query_function: "elyQuery".into(), js_cancel_function: "elyQueryCancel".into(), ..Default::default() } } /// Each browser's surface, by CEF's browser id. fn surfaces() -> &'static Mutex> { static SURFACES: OnceLock>> = OnceLock::new(); SURFACES.get_or_init(Default::default) } pub(crate) fn adopt(browser: &Browser, surface: Shared) { surfaces() .lock() .expect("the surface lock") .insert(browser.identifier(), surface); } fn surface_of(browser: Option<&Browser>) -> Option { let id = browser?.identifier(); surfaces() .lock() .expect("the surface lock") .get(&id) .cloned() } /// Queries go to the view whose page asked. struct Queries; impl BrowserSideHandler for Queries { fn on_query_str( &self, browser: Option, _frame: Option, _query_id: i64, request: &str, _persistent: bool, callback: Arc>, ) -> bool { let Some(surface) = surface_of(browser.as_ref()) else { return false; }; surface .lock() .expect("the surface lock") .queries .push((request.to_string(), callback)); true } } pub(crate) fn router() -> &'static Arc { static ROUTER: OnceLock> = OnceLock::new(); ROUTER.get_or_init(|| { let router = BrowserSideRouter::new(config()); router.add_handler(Arc::new(Queries), true); router }) } fn renderer_router() -> &'static Arc { static ROUTER: OnceLock> = OnceLock::new(); ROUTER.get_or_init(|| RendererSideRouter::new(config())) } /// WebRTC reaches the network by UDP; pages lose it. const NO_PEERS: &str = "for (const name of ['RTCPeerConnection', 'webkitRTCPeerConnection', \ 'RTCDataChannel', 'RTCSessionDescription', 'RTCIceCandidate', 'RTCRtpSender', \ 'RTCRtpReceiver', 'RTCRtpTransceiver']) delete globalThis[name];"; wrap_app! { struct ElyApp; impl App { fn on_before_command_line_processing( &self, _process_type: Option<&CefString>, command_line: Option<&mut CommandLine>, ) { let Some(line) = command_line else { return }; // No keychain prompt; the content keeps no secrets. line.append_switch(Some(&"use-mock-keychain".into())); line.append_switch(Some(&"disable-extensions".into())); // Offline pages: all traffic meets a dead proxy. line.append_switch_with_value(Some(&"proxy-server".into()), Some(&"127.0.0.1:9".into())); line.append_switch_with_value( Some(&"proxy-bypass-list".into()), Some(&"<-loopback>".into()), ); // WebRTC sends UDP past proxies; it may use proxies only. line.append_switch_with_value( Some(&"force-webrtc-ip-handling-policy".into()), Some(&"disable_non_proxied_udp".into()), ); } fn browser_process_handler(&self) -> Option { Some(Pump::new()) } fn render_process_handler(&self) -> Option { Some(Renderer::new()) } } } pub(crate) fn app() -> cef::App { ElyApp::new() } wrap_browser_process_handler! { struct Pump; impl BrowserProcessHandler { fn on_schedule_message_pump_work(&self, delay_ms: i64) { crate::engine::schedule(delay_ms); } } } wrap_render_process_handler! { struct Renderer; impl RenderProcessHandler { fn on_context_created( &self, browser: Option<&mut Browser>, frame: Option<&mut Frame>, context: Option<&mut V8Context>, ) { // Before any page script: no peer connections at all. if let Some(context) = context.as_ref() { let code = CefString::from(NO_PEERS); let (mut value, mut thrown) = (None, None); if context.eval(Some(&code), None, 0, Some(&mut value), Some(&mut thrown)) != 1 { eprintln!("web: WebRTC could not be removed from a page"); } } renderer_router().on_context_created( browser.map(|b| b.clone()), frame.map(|f| f.clone()), context.map(|c| c.clone()), ); } fn on_context_released( &self, browser: Option<&mut Browser>, frame: Option<&mut Frame>, context: Option<&mut V8Context>, ) { renderer_router().on_context_released( browser.map(|b| b.clone()), frame.map(|f| f.clone()), context.map(|c| c.clone()), ); } fn on_process_message_received( &self, browser: Option<&mut Browser>, frame: Option<&mut Frame>, source_process: ProcessId, message: Option<&mut ProcessMessage>, ) -> ::std::os::raw::c_int { renderer_router().on_process_message_received( browser.map(|b| b.clone()), frame.map(|f| f.clone()), Some(source_process), message.map(|m| m.clone()), ) as _ } } } wrap_render_handler! { struct Paint { surface: Shared, } impl RenderHandler { fn view_rect(&self, _browser: Option<&mut Browser>, rect: Option<&mut Rect>) { let Some(rect) = rect else { return }; let surface = self.surface.lock().expect("the surface lock"); // CEF needs a page at least one point square. rect.width = (surface.size.0.round() as i32).max(1); rect.height = (surface.size.1.round() as i32).max(1); } fn screen_info( &self, _browser: Option<&mut Browser>, screen_info: Option<&mut ScreenInfo>, ) -> ::std::os::raw::c_int { let Some(info) = screen_info else { return 0 }; info.device_scale_factor = self.surface.lock().expect("the surface lock").scale; 1 } fn on_paint( &self, _browser: Option<&mut Browser>, type_: PaintElementType, _dirty_rects: Option<&[Rect]>, buffer: *const u8, width: ::std::os::raw::c_int, height: ::std::os::raw::c_int, ) { // Popups (select menus) are not drawn; pages avoid them. if type_ != PaintElementType::VIEW || buffer.is_null() || width <= 0 || height <= 0 { return; } let length = width as usize * height as usize * 4; let bgra = unsafe { std::slice::from_raw_parts(buffer, length) }.to_vec(); self.surface.lock().expect("the surface lock").frame = Some((width as u32, height as u32, bgra)); } fn on_ime_composition_range_changed( &self, _browser: Option<&mut Browser>, _selected_range: Option<&Range>, character_bounds: Option<&[Rect]>, ) { let bounds = character_bounds.unwrap_or_default(); self.surface.lock().expect("the surface lock").ime = bounds .iter() .map(|r| (r.x as f32, r.y as f32, r.width as f32, r.height as f32)) .collect(); } } } wrap_display_handler! { struct Display { surface: Shared, } impl DisplayHandler { fn on_console_message( &self, _browser: Option<&mut Browser>, level: LogSeverity, message: Option<&CefString>, source: Option<&CefString>, line: ::std::os::raw::c_int, ) -> ::std::os::raw::c_int { // A page's warnings and errors, never its other chatter. if level.get_raw() >= LogSeverity::WARNING.get_raw() { let said = message.map(CefString::to_string).unwrap_or_default(); let at = source.map(CefString::to_string).unwrap_or_default(); log::warn!("web: page says {said} at {at}:{line}"); } 0 } fn on_cursor_change( &self, _browser: Option<&mut Browser>, _cursor: *mut u8, type_: CursorType, _custom_cursor_info: Option<&CursorInfo>, ) -> ::std::os::raw::c_int { self.surface.lock().expect("the surface lock").cursor = type_; 1 } } } wrap_load_handler! { struct Load { surface: Shared, } impl LoadHandler { fn on_load_start( &self, _browser: Option<&mut Browser>, frame: Option<&mut Frame>, _transition_type: TransitionType, ) { if frame.is_some_and(|frame| frame.is_main() == 1) { self.surface.lock().expect("the surface lock").errored = false; } } fn on_load_error( &self, _browser: Option<&mut Browser>, frame: Option<&mut Frame>, error_code: Errorcode, error_text: Option<&CefString>, failed_url: Option<&CefString>, ) { // A stopped load is no failure; a fenced one is. if !frame.is_some_and(|frame| frame.is_main() == 1) || error_code == Errorcode::ABORTED { return; } let text = error_text.map(CefString::to_string).unwrap_or_default(); let url = failed_url.map(CefString::to_string).unwrap_or_default(); let mut surface = self.surface.lock().expect("the surface lock"); surface.errored = true; surface.failed = Some(format!("{text} ({}) {url}", error_code.get_raw())); } fn on_load_end( &self, _browser: Option<&mut Browser>, frame: Option<&mut Frame>, _http_status_code: ::std::os::raw::c_int, ) { if frame.is_some_and(|frame| frame.is_main() == 1) { let mut surface = self.surface.lock().expect("the surface lock"); surface.loaded = !surface.errored; } } } } wrap_life_span_handler! { struct Life { surface: Shared, } impl LifeSpanHandler { fn on_after_created(&self, browser: Option<&mut Browser>) { let Some(browser) = browser.map(|b| b.clone()) else { return }; log::info!("web: browser {} made", browser.identifier()); adopt(&browser, self.surface.clone()); self.surface.lock().expect("the surface lock").browser = Some(browser); } fn on_before_close(&self, browser: Option<&mut Browser>) { let browser = browser.map(|b| b.clone()); router().on_before_close(browser.clone()); if let Some(browser) = browser { surfaces().lock().expect("the surface lock").remove(&browser.identifier()); } // The browser holds these handlers; they hold the surface. self.surface.lock().expect("the surface lock").browser = None; } } } wrap_client! { struct Handlers { paint: RenderHandler, display: DisplayHandler, load: LoadHandler, life: LifeSpanHandler, requests: RequestHandler, keys: Option, } impl Client { fn keyboard_handler(&self) -> Option { self.keys.clone() } fn render_handler(&self) -> Option { Some(self.paint.clone()) } fn display_handler(&self) -> Option { Some(self.display.clone()) } fn load_handler(&self) -> Option { Some(self.load.clone()) } fn life_span_handler(&self) -> Option { Some(self.life.clone()) } fn request_handler(&self) -> Option { Some(self.requests.clone()) } fn on_process_message_received( &self, browser: Option<&mut Browser>, frame: Option<&mut Frame>, source_process: ProcessId, message: Option<&mut ProcessMessage>, ) -> ::std::os::raw::c_int { router().on_process_message_received( browser.map(|b| b.clone()), frame.map(|f| f.clone()), source_process, message.map(|m| m.clone()), ) as _ } } } /// A browser's handlers, all sharing its surface. pub(crate) fn client(surface: &Shared) -> cef::Client { Handlers::new( Paint::new(surface.clone()), Display::new(surface.clone()), Load::new(surface.clone()), Life::new(surface.clone()), Requests::new(surface.clone()), keys(), ) } #[cfg(target_os = "macos")] fn keys() -> Option { Some(crate::edit::Keys::new()) } /// Elsewhere Chromium binds these keys itself. #[cfg(not(target_os = "macos"))] fn keys() -> Option { None }