Cleanup + Scheudule cef message loop work

Author: TrueDoctor

desktop/src/app.rs

@@ -19,6 +19,7 @@ pub(crate) struct WinitApp {
 	pub(crate) window_state: WindowStateHandle,
 	pub(crate) cef_context: cef::Context<cef::Initialized>,
 	pub(crate) window: Option<Arc<Window>>,
+	cef_schedule: Instant,
 }
 
 impl WinitApp {
@@ -27,18 +28,22 @@ impl WinitApp {
 			window_state,
 			cef_context,
 			window: None,
+			cef_schedule: Instant::now(),
 		}
 	}
 }
 
 impl ApplicationHandler<CustomEvent> for WinitApp {
 	fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
-		event_loop.set_control_flow(ControlFlow::WaitUntil(Instant::now() + Duration::from_millis(2)));
-		self.cef_context.work();
+		let timeout = Instant::now() + Duration::from_millis(10);
+		let wait_until = timeout.min(self.cef_schedule);
+		event_loop.set_control_flow(ControlFlow::WaitUntil(wait_until));
 	}
 
 	fn new_events(&mut self, _event_loop: &ActiveEventLoop, _cause: StartCause) {
-		self.cef_context.work();
+		if Instant::now() > self.cef_schedule {
+			self.cef_context.work();
+		}
 	}
 
 	fn resumed(&mut self, event_loop: &ActiveEventLoop) {
@@ -67,11 +72,14 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 
 	fn user_event(&mut self, _: &ActiveEventLoop, event: CustomEvent) {
 		match event {
-			CustomEvent::UiUpdate | CustomEvent::Resized => {
+			CustomEvent::UiUpdate => {
 				if let Some(window) = &self.window {
 					window.request_redraw();
 				}
 			}
+			CustomEvent::ScheduleBrowserWork(instant) => {
+				self.cef_schedule = instant;
+			}
 		}
 	}
 
@@ -90,9 +98,6 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 						let height = physical_size.height as usize;
 						s.width = Some(width);
 						s.height = Some(height);
-						if let Some(elp) = &s.event_loop_proxy {
-							let _ = elp.send_event(CustomEvent::Resized);
-						}
 						if let Some(graphics_state) = &mut s.graphics_state {
 							graphics_state.resize(width, height);
 						}

desktop/src/cef/context.rs

@@ -1,11 +1,12 @@
 use cef::sys::CEF_API_VERSION_LAST;
+use cef::{App, BrowserSettings, Client, DictionaryValue, ImplBrowser, ImplBrowserHost, ImplCommandLine, RenderHandler, RequestContext, WindowInfo, browser_host_create_browser_sync, initialize};
 use cef::{Browser, CefString, Settings, api_hash, args::Args, execute_process};
-use cef::{BrowserSettings, DictionaryValue, ImplBrowser, ImplBrowserHost, ImplCommandLine, RenderHandler, RequestContext, WindowInfo, browser_host_create_browser_sync, initialize};
 use thiserror::Error;
 use winit::event::WindowEvent;
 
-use super::CefEventHandler;
-use super::input::{InputState, handle_window_event};
+use super::input::InputState;
+use super::scheme_handler::{FRONTEND_DOMAIN, GRAPHITE_SCHEME};
+use super::{CefEventHandler, input};
 
 use super::internal::{AppImpl, ClientImpl, NonBrowserAppImpl, RenderHandlerImpl};
 
@@ -21,13 +22,6 @@ pub(crate) struct Context<S: ContextState> {
 	pub(crate) input_state: InputState,
 	marker: std::marker::PhantomData<S>,
 }
-impl<S: ContextState> Drop for Context<S> {
-	fn drop(&mut self) {
-		if self.browser.is_some() {
-			cef::shutdown();
-		}
-	}
-}
 
 impl Context<Setup> {
 	pub(crate) fn new() -> Result<Context<Setup>, SetupError> {
@@ -38,22 +32,23 @@ impl Context<Setup> {
 			loader
 		};
 		let _ = api_hash(CEF_API_VERSION_LAST, 0);
+
 		let args = Args::new();
 		let cmd = args.as_cmd_line().unwrap();
 		let switch = CefString::from("type");
-		cmd.append_switch(Some(&CefString::from("disable-gpu")));
-		cmd.append_switch(Some(&CefString::from("disable-gpu-compositing")));
 		let is_browser_process = cmd.has_switch(Some(&switch)) != 1;
+
 		if !is_browser_process {
 			let process_type = CefString::from(&cmd.switch_value(Some(&switch)));
-			let mut app = NonBrowserAppImpl::new();
+			let mut app = NonBrowserAppImpl::app();
 			let ret = execute_process(Some(args.as_main_args()), Some(&mut app), std::ptr::null_mut());
 			if ret >= 0 {
 				return Err(SetupError::SubprocessFailed(process_type.to_string()));
 			} else {
 				return Err(SetupError::Subprocess);
 			}
 		}
+
 		Ok(Context {
 			args,
 			browser: None,
@@ -70,17 +65,18 @@ impl Context<Setup> {
 			..Default::default()
 		};
 
-		let mut cef_app = AppImpl::new(event_handler.clone());
+		// Attention! Wrapping this in an extra App is necessary, otherwise the program still compiles but segfaults
+		let mut cef_app = App::new(AppImpl::new(event_handler.clone()));
 
-		let res = initialize(Some(self.args.as_main_args()), Some(&settings), Some(&mut cef_app), std::ptr::null_mut());
-		if res != 1 {
+		let result = initialize(Some(self.args.as_main_args()), Some(&settings), Some(&mut cef_app), std::ptr::null_mut());
+		if result != 1 {
 			return Err(InitError::InitializationFailed);
 		}
 
 		let render_handler = RenderHandlerImpl::new(event_handler.clone());
-		let mut client = ClientImpl::new(RenderHandler::new(render_handler));
+		let mut client = Client::new(ClientImpl::new(RenderHandler::new(render_handler)));
 
-		let url = CefString::from("graphite://frontend/");
+		let url = CefString::from(format!("{GRAPHITE_SCHEME}://{FRONTEND_DOMAIN}/").as_str());
 
 		let window_info = WindowInfo {
 			windowless_rendering_enabled: 1,
@@ -117,7 +113,7 @@ impl Context<Initialized> {
 	}
 
 	pub(crate) fn handle_window_event(&mut self, event: WindowEvent) -> Option<WindowEvent> {
-		handle_window_event(self, event)
+		input::handle_window_event(self, event)
 	}
 
 	pub(crate) fn notify_of_resize(&self) {
@@ -127,6 +123,14 @@ impl Context<Initialized> {
 	}
 }
 
+impl<S: ContextState> Drop for Context<S> {
+	fn drop(&mut self) {
+		if self.browser.is_some() {
+			cef::shutdown();
+		}
+	}
+}
+
 #[derive(Error, Debug)]
 pub(crate) enum SetupError {
 	#[error("this is the sub process should exit immediately")]

desktop/src/cef/input/keymap.rs

@@ -20,6 +20,7 @@ macro_rules! map {
 	};
 }
 
+// Windows Virtual keyboard binary representation
 pub(crate) trait ToVKBits {
 	fn to_vk_bits(&self) -> i32;
 }
@@ -205,6 +206,7 @@ impl ToVKBits for char {
 	}
 }
 
+// Chromium dom key binary representation
 pub(crate) trait ToDomBits {
 	fn to_dom_bits(&self) -> i32;
 }

desktop/src/cef/internal/app.rs

@@ -1,6 +1,6 @@
 use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_app_t, cef_base_ref_counted_t};
-use cef::{App, BrowserProcessHandler, ImplApp, SchemeRegistrar, WrapApp};
+use cef::{BrowserProcessHandler, ImplApp, SchemeRegistrar, WrapApp};
 
 use crate::cef::CefEventHandler;
 use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
@@ -12,17 +12,17 @@ pub(crate) struct AppImpl<H: CefEventHandler> {
 	event_handler: H,
 }
 impl<H: CefEventHandler> AppImpl<H> {
-	pub(crate) fn new(event_handler: H) -> App {
-		App::new(Self {
+	pub(crate) fn new(event_handler: H) -> Self {
+		Self {
 			object: std::ptr::null_mut(),
 			event_handler,
-		})
+		}
 	}
 }
 
 impl<H: CefEventHandler> ImplApp for AppImpl<H> {
 	fn browser_process_handler(&self) -> Option<BrowserProcessHandler> {
-		Some(BrowserProcessHandlerImpl::new(self.event_handler.clone()))
+		Some(BrowserProcessHandler::new(BrowserProcessHandlerImpl::new(self.event_handler.clone())))
 	}
 
 	fn on_register_custom_schemes(&self, registrar: Option<&mut SchemeRegistrar>) {

desktop/src/cef/internal/browser_process_handler.rs

@@ -1,31 +1,37 @@
+use std::time::{Duration, Instant};
+
 use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_browser_process_handler_t, cef_base_ref_counted_t, cef_browser_process_handler_t};
-use cef::{BrowserProcessHandler, CefString, ImplBrowserProcessHandler, SchemeHandlerFactory, WrapBrowserProcessHandler};
+use cef::{CefString, ImplBrowserProcessHandler, SchemeHandlerFactory, WrapBrowserProcessHandler};
 
 use crate::cef::CefEventHandler;
-use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
+use crate::cef::scheme_handler::{GRAPHITE_SCHEME, GraphiteSchemeHandlerFactory};
 
 pub(crate) struct BrowserProcessHandlerImpl<H: CefEventHandler> {
 	object: *mut RcImpl<cef_browser_process_handler_t, Self>,
 	event_handler: H,
 }
 impl<H: CefEventHandler> BrowserProcessHandlerImpl<H> {
-	pub(crate) fn new(event_handler: H) -> BrowserProcessHandler {
-		BrowserProcessHandler::new(Self {
+	pub(crate) fn new(event_handler: H) -> Self {
+		Self {
 			object: std::ptr::null_mut(),
 			event_handler,
-		})
+		}
 	}
 }
 
 impl<H: CefEventHandler> ImplBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
 	fn on_context_initialized(&self) {
-		cef::register_scheme_handler_factory(Some(&CefString::from("graphite")), None, Some(&mut SchemeHandlerFactory::new(GraphiteSchemeHandlerFactory::new())));
+		cef::register_scheme_handler_factory(Some(&CefString::from(GRAPHITE_SCHEME)), None, Some(&mut SchemeHandlerFactory::new(GraphiteSchemeHandlerFactory::new())));
 	}
 
 	fn get_raw(&self) -> *mut _cef_browser_process_handler_t {
 		self.object.cast()
 	}
+
+	fn on_schedule_message_pump_work(&self, delay_ms: i64) {
+		self.event_handler.schedule_cef_message_loop_work(Instant::now() + Duration::from_millis(delay_ms as u64));
+	}
 }
 
 impl<H: CefEventHandler> Clone for BrowserProcessHandlerImpl<H> {

desktop/src/cef/internal/client.rs

@@ -1,17 +1,17 @@
 use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_client_t, cef_base_ref_counted_t};
-use cef::{Client, ImplClient, RenderHandler, WrapClient};
+use cef::{ImplClient, RenderHandler, WrapClient};
 
 pub(crate) struct ClientImpl {
 	object: *mut RcImpl<_cef_client_t, Self>,
 	render_handler: RenderHandler,
 }
 impl ClientImpl {
-	pub(crate) fn new(render_handler: RenderHandler) -> Client {
-		Client::new(Self {
+	pub(crate) fn new(render_handler: RenderHandler) -> Self {
+		Self {
 			object: std::ptr::null_mut(),
 			render_handler,
-		})
+		}
 	}
 }
 

desktop/src/cef/internal/non_browser_app.rs

@@ -8,7 +8,7 @@ pub(crate) struct NonBrowserAppImpl {
 	object: *mut RcImpl<_cef_app_t, Self>,
 }
 impl NonBrowserAppImpl {
-	pub(crate) fn new() -> App {
+	pub(crate) fn app() -> App {
 		App::new(Self { object: std::ptr::null_mut() })
 	}
 }

desktop/src/cef/mod.rs

@@ -1,14 +1,19 @@
-mod input;
-
-mod scheme_handler;
+use crate::FrameBuffer;
+use std::time::Instant;
 
 mod context;
-
+mod input;
 mod internal;
+mod scheme_handler;
+
+pub(crate) use context::{Context, InitError, Initialized, Setup, SetupError};
 
 pub(crate) trait CefEventHandler: Clone {
 	fn window_size(&self) -> WindowSize;
 	fn draw(&self, frame_buffer: FrameBuffer) -> bool;
+	/// Scheudule the main event loop to run the cef event loop after the timeout
+	///  [`_cef_browser_process_handler_t::on_schedule_message_pump_work`] for more documentation.
+	fn schedule_cef_message_loop_work(&self, scheduled_time: Instant);
 }
 
 #[derive(Clone)]
@@ -22,7 +27,3 @@ impl WindowSize {
 		Self { width, height }
 	}
 }
-
-pub(crate) use context::{Context, InitError, Initialized, Setup, SetupError};
-
-use crate::FrameBuffer;