Desktop: Cleaner CEF bidirectional message implementation (#2950)

* Rename CEF implementations to match the process they are called in

* Rename CEF implementations to match the process they are called in

* Implement ipc abstraction

* Call js function `receiveNativeMessage` for all SendToJS ipc messages

* Allow js to call `sendNativeMessage` for sending messages to the browser process

Co-authored-by: Adam <[email protected]>
Co-authored-by: Dennis Kobert <[email protected]>

* Fix missing safety consideration

---------

Co-authored-by: Adam <[email protected]>
Co-authored-by: Dennis Kobert <[email protected]>

Author: 3 people

desktop/src/cef.rs

@@ -8,7 +8,9 @@ mod context;
 mod dirs;
 mod input;
 mod internal;
+mod ipc;
 mod scheme_handler;
+mod utility;
 
 pub(crate) use context::{Context, InitError, Initialized, Setup, SetupError};
 use winit::event_loop::EventLoopProxy;
@@ -19,6 +21,7 @@ pub(crate) trait CefEventHandler: Clone {
 	/// 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);
+	fn receive_web_message(&self, message: &[u8]);
 }
 
 #[derive(Clone, Copy)]
@@ -116,4 +119,6 @@ impl CefEventHandler for CefHandler {
 	fn schedule_cef_message_loop_work(&self, scheduled_time: std::time::Instant) {
 		let _ = self.event_loop_proxy.send_event(CustomEvent::ScheduleBrowserWork(scheduled_time));
 	}
+
+	fn receive_web_message(&self, message: &[u8]) {}
 }

desktop/src/cef/context.rs

@@ -7,10 +7,11 @@ use winit::event::WindowEvent;
 use crate::cef::dirs::{cef_cache_dir, cef_data_dir};
 
 use super::input::InputState;
+use super::ipc::{MessageType, SendMessage};
 use super::scheme_handler::{FRONTEND_DOMAIN, GRAPHITE_SCHEME};
 use super::{CefEventHandler, input};
 
-use super::internal::{AppImpl, ClientImpl, NonBrowserAppImpl, RenderHandlerImpl};
+use super::internal::{BrowserProcessAppImpl, BrowserProcessClientImpl, RenderHandlerImpl, RenderProcessAppImpl};
 
 pub(crate) struct Setup {}
 pub(crate) struct Initialized {}
@@ -42,7 +43,7 @@ impl Context<Setup> {
 
 		if !is_browser_process {
 			let process_type = CefString::from(&cmd.switch_value(Some(&switch)));
-			let mut app = NonBrowserAppImpl::app();
+			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()));
@@ -70,7 +71,7 @@ impl Context<Setup> {
 		};
 
 		// 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 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 {
@@ -81,8 +82,8 @@ impl Context<Setup> {
 			return Err(InitError::InitializationFailed(cef_exit_code));
 		}
 
-		let render_handler = RenderHandlerImpl::new(event_handler.clone());
-		let mut client = Client::new(ClientImpl::new(RenderHandler::new(render_handler)));
+		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());
 
