Struct PagePool 

pub struct PagePool {
    pub max_pages: u32,
    /* private fields */
}

Thread-safe pool that tracks browser page states and enforces a capacity limit.

The pool uses a Mutex<Vec<PageInfo>> internally, making it safe to share across async tasks. All mutation methods acquire the lock, perform the update, and release it immediately to minimise contention.

Fields

max_pages: u32

Maximum number of pages allowed in the pool.

Implementations

impl PagePool

pub fn new(max_pages: u32) -> Self

Create an empty page pool with the given capacity. No pages are registered yet – call add_page to register each new page as it is created by the session.

pub fn add_page(&self, page_index: usize) -> Result<()>

Register a new page in the pool, returning an error if the pool is full. The page starts in the PageState::Ready state. Returns [BrowserError::PagePool] when the number of registered pages already equals max_pages.

pub fn mark_busy(&self, page_index: usize, url: &str)

Mark a page as busy and record the URL it is navigating to. Call this at the start of a fetch cycle to signal that the page is in use.

pub fn mark_ready(&self, page_index: usize)

Mark a page as ready (idle) for reuse. Call this after a fetch cycle completes successfully.

pub fn mark_error(&self, page_index: usize)

Mark a page as having encountered an error. The page will not be reused until it is cleaned up via cleanup_error_pages.

pub fn pages_count(&self) -> usize

Return the total number of pages currently in the pool (all states combined).

pub fn busy_count(&self) -> usize

Return the number of pages currently in the Busy state.

pub fn cleanup_error_pages(&self)

Remove all pages in the Error state from the pool. This frees up capacity so new pages can be registered. You should call this periodically or after a batch of fetches to reclaim slots.

pub fn stats(&self) -> PoolStats

Take a snapshot of the pool’s current statistics. The snapshot is a point-in-time copy and does not hold the lock after returning.