ZacharyZhang-NY/ELY-Browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Document T13 bisect probes: capture phase bug is in ElyShell::new

Browse Source 
T13 (the still-red `user_click_in_rendered_web_canvas_reaches_input_pipeline`
guard) is now backed by five bisect probes that each reproduce one
slice of the real ElyShell render tree and assert the listener combo
still receives a simulated click. Every probe passes:

  * baseline_overlay_div_receives_simulated_click — GPUI primitives
  * baseline_overlay_with_full_listener_combo_receives_click — exact
    listener combo (on_mouse_down + capture_any_mouse_up +
    on_mouse_move + on_scroll_wheel) on a single .occlude() div
  * baseline_overlay_under_overflow_hidden_relative_receives_click —
    the relative + overflow_hidden wrapper render_web_surface uses
  * baseline_overlay_under_full_elyshell_wrapper_chain_receives_click —
    root → absolute-flex container → main-pane → content-wrapper
    → surface-wrapper chain
  * baseline_overlay_with_canvas_sibling_receives_click — adds the
    canvas viewport_tracker sibling
  * baseline_overlay_with_entity_update_in_mouse_down_receives_click —
    on_mouse_down's bubble fires entity.update (auto-notify) before
    MouseUp dispatches
  * baseline_overlay_under_root_with_track_focus_receives_click —
    the full chain wrapped in a root div with track_focus +
    on_mouse_up(Left, bubble)

The red guard meanwhile reports `hover_point = None` after
`simulate_mouse_move`, meaning input_overlay's `on_mouse_move`
also never fires — so the failure mode isn't capture-specific.
ALL of the overlay's listeners share the same `hitbox.is_hovered`
check, and it returns false in the real ElyShell tree but true in
every probe. Whatever the difference is, it is in
`ElyShell::new`'s setup (BrowserCore, Entity<InputState>,
SliderState, subscriptions, `start_external_web_surface_timer`'s
detached task) or in the `sync_address_input` call that
`navigate_active_tab` runs through Input's `set_value` — none of
which the probes touch.

