Desktop: Use multithreaded CEF event loop on Windows and Linux (#3076)

* Prototype multi threaded event loop

* Fix input event dispatch

* Remove dead code

* Reenable do_message_loop_work for macos targets

* Cleanup

* Review cleanup

* Remove outdated comment

* Attempt to fix texture import errors

---------

Co-authored-by: Timon Schelling <me@timon.zip>

Author: TrueDoctor

desktop/src/app.rs

@@ -24,7 +24,7 @@ use winit::window::WindowId;
 use crate::cef;
 
 pub(crate) struct WinitApp {
-	cef_context: cef::Context<cef::Initialized>,
+	cef_context: Box<dyn cef::CefContext>,
 	window: Option<Arc<Window>>,
 	cef_schedule: Option<Instant>,
 	window_size_sender: Sender<WindowSize>,
@@ -38,7 +38,7 @@ pub(crate) struct WinitApp {
 }
 
 impl WinitApp {
-	pub(crate) fn new(cef_context: cef::Context<cef::Initialized>, window_size_sender: Sender<WindowSize>, wgpu_context: WgpuContext, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
+	pub(crate) fn new(cef_context: Box<dyn cef::CefContext>, window_size_sender: Sender<WindowSize>, wgpu_context: WgpuContext, event_loop_proxy: EventLoopProxy<CustomEvent>) -> Self {
 		let rendering_loop_proxy = event_loop_proxy.clone();
 		let (start_render_sender, start_render_receiver) = std::sync::mpsc::sync_channel(1);
 		std::thread::spawn(move || {
@@ -71,7 +71,7 @@ impl WinitApp {
 					tracing::error!("Failed to serialize frontend messages");
 					return;
 				};
-				self.cef_context.send_web_message(bytes.as_slice());
+				self.cef_context.send_web_message(bytes);
 			}
 			DesktopFrontendMessage::OpenFileDialog { title, filters, context } => {
 				let event_loop_proxy = self.event_loop_proxy.clone();
@@ -254,7 +254,7 @@ impl ApplicationHandler<CustomEvent> for WinitApp {
 	}
 
 	fn window_event(&mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {
-		let Some(event) = self.cef_context.handle_window_event(event) else { return };
+		self.cef_context.handle_window_event(&event);
 
 		match event {
 			WindowEvent::CloseRequested => {

desktop/src/cef.rs

@@ -20,6 +20,7 @@ use std::sync::mpsc::Receiver;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
+mod consts;
 mod context;
 mod dirs;
 mod input;
@@ -34,7 +35,7 @@ mod texture_import;
 #[cfg(feature = "accelerated_paint")]
 use texture_import::SharedTextureHandle;
 
-pub(crate) use context::{Context, InitError, Initialized, Setup, SetupError};
+pub(crate) use context::{CefContext, CefContextBuilder, InitError};
 use winit::event_loop::EventLoopProxy;
 
 pub(crate) trait CefEventHandler: Clone {

desktop/src/cef/consts.rs

@@ -0,0 +1,2 @@
+pub(crate) const GRAPHITE_SCHEME: &str = "graphite-static";
+pub(crate) const FRONTEND_DOMAIN: &str = "frontend";

desktop/src/cef/context.rs

@@ -1,164 +1,15 @@
-use cef::sys::{CEF_API_VERSION_LAST, cef_resultcode_t};
-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 thiserror::Error;
-use winit::event::WindowEvent;
+mod multithreaded;
+mod singlethreaded;
 
-use crate::cef::dirs::{cef_cache_dir, cef_data_dir};
+mod builder;
+pub(crate) use builder::{CefContextBuilder, InitError};
 
-use super::input::InputState;
-use super::ipc::{MessageType, SendMessage};
-use super::scheme_handler::{FRONTEND_DOMAIN, GRAPHITE_SCHEME};
-use super::{CefEventHandler, input};
+pub(crate) trait CefContext {
+	fn work(&mut self);
 
-use super::internal::{BrowserProcessAppImpl, BrowserProcessClientImpl, RenderHandlerImpl, RenderProcessAppImpl};
+	fn handle_window_event(&mut self, event: &winit::event::WindowEvent);
 
-pub(crate) struct Setup {}
-pub(crate) struct Initialized {}
-pub(crate) trait ContextState {}
-impl ContextState for Setup {}
-impl ContextState for Initialized {}
+	fn notify_of_resize(&self);
 
-pub(crate) struct Context<S: ContextState> {
-	args: Args,
-	pub(crate) browser: Option<Browser>,
-	pub(crate) input_state: InputState,
-	marker: std::marker::PhantomData<S>,
-}
-
-impl Context<Setup> {
-	pub(crate) fn new() -> Result<Context<Setup>, SetupError> {
-		#[cfg(target_os = "macos")]
-		let _loader = {
-			let loader = library_loader::LibraryLoader::new(&std::env::current_exe().unwrap(), false);
-			assert!(loader.load());
-			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");
-		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 = RenderProcessAppImpl::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,
-			input_state: InputState::default(),
-			marker: std::marker::PhantomData::<Setup>,
-		})
-	}
-
-	pub(crate) fn init(self, event_handler: impl CefEventHandler) -> Result<Context<Initialized>, InitError> {
-		let settings = Settings {
-			windowless_rendering_enabled: 1,
-			multi_threaded_message_loop: 0,
-			external_message_pump: 1,
-			root_cache_path: cef_data_dir().to_str().map(CefString::from).unwrap(),
-			cache_path: cef_cache_dir().to_str().map(CefString::from).unwrap(),
-			..Default::default()
-		};
-
-		// Attention! Wrapping this in an extra App is necessary, otherwise the program still compiles but segfaults
-		let mut cef_app = App::new(BrowserProcessAppImpl::new(event_handler.clone()));
-
-		let result = initialize(Some(self.args.as_main_args()), Some(&settings), Some(&mut cef_app), std::ptr::null_mut());
-		if result != 1 {
-			let cef_exit_code = cef::get_exit_code() as u32;
-			if cef_exit_code == cef_resultcode_t::CEF_RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED as u32 {
-				return Err(InitError::AlreadyRunning);
-			}
-			return Err(InitError::InitializationFailed(cef_exit_code));
-		}
-
-		let render_handler = RenderHandler::new(RenderHandlerImpl::new(event_handler.clone()));
-		let mut client = Client::new(BrowserProcessClientImpl::new(render_handler, event_handler.clone()));
-
-		let url = CefString::from(format!("{GRAPHITE_SCHEME}://{FRONTEND_DOMAIN}/").as_str());
-		// let url = CefString::from("chrome://gpu");
-
-		let window_info = WindowInfo {
-			windowless_rendering_enabled: 1,
-			#[cfg(feature = "accelerated_paint")]
-			shared_texture_enabled: if crate::cef::platform::should_enable_hardware_acceleration() { 1 } else { 0 },
-			..Default::default()
-		};
-
-		let settings = BrowserSettings {
-			windowless_frame_rate: crate::consts::CEF_WINDOWLESS_FRAME_RATE,
-			background_color: 0x0,
-			..Default::default()
-		};
-
-		let browser = browser_host_create_browser_sync(
-			Some(&window_info),
-			Some(&mut client),
-			Some(&url),
-			Some(&settings),
-			Option::<&mut DictionaryValue>::None,
-			Option::<&mut RequestContext>::None,
-		);
-
-		Ok(Context {
-			args: self.args.clone(),
-			browser,
-			input_state: self.input_state.clone(),
-			marker: std::marker::PhantomData::<Initialized>,
-		})
-	}
-}
-
-impl Context<Initialized> {
-	pub(crate) fn work(&mut self) {
-		cef::do_message_loop_work();
-	}
-
-	pub(crate) fn handle_window_event(&mut self, event: WindowEvent) -> Option<WindowEvent> {
-		input::handle_window_event(self, event)
-	}
-
-	pub(crate) fn notify_of_resize(&self) {
-		if let Some(browser) = &self.browser {
-			browser.host().unwrap().was_resized();
-		}
-	}
-
-	pub(crate) fn send_web_message(&self, message: &[u8]) {
-		self.send_message(MessageType::SendToJS, message);
-	}
-}
-
-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")]
-	Subprocess,
-	#[error("subprocess returned non zero exit code")]
-	SubprocessFailed(String),
-}
-
-#[derive(Error, Debug)]
-pub(crate) enum InitError {
-	#[error("initialization failed")]
-	InitializationFailed(u32),
-	#[error("Another instance is already running")]
-	AlreadyRunning,
+	fn send_web_message(&self, message: Vec<u8>);
 }