Struct TestEngine 

pub struct TestEngine { /* private fields */ }

Implementations

impl TestEngine

pub fn new() -> Arc<TestEngine>

pub fn commands(&self) -> Vec<WebViewCommand>

Every command received so far, in order.

pub fn current_uri(&self) -> Option<String>

pub fn set_media_element(&self, media: Option<MediaElementInfo>)

Configure the deterministic response to a media-element probe.

pub fn visibility_changes(&self) -> Vec<bool>

Every visibility change the engine was told, oldest first.

pub fn set_paint_snapshot(&self, snapshot: impl Into<String>)

Answer every later paint capture with this layout snapshot (raw DOMSnapshot JSON), as a real engine would for its current page.

pub fn set_measures_document(&self, measures: bool)

Say the engine measures its document (answers WebViewCommand::ReportDocumentSize), as a ready host that can does.

pub fn push_new_tab_request(&self, url: impl Into<String>)

Say the page asked to open url in a new window, as a link the person followed does.

pub fn push_popup( &self, id: u32, url: impl Into<String>, width: u32, height: u32, )

Say the page opened a popup, as window.open with a size does. An engine nobody asked for popups ignores it, as Chromium’s opens it as a tab.

pub fn accepts_popups(&self) -> bool

Whether it was asked for the page’s popups.

pub fn accepts_page_dialogs(&self) -> bool

Whether it was asked for the page’s own questions.

pub fn created_tabs(&self) -> Vec<Arc<TestEngine>>

The tabs it created, oldest first.

pub fn adopted(&self, id: u32) -> Option<Arc<TestEngine>>

The engine a popup was adopted as.

pub fn set_selection(&self, text: impl Into<String>)

Say the page has text selected: a later WebViewCommand::CopySelection answers with it.

pub fn set_text_field(&self, field: Option<TextField>)

Report the page’s focused field (None: nothing editable has the focus), as a host that takes compositions does.

pub fn hold_frames(&self, hold: bool)

Hold back every frame, as a renderer still laying out a page does, or paint the page at the view’s current size now.

pub fn mark_page_end(&self)

Paint its pages with a document’s end mark: the bottom-right 2×2 pixels one level off the page beneath, as a mail’s document marks them (mix-blend-mode: difference with rgb(1,1,1)).

pub fn paint_before_page(&self)

Paint the view at its current size in the page’s background colour and nothing of the page, as Chromium paints a resized view before the page has drawn there.

pub fn paint_stale(&self, width: u32, height: u32)

Deliver a frame painted for an earlier width × height, as an engine does that finishes a paint after the view has moved on.

pub fn fail_address(&self, uri: impl Into<String>, error: impl Into<String>)

Make every load of uri fail with the network error (ERR_CONNECTION_REFUSED), as an unreachable site does: the engine reports the address, the failure and its history, and an owned navigation’s outcome carries the error.

pub fn push_event(&self, event: WebViewEvent)

Deliver event on the next drain, as the engine would on its own (a page reporting its document size).

pub fn set_page_capture(&self, image: impl Into<Vec<u8>>)

Answer every later page capture with these pixels (a PNG), as a real engine paints the page it shows.

pub fn push_page_reply(&self, reply: Result<PageReply, PageFailure>)

Queue the answer to the next page request. Without one, an outline is a single document line and every other request succeeds.

pub fn page_color(uri: &str) -> [u8; 3]

Stable page colour for a URL — exposed so tests can compute the expected pixels.

Trait Implementations

impl WebViewEngine for TestEngine

fn measures_document(&self) -> bool

Whether WebViewCommand::ReportDocumentSize is answered: the engine measures its document. Known once the engine is ready.

fn supports_composition(&self) -> bool

Whether the engine takes an input method’s composition (WebViewCommand::ImeComposition, WebViewCommand::ImeCommit) and reports the page’s focused field (Self::text_field).

fn text_field(&self) -> Option<TextField>

The page’s focused editable field, for the platform input method; None while nothing editable in the page has the focus.

fn take_new_tab_requests(&self) -> Vec<(String, bool)>

Native new-window intents, delivered to browser chrome as tab requests.

fn create_tab(&self) -> Result<Arc<dyn WebViewEngine>, String>

