mod frame_clock;
mod gl_context;
mod input;
mod ipc;
use std::cell::{Cell, RefCell};
use std::rc::{Rc, Weak};
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant};
use teksilo_canvas::live_image::{LiveImageDiffWriter, LiveImageWriter};
use teksilo_canvas::{ImageOrientation, Rect};
use teksilo_core::AppEventPoster;
use teksilo_core::raw_handle::ParentHandle;
use teksilo_core::window::TeksiloWindowId;
use dpi::PhysicalSize;
use euclid::Scale;
use servo::protocol_handler::ProtocolRegistry;
use servo::{
ConsoleLogLevel, Cursor, EmbedderControl, EmbedderControlId, EventLoopWaker, LoadStatus,
NavigationRequest, RenderingContext, SelectElement, SelectElementOptionOrOptgroup, Servo,
ServoBuilder, SimpleDialog, UserContentManager, UserScript, WebView as ServoWebView,
WebViewBuilder, WebViewDelegate,
};
use teksilo_core::widget::CursorIcon;
use url::Url;
use crate::controls::{WebViewControl, WebViewControlAnswer, WebViewSelectOption};
use crate::backend::{
ConsoleLevel, NoopWebViewHandle, WebSource, WebViewAttributes, WebViewBackend, WebViewEvent,
WebViewHandle, WebViewId, WebViewInputEvent, WebViewRendering, js_string, post_event,
post_pump,
};
use frame_clock::FrameClock;
use gl_context::{AdapterKind, HeadlessGlContext};
const READ_WAIT: Duration = Duration::from_millis(2);
const READ_RETRY: Duration = Duration::from_millis(3);
#[derive(Default)]
pub struct ServoBackend {
engine: Option<Rc<Engine>>,
}
impl std::fmt::Debug for ServoBackend {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ServoBackend")
.field("engine_built", &self.engine.is_some())
.finish()
}
}
impl ServoBackend {
pub fn new() -> Self {
Self::default()
}
}
static ENGINE_BUILT: AtomicBool = AtomicBool::new(false);
#[derive(Debug, PartialEq, Eq)]
struct EngineTaken;
fn shared_engine<T: Clone>(
slot: &mut Option<T>,
built: &AtomicBool,
build: impl FnOnce() -> T,
) -> Result<T, EngineTaken> {
if let Some(engine) = slot {
return Ok(engine.clone());
}
if built.swap(true, Ordering::AcqRel) {
return Err(EngineTaken);
}
Ok(slot.insert(build()).clone())
}
fn fail(
poster: &Option<Arc<dyn AppEventPoster>>,
window_id: TeksiloWindowId,
web_view_id: WebViewId,
text: String,
) -> Box<dyn WebViewHandle> {
post_event(
poster,
window_id,
web_view_id,
WebViewEvent::ConsoleMessage {
level: ConsoleLevel::Error,
text,
},
);
post_event(
poster,
window_id,
web_view_id,
WebViewEvent::NavigationFinished {
url: String::new(),
success: false,
},
);
Box::new(NoopWebViewHandle)
}
#[derive(Clone)]
struct ServoWaker {
inner: Arc<WakerState>,
}
struct WakerState {
posted: AtomicBool,
poster: Option<Arc<dyn AppEventPoster>>,
}
impl ServoWaker {
fn new(poster: Option<Arc<dyn AppEventPoster>>) -> Self {
Self {
inner: Arc::new(WakerState {
posted: AtomicBool::new(false),
poster,
}),
}
}
fn answered(&self) {
self.inner.posted.store(false, Ordering::Release);
}
}
impl EventLoopWaker for ServoWaker {
fn clone_box(&self) -> Box<dyn EventLoopWaker> {
Box::new(self.clone())
}
fn wake(&self) {
if !self.inner.posted.swap(true, Ordering::AcqRel) {
post_pump(&self.inner.poster);
}
}
}
struct Engine {
servo: Servo,
waker: ServoWaker,
clock: FrameClock,
views: RefCell<Vec<Weak<View>>>,
routes: ipc::Routes,
user_content: Rc<UserContentManager>,
}
impl Engine {
fn start(poster: Option<Arc<dyn AppEventPoster>>) -> Rc<Self> {
let waker = ServoWaker::new(poster);
let clock_waker = waker.clone();
let clock = FrameClock::start(move || clock_waker.wake());
let routes = ipc::Routes::default();
let mut protocols = ProtocolRegistry::default();
let _ = protocols.register(
ipc::IPC_SCHEME,
ipc::IpcHandler {
routes: routes.clone(),
},
);
let preferences = servo::Preferences {
accessibility_enabled: true,
..Default::default()
};
let servo = ServoBuilder::default()
.preferences(preferences)
.event_loop_waker(Box::new(waker.clone()))
.protocol_registry(protocols)
.build();
let user_content = Rc::new(UserContentManager::new(&servo));
user_content.add_script(Rc::new(UserScript::new(ipc::IPC_SCRIPT.to_string(), None)));
Rc::new(Self {
servo,
waker,
clock,
views: RefCell::new(Vec::new()),
routes,
user_content,
})
}
fn pump(&self) {
self.waker.answered();
self.servo.spin_event_loop();
let views: Vec<Rc<View>> = {
let mut views = self.views.borrow_mut();
views.retain(|view| view.strong_count() > 0);
views.iter().filter_map(Weak::upgrade).collect()
};
let now = Instant::now();
for view in views {
view.present(&self.clock, now);
}
}
}
struct View {
gl: Rc<HeadlessGlContext>,
webview: RefCell<Option<ServoWebView>>,
picture: RefCell<LiveImageDiffWriter>,
frame_ready: Cell<bool>,
shown: Cell<bool>,
size: Cell<PhysicalSize<u32>>,
scale: Cell<f32>,
inline_url: RefCell<Option<String>>,
controls: RefCell<std::collections::HashMap<u64, PendingControl>>,
next_control: Cell<u64>,
}
enum PendingControl {
Dialog(SimpleDialog),
Select(SelectElement),
}
impl View {
fn present(&self, clock: &FrameClock, now: Instant) {
if self.gl.reads_pending() {
let mut picture = self.picture.borrow_mut();
self.gl.finish_reads(READ_WAIT, &mut |rows, width, height| {
let _ = picture.write_frame(width, height, rows, width as usize * 4);
});
if self.gl.reads_pending() {
clock.wake_at(now + READ_RETRY);
}
}
if !self.frame_ready.get() || !self.shown.get() {
return;
}
self.frame_ready.set(false);
let Some(webview) = self.webview.borrow().clone() else {
return;
};
webview.paint();
self.gl.begin_read();
clock.wake_at(now + READ_RETRY);
}
}
struct ServoEventDelegate {
view: Weak<View>,
poster: Option<Arc<dyn AppEventPoster>>,
window_id: TeksiloWindowId,
web_view_id: WebViewId,
}
impl ServoEventDelegate {
fn post(&self, event: WebViewEvent) {
post_event(&self.poster, self.window_id, self.web_view_id, event);
}
fn reported(&self, url: String) -> String {
let inline = self
.view
.upgrade()
.is_some_and(|view| view.inline_url.borrow().as_deref() == Some(url.as_str()));
if inline {
"about:blank".to_string()
} else {
url
}
}
}
impl WebViewDelegate for ServoEventDelegate {
fn notify_new_frame_ready(&self, _webview: ServoWebView) {
if let Some(view) = self.view.upgrade() {
view.frame_ready.set(true);
}
}
fn notify_load_status_changed(&self, webview: ServoWebView, status: LoadStatus) {
match status {
LoadStatus::Started => self.post(WebViewEvent::PageLoadStarted),
LoadStatus::HeadParsed => {}
LoadStatus::Complete => {
self.post(WebViewEvent::PageLoadFinished);
self.post(WebViewEvent::NavigationFinished {
url: self.reported(webview.url().map(|u| u.to_string()).unwrap_or_default()),
success: true,
});
}
}
}
fn notify_page_title_changed(&self, _webview: ServoWebView, title: Option<String>) {
self.post(WebViewEvent::TitleChanged(title.unwrap_or_default()));
}
fn request_navigation(&self, _webview: ServoWebView, request: NavigationRequest) {
self.post(WebViewEvent::NavigationStarted {
url: self.reported(request.url.to_string()),
can_cancel: false,
});
drop(request);
}
fn notify_url_changed(&self, _webview: ServoWebView, url: Url) {
self.post(WebViewEvent::NavigationFinished {
url: self.reported(url.to_string()),
success: true,
});
}
fn notify_focus_changed(&self, _webview: ServoWebView, focused: bool) {
self.post(WebViewEvent::EngineFocusChanged(focused));
}
fn notify_accessibility_tree_update(
&self,
_webview: ServoWebView,
update: servo::accesskit::TreeUpdate,
) {
if let Some(update) = page_accessibility(&update) {
self.post(WebViewEvent::PageAccessibility(update));
}
}
fn notify_cursor_changed(&self, _webview: ServoWebView, cursor: Cursor) {
self.post(WebViewEvent::CursorChanged(cursor_icon(cursor)));
}
fn show_embedder_control(&self, _webview: ServoWebView, control: EmbedderControl) {
let device_rect = |r: servo::DeviceIntRect| {
Rect::new(
r.min.x as f32,
r.min.y as f32,
r.width() as f32,
r.height() as f32,
)
};
let (pending, described) = match control {
EmbedderControl::InputMethod(input) => {
self.post(WebViewEvent::InputMethodArea(Some(device_rect(
input.position(),
))));
return;
}
EmbedderControl::SimpleDialog(dialog) => {
let described = match &dialog {
SimpleDialog::Alert(alert) => WebViewControl::Alert {
message: alert.message().to_string(),
},
SimpleDialog::Confirm(confirm) => WebViewControl::Confirm {
message: confirm.message().to_string(),
},
SimpleDialog::Prompt(prompt) => WebViewControl::Prompt {
message: prompt.message().to_string(),
default: prompt.current_value().to_string(),
},
};
(PendingControl::Dialog(dialog), described)
}
EmbedderControl::SelectElement(select) => {
let described = WebViewControl::Select {
options: select_options(select.options()),
selected: select.selected_options().first().copied(),
area: device_rect(select.position()),
};
(PendingControl::Select(select), described)
}
_ => return,
};
let Some(view) = self.view.upgrade() else {
return;
};
let key = view.next_control.get();
view.next_control.set(key + 1);
view.controls.borrow_mut().insert(key, pending);
self.post(WebViewEvent::ControlRequested {
key,
control: described,
});
}
fn hide_embedder_control(&self, _webview: ServoWebView, _id: EmbedderControlId) {
self.post(WebViewEvent::InputMethodArea(None));
}
fn show_console_message(&self, _webview: ServoWebView, level: ConsoleLogLevel, text: String) {
self.post(WebViewEvent::ConsoleMessage {
level: console_level(level),
text,
});
}
}
fn page_accessibility(
update: &servo::accesskit::TreeUpdate,
) -> Option<crate::PageAccessibilityUpdate> {
let value = serde_json::to_value(update).ok()?;
let update: teksilo_core::accesskit::TreeUpdate = serde_json::from_value(value).ok()?;
Some(crate::PageAccessibilityUpdate {
root: update.tree.map(|tree| tree.root.0),
nodes: update
.nodes
.into_iter()
.map(|(id, node)| (id.0, node))
.collect(),
})
}
fn select_options(options: &[SelectElementOptionOrOptgroup]) -> Vec<WebViewSelectOption> {
let mut out = Vec::new();
for entry in options {
match entry {
SelectElementOptionOrOptgroup::Option(option) => out.push(WebViewSelectOption {
id: option.id,
label: option.label.clone(),
disabled: option.is_disabled,
group: None,
}),
SelectElementOptionOrOptgroup::Optgroup { label, options } => {
out.extend(options.iter().map(|option| WebViewSelectOption {
id: option.id,
label: option.label.clone(),
disabled: option.is_disabled,
group: Some(label.clone()),
}));
}
}
}
out
}
fn cursor_icon(cursor: Cursor) -> CursorIcon {
match cursor {
Cursor::Pointer | Cursor::Alias | Cursor::ContextMenu => CursorIcon::Pointer,
Cursor::Text | Cursor::VerticalText => CursorIcon::Text,
Cursor::Crosshair | Cursor::Cell => CursorIcon::Crosshair,
Cursor::Move | Cursor::AllScroll => CursorIcon::Move,
Cursor::NotAllowed | Cursor::NoDrop => CursorIcon::NotAllowed,
Cursor::Grab => CursorIcon::Grab,
Cursor::Grabbing => CursorIcon::Grabbing,
Cursor::EResize | Cursor::WResize | Cursor::EwResize | Cursor::ColResize => {
CursorIcon::ColResize
}
Cursor::NResize | Cursor::SResize | Cursor::NsResize | Cursor::RowResize => {
CursorIcon::RowResize
}
Cursor::NeResize | Cursor::SwResize | Cursor::NeswResize => CursorIcon::NeswResize,
Cursor::NwResize | Cursor::SeResize | Cursor::NwseResize => CursorIcon::NwseResize,
_ => CursorIcon::Default,
}
}
fn console_level(level: ConsoleLogLevel) -> ConsoleLevel {
match level {
ConsoleLogLevel::Warn => ConsoleLevel::Warn,
ConsoleLogLevel::Error => ConsoleLevel::Error,
ConsoleLogLevel::Log
| ConsoleLogLevel::Debug
| ConsoleLogLevel::Info
| ConsoleLogLevel::Trace
| ConsoleLogLevel::Dir => ConsoleLevel::Log,
}
}
impl WebViewBackend for ServoBackend {
fn rendering(&self) -> WebViewRendering {
WebViewRendering::Surface {
orientation: ImageOrientation::FlipVertical,
}
}
fn open(
&mut self,
web_view_id: WebViewId,
window_id: TeksiloWindowId,
_parent: Option<ParentHandle>,
attrs: WebViewAttributes,
poster: Option<Arc<dyn AppEventPoster>>,
surface: Option<LiveImageWriter>,
) -> Box<dyn WebViewHandle> {
let Some(surface) = surface else {
return fail(
&poster,
window_id,
web_view_id,
"ServoBackend: opened without a picture to render into".to_string(),
);
};
let engine_poster = poster.clone();
let engine = match shared_engine(&mut self.engine, &ENGINE_BUILT, || {
Engine::start(engine_poster)
}) {
Ok(engine) => engine,
Err(EngineTaken) => {
return fail(
&poster,
window_id,
web_view_id,
"ServoBackend: this process already built its one Servo engine for another \
backend, and Servo allows only one; install a single ServoBackend"
.to_string(),
);
}
};
let size = PhysicalSize::new(1, 1);
let gl = match HeadlessGlContext::new(size, Rc::new(engine.clock.driver())) {
Ok(gl) => Rc::new(gl),
Err(error) => {
return fail(
&poster,
window_id,
web_view_id,
format!("ServoBackend: no OpenGL context to render into: {error:?}"),
);
}
};
if gl.adapter() == AdapterKind::Software {
post_event(
&poster,
window_id,
web_view_id,
WebViewEvent::ConsoleMessage {
level: ConsoleLevel::Warn,
text: format!(
"ServoBackend: no hardware OpenGL adapter, rendering on {}",
gl.renderer()
),
},
);
}
let view = Rc::new(View {
gl: gl.clone(),
webview: RefCell::new(None),
picture: RefCell::new(LiveImageDiffWriter::new(surface)),
frame_ready: Cell::new(false),
shown: Cell::new(true),
size: Cell::new(size),
scale: Cell::new(1.0),
inline_url: RefCell::new(None),
controls: RefCell::new(std::collections::HashMap::new()),
next_control: Cell::new(0),
});
let delegate: Rc<dyn WebViewDelegate> = Rc::new(ServoEventDelegate {
view: Rc::downgrade(&view),
poster: poster.clone(),
window_id,
web_view_id,
});
let mut builder = WebViewBuilder::new(&engine.servo, gl as Rc<dyn RenderingContext>)
.delegate(delegate)
.user_content_manager(engine.user_content.clone())
.hidpi_scale_factor(Scale::new(1.0));
if let Some(url) = attrs.source.as_ref().and_then(source_url) {
if matches!(attrs.source, Some(WebSource::Html { .. })) {
*view.inline_url.borrow_mut() = Some(url.to_string());
}
builder = builder.url(url);
}
let webview = builder.build();
let _ = webview.set_accessibility_active(true);
engine
.routes
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.insert(
webview.id(),
ipc::Route {
web_view_id,
window_id,
poster: poster.clone(),
},
);
*view.webview.borrow_mut() = Some(webview);
engine.views.borrow_mut().push(Rc::downgrade(&view));
Box::new(ServoHandle { engine, view })
}
fn pump(&mut self) {
if let Some(engine) = &self.engine {
engine.pump();
}
}
}
fn source_url(source: &WebSource) -> Option<Url> {
match source {
WebSource::Url(url) => Url::parse(url).ok(),
WebSource::Html { html, .. } => html_url(html),
}
}
fn html_url(html: &str) -> Option<Url> {
let mut url = String::with_capacity(html.len() + 32);
url.push_str("data:text/html;charset=utf-8,");
for byte in html.bytes() {
if byte.is_ascii_alphanumeric() || b"-_.~".contains(&byte) {
url.push(byte as char);
} else {
url.push_str(&format!("%{byte:02X}"));
}
}
Url::parse(&url).ok()
}
struct ServoHandle {
engine: Rc<Engine>,
view: Rc<View>,
}
impl Drop for ServoHandle {
fn drop(&mut self) {
if let Some(webview) = self.view.webview.borrow().as_ref() {
self.engine
.routes
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.remove(&webview.id());
}
}
}
impl ServoHandle {
fn with_webview(&self, f: impl FnOnce(&ServoWebView)) {
if let Some(webview) = self.view.webview.borrow().as_ref() {
f(webview);
}
}
}
impl WebViewHandle for ServoHandle {
fn set_bounds(&self, bounds: Rect, scale_factor: f32) {
let scale = if scale_factor.is_finite() && scale_factor > 0.0 {
scale_factor
} else {
1.0
};
let size = PhysicalSize::new(
(bounds.width * scale).round().max(1.0) as u32,
(bounds.height * scale).round().max(1.0) as u32,
);
let view = &self.view;
if (view.scale.get() - scale).abs() > f32::EPSILON {
view.scale.set(scale);
self.with_webview(|w| w.set_hidpi_scale_factor(Scale::new(scale)));
}
let limit = view.gl.max_surface_size();
let size = PhysicalSize::new(size.width.min(limit), size.height.min(limit));
if view.size.get() != size {
view.size.set(size);
self.with_webview(|w| w.resize(size));
}
}
fn load_url(&self, url: &str) {
if let Ok(parsed) = Url::parse(url) {
self.with_webview(|w| w.load(parsed));
}
}
fn load_html(&self, html: &str, _base_url: Option<&str>) {
if let Some(url) = html_url(html) {
*self.view.inline_url.borrow_mut() = Some(url.to_string());
self.with_webview(|w| w.load(url));
}
}
fn eval(&self, script: &str) {
self.with_webview(|w| w.evaluate_javascript(script.to_string(), |_result| {}));
}
fn post_message(&self, msg: &str) {
let script = format!(
"window.dispatchEvent(new MessageEvent('teksilo-message',{{data:{}}}))",
js_string(msg)
);
self.with_webview(|w| w.evaluate_javascript(script, |_result| {}));
}
fn reload(&self) {
self.with_webview(|w| w.reload());
}
fn go_back(&self) {
self.with_webview(|w| {
w.go_back(1);
});
}
fn go_forward(&self) {
self.with_webview(|w| {
w.go_forward(1);
});
}
fn stop(&self) {
self.eval("window.stop()");
}
fn set_visible(&self, visible: bool) {
self.view.shown.set(visible);
self.with_webview(|w| {
if visible {
w.show();
} else {
w.hide();
}
w.set_throttled(!visible);
});
if visible && self.view.frame_ready.get() {
self.engine.waker.wake();
}
}
fn set_focus(&self) {
self.with_webview(|w| w.focus());
}
fn blur(&self) {
self.with_webview(|w| w.blur());
}
fn answer_control(&self, key: u64, answer: WebViewControlAnswer) {
let Some(control) = self.view.controls.borrow_mut().remove(&key) else {
return;
};
match (control, answer) {
(PendingControl::Dialog(SimpleDialog::Alert(alert)), _) => alert.confirm(),
(
PendingControl::Dialog(SimpleDialog::Confirm(confirm)),
WebViewControlAnswer::Confirmed,
) => confirm.confirm(),
(
PendingControl::Dialog(SimpleDialog::Prompt(mut prompt)),
WebViewControlAnswer::Text(text),
) => {
prompt.set_current_value(&text);
prompt.confirm();
}
(PendingControl::Select(mut select), WebViewControlAnswer::Selected(id)) => {
select.select(vec![id]);
select.submit();
}
(PendingControl::Dialog(SimpleDialog::Confirm(confirm)), _) => confirm.dismiss(),
(PendingControl::Dialog(SimpleDialog::Prompt(prompt)), _) => prompt.dismiss(),
(PendingControl::Select(_), _) => {}
}
}
fn set_input_passthrough(&self, _passthrough: bool) {
}
fn send_input(&self, event: &WebViewInputEvent) {
let Some(event) = input::to_servo(event, self.view.scale.get()) else {
return;
};
self.with_webview(|w| {
w.notify_input_event(event);
});
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_backend_builds_its_engine_once_and_shares_it() {
let built = AtomicBool::new(false);
let mut slot = None;
let mut builds = 0;
let mut build = || {
builds += 1;
builds
};
assert_eq!(shared_engine(&mut slot, &built, &mut build), Ok(1));
assert_eq!(shared_engine(&mut slot, &built, &mut build), Ok(1));
assert_eq!(builds, 1);
}
#[test]
fn a_second_backend_in_the_process_gets_no_engine() {
let built = AtomicBool::new(false);
let mut first = None;
let mut second = None;
assert_eq!(shared_engine(&mut first, &built, || 1), Ok(1));
assert_eq!(shared_engine(&mut second, &built, || 2), Err(EngineTaken));
assert_eq!(second, None);
}
#[test]
fn inline_html_travels_as_a_data_url() {
let url = html_url("<p>a&b # 50% é</p>").expect("a data: URL");
assert_eq!(url.scheme(), "data");
assert!(
!url.as_str().contains('#'),
"a raw '#' would cut the document at a fragment: {url}"
);
assert!(url.as_str().contains("%25"), "a raw '%' is escaped: {url}");
}
}