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

Co-authored-by: Adam <adamgerhant@gmail.com>
Co-authored-by: Dennis Kobert <dennis@kobert.dev>

Author: 3 people

desktop/src/cef.rs

@@ -21,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)]
@@ -118,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,6 +7,7 @@ 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};
 
@@ -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

@@ -4,6 +4,7 @@ mod browser_process_handler;
 mod render_handler;
 mod render_process_app;
 mod render_process_handler;
+mod render_process_v8_handler;
 
 pub(crate) use browser_process_app::BrowserProcessAppImpl;
 pub(crate) use browser_process_client::BrowserProcessClientImpl;

desktop/src/cef/internal/browser_process_client.rs

@@ -32,7 +32,8 @@ impl<H: CefEventHandler> ImplClient for BrowserProcessClientImpl<H> {
 			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;

desktop/src/cef/internal/render_process_handler.rs

@@ -1,9 +1,14 @@
 use cef::rc::{ConvertReturnValue, Rc, RcImpl};
 use cef::sys::{_cef_render_process_handler_t, cef_base_ref_counted_t, cef_render_process_handler_t, cef_v8_propertyattribute_t, cef_v8_value_create_array_buffer_with_copy};
-use cef::{CefString, ImplFrame, ImplRenderProcessHandler, ImplV8Context, ImplV8Value, V8Value, WrapRenderProcessHandler, v8_context_get_entered_context};
+use cef::{
+	CefString, ImplFrame, ImplRenderProcessHandler, ImplV8Context, ImplV8Value, V8Handler, V8Propertyattribute, V8Value, WrapRenderProcessHandler, v8_context_get_entered_context,
+	v8_value_create_function,
+};
 
 use crate::cef::ipc::{MessageType, UnpackMessage, UnpackedMessage};
 
+use super::render_process_v8_handler::BrowserProcessV8HandlerImpl;
+
 pub(crate) struct RenderProcessHandlerImpl {
 	object: *mut RcImpl<cef_render_process_handler_t, Self>,
 }
@@ -70,6 +75,27 @@ impl ImplRenderProcessHandler for RenderProcessHandlerImpl {
 		1
 	}
 
+	fn on_context_created(&self, _browser: Option<&mut cef::Browser>, _frame: Option<&mut cef::Frame>, context: Option<&mut cef::V8Context>) {
+		let function_name = "sendNativeMessage";
+
+		let Some(context) = context else {
+			tracing::error!("V8 context is not available");
+			return;
+		};
+
+		let mut v8_handler = V8Handler::new(BrowserProcessV8HandlerImpl::new());
+		let Some(mut function) = v8_value_create_function(Some(&CefString::from(function_name)), Some(&mut v8_handler)) else {
+			tracing::error!("Failed to create V8 function {function_name}");
+			return;
+		};
+
+		let Some(global) = context.global() else {
+			tracing::error!("Global object is not available in V8 context");
+			return;
+		};
+		global.set_value_bykey(Some(&CefString::from(function_name)), Some(&mut function), V8Propertyattribute::default());
+	}
+
 	fn get_raw(&self) -> *mut _cef_render_process_handler_t {
 		self.object.cast()
 	}

desktop/src/cef/internal/render_process_v8_handler.rs

@@ -0,0 +1,83 @@
+use cef::{ImplV8Handler, ImplV8Value, V8Value, WrapV8Handler, rc::Rc, v8_context_get_current_context};
+
+use crate::cef::ipc::{MessageType, SendMessage};
+
+pub struct BrowserProcessV8HandlerImpl {
+	object: *mut cef::rc::RcImpl<cef::sys::_cef_v8_handler_t, Self>,
+}
+
+impl BrowserProcessV8HandlerImpl {
+	pub(crate) fn new() -> Self {
+		Self { object: std::ptr::null_mut() }
+	}
+}
+
+impl ImplV8Handler for BrowserProcessV8HandlerImpl {
+	fn execute(
+		&self,
+		name: Option<&cef::CefString>,
+		_object: Option<&mut V8Value>,
+		arguments: Option<&[Option<V8Value>]>,
+		_retval: Option<&mut Option<V8Value>>,
+		_exception: Option<&mut cef::CefString>,
+	) -> ::std::os::raw::c_int {
+		if let Some(name) = name {
+			if name.to_string() == "sendNativeMessage" {
+				let Some(args) = arguments else {
+					tracing::error!("No arguments provided to sendNativeMessage");
+					return 0;
+				};
+				let Some(arg1) = args.first() else {
+					tracing::error!("No arguments provided to sendNativeMessage");
+					return 0;
+				};
+				let Some(arg1) = arg1.as_ref() else {
+					tracing::error!("First argument to sendNativeMessage is not an ArrayBuffer");
+					return 0;
+				};
+				if arg1.is_array_buffer() == 0 {
+					tracing::error!("First argument to sendNativeMessage is not an ArrayBuffer");
+					return 0;
+				}
+
+				let size = arg1.array_buffer_byte_length();
+				let ptr = arg1.array_buffer_data();
+				let data = unsafe { std::slice::from_raw_parts_mut(ptr as *mut u8, size) };
+
+				v8_context_get_current_context().send_message(MessageType::SendToNative, data);
+
+				return 1;
+			}
+		}
+		1
+	}
+
+	fn get_raw(&self) -> *mut cef::sys::_cef_v8_handler_t {
+		self.object.cast()
+	}
+}
+
+impl Clone for BrowserProcessV8HandlerImpl {
+	fn clone(&self) -> Self {
+		unsafe {
+			let rc_impl = &mut *self.object;
+			rc_impl.interface.add_ref();
+		}
+		Self { object: self.object }
+	}
+}
+
+impl Rc for BrowserProcessV8HandlerImpl {
+	fn as_base(&self) -> &cef::sys::cef_base_ref_counted_t {
+		unsafe {
+			let base = &*self.object;
+			std::mem::transmute(&base.cef_object)
+		}
+	}
+}
+
+impl WrapV8Handler for BrowserProcessV8HandlerImpl {
+	fn wrap_rc(&mut self, object: *mut cef::rc::RcImpl<cef::sys::_cef_v8_handler_t, Self>) {
+		self.object = object;
+	}
+}