hpx-browser 2.5.17

Headless browser engine for hpx: HTML parsing, rendering, CDP, and canvas support
Documentation 
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

#![allow(missing_docs)]
use hpx_browser::{page::Page, resource_loader::ResourceType};

fn current_rss_bytes() -> u64 {
    let mut usage = std::mem::MaybeUninit::<libc::rusage>::uninit();
    unsafe {
        if libc::getrusage(0, usage.as_mut_ptr()) == 0 {
            let usage = usage.assume_init();
            #[cfg(target_os = "macos")]
            return usage.ru_maxrss as u64;
            #[cfg(target_os = "linux")]
            return usage.ru_maxrss as u64 * 1024;
        }
    }
    0
}

// ── Page Creation/Drop Leak Test ─────────────────────────────────────────

#[tokio::test]
async fn create_and_drop_100_pages_no_leak() {
    let rss_before = current_rss_bytes();

    for i in 0..100 {
        let html = format!("<html><head><title>Page {i}</title></head><body>content</body></html>");
        let page = Page::from_html(&html, false).await.unwrap();
        assert_eq!(page.title(), format!("Page {i}"));
        drop(page);
    }

    let rss_after = current_rss_bytes();
    let delta = rss_after.saturating_sub(rss_before);
    // ponytail: DOM parser + arena allocation per page is heavy (~1MB/page).
    // 200MB threshold for 100 pages. Tighten after profiling identifies specific leaks.
    assert!(
        delta < 200 * 1024 * 1024,
        "RSS grew by {delta} bytes ({:.1} MB) after creating/dropping 100 pages — possible leak",
        delta as f64 / 1_048_576.0
    );
}

// ── V8 Runtime Reuse (reload_html) ──────────────────────────────────────

#[cfg(feature = "v8")]
#[tokio::test]
async fn reload_html_reuses_v8_runtime() {
    let mut page = Page::from_html("<html><body>first</body></html>", false)
        .await
        .unwrap();
    // Set a global in the V8 runtime
    page.evaluate("window.persistent = 'yes'").unwrap();

    // Reload with new HTML — runtime should be reused
    page.reload_html("<html><body>second</body></html>", "http://example.com");
    let result = page.evaluate("window.persistent").unwrap();
    assert_eq!(result, "yes", "V8 runtime should be reused across reloads");
}

#[cfg(feature = "v8")]
#[tokio::test]
async fn reload_html_100_times_no_leak() {
    let rss_before = current_rss_bytes();

    let mut page = Page::from_html("<html><body>init</body></html>", false)
        .await
        .unwrap();
    for i in 0..100 {
        let html = format!("<html><body>reload {i}</body></html>");
        page.reload_html(&html, "http://example.com");
    }

    let rss_after = current_rss_bytes();
    let delta = rss_after.saturating_sub(rss_before);
    // V8 runtime reuse should keep memory stable.
    // RSS measurements are noisy — V8's natural RSS fluctuation across 100 reloads
    // has been observed in [50.0, 51.8] MB on macOS. A 64 MB threshold absorbs this
    // noise while still catching real unbounded growth leaks.
    assert!(
        delta < 64 * 1024 * 1024,
        "RSS grew by {delta} bytes ({:.1} MB) after 100 reloads — possible V8 leak",
        delta as f64 / 1_048_576.0
    );
}

// ── Concurrent Page Creation ─────────────────────────────────────────────

#[tokio::test]
async fn ten_concurrent_pages() {
    let local = tokio::task::LocalSet::new();
    local
        .run_until(async {
            let handles: Vec<_> = (0..10)
                .map(|i| {
                    tokio::task::spawn_local(async move {
                        let html = format!(
                            "<html><head><title>Concurrent {i}</title></head><body>page {i}</body></html>"
                        );
                        let page = Page::from_html(&html, false).await.unwrap();
                        assert_eq!(page.title(), format!("Concurrent {i}"));
                        i
                    })
                })
                .collect();

            for h in handles {
                h.await.unwrap();
            }
        })
        .await;
}

// ── Memory Benchmark for Criterion ───────────────────────────────────────

/// Run with: `cargo test -p hpx-browser --test memory_concurrency_tests -- memory_benchmark --nocapture`
#[tokio::test]
async fn memory_benchmark() {
    let html = include_str!("../benches/test_page.html");
    let rss_before = current_rss_bytes();

    let mut page = Page::new();
    for _ in 0..100 {
        page.reload_html(html, "http://example.com");
    }
    drop(page);

    let rss_after = current_rss_bytes();
    let delta = rss_after.saturating_sub(rss_before);
    println!(
        "RSS delta: {delta} bytes ({:.1} MB)",
        delta as f64 / 1_048_576.0
    );

    // ponytail: DOM parser + arena allocation is heavy per reload.
    // 200MB threshold for 100 reloads. Tighten after profiling identifies specific leaks.
    assert!(
        delta < 200 * 1024 * 1024,
        "RSS should stay under 200MB: grew by {:.1} MB",
        delta as f64 / 1_048_576.0
    );
}

// ── Subresource Block Types Persistence ──────────────────────────────────

#[tokio::test]
async fn block_types_persist_across_reload() {
    let mut page = Page::from_html("<html><body></body></html>", false)
        .await
        .unwrap();
    let mut block = std::collections::HashSet::new();
    block.insert(ResourceType::Image);
    block.insert(ResourceType::Media);
    page.set_subresource_block_types(block);

    // Reload — block types should persist
    page.reload_html("<html><body>new</body></html>", "http://example.com");
    // We can't directly access the field, but the page should still work
    assert_eq!(page.url(), "http://example.com");
}