bao-browser 0.1.0

A Rust-native programmable browser runtime built on Servo and SpiderMonkey
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// @trace REQ-BRW-002  REQ-CDP-007: Screenshot capture via servo rendering pipeline
use std::io::Cursor;

use image::{ImageFormat, RgbaImage};

use crate::error::BrowserError;

pub enum ScreenshotFormat {
    Png,
    Jpeg,
    WebP,
}

pub fn encode_image(image: &RgbaImage, format: ScreenshotFormat) -> Result<Vec<u8>, BrowserError> {
    let mut buf = Cursor::new(Vec::with_capacity(
        image.width() as usize * image.height() as usize,
    ));
    match format {
        ScreenshotFormat::Png => image
            .write_to(&mut buf, ImageFormat::Png)
            .map_err(|e| BrowserError::Rendering(format!("PNG encode failed: {e}")))?,
        ScreenshotFormat::Jpeg => {
            let rgb = image::DynamicImage::ImageRgba8(image.clone()).to_rgb8();
            rgb.write_to(&mut buf, ImageFormat::Jpeg)
                .map_err(|e| BrowserError::Rendering(format!("JPEG encode failed: {e}")))?;
        }
        ScreenshotFormat::WebP => image
            .write_to(&mut buf, ImageFormat::WebP)
            .map_err(|e| BrowserError::Rendering(format!("WebP encode failed: {e}")))?,
    }
    Ok(buf.into_inner())
}

#[cfg(test)]
mod tests {
    // @trace REQ-BRW-002 [req:REQ-BRW-002,REQ-CDP-007] [level:unit]
    use super::*;
    use image::Rgba;

    fn red_image(w: u32, h: u32) -> RgbaImage {
        RgbaImage::from_pixel(w, h, Rgba([255, 0, 0, 255]))
    }

    #[test]
    fn encode_1x1_png_returns_nonempty_with_magic() {
        let img = red_image(1, 1);
        let out = encode_image(&img, ScreenshotFormat::Png).unwrap();
        assert!(!out.is_empty());
        assert_eq!(&out[0..4], &[0x89, 0x50, 0x4E, 0x47]);
    }

    #[test]
    fn encode_1x1_jpeg_returns_nonempty_with_magic() {
        let img = red_image(1, 1);
        let out = encode_image(&img, ScreenshotFormat::Jpeg).unwrap();
        assert!(!out.is_empty());
        assert_eq!(&out[0..2], &[0xFF, 0xD8]);
    }

    #[test]
    fn encode_100x100_png_produces_valid_data() {
        let img = red_image(100, 100);
        let out = encode_image(&img, ScreenshotFormat::Png).unwrap();
        assert!(!out.is_empty());
        assert_eq!(&out[0..4], &[0x89, 0x50, 0x4E, 0x47]);
    }

    #[test]
    fn encode_100x100_jpeg_produces_valid_data() {
        let img = red_image(100, 100);
        let out = encode_image(&img, ScreenshotFormat::Jpeg).unwrap();
        assert!(!out.is_empty());
        assert_eq!(&out[0..2], &[0xFF, 0xD8]);
    }

    #[test]
    fn encode_1x1_webp_returns_nonempty_with_riff_magic() {
        let img = red_image(1, 1);
        let out = encode_image(&img, ScreenshotFormat::WebP).unwrap();
        assert!(!out.is_empty());
        // WebP files start with "RIFF" header
        assert_eq!(&out[0..4], b"RIFF");
    }

    #[test]
    fn encode_100x100_webp_produces_valid_data() {
        let img = red_image(100, 100);
        let out = encode_image(&img, ScreenshotFormat::WebP).unwrap();
        assert!(!out.is_empty());
        assert_eq!(&out[0..4], b"RIFF");
    }

    #[test]
    fn encode_empty_image_no_panic() {
        let img = red_image(0, 0);
        let _ = encode_image(&img, ScreenshotFormat::Png);
        let _ = encode_image(&img, ScreenshotFormat::Jpeg);
        let _ = encode_image(&img, ScreenshotFormat::WebP);
    }

    #[test]
    fn all_formats_produce_nontrivial_output() {
        let img = red_image(200, 200);
        let png = encode_image(&img, ScreenshotFormat::Png).unwrap();
        let jpeg = encode_image(&img, ScreenshotFormat::Jpeg).unwrap();
        let webp = encode_image(&img, ScreenshotFormat::WebP).unwrap();
        assert!(
            png.len() > 100,
            "PNG should be nontrivial: {} bytes",
            png.len()
        );
        assert!(
            jpeg.len() > 100,
            "JPEG should be nontrivial: {} bytes",
            jpeg.len()
        );
        assert!(
            webp.len() > 100,
            "WebP should be nontrivial: {} bytes",
            webp.len()
        );
    }
}