Struct Provider 

pub struct Provider { /* private fields */ }

Available on crate feature net only.

Implementations

impl Provider

pub fn new(waker: Option<Arc<dyn NetWaker>>) -> Provider

pub fn with_user_agent( waker: Option<Arc<dyn NetWaker>>, user_agent: &str, ) -> Provider

A provider that identifies itself as user_agent.

The string is sent verbatim on document, subresource and script requests alike, because a server that decides what to serve from the User-Agent will do so on every one of them, and a client that agreed with itself on only some would fetch a page assembled for two different browsers.

pub fn shared(waker: Option<Arc<dyn NetWaker>>) -> Arc<dyn NetProvider>

pub fn shared_with_user_agent( waker: Option<Arc<dyn NetWaker>>, user_agent: &str, ) -> Arc<dyn NetProvider>

pub fn user_agent(&self) -> &str

What this provider identifies itself as.

pub fn is_empty(&self) -> bool

pub fn count(&self) -> usize

impl Provider

pub fn fetch_with_callback( &self, request: Request, callback: Box<dyn FnOnce(Result<(String, Bytes), ProviderError>) + Sync + Send>, )

pub async fn fetch_async( &self, request: Request, ) -> Result<(String, Bytes), ProviderError>

pub async fn fetch_response_async( &self, request: Request, ) -> Result<FetchResponse, ProviderError>

Fetch, keeping the response metadata that Provider::fetch_async discards.

fetch_async returns (String, Bytes): the final URL and the body. That is the right shape for the overwhelmingly common case, a document or a subresource whose bytes are the whole answer, and it stays as it is.

What it cannot answer is what the server said the bytes were. An embedder loading a WebAssembly module wants to reject Content-Type: text/html before handing the bytes to a parser that will report an offset into a file that is not a module at all. That check needs headers, and the headers already exist: fetch_http reads them off the response and drops them on the way out.

Additive rather than a widening of fetch_async, deliberately. Changing that return type touches every caller in every embedder for a need only some of them have, and HeaderMap is a heap-allocated multimap the hot path would then build and clone for every subresource. This allocates only for the callers that ask.

data: and file: URLs synthesise a response. A data: URL states its own mime type, so that becomes a real Content-Type; a file: URL has none, and a caller that requires one should read an absent header as unknown rather than as a mismatch.

impl Provider

This impl block contains no public items.

The fetch() path.

Separate from Provider::fetch_inner rather than layered on it, and the reason is the whole point of the trait: fetch_inner returns (String, Bytes) and turns any non-success status into a ProviderError that NetProvider::fetch then logs and drops. A caller loading an image wants exactly that. A fetch() caller wants the 404.

Trait Implementations

impl FetchProvider for Provider

fn fetch(&self, request: FetchRequest, handler: Box<dyn FetchHandler>)

impl NetProvider for Provider

fn fetch(&self, doc_id: usize, request: Request, handler: Box<dyn NetHandler>)

fn is_noop(&self) -> bool

Whether this provider is a no-op (e.g. DummyNetProvider) that will never deliver resources. When true, callers must NOT register resources as “pending critical” — doing so blocks painting forever, since the completion callback never fires. Used by integrations that feed a pre-rendered DOM and perform no sub-fetches (e.g. aginxbrowser).