Create an independent document in the same runtime/profile.

fn accept_popups(&self)

Have the page’s popup windows (window.open with a size: a sign-in, a payment) opened as popups of this page, which can answer it, rather than as tabs: Self::take_popups then lists them. An engine that cannot goes on opening them as tabs.

fn accept_page_dialogs(&self)

Have the page’s own questions (alert, confirm, prompt, “leave this page?”) sent as WebViewEvent::PageDialog for the embedder to show and answer. Until then, and in an engine that cannot, each is declined at once and a page may always be left.

fn take_popups(&self) -> Vec<Popup>

The popups the page opened since the last call.

fn adopt_popup(&self, popup: u32) -> Result<Arc<dyn WebViewEngine>, String>

The engine of a popup Self::take_popups listed, to show it. Dropping it closes the popup.

fn navigate_owned( &self, request_id: u32, command: NavigationCommand, ) -> Result<(), String>

Admit a navigation and reserve its terminal outcome. IDs must increase strictly within this engine’s lifetime and fit a positive CEF signed integer.

fn set_visible(&self, visible: bool)

Suspend painting without discarding the document or its session history.

fn send(&self, cmd: WebViewCommand)

Enqueue a command. Must never block on engine work.

fn frames(&self) -> Arc<Mutex<Option<Frame>>>

fn drain_events(&self) -> Vec<WebViewEvent>

Take all pending events, oldest first.

fn supports_text_input(&self) -> bool

fn supports_guarded_edit_history(&self) -> bool

Whether original-field acknowledged Undo/Redo is supported.

fn handle_undo_request(&self, request: UndoRequest) -> bool

Offer system Undo/Redo to this page’s native editing history. True means the backend consumed the request, not that a history entry existed or that an asynchronous edit has already completed.

fn text_input(&self, request: Request) -> Option<Receipt>

Private text transactions never enter the app event or page-agent stream.

fn set_modifiers(&self, modifiers: KeyModifiers)

Keep pointer modifiers current even when no key event reaches the page.

fn share_clipboard(&self)

Have what the page copies sent as WebViewEvent::ClipboardWrite, and its pastes and reads asked of the embedder (WebViewEvent::ClipboardRead), where the engine cannot reach the system clipboard itself. Until then, and in an engine that can or cannot ask, the page’s clipboard is the engine’s own.

fn supports_native_filtering(&self) -> bool

Whether this backend accepts source rules instead of WebKit JSON.

fn paint_seq(&self) -> u64

The sequence number of the display list this engine paints (Self::paint_frame’s Frame::seq): moves on with every change to what the page draws, so a widget repaints exactly when the page did. 0 for an engine that paints pixels rather than a display list.

fn request_close(&self) -> bool

Request native close admission. True allows immediate local close; false completes asynchronously through TabClosed, TabDetached or TabCloseBlocked.

fn drain_download_events(&self) -> Vec<WebViewEvent>

Runtime-owned download events, independent of a tab lifetime.

fn set_waker(&self, _waker: Box<dyn Fn() + Send + Sync>)

Invoked (from any thread) whenever a new frame or event is ready — typically wired to the winit event loop proxy so idle apps repaint on engine activity. Synchronous engines don’t need one.

fn presented(&self)

A view drew this engine’s page just now. Engines that stop painting pages nobody draws (see paint::PaintEngine) resume here.

fn wrapped(&self) -> Option<&Arc<dyn WebViewEngine>>

The engine this one wraps, for what only a backend can answer.

fn cursor(&self) -> Option<CursorIcon>

The pointer shape the page last asked for where the pointer is (a hand on a link, an I-beam on text); None for the default arrow, or an engine that does not say.

fn paint_frame(&self) -> Option<Arc<Frame>>

The page as a display list. An engine that has one is drawn from it instead of frames (see paint).

fn paint_blob(&self, _hash: &[u8; 32]) -> Option<Arc<Vec<u8>>>

Encoded bytes of an image a paint_frame references.

fn take_paint_stream(&self, _keyframe: bool) -> Vec<Payload>

The page as a stream for a session to share: a whole frame when keyframe (or when the consumer must start over), else the patches since the last call, followed by images not sent yet. Empty for an engine without a display list.