Skip to main content

blitz_shell/
net.rs

1// use std::sync::Arc;
2
3// use blitz_traits::net::NetWaker;
4// use winit::event_loop::EventLoopProxy;
5
6// use crate::{BlitzShellEvent, event::BlitzShellProxy};
7
8// /// A NetWaker that wakes up our winit event loop
9// pub struct BlitzShellNetWaker(BlitzShellProxy);
10
11// impl BlitzShellNetWaker {
12//     pub fn new(proxy: BlitzShellProxy) -> Self {
13//         Self(proxy)
14//     }
15
16//     pub fn shared(proxy: BlitzShellProxy) -> Arc<dyn NetWaker> {
17//         Arc::new(Self(proxy))
18//     }
19// }
20// impl NetWaker for BlitzShellNetWaker {
21//     fn wake(&self, doc_id: usize) {
22//         self.0.send_event(BlitzShellEvent::RequestRedraw { doc_id })
23//     }
24// }
25
26#[cfg(feature = "data-uri")]
27mod data_uri_net_provider {
28    //! Data-URI only networking for Blitz
29    //!
30    //! Provides an implementation of the [`blitz_traits::net::NetProvider`] trait.
31
32    use blitz_traits::net::{Bytes, NetHandler, NetProvider, NetWaker, Request};
33    use data_url::DataUrl;
34    use std::sync::Arc;
35
36    pub struct DataUriNetProvider {
37        #[allow(unused)]
38        waker: Option<Arc<dyn NetWaker>>,
39    }
40    impl DataUriNetProvider {
41        pub fn new(waker: Option<Arc<dyn NetWaker>>) -> Self {
42            Self { waker }
43        }
44        pub fn shared(waker: Option<Arc<dyn NetWaker>>) -> Arc<dyn NetProvider> {
45            Arc::new(Self::new(waker))
46        }
47    }
48
49    impl NetProvider for DataUriNetProvider {
50        fn fetch(&self, _doc_id: usize, request: Request, handler: Box<dyn NetHandler>) {
51            // let callback = &self.resource_callback;
52            match request.url.scheme() {
53                "data" => {
54                    let Ok(data_url) = DataUrl::process(request.url.as_str()) else {
55                        // callback.call(doc_id, Err(Some(String::from("Failed to parse data uri"))));
56                        return;
57                    };
58                    let Ok(decoded) = data_url.decode_to_vec() else {
59                        // callback.call(doc_id, Err(Some(String::from("Failed to decode data uri"))));
60                        return;
61                    };
62                    let bytes = Bytes::from(decoded.0);
63                    handler.bytes(request.url.to_string(), bytes);
64                }
65                _ => {
66                    // callback.call(doc_id, Err(Some(String::from("UnsupportedScheme"))));
67                }
68            };
69        }
70    }
71}
72#[cfg(feature = "data-uri")]
73pub use data_uri_net_provider::DataUriNetProvider;