@@ -129,6 +130,10 @@ impl Context<Initialized> {
 			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> {

desktop/src/cef/internal.rs

@@ -1,10 +1,12 @@
-mod app;
+mod browser_process_app;
+mod browser_process_client;
 mod browser_process_handler;
-mod client;
-mod non_browser_app;
 mod render_handler;
+mod render_process_app;
+mod render_process_handler;
+mod render_process_v8_handler;
 
-pub(crate) use app::AppImpl;
-pub(crate) use client::ClientImpl;
-pub(crate) use non_browser_app::NonBrowserAppImpl;
+pub(crate) use browser_process_app::BrowserProcessAppImpl;
+pub(crate) use browser_process_client::BrowserProcessClientImpl;
 pub(crate) use render_handler::RenderHandlerImpl;
+pub(crate) use render_process_app::RenderProcessAppImpl;

desktop/src/cef/internal/app.rs renamed to desktop/src/cef/internal/browser_process_app.rs

@@ -5,15 +5,16 @@ use cef::sys::{_cef_app_t, cef_base_ref_counted_t};
 use cef::{BrowserProcessHandler, CefString, ImplApp, ImplCommandLine, SchemeRegistrar, WrapApp};
 
 use crate::cef::CefEventHandler;
+
 use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
 
 use super::browser_process_handler::BrowserProcessHandlerImpl;
 
-pub(crate) struct AppImpl<H: CefEventHandler> {
+pub(crate) struct BrowserProcessAppImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_app_t, Self>,
 	event_handler: H,
 }
-impl<H: CefEventHandler + Clone> AppImpl<H> {
+impl<H: CefEventHandler + Clone> BrowserProcessAppImpl<H> {
 	pub(crate) fn new(event_handler: H) -> Self {
 		Self {
 			object: std::ptr::null_mut(),
@@ -22,7 +23,7 @@ impl<H: CefEventHandler + Clone> AppImpl<H> {
 	}
 }
 
-impl<H: CefEventHandler + Clone> ImplApp for AppImpl<H> {
+impl<H: CefEventHandler + Clone> ImplApp for BrowserProcessAppImpl<H> {
 	fn browser_process_handler(&self) -> Option<BrowserProcessHandler> {
 		Some(BrowserProcessHandler::new(BrowserProcessHandlerImpl::new(self.event_handler.clone())))
 	}
@@ -58,7 +59,7 @@ impl<H: CefEventHandler + Clone> ImplApp for AppImpl<H> {
 	}
 }
 
-impl<H: CefEventHandler + Clone> Clone for AppImpl<H> {
+impl<H: CefEventHandler + Clone> Clone for BrowserProcessAppImpl<H> {
 	fn clone(&self) -> Self {
 		unsafe {
 			let rc_impl = &mut *self.object;
@@ -70,15 +71,15 @@ impl<H: CefEventHandler + Clone> Clone for AppImpl<H> {
 		}
 	}
 }
-impl<H: CefEventHandler> Rc for AppImpl<H> {
+impl<H: CefEventHandler> Rc for BrowserProcessAppImpl<H> {
 	fn as_base(&self) -> &cef_base_ref_counted_t {
 		unsafe {
 			let base = &*self.object;
 			std::mem::transmute(&base.cef_object)
 		}
 	}
 }
-impl<H: CefEventHandler + Clone> WrapApp for AppImpl<H> {
+impl<H: CefEventHandler + Clone> WrapApp for BrowserProcessAppImpl<H> {
 	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_app_t, Self>) {
 		self.object = object;
 	}

desktop/src/cef/internal/browser_process_client.rs

@@ -0,0 +1,80 @@
+use cef::rc::{Rc, RcImpl};
+use cef::sys::{_cef_client_t, cef_base_ref_counted_t};
+use cef::{ImplClient, RenderHandler, WrapClient};
+
+use crate::cef::CefEventHandler;
+use crate::cef::ipc::{MessageType, UnpackMessage, UnpackedMessage};
+
+pub(crate) struct BrowserProcessClientImpl<H: CefEventHandler> {
+	object: *mut RcImpl<_cef_client_t, Self>,
+	render_handler: RenderHandler,
+	event_handler: H,
+}
+impl<H: CefEventHandler> BrowserProcessClientImpl<H> {
+	pub(crate) fn new(render_handler: RenderHandler, event_handler: H) -> Self {
+		Self {
+			object: std::ptr::null_mut(),
+			render_handler,
+			event_handler,
+		}
+	}
+}
+
+impl<H: CefEventHandler> ImplClient for BrowserProcessClientImpl<H> {
+	fn on_process_message_received(
+		&self,
+		_browser: Option<&mut cef::Browser>,
+		_frame: Option<&mut cef::Frame>,
+		_source_process: cef::ProcessId,
+		message: Option<&mut cef::ProcessMessage>,
+	) -> ::std::os::raw::c_int {
+		let unpacked_message = unsafe { message.and_then(|m| m.unpack()) };
+		match unpacked_message {
+			Some(UnpackedMessage {
+				message_type: MessageType::SendToNative,
+				data,
+			}) => self.event_handler.receive_web_message(data),
+
+			_ => {
+				tracing::error!("Unexpected message type received in browser process");
+				return 0;
+			}
+		}
+		1
+	}
+
+	fn render_handler(&self) -> Option<RenderHandler> {
+		Some(self.render_handler.clone())
+	}
+
+	fn get_raw(&self) -> *mut _cef_client_t {
+		self.object.cast()
+	}
+}
+
+impl<H: CefEventHandler> Clone for BrowserProcessClientImpl<H> {
+	fn clone(&self) -> Self {
+		unsafe {
+			let rc_impl = &mut *self.object;
+			rc_impl.interface.add_ref();
+		}
+		Self {
+			object: self.object,
+			render_handler: self.render_handler.clone(),
+			event_handler: self.event_handler.clone(),
+		}
+	}
+}
+impl<H: CefEventHandler> Rc for BrowserProcessClientImpl<H> {
+	fn as_base(&self) -> &cef_base_ref_counted_t {
+		unsafe {
+			let base = &*self.object;
+			std::mem::transmute(&base.cef_object)
+		}
+	}
+}
+impl<H: CefEventHandler> WrapClient for BrowserProcessClientImpl<H> {
+	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_client_t, Self>) {
+		self.object = object;
+	}
+}

desktop/src/cef/internal/client.rs

@@ -1,46 +1,58 @@
 use cef::rc::{Rc, RcImpl};
 use cef::sys::{_cef_app_t, cef_base_ref_counted_t};
-use cef::{App, ImplApp, SchemeRegistrar, WrapApp};
+use cef::{App, ImplApp, RenderProcessHandler, SchemeRegistrar, WrapApp};
 
+use super::render_process_handler::RenderProcessHandlerImpl;
 use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
 
-pub(crate) struct NonBrowserAppImpl {
+pub(crate) struct RenderProcessAppImpl {
 	object: *mut RcImpl<_cef_app_t, Self>,
+	render_process_handler: RenderProcessHandler,
 }
-impl NonBrowserAppImpl {
+impl RenderProcessAppImpl {
 	pub(crate) fn app() -> App {
-		App::new(Self { object: std::ptr::null_mut() })
+		App::new(Self {
+			object: std::ptr::null_mut(),
+			render_process_handler: RenderProcessHandler::new(RenderProcessHandlerImpl::new()),
+		})
 	}
 }
 
-impl ImplApp for NonBrowserAppImpl {
+impl ImplApp for RenderProcessAppImpl {
 	fn on_register_custom_schemes(&self, registrar: Option<&mut SchemeRegistrar>) {
 		GraphiteSchemeHandlerFactory::register_schemes(registrar);
 	}
 
+	fn render_process_handler(&self) -> Option<RenderProcessHandler> {
+		Some(self.render_process_handler.clone())
+	}
+
 	fn get_raw(&self) -> *mut _cef_app_t {
 		self.object.cast()
 	}
 }
 
-impl Clone for NonBrowserAppImpl {
+impl Clone for RenderProcessAppImpl {
 	fn clone(&self) -> Self {
 		unsafe {
 			let rc_impl = &mut *self.object;
 			rc_impl.interface.add_ref();
 		}
-		Self { object: self.object }
+		Self {
+			object: self.object,
+			render_process_handler: self.render_process_handler.clone(),
+		}
 	}
 }
-impl Rc for NonBrowserAppImpl {
+impl Rc for RenderProcessAppImpl {
 	fn as_base(&self) -> &cef_base_ref_counted_t {
 		unsafe {
 			let base = &*self.object;
 			std::mem::transmute(&base.cef_object)
 		}
 	}
 }
-impl WrapApp for NonBrowserAppImpl {
+impl WrapApp for RenderProcessAppImpl {
 	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_app_t, Self>) {
 		self.object = object;
 	}