Bridge web surface keyboard input

2026-05-08 14:49:57 -04:00
parent 292824dc10
commit 21a72e157a
9 changed files with 485 additions and 159 deletions
@@ -0,0 +1,192 @@
+use ely_domain::{BrowserTab, TabId};
+use gpui::{AnyElement, Bounds, Context, Pixels, Point};
+
+use crate::services::servo_sidecar::{ServoSidecarError, SidecarSnapshot};
+
+use super::{
+    ElyShell,
+    web_surface_frame::WebSurfaceFrame,
+    web_surface_geometry::{WebSurfaceClickPoint, WebSurfaceScrollOffset, WebSurfaceSize},
+    web_surface_state::{WebSurfaceRequest, WebSurfaceState},
+    web_surface_view::{
+        render_failed_web_surface, render_loading_web_surface, render_ready_web_surface,
+    },
+};
+
+struct PendingWebSurfaceFrame {
+    tab_id: TabId,
+    requested_url: String,
+    size: WebSurfaceSize,
+    scroll_offset: WebSurfaceScrollOffset,
+    click_point: Option<WebSurfaceClickPoint>,
+    typed_text: Option<String>,
+}
+
+impl ElyShell {
+    pub(super) fn render_external_web_canvas(
+        &mut self,
+        tab: &BrowserTab,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        self.ensure_external_web_frame(tab, cx);
+
+        let state_entity = cx.entity().clone();
+        match self.web_surfaces.state(tab.id()) {
+            Some(WebSurfaceState::Ready(frame)) => {
+                render_ready_web_surface(frame, tab, state_entity)
+            }
+            Some(WebSurfaceState::Failed { message, .. }) => {
+                render_failed_web_surface(tab, message.as_str(), state_entity)
+            }
+            Some(WebSurfaceState::Loading { previous_frame: Some(frame), .. }) => {
+                render_ready_web_surface(frame, tab, state_entity)
+            }
+            Some(WebSurfaceState::Loading { previous_frame: None, .. }) | None => {
+                render_loading_web_surface(tab, state_entity)
+            }
+        }
+    }
+
+    fn ensure_external_web_frame(&mut self, tab: &BrowserTab, cx: &mut Context<Self>) {
+        let Some(request) = self.web_surfaces.prepare_request(tab) else {
+            return;
+        };
+
+        let WebSurfaceRequest {
+            tab_id,
+            requested_url,
+            size,
+            scroll_offset,
+            click_point,
+            typed_text,
+            client,
+            snapshot_request,
+        } = request;
+        let pending_frame = PendingWebSurfaceFrame {
+            tab_id,
+            requested_url,
+            size,
+            scroll_offset,
+            click_point,
+            typed_text,
+        };
+        cx.spawn(async move |shell, cx| {
+            let result = cx
+                .background_executor()
+                .spawn(async move { client.snapshot(snapshot_request) })
+                .await;
+
+            _ = shell.update(cx, |shell, cx| {
+                shell.handle_external_web_frame_result(pending_frame, result);
+                cx.notify();
+            });
+        })
+        .detach();
+    }
+
+    fn handle_external_web_frame_result(
+        &mut self,
+        pending_frame: PendingWebSurfaceFrame,
+        result: Result<SidecarSnapshot, ServoSidecarError>,
+    ) {
+        let PendingWebSurfaceFrame {
+            tab_id,
+            requested_url,
+            size,
+            scroll_offset,
+            click_point,
+            typed_text,
+        } = pending_frame;
+        if !self.web_surfaces.is_loading(
+            &tab_id,
+            requested_url.as_str(),
+            size,
+            scroll_offset,
+            click_point,
+            typed_text.as_deref(),
+        ) {
+            return;
+        }
+
+        let state = match result {
+            Ok(snapshot) => match WebSurfaceFrame::from_snapshot(
+                requested_url.clone(),
+                scroll_offset,
+                click_point,
+                typed_text.clone(),
+                snapshot,
+            ) {
+                Ok(frame) => WebSurfaceState::Ready(frame),
+                Err(error) => WebSurfaceState::Failed {
+                    requested_url,
+                    size,
+                    scroll_offset,
+                    click_point,
+                    typed_text,
+                    message: error.to_string(),
+                },
+            },
+            Err(error) => WebSurfaceState::Failed {
+                requested_url,
+                size,
+                scroll_offset,
+                click_point,
+                typed_text,
+                message: error.to_string(),
+            },
+        };
+        self.web_surfaces.finish(tab_id, state);
+    }
+
+    pub(super) fn record_external_web_viewport(
+        &mut self,
+        tab_id: TabId,
+        bounds: Bounds<Pixels>,
+        cx: &mut Context<Self>,
+    ) {
+        if self.web_surfaces.record_viewport_size(&tab_id, bounds) {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn scroll_external_web_viewport(
+        &mut self,
+        tab_id: TabId,
+        requested_url: String,
+        delta: gpui::Point<Pixels>,
+        cx: &mut Context<Self>,
+    ) {
+        if self.web_surfaces.record_scroll_delta(&tab_id, requested_url.as_str(), delta) {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn click_external_web_viewport(
+        &mut self,
+        tab_id: TabId,
+        requested_url: String,
+        position: Point<Pixels>,
+        window: &mut gpui::Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.focus_handle.focus(window);
+        if self.web_surfaces.record_click_point(&tab_id, requested_url.as_str(), position) {
+            cx.notify();
+        }
+    }
+
+    pub(super) fn type_text_in_external_web_viewport(
+        &mut self,
+        tab_id: TabId,
+        requested_url: String,
+        text: &str,
+        cx: &mut Context<Self>,
+    ) -> bool {
+        if self.web_surfaces.record_typed_text(&tab_id, requested_url.as_str(), text) {
+            cx.notify();
+            return true;
+        }
+
+        false
+    }
+}