The probes stay in the suite as both documentation (they encode
what is *not* the bug, narrowing the search for the next round)
and as regression guards (a future change that breaks them is a
real new regression in plain layout, not in the still-elusive
ElyShell-specific bug). Tests run as 118 passed + 1 ignored;
`cargo test -- --ignored` continues to fail with the same T7 red
guard. T13 is intentionally still in progress.
This commit is contained in:
ZacharyZhang-NY
2026-05-10 19:49:51 -04:00
parent 7f3b8b42b3
commit 94194e933e
1 changed files with 486 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/ely_app/src/shell/gpui_harness_tests.rs
+486 -7
View File
@@ -30,7 +30,7 @@ use std::sync::Arc;
use ely_domain::{TabId, UrlText};
use gpui::{
Bounds, Context, IntoElement, Modifiers, MouseButton, ParentElement, Pixels, Render,
Styled, TestAppContext, Window, div, point, px,
Styled, TestAppContext, Window, canvas, div, point, px,
};
use gpui::InteractiveElement;
@@ -143,11 +143,34 @@ async fn user_click_in_rendered_web_canvas_reaches_input_pipeline(
regression test catches the upstream failure mode separately",
);
let surface_state_label = shell.read_with(cx, |shell, _| {
match shell
.web_surfaces_for_test()
.surface_for_test(&active_tab_id)
.and_then(|s| s.state.as_ref())
{
Some(super::web_surface_state::WebSurfaceState::Ready(_)) => "Ready",
Some(super::web_surface_state::WebSurfaceState::Loading { .. }) => "Loading",
Some(super::web_surface_state::WebSurfaceState::Failed { .. }) => "Failed",
None => "None",
}
});
let click_at = point(
bounds.origin.x + bounds.size.width / 2.0,
bounds.origin.y + bounds.size.height / 2.0,
);
cx.simulate_mouse_move(click_at, None, Modifiers::default());
cx.run_until_parked();
let hover_point_after_move = shell.read_with(cx, |shell, _| {
shell
.web_surfaces_for_test()
.surface_for_test(&active_tab_id)
.and_then(|surface| surface.hover_point)
.map(|point| (point.x(), point.y()))
});
cx.simulate_click(click_at, Modifiers::default());
cx.run_until_parked();
@@ -160,16 +183,472 @@ async fn user_click_in_rendered_web_canvas_reaches_input_pipeline(
assert!(
click_point.is_some(),
"TDD red: clicked at {click_at:?} inside the measured \
viewport_bounds {bounds:?}, yet WebSurfaceStore.click_point is \
None. The MouseUp event reached the window but was not delivered \
to input_overlay's capture_any_mouse_up listener. Diagnosis: \
walk rendered_frame.mouse_listeners ordering vs hitbox \
content_mask for the overlay — likely an ancestor with \
stop_propagation or a sibling occluding the hitbox."
viewport_bounds {bounds:?} (state = {surface_state_label}, \
hover_point after move = {hover_point_after_move:?}), yet \
WebSurfaceStore.click_point is None. If hover_point is \
Some, input_overlay's on_mouse_move listener fires but \
capture_any_mouse_up does not — capture phase specifically \
is being eaten."
);
});
}
/// Bisect probe for T7: same listener combo as `input_overlay`, but
/// wrap it in the exact `.relative().size_full().min_w_0().overflow_hidden()`
/// shell that `render_web_surface` puts around it after the layout
/// fix in 840255f. If this passes, the bug is upstream of the
/// relative wrapper itself.
#[gpui::test]
async fn baseline_overlay_under_overflow_hidden_relative_receives_click(
cx: &mut TestAppContext,
) {
let click_count = Rc::new(RefCell::new(0u32));
let counter_for_render = click_count.clone();
struct WrappedProbe {
on_up_counter: Rc<RefCell<u32>>,
}
impl Render for WrappedProbe {
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
let counter = self.on_up_counter.clone();
div()
.relative()
.size_full()
.min_w_0()
.overflow_hidden()
.child(
div()
.absolute()
.size_full()
.occlude()
.on_mouse_down(MouseButton::Left, |_event, _window, _cx| {})
.capture_any_mouse_up(move |_event, _window, _cx| {
*counter.borrow_mut() += 1;
})
.on_mouse_move(|_event, _window, _cx| {})
.on_scroll_wheel(|_event, _window, _cx| {}),
)
}
}
let (_probe, cx) = cx.add_window_view(|_window, _cx| WrappedProbe {
on_up_counter: counter_for_render,
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(100.0), px(100.0)), None, Modifiers::default());
cx.simulate_click(point(px(100.0), px(100.0)), Modifiers::default());
cx.run_until_parked();
assert_eq!(
*click_count.borrow(),
1,
"Bisect: wrapping the input_overlay's listener combo in a \
.relative().size_full().min_w_0().overflow_hidden() parent (the \
exact shell render_web_surface uses) should still deliver the \
click. If this fails, the overflow_hidden parent itself clips the \
overlay's hitbox content_mask and the fix is to remove \
overflow_hidden from the relative wrapper or move it elsewhere."
);
}
/// Bisect probe layer 2: stack the full ElyShell wrapper chain that
/// sits between the window root and the overlay — root size_full,
/// absolute inset_0 flex container, flex_1 + flex_col main pane with
/// rounded/border/shadow/overflow_hidden, flex_1 content wrapper,
/// then the relative+overflow_hidden surface wrapper from
/// `render_web_surface`. If this passes, the bug is in something
/// `render_external_web_canvas` adds (not in the plain layout chain).
#[gpui::test]
async fn baseline_overlay_under_full_elyshell_wrapper_chain_receives_click(
cx: &mut TestAppContext,
) {
let click_count = Rc::new(RefCell::new(0u32));
let counter_for_render = click_count.clone();
struct DeepProbe {
on_up_counter: Rc<RefCell<u32>>,
}
impl Render for DeepProbe {
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
let counter = self.on_up_counter.clone();
// Root: matches render_browser's outer div.
div()
.size_full()
.child(
// Absolute flex container matches render_browser's child layout.
div()
.absolute()
.inset_0()
.p(px(16.0))
.gap(px(12.0))
.flex()
.child(
// Main pane: matches render_main_pane.
div()
.flex_1()
.h_full()
.min_w_0()
.flex()
.flex_col()
.rounded(px(18.0))
.border_1()
.overflow_hidden()
.child(
// Content wrapper: matches the flex_1 child of main_pane.
div()
.flex_1()
.overflow_hidden()
.child(
// Surface wrapper: matches render_web_surface root.
div()
.relative()
.size_full()
.min_w_0()
.overflow_hidden()
.child(
div()
.absolute()
.size_full()
.occlude()
.on_mouse_down(
MouseButton::Left,
|_event, _window, _cx| {},
)
.capture_any_mouse_up(
move |_event, _window, _cx| {
*counter.borrow_mut() += 1;
},
)
.on_mouse_move(
|_event, _window, _cx| {},
)
.on_scroll_wheel(
|_event, _window, _cx| {},
),
),
),
),
),
)
}
}
let (_probe, cx) = cx.add_window_view(|_window, _cx| DeepProbe {
on_up_counter: counter_for_render,
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(400.0), px(400.0)), None, Modifiers::default());
cx.simulate_click(point(px(400.0), px(400.0)), Modifiers::default());
cx.run_until_parked();
assert_eq!(
*click_count.borrow(),
1,
"Bisect layer 2: the full root → absolute-flex → main-pane → \
content-wrapper → surface-wrapper chain (sans listeners) \
should still deliver the click. If this fails, the bug is in \
this wrapper chain itself; if it passes, the bug is in \
something render_external_web_canvas adds (canvas tracker, \
absolute content wrapper sibling, or a gpui-component widget)."
);
}
/// Diagnostic probes (T13 bisect): each layer of the ElyShell render
/// tree was reproduced in isolation and **all passed**, confirming the
/// listener combo, layout wrapper chain, canvas sibling, entity
/// update side effects, and track_focus root listeners are NOT the
/// cause. The bug is elsewhere — likely in ElyShell::new's setup
/// (subscriptions, timer, InputState side effects) or in the
/// sync_address_input call inside navigate_active_tab that mutates
/// Input widget state which may invalidate the rendered_frame
/// between MouseMove and MouseUp. Kept for regression coverage.
/// Bisect probe layer 5: the full chain WITH the root-level
/// `track_focus + on_mouse_up(Left, bubble)` listeners ElyShell
/// puts on its outermost div. If track_focus's auto-focus MouseDown
/// handler, or the root's bubble-phase MouseUp listener, somehow
/// invalidates the rendered_frame between MouseDown and MouseUp,
/// input_overlay's hitbox will no longer match the listener
/// snapshot's id and `is_hovered` will return false. That's the
/// exact symptom we see: hover_point is None too, so it's not
/// capture-specific — every listener on input_overlay is missing
/// its hit.
#[gpui::test]
async fn baseline_overlay_under_root_with_track_focus_receives_click(
cx: &mut TestAppContext,
) {
use gpui::FocusHandle;
let click_count = Rc::new(RefCell::new(0u32));
let move_count = Rc::new(RefCell::new(0u32));
let counter_for_up = click_count.clone();
let counter_for_move = move_count.clone();
struct TrackFocusProbe {
focus: FocusHandle,
on_up_counter: Rc<RefCell<u32>>,
on_move_counter: Rc<RefCell<u32>>,
}
impl Render for TrackFocusProbe {
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
let counter_up = self.on_up_counter.clone();
let counter_move = self.on_move_counter.clone();
div()
.size_full()
.track_focus(&self.focus)
.on_mouse_up(MouseButton::Left, |_event, _window, _cx| {})
.child(
div()
.absolute()
.inset_0()
.p(px(16.0))
.gap(px(12.0))
.flex()
.child(
div()
.flex_1()
.h_full()
.min_w_0()
.flex()
.flex_col()
.rounded(px(18.0))
.border_1()
.overflow_hidden()
.child(
div()
.flex_1()
.overflow_hidden()
.child(
div()
.relative()
.size_full()
.min_w_0()
.overflow_hidden()
.child(
div()
.absolute()
.inset_0()
.child(div().size_full()),
)
.child(
canvas(
move |_b, _w, _c| {},
|_, _, _, _| {},
)
.absolute()
.size_full(),
)
.child(
div()
.absolute()
.size_full()
.occlude()
.on_mouse_down(
MouseButton::Left,
|_e, _w, _c| {},
)
.capture_any_mouse_up(
move |_e, _w, _c| {
*counter_up
.borrow_mut() += 1;
},
)
.on_mouse_move(
move |_e, _w, _c| {
*counter_move
.borrow_mut() += 1;
},
)
.on_scroll_wheel(
|_e, _w, _c| {},
),
),
),
),
),
)
}
}
let (_probe, cx) = cx.add_window_view(|_window, cx| TrackFocusProbe {
focus: cx.focus_handle(),
on_up_counter: counter_for_up,
on_move_counter: counter_for_move,
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(400.0), px(400.0)), None, Modifiers::default());
cx.run_until_parked();
cx.simulate_click(point(px(400.0), px(400.0)), Modifiers::default());
cx.run_until_parked();
assert!(
*move_count.borrow() > 0,
"Bisect layer 5: input_overlay's on_mouse_move never fired even \
though the cursor was simulated over it. The same `is_hovered` \
check fails for every listener, exactly mirroring the T7 red \
test's observation that hover_point is None."
);
assert_eq!(
*click_count.borrow(),
1,
"Bisect layer 5: capture_any_mouse_up did not fire under the \
full track_focus + bubble-mouse_up root chain. This isolates \
the culprit to the root-level listeners that ElyShell adds \
around its widget tree."
);
}
/// Bisect probe layer 4: same shape as the canvas-sibling probe but
/// the on_mouse_down listener calls `cx.update` on a self-entity
/// (mirroring `down_entity.update(cx, |shell, _| shell.focus_web_surface(window))`).
/// `entity.update` notifies subscribers; if that side effect during
/// mouse_down's bubble phase disturbs mouse dispatch — invalidates
/// the rendered_frame, regenerates hitboxes, or otherwise corrupts
/// the in-flight dispatch — the subsequent MouseUp will land on a
/// frame whose hitboxes no longer match the listeners' captured
/// snapshots, and this test will go red.
#[gpui::test]
async fn baseline_overlay_with_entity_update_in_mouse_down_receives_click(
cx: &mut TestAppContext,
) {
let click_count = Rc::new(RefCell::new(0u32));
let counter_for_render = click_count.clone();
struct EntityUpdateProbe {
on_up_counter: Rc<RefCell<u32>>,
tick: u32,
}
impl Render for EntityUpdateProbe {
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let counter = self.on_up_counter.clone();
let self_entity = cx.entity().clone();
div()
.relative()
.size_full()
.min_w_0()
.overflow_hidden()
.child(div().absolute().inset_0().child(div().size_full()))
.child(
canvas(
move |_bounds, _window, _cx| {},
|_, _, _, _| {},
)
.absolute()
.size_full(),
)
.child(
div()
.absolute()
.size_full()
.occlude()
.on_mouse_down(MouseButton::Left, move |_event, _window, cx| {
self_entity.update(cx, |probe, _cx| {
probe.tick += 1;
});
})
.capture_any_mouse_up(move |_event, _window, _cx| {
*counter.borrow_mut() += 1;
})
.on_mouse_move(|_event, _window, _cx| {})
.on_scroll_wheel(|_event, _window, _cx| {}),
)
}
}
let (_probe, cx) = cx.add_window_view(|_window, _cx| EntityUpdateProbe {
on_up_counter: counter_for_render,
tick: 0,
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(400.0), px(400.0)), None, Modifiers::default());
cx.simulate_click(point(px(400.0), px(400.0)), Modifiers::default());
cx.run_until_parked();
assert_eq!(
*click_count.borrow(),
1,
"Bisect layer 4: on_mouse_down's bubble fires entity.update \
which automatically notifies subscribers. If this test fails, \
the cx.notify side effect during in-flight dispatch corrupts \
the rendered_frame for the immediately-following MouseUp."
);
}
/// Bisect probe layer 3: add a canvas sibling BEFORE the overlay,
/// matching render_web_surface's viewport_tracker sibling exactly.
/// The canvas's prepaint callback fires during paint phase; if it
/// somehow disturbs hitbox registration or mouse_listeners ordering,
/// this test will go red and pinpoint the suspect.
#[gpui::test]
async fn baseline_overlay_with_canvas_sibling_receives_click(
cx: &mut TestAppContext,
) {
let click_count = Rc::new(RefCell::new(0u32));
let counter_for_render = click_count.clone();
struct CanvasSiblingProbe {
on_up_counter: Rc<RefCell<u32>>,
}
impl Render for CanvasSiblingProbe {
fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
let counter = self.on_up_counter.clone();
div()
.relative()
.size_full()
.min_w_0()
.overflow_hidden()
.child(
div()
.absolute()
.inset_0()
.child(div().size_full()),
)
.child(
canvas(
move |_bounds, _window, _cx| {},
|_, _, _, _| {},
)
.absolute()
.size_full(),
)
.child(
div()
.absolute()
.size_full()
.occlude()
.on_mouse_down(MouseButton::Left, |_event, _window, _cx| {})
.capture_any_mouse_up(move |_event, _window, _cx| {
*counter.borrow_mut() += 1;
})
.on_mouse_move(|_event, _window, _cx| {})
.on_scroll_wheel(|_event, _window, _cx| {}),
)
}
}
let (_probe, cx) = cx.add_window_view(|_window, _cx| CanvasSiblingProbe {
on_up_counter: counter_for_render,
});
cx.run_until_parked();
cx.simulate_mouse_move(point(px(400.0), px(400.0)), None, Modifiers::default());
cx.simulate_click(point(px(400.0), px(400.0)), Modifiers::default());
cx.run_until_parked();
assert_eq!(
*click_count.borrow(),
1,
"Bisect layer 3: adding a canvas sibling (the shape \
render_viewport_tracker uses) between the content wrapper and \
the overlay should not break click delivery. If this fails, \
the canvas element itself disturbs mouse dispatch — likely \
via its prepaint callback's interaction with hit_test."
);
}
#[gpui::test]
async fn baseline_overlay_with_full_listener_combo_receives_click(
cx: &mut TestAppContext,