Desktop: Make embedded resources optional (#3094)

* Make embedding resources optional

* Move remaining cef rc to internal module

* Move embedded resources to separate crate

* Review fixup

* Fix

* Fix read

* Add read error

desktop/src/cef/internal/browser_process_app.rs

@@ -5,11 +5,9 @@ use cef::rc::{Rc, RcImpl};
 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;
+use super::scheme_handler_factory::SchemeHandlerFactoryImpl;
+use crate::cef::CefEventHandler;
 
 pub(crate) struct BrowserProcessAppImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_app_t, Self>,
@@ -30,7 +28,7 @@ impl<H: CefEventHandler + Clone> ImplApp for BrowserProcessAppImpl<H> {
 	}
 
 	fn on_register_custom_schemes(&self, registrar: Option<&mut SchemeRegistrar>) {
-		GraphiteSchemeHandlerFactory::register_schemes(registrar);
+		SchemeHandlerFactoryImpl::<H>::register_schemes(registrar);
 	}
 
 	fn on_before_command_line_processing(&self, _process_type: Option<&cef::CefString>, command_line: Option<&mut cef::CommandLine>) {

desktop/src/cef/internal/browser_process_handler.rs

@@ -4,9 +4,9 @@ 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::{CefString, ImplBrowserProcessHandler, SchemeHandlerFactory, WrapBrowserProcessHandler};
 
+use super::scheme_handler_factory::SchemeHandlerFactoryImpl;
 use crate::cef::CefEventHandler;
-use crate::cef::consts::GRAPHITE_SCHEME;
-use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
+use crate::cef::consts::RESOURCE_SCHEME;
 
 pub(crate) struct BrowserProcessHandlerImpl<H: CefEventHandler> {
 	object: *mut RcImpl<cef_browser_process_handler_t, Self>,
@@ -23,7 +23,11 @@ impl<H: CefEventHandler> BrowserProcessHandlerImpl<H> {
 
 impl<H: CefEventHandler + Clone> ImplBrowserProcessHandler for BrowserProcessHandlerImpl<H> {
 	fn on_context_initialized(&self) {
-		cef::register_scheme_handler_factory(Some(&CefString::from(GRAPHITE_SCHEME)), None, Some(&mut SchemeHandlerFactory::new(GraphiteSchemeHandlerFactory::new())));
+		cef::register_scheme_handler_factory(
+			Some(&CefString::from(RESOURCE_SCHEME)),
+			None,
+			Some(&mut SchemeHandlerFactory::new(SchemeHandlerFactoryImpl::new(self.event_handler.clone()))),
+		);
 	}
 
 	fn on_schedule_message_pump_work(&self, delay_ms: i64) {

desktop/src/cef/internal/render_handler.rs

@@ -9,7 +9,6 @@ pub(crate) struct RenderHandlerImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_render_handler_t, Self>,
 	event_handler: H,
 }
-
 impl<H: CefEventHandler> RenderHandlerImpl<H> {
 	pub(crate) fn new(event_handler: H) -> Self {
 		Self {
@@ -18,6 +17,7 @@ impl<H: CefEventHandler> RenderHandlerImpl<H> {
 		}
 	}
 }
+
 impl<H: CefEventHandler> ImplRenderHandler for RenderHandlerImpl<H> {
 	fn view_rect(&self, _browser: Option<&mut Browser>, rect: Option<&mut Rect>) {
 		if let Some(rect) = rect {

desktop/src/cef/internal/render_process_app.rs

@@ -3,13 +3,14 @@ use cef::sys::{_cef_app_t, cef_base_ref_counted_t};
 use cef::{App, ImplApp, RenderProcessHandler, SchemeRegistrar, WrapApp};
 
 use super::render_process_handler::RenderProcessHandlerImpl;
-use crate::cef::scheme_handler::GraphiteSchemeHandlerFactory;
+use super::scheme_handler_factory::SchemeHandlerFactoryImpl;
+use crate::cef::CefEventHandler;
 
-pub(crate) struct RenderProcessAppImpl {
+pub(crate) struct RenderProcessAppImpl<H: CefEventHandler> {
 	object: *mut RcImpl<_cef_app_t, Self>,
 	render_process_handler: RenderProcessHandler,
 }
-impl RenderProcessAppImpl {
+impl<H: CefEventHandler> RenderProcessAppImpl<H> {
 	pub(crate) fn app() -> App {
 		App::new(Self {
 			object: std::ptr::null_mut(),
@@ -18,9 +19,9 @@ impl RenderProcessAppImpl {
 	}
 }
 
-impl ImplApp for RenderProcessAppImpl {
+impl<H: CefEventHandler> ImplApp for RenderProcessAppImpl<H> {
 	fn on_register_custom_schemes(&self, registrar: Option<&mut SchemeRegistrar>) {
-		GraphiteSchemeHandlerFactory::register_schemes(registrar);
+		SchemeHandlerFactoryImpl::<H>::register_schemes(registrar);
 	}
 
 	fn render_process_handler(&self) -> Option<RenderProcessHandler> {
@@ -32,7 +33,7 @@ impl ImplApp for RenderProcessAppImpl {
 	}
 }
 
-impl Clone for RenderProcessAppImpl {
+impl<H: CefEventHandler> Clone for RenderProcessAppImpl<H> {
 	fn clone(&self) -> Self {
 		unsafe {
 			let rc_impl = &mut *self.object;
@@ -44,7 +45,7 @@ impl Clone for RenderProcessAppImpl {
 		}
 	}
 }
-impl Rc for RenderProcessAppImpl {
+impl<H: CefEventHandler> Rc for RenderProcessAppImpl<H> {
 	fn as_base(&self) -> &cef_base_ref_counted_t {
 		unsafe {
 			let base = &*self.object;
@@ -52,7 +53,7 @@ impl Rc for RenderProcessAppImpl {
 		}
 	}
 }
-impl WrapApp for RenderProcessAppImpl {
+impl<H: CefEventHandler> WrapApp for RenderProcessAppImpl<H> {
 	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_app_t, Self>) {
 		self.object = object;
 	}

desktop/src/cef/internal/render_process_v8_handler.rs

@@ -5,7 +5,6 @@ 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() }
@@ -72,7 +71,6 @@ impl Clone for BrowserProcessV8HandlerImpl {
 		Self { object: self.object }
 	}
 }
-
 impl Rc for BrowserProcessV8HandlerImpl {
 	fn as_base(&self) -> &cef::sys::cef_base_ref_counted_t {
 		unsafe {
@@ -81,7 +79,6 @@ impl Rc for BrowserProcessV8HandlerImpl {
 		}
 	}
 }
-
 impl WrapV8Handler for BrowserProcessV8HandlerImpl {
 	fn wrap_rc(&mut self, object: *mut cef::rc::RcImpl<cef::sys::_cef_v8_handler_t, Self>) {
 		self.object = object;

desktop/src/cef/internal/resource_handler.rs

@@ -0,0 +1,108 @@
+use cef::rc::{Rc, RcImpl};
+use cef::sys::{_cef_resource_handler_t, cef_base_ref_counted_t};
+use cef::{Callback, CefString, ImplResourceHandler, ImplResponse, Request, ResourceReadCallback, Response, WrapResourceHandler};
+use std::cell::RefCell;
+use std::ffi::c_int;
+use std::io::Read;
+
+use crate::cef::{Resource, ResourceReader};
+
+pub(crate) struct ResourceHandlerImpl {
+	object: *mut RcImpl<_cef_resource_handler_t, Self>,
+	reader: Option<RefCell<ResourceReader>>,
+	mimetype: Option<String>,
+}
+
+impl ResourceHandlerImpl {
+	pub fn new(resource: Option<Resource>) -> Self {
+		if let Some(resource) = resource {
+			Self {
+				object: std::ptr::null_mut(),
+				reader: Some(resource.reader.into()),
+				mimetype: resource.mimetype,
+			}
+		} else {
+			Self {
+				object: std::ptr::null_mut(),
+				reader: None,
+				mimetype: None,
+			}
+		}
+	}
+}
+
+impl ImplResourceHandler for ResourceHandlerImpl {
+	fn open(&self, _request: Option<&mut Request>, handle_request: Option<&mut c_int>, _callback: Option<&mut Callback>) -> c_int {
+		if let Some(handle_request) = handle_request {
+			*handle_request = 1;
+		}
+		1
+	}
+
+	fn response_headers(&self, response: Option<&mut Response>, response_length: Option<&mut i64>, _redirect_url: Option<&mut CefString>) {
+		if let Some(response_length) = response_length {
+			*response_length = -1; // Indicating that the length is unknown
+		}
+		if let Some(response) = response {
+			if self.reader.is_some() {
+				if let Some(mimetype) = &self.mimetype {
+					let cef_mime = CefString::from(mimetype.as_str());
+					response.set_mime_type(Some(&cef_mime));
+				} else {
+					response.set_mime_type(None);
+				}
+				response.set_status(200);
+			} else {
+				response.set_status(404);
+				response.set_mime_type(Some(&CefString::from("text/plain")));
+			}
+		}
+	}
+
+	fn read(&self, data_out: *mut u8, bytes_to_read: c_int, bytes_read: Option<&mut c_int>, _callback: Option<&mut ResourceReadCallback>) -> c_int {
+		let Some(bytes_read) = bytes_read else { unreachable!() };
+		let out = unsafe { std::slice::from_raw_parts_mut(data_out, bytes_to_read as usize) };
+		if let Some(reader) = &self.reader {
+			if let Ok(read) = reader.borrow_mut().read(out) {
+				*bytes_read = read as i32;
+				if read > 0 {
+					return 1; // Indicating that data was read
+				}
+			} else {
+				*bytes_read = -2; // Indicating ERR_FAILED
+			}
+		}
+		0 // Indicating no data was read
+	}
+
+	fn get_raw(&self) -> *mut _cef_resource_handler_t {
+		self.object.cast()
+	}
+}
+
+impl Clone for ResourceHandlerImpl {
+	fn clone(&self) -> Self {
+		unsafe {
+			let rc_impl = &mut *self.object;
+			rc_impl.interface.add_ref();
+		}
+		Self {
+			object: self.object,
+			reader: self.reader.clone(),
+			mimetype: self.mimetype.clone(),
+		}
+	}
+}
+impl Rc for ResourceHandlerImpl {
+	fn as_base(&self) -> &cef_base_ref_counted_t {
+		unsafe {
+			let base = &*self.object;
+			std::mem::transmute(&base.cef_object)
+		}
+	}
+}
+impl WrapResourceHandler for ResourceHandlerImpl {
+	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_resource_handler_t, Self>) {
+		self.object = object;
+	}
+}

desktop/src/cef/internal/scheme_handler_factory.rs

@@ -0,0 +1,86 @@
+use cef::rc::{Rc, RcImpl};
+use cef::sys::{_cef_scheme_handler_factory_t, cef_base_ref_counted_t, cef_scheme_options_t};
+use cef::{Browser, CefString, Frame, ImplRequest, ImplSchemeHandlerFactory, ImplSchemeRegistrar, Request, ResourceHandler, SchemeRegistrar, WrapSchemeHandlerFactory};
+
+use super::resource_handler::ResourceHandlerImpl;
+use crate::cef::CefEventHandler;
+use crate::cef::consts::{RESOURCE_DOMAIN, RESOURCE_SCHEME};
+
+pub(crate) struct SchemeHandlerFactoryImpl<H: CefEventHandler> {
+	object: *mut RcImpl<_cef_scheme_handler_factory_t, Self>,
+	event_handler: H,
+}
+impl<H: CefEventHandler> SchemeHandlerFactoryImpl<H> {
+	pub(crate) fn new(event_handler: H) -> Self {
+		Self {
+			object: std::ptr::null_mut(),
+			event_handler,
+		}
+	}
+
+	pub(crate) fn register_schemes(registrar: Option<&mut SchemeRegistrar>) {
+		if let Some(registrar) = registrar {
+			let mut scheme_options = 0;
+			scheme_options |= cef_scheme_options_t::CEF_SCHEME_OPTION_STANDARD as i32;
+			scheme_options |= cef_scheme_options_t::CEF_SCHEME_OPTION_FETCH_ENABLED as i32;
+			scheme_options |= cef_scheme_options_t::CEF_SCHEME_OPTION_SECURE as i32;
+			scheme_options |= cef_scheme_options_t::CEF_SCHEME_OPTION_CORS_ENABLED as i32;
+			registrar.add_custom_scheme(Some(&CefString::from(RESOURCE_SCHEME)), scheme_options);
+		}
+	}
+}
+
+impl<H: CefEventHandler> ImplSchemeHandlerFactory for SchemeHandlerFactoryImpl<H> {
+	fn create(&self, _browser: Option<&mut Browser>, _frame: Option<&mut Frame>, scheme_name: Option<&CefString>, request: Option<&mut Request>) -> Option<ResourceHandler> {
+		if let Some(scheme_name) = scheme_name {
+			if scheme_name.to_string() != RESOURCE_SCHEME {
+				return None;
+			}
+			if let Some(request) = request {
+				let url = CefString::from(&request.url()).to_string();
+				let path = url.strip_prefix(&format!("{RESOURCE_SCHEME}://")).unwrap();
+				let domain = path.split('/').next().unwrap_or("");
+				let path = path.strip_prefix(domain).unwrap_or("");
+				let path = path.trim_start_matches('/');
+				return match domain {
+					RESOURCE_DOMAIN => {
+						let resource = self.event_handler.load_resource(path.to_string().into());
+						Some(ResourceHandler::new(ResourceHandlerImpl::new(resource)))
+					}
+					_ => None,
+				};
+			}
+			return None;
+		}
+		None
+	}
+	fn get_raw(&self) -> *mut _cef_scheme_handler_factory_t {
+		self.object.cast()
+	}
+}
+
+impl<H: CefEventHandler> Clone for SchemeHandlerFactoryImpl<H> {
+	fn clone(&self) -> Self {
+		unsafe {
+			let rc_impl = &mut *self.object;
+			rc_impl.interface.add_ref();
+		}
+		Self {
+			object: self.object,
+			event_handler: self.event_handler.clone(),
+		}
+	}
+}
+impl<H: CefEventHandler> Rc for SchemeHandlerFactoryImpl<H> {
+	fn as_base(&self) -> &cef_base_ref_counted_t {
+		unsafe {
+			let base = &*self.object;
+			std::mem::transmute(&base.cef_object)
+		}
+	}
+}
+impl<H: CefEventHandler> WrapSchemeHandlerFactory for SchemeHandlerFactoryImpl<H> {
+	fn wrap_rc(&mut self, object: *mut RcImpl<_cef_scheme_handler_factory_t, Self>) {
+		self.object = object;
+	}
+}