Add ureq backend for blitz-net

Cargo.toml

@@ -69,6 +69,8 @@ http = "1.1.0"
 data-url = "0.3.1"
 tokio = "1.42"
 reqwest = "0.12"
+ureq = "3.0"
+rayon = "1.10"
 
 # Media & Decoding
 image = { version = "0.25", default-features = false }

examples/screenshot.rs

@@ -2,7 +2,7 @@
 
 use blitz_dom::net::Resource;
 use blitz_html::HtmlDocument;
-use blitz_net::{MpscCallback, Provider};
+use blitz_net::{callback::MpscCallback, Provider};
 use blitz_renderer_vello::render_to_buffer;
 use blitz_traits::navigation::DummyNavigationProvider;
 use blitz_traits::net::SharedProvider;
@@ -23,8 +23,7 @@ async fn main() {
     let mut timer = Timer::init();
 
     let url_string = std::env::args()
-        .skip(1)
-        .next()
+        .nth(1)
         .unwrap_or_else(|| "https://www.google.com".into());
 
     println!("{}", url_string);
@@ -56,8 +55,7 @@ async fn main() {
     let scale = 2;
     let height = 800;
     let width: u32 = std::env::args()
-        .skip(2)
-        .next()
+        .nth(2)
         .and_then(|arg| arg.parse().ok())
         .unwrap_or(1200);
 
@@ -151,7 +149,7 @@ fn write_png<W: Write>(writer: W, buffer: &[u8], width: u32, height: u32) {
 
     // Write PNG data to writer
     let mut writer = encoder.write_header().unwrap();
-    writer.write_image_data(&buffer).unwrap();
+    writer.write_image_data(buffer).unwrap();
     writer.finish().unwrap();
 }
 

examples/url.rs

@@ -2,8 +2,7 @@
 
 fn main() {
     let url = std::env::args()
-        .skip(1)
-        .next()
+        .nth(1)
         .unwrap_or_else(|| "https://www.google.com".into());
     blitz::launch_url(&url);
 }

packages/blitz-net/Cargo.toml

@@ -4,9 +4,18 @@ version = "0.1.0"
 license.workspace = true
 edition = "2024"
 
+[features]
+default = ["reqwest"]
+reqwest = ["dep:reqwest", "dep:tokio"]
+ureq = ["dep:ureq", "dep:rayon"]
+
 [dependencies]
 blitz-traits = { path = "../blitz-traits" }
-tokio = { workspace = true }
-reqwest = { workspace = true }
+tokio = { workspace = true, optional = true }
+reqwest = { workspace = true, optional = true }
+ureq = { workspace = true, optional = true }
 data-url = { workspace = true }
 thiserror = { workspace = true }
+http = { workspace = true }
+url = { workspace = true }
+rayon = { workspace = true, optional = true }

packages/blitz-net/src/backend/mod.rs

@@ -0,0 +1,24 @@
+use std::fmt::{Display, Formatter};
+
+use thiserror::Error;
+
+#[cfg(feature = "reqwest")]
+mod reqwest;
+#[cfg(feature = "ureq")]
+mod ureq;
+
+#[cfg(feature = "reqwest")]
+pub use reqwest::{get_text, Provider};
+#[cfg(feature = "ureq")]
+pub use ureq::{get_text, Provider};
+
+#[derive(Debug, Error)]
+pub struct BackendError {
+    pub message: String,
+}
+
+impl Display for BackendError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}

packages/blitz-net/src/backend/reqwest.rs

@@ -0,0 +1,129 @@
+use std::sync::Arc;
+
+use crate::{ProviderError, USER_AGENT};
+
+use super::BackendError;
+use blitz_traits::net::{BoxedHandler, Bytes, NetProvider, Request, Response, SharedCallback};
+use data_url::DataUrl;
+use http::HeaderValue;
+use tokio::runtime::Handle;
+use url::Url;
+
+// Compat with reqwest
+impl From<reqwest::Error> for BackendError {
+    fn from(e: reqwest::Error) -> Self {
+        BackendError {
+            message: e.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Backend {
+    client: reqwest::Client,
+}
+
+impl Backend {
+    pub fn new() -> Self {
+        Self {
+            client: reqwest::Client::new(),
+        }
+    }
+
+    pub async fn request(&mut self, request: Request) -> Result<Response, BackendError> {
+        let request = self
+            .client
+            .request(request.method, request.url.clone())
+            .headers(request.headers);
+
+        let response = request.send().await?;
+        let status = response.status();
+        let headers = response.headers().clone();
+        let body = response.bytes().await?;
+
+        Ok(Response {
+            status: status.as_u16(),
+            headers,
+            body,
+        })
+    }
+}
+
+pub async fn get_text(url: &str) -> String {
+    let mut backend = Backend::new();
+    let request = Request::get(Url::parse(url).unwrap());
+    let response = backend.request(request).await.unwrap();
+    String::from_utf8_lossy(&response.body).to_string()
+}
+
+pub struct Provider<D> {
+    rt: Handle,
+    client: Backend,
+    resource_callback: SharedCallback<D>,
+}
+
+impl<D: 'static> Provider<D> {
+    pub fn new(res_callback: SharedCallback<D>) -> Self {
+        Self {
+            rt: Handle::current(),
+            client: Backend::new(),
+            resource_callback: res_callback,
+        }
+    }
+
+    pub fn shared(res_callback: SharedCallback<D>) -> Arc<dyn NetProvider<Data = D>> {
+        Arc::new(Self::new(res_callback))
+    }
+
+    pub fn is_empty(&self) -> bool {
+        Arc::strong_count(&self.resource_callback) == 1
+    }
+
+    async fn fetch_inner(
+        mut client: Backend,
+        doc_id: usize,
+        request: Request,
+        handler: BoxedHandler<D>,
+        res_callback: SharedCallback<D>,
+    ) -> Result<(), ProviderError> {
+        match request.url.scheme() {
+            "data" => {
+                let data_url = DataUrl::process(request.url.as_str())?;
+                let decoded = data_url.decode_to_vec()?;
+                handler.bytes(doc_id, Bytes::from(decoded.0), res_callback);
+            }
+            "file" => {
+                let file_content = std::fs::read(request.url.path())?;
+                handler.bytes(doc_id, Bytes::from(file_content), res_callback);
+            }
+            _ => {
+                let mut request = Request::get(request.url);
+                request
+                    .headers
+                    .insert("User-Agent", HeaderValue::from_static(USER_AGENT));
+                let response = client.request(request).await?;
+
+                handler.bytes(doc_id, response.body, res_callback);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<D: 'static> NetProvider for Provider<D> {
+    type Data = D;
+
+    fn fetch(&self, doc_id: usize, request: Request, handler: BoxedHandler<D>) {
+        let client = self.client.clone();
+        let callback = Arc::clone(&self.resource_callback);
+        drop(self.rt.spawn(async move {
+            let url = request.url.to_string();
+            let res = Self::fetch_inner(client, doc_id, request, handler, callback).await;
+            if let Err(e) = res {
+                eprintln!("Error fetching {}: {e}", url);
+            } else {
+                println!("Success {}", url);
+            }
+        }));
+    }
+}