Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

40.9 KB
Raw Blame
//! Browser-resource-runtime scoped renderer memory cache.
//!
//! The cache deliberately outlives individual Document and Worker loaders. Its
//! retained-byte budget is shared by every consumer of one browser resource
//! runtime and must never be multiplied per execution context. Entries retain
//! the owning Page cache partition, so a DevTools cache bypass can replace one
//! Page's retained resource without rewriting a live peer Page's resource.

use std::sync::{Arc, Weak};

use indexmap::IndexMap;
use moli_fetch::{BrowserRequestMetadata, RawResponse, Request, RequestResourceType, Response};
use moli_http_cache::{cacheable_response_parts_policy, unix_now_ms};
use parking_lot::Mutex;
use tokio::sync::Notify;
use url::Url;

/// Strong-reference budget for renderer subresources.
///
/// Chromium's Linux MemoryCache currently keeps at most 15 MiB of strong
/// references and excludes resources whose decoded body exceeds 3 MiB.
/// Moli stores materialized text as both UTF-8 bytes and a `String`, so
/// the total budget below charges both representations instead of only the
/// encoded body.
const DEFAULT_RETAINED_BYTES_LIMIT: usize = 15 * 1024 * 1024;
const DEFAULT_RESOURCE_BODY_BYTES_LIMIT: usize = 3 * 1024 * 1024;

#[derive(Debug, Clone, Copy, Default, serde::Serialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct SharedMemoryResourceCacheDiagnostics {
    pub entry_count: usize,
    pub pending_script_entry_count: usize,
    pub completed_script_entry_count: usize,
    pub raw_subresource_entry_count: usize,
    pub retained_bytes: usize,
    pub retained_bytes_limit: usize,
    pub resource_body_bytes_limit: usize,
}

pub(in crate::network) type SharedScriptTextLoad = Arc<ScriptTextLoad>;
type ScriptTextLoadResult = std::result::Result<Response, String>;
type ScriptTextLoadCallback = Box<dyn FnOnce(ScriptTextLoadResult) + Send + 'static>;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(in crate::network) struct ScriptTextCacheKey {
    page_cache_partition_id: u64,
    url: String,
    credentials_mode: String,
    request_origin: Option<String>,
    request_mode: String,
    site_context: String,
    site_for_cookies_origin: String,
    top_frame_origin: String,
    network_partition_key: Option<String>,
    storage_access_status: String,
    integrity: Option<String>,
    request_headers: Vec<(String, String)>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(in crate::network) struct RawSubresourceCacheKey {
    page_cache_partition_id: u64,
    url: String,
    resource_type: &'static str,
    credentials_mode: String,
    request_origin: Option<String>,
    request_mode: String,
    network_partition_key: Option<String>,
    cookie_context: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum MemoryCacheKey {
    ScriptText(ScriptTextCacheKey),
    RawSubresource(RawSubresourceCacheKey),
}

impl ScriptTextCacheKey {
    pub(in crate::network) fn for_page_cache_partition(mut self, partition_id: u64) -> Self {
        self.page_cache_partition_id = partition_id;
        self
    }
}

impl RawSubresourceCacheKey {
    pub(in crate::network) fn for_page_cache_partition(mut self, partition_id: u64) -> Self {
        self.page_cache_partition_id = partition_id;
        self
    }
}

enum MemoryCacheEntry {
    ScriptText {
        load: SharedScriptTextLoad,
        expires_at_unix_ms: Option<u64>,
        retained_bytes: usize,
    },
    RawSubresource {
        response: Box<RawResponse>,
        expires_at_unix_ms: u64,
        retained_bytes: usize,
    },
}

impl MemoryCacheEntry {
    fn retained_bytes(&self) -> usize {
        match self {
            Self::ScriptText { retained_bytes, .. }
            | Self::RawSubresource { retained_bytes, .. } => *retained_bytes,
        }
    }

    fn is_completed(&self) -> bool {
        match self {
            Self::ScriptText {
                expires_at_unix_ms, ..
            } => expires_at_unix_ms.is_some(),
            Self::RawSubresource { .. } => true,
        }
    }

    fn is_expired(&self, now_unix_ms: u64) -> bool {
        match self {
            Self::ScriptText {
                expires_at_unix_ms: Some(expires_at_unix_ms),
                ..
            }
            | Self::RawSubresource {
                expires_at_unix_ms, ..
            } => *expires_at_unix_ms <= now_unix_ms,
            Self::ScriptText {
                expires_at_unix_ms: None,
                ..
            } => false,
        }
    }
}

pub(in crate::network) struct SharedMemoryResourceCache {
    entries: IndexMap<MemoryCacheKey, MemoryCacheEntry>,
    retained_bytes: usize,
    retained_bytes_limit: usize,
    resource_body_bytes_limit: usize,
}

pub(in crate::network) enum ScriptTextCacheLookup {
    Owner(SharedScriptTextLoad),
    PendingWaiter(SharedScriptTextLoad),
    CompletedHit(Box<ScriptTextLoadResult>),
}

pub(in crate::network) struct ScriptTextLoad {
    state: Mutex<ScriptTextLoadState>,
    notify: Notify,
}

#[derive(Default)]
struct ScriptTextLoadState {
    result: Option<ScriptTextLoadResult>,
    next_consumer_id: u64,
    // Preserve the callback order of the former Vec implementation. Different
    // consumers may enqueue observable parser tasks when the shared load
    // completes, so cancellation must not make the survivors unordered.
    callbacks: IndexMap<u64, ScriptTextLoadCallback>,
    transport_cancel: Option<moli_fetch::FetchCancelHandle>,
}

/// Cancellable registration for one context waiting on a shared script load.
///
/// Dropping one lease removes only that callback. If it was the last pending
/// consumer, the shared transport is cancelled; other Documents or Workers
/// are never affected by a sibling consumer retiring.
pub(in crate::network) struct ScriptTextConsumerLease {
    load: Weak<ScriptTextLoad>,
    consumer_id: u64,
}

impl ScriptTextConsumerLease {
    pub(in crate::network) fn cancel(&self) {
        if let Some(load) = self.load.upgrade() {
            load.cancel_consumer(self.consumer_id);
        }
    }
}

impl Drop for ScriptTextConsumerLease {
    fn drop(&mut self) {
        self.cancel();
    }
}

impl ScriptTextLoad {
    fn pending() -> SharedScriptTextLoad {
        Arc::new(Self {
            state: Mutex::new(ScriptTextLoadState::default()),
            notify: Notify::new(),
        })
    }

    fn try_result(&self) -> Option<ScriptTextLoadResult> {
        self.state.lock().result.clone()
    }

    pub(in crate::network) async fn wait(&self) -> ScriptTextLoadResult {
        loop {
            let notified = self.notify.notified();
            tokio::pin!(notified);
            notified.as_mut().enable();
            if let Some(result) = self.try_result() {
                return result;
            }
            notified.await;
        }
    }

    pub(in crate::network) fn wait_callback(
        self: &Arc<Self>,
        callback: ScriptTextLoadCallback,
    ) -> Option<ScriptTextConsumerLease> {
        let mut state = self.state.lock();
        if let Some(result) = state.result.clone() {
            drop(state);
            callback(result);
            return None;
        }
        state.next_consumer_id = state
            .next_consumer_id
            .checked_add(1)
            .expect("script text consumer id exhausted");
        let consumer_id = state.next_consumer_id;
        let previous = state.callbacks.insert(consumer_id, callback);
        debug_assert!(previous.is_none());
        Some(ScriptTextConsumerLease {
            load: Arc::downgrade(self),
            consumer_id,
        })
    }

    pub(in crate::network) fn attach_transport_cancel(
        &self,
        cancel_handle: moli_fetch::FetchCancelHandle,
    ) {
        let cancel_immediately = {
            let mut state = self.state.lock();
            if state.result.is_some() || state.callbacks.is_empty() {
                true
            } else {
                debug_assert!(
                    state.transport_cancel.is_none(),
                    "shared script load must own exactly one transport"
                );
                state.transport_cancel = Some(cancel_handle.clone());
                false
            }
        };
        if cancel_immediately {
            cancel_handle.cancel();
        }
    }

    fn cancel_consumer(&self, consumer_id: u64) {
        let transport_cancel = {
            let mut state = self.state.lock();
            if state.callbacks.shift_remove(&consumer_id).is_none()
                || state.result.is_some()
                || !state.callbacks.is_empty()
            {
                None
            } else {
                state.transport_cancel.take()
            }
        };
        if let Some(transport_cancel) = transport_cancel {
            transport_cancel.cancel();
        }
    }

    pub(in crate::network) fn finish(&self, result: ScriptTextLoadResult) {
        let callbacks = {
            let mut state = self.state.lock();
            if state.result.is_none() {
                state.result = Some(result.clone());
                state.transport_cancel.take();
                std::mem::take(&mut state.callbacks)
                    .into_values()
                    .collect::<Vec<_>>()
            } else {
                Vec::new()
            }
        };
        self.notify.notify_waiters();
        for callback in callbacks {
            callback(result.clone());
        }
    }
}

impl Default for SharedMemoryResourceCache {
    fn default() -> Self {
        Self::with_limits(
            DEFAULT_RETAINED_BYTES_LIMIT,
            DEFAULT_RESOURCE_BODY_BYTES_LIMIT,
        )
    }
}

impl SharedMemoryResourceCache {
    fn with_limits(retained_bytes_limit: usize, resource_body_bytes_limit: usize) -> Self {
        Self {
            entries: IndexMap::new(),
            retained_bytes: 0,
            retained_bytes_limit,
            resource_body_bytes_limit,
        }
    }

    pub(in crate::network) fn lookup_script_text(
        &mut self,
        key: ScriptTextCacheKey,
    ) -> ScriptTextCacheLookup {
        let cache_key = MemoryCacheKey::ScriptText(key);
        if let Some(entry) = self.remove_entry(&cache_key) {
            let MemoryCacheEntry::ScriptText {
                load,
                expires_at_unix_ms,
                retained_bytes,
            } = entry
            else {
                unreachable!("script cache key must map to a script cache entry");
            };

            if expires_at_unix_ms.is_some_and(|expires_at| expires_at <= unix_now_ms()) {
                return self.insert_pending_script(cache_key);
            }

            let result = load.try_result();
            self.insert_entry(
                cache_key,
                MemoryCacheEntry::ScriptText {
                    load: Arc::clone(&load),
                    expires_at_unix_ms,
                    retained_bytes,
                },
            );
            return match result {
                Some(result) => ScriptTextCacheLookup::CompletedHit(Box::new(result)),
                None => ScriptTextCacheLookup::PendingWaiter(load),
            };
        }

        self.insert_pending_script(cache_key)
    }

    pub(in crate::network) fn replace_script_text(
        &mut self,
        key: ScriptTextCacheKey,
    ) -> ScriptTextCacheLookup {
        let cache_key = MemoryCacheKey::ScriptText(key);
        self.remove_entry(&cache_key);
        self.insert_pending_script(cache_key)
    }

    fn insert_pending_script(&mut self, key: MemoryCacheKey) -> ScriptTextCacheLookup {
        let load = ScriptTextLoad::pending();
        self.insert_entry(
            key,
            MemoryCacheEntry::ScriptText {
                load: Arc::clone(&load),
                expires_at_unix_ms: None,
                retained_bytes: 0,
            },
        );
        ScriptTextCacheLookup::Owner(load)
    }

    /// Finalizes cache metadata before `ScriptTextLoad::finish()` invokes
    /// callbacks. This ordering lets reentrant callbacks observe either a
    /// complete retained entry or no cache entry, never a completed load with
    /// stale pending metadata.
    pub(in crate::network) fn complete_script_text(
        &mut self,
        key: &ScriptTextCacheKey,
        load: &SharedScriptTextLoad,
        request: &Request,
        result: &ScriptTextLoadResult,
    ) {
        let cache_key = MemoryCacheKey::ScriptText(key.clone());
        let Some(entry) = self.remove_entry(&cache_key) else {
            return;
        };
        let MemoryCacheEntry::ScriptText {
            load: cached_load,
            expires_at_unix_ms,
            retained_bytes,
        } = entry
        else {
            unreachable!("script cache key must map to a script cache entry");
        };
        if !Arc::ptr_eq(&cached_load, load) {
            self.insert_entry(
                cache_key,
                MemoryCacheEntry::ScriptText {
                    load: cached_load,
                    expires_at_unix_ms,
                    retained_bytes,
                },
            );
            return;
        }

        let Some(response) = result.as_ref().ok() else {
            return;
        };
        let Some(expires_at_unix_ms) = script_text_memory_cache_expiry(request, response) else {
            return;
        };
        if response.body_text().len() > self.resource_body_bytes_limit
            || response.body_bytes().len() > self.resource_body_bytes_limit
        {
            return;
        }

        let retained_bytes = script_text_retained_bytes(key, response);
        if retained_bytes > self.retained_bytes_limit {
            return;
        }
        self.insert_entry(
            cache_key,
            MemoryCacheEntry::ScriptText {
                load: cached_load,
                expires_at_unix_ms: Some(expires_at_unix_ms),
                retained_bytes,
            },
        );
        self.evict_to_budget();
    }

    pub(in crate::network) fn lookup_raw_subresource(
        &mut self,
        key: &RawSubresourceCacheKey,
    ) -> Option<RawResponse> {
        let cache_key = MemoryCacheKey::RawSubresource(key.clone());
        let entry = self.remove_entry(&cache_key)?;
        let MemoryCacheEntry::RawSubresource {
            response,
            expires_at_unix_ms,
            retained_bytes,
        } = entry
        else {
            unreachable!("raw cache key must map to a raw cache entry");
        };
        if expires_at_unix_ms <= unix_now_ms() {
            return None;
        }
        let hit = response.as_ref().clone();
        self.insert_entry(
            cache_key,
            MemoryCacheEntry::RawSubresource {
                response,
                expires_at_unix_ms,
                retained_bytes,
            },
        );
        Some(hit)
    }

    pub(in crate::network) fn insert_raw_subresource(
        &mut self,
        key: RawSubresourceCacheKey,
        response: RawResponse,
        expires_at_unix_ms: u64,
    ) {
        if response.body_bytes().len() > self.resource_body_bytes_limit {
            return;
        }
        let retained_bytes = raw_subresource_retained_bytes(&key, &response);
        if retained_bytes > self.retained_bytes_limit {
            return;
        }

        let cache_key = MemoryCacheKey::RawSubresource(key);
        self.remove_entry(&cache_key);
        self.insert_entry(
            cache_key,
            MemoryCacheEntry::RawSubresource {
                response: Box::new(response),
                expires_at_unix_ms,
                retained_bytes,
            },
        );
        self.evict_to_budget();
    }

    fn insert_entry(&mut self, key: MemoryCacheKey, entry: MemoryCacheEntry) {
        self.retained_bytes = self.retained_bytes.saturating_add(entry.retained_bytes());
        let replaced = self.entries.insert(key, entry);
        debug_assert!(
            replaced.is_none(),
            "cache entries must be removed before insert"
        );
    }

    fn remove_entry(&mut self, key: &MemoryCacheKey) -> Option<MemoryCacheEntry> {
        let entry = self.entries.shift_remove(key)?;
        self.retained_bytes = self.retained_bytes.saturating_sub(entry.retained_bytes());
        Some(entry)
    }

    fn evict_to_budget(&mut self) {
        let now_unix_ms = unix_now_ms();
        let mut expired_retained_bytes = 0usize;
        self.entries.retain(|_, entry| {
            if entry.is_expired(now_unix_ms) {
                expired_retained_bytes =
                    expired_retained_bytes.saturating_add(entry.retained_bytes());
                false
            } else {
                true
            }
        });
        self.retained_bytes = self.retained_bytes.saturating_sub(expired_retained_bytes);

        while self.retained_bytes > self.retained_bytes_limit {
            let Some(index) = self
                .entries
                .values()
                .position(MemoryCacheEntry::is_completed)
            else {
                break;
            };
            let (_, entry) = self
                .entries
                .shift_remove_index(index)
                .expect("completed cache entry index should remain valid");
            self.retained_bytes = self.retained_bytes.saturating_sub(entry.retained_bytes());
        }
    }

    pub(in crate::network) fn diagnostics(&self) -> SharedMemoryResourceCacheDiagnostics {
        let mut pending_script_entry_count = 0;
        let mut completed_script_entry_count = 0;
        let mut raw_subresource_entry_count = 0;
        for entry in self.entries.values() {
            match entry {
                MemoryCacheEntry::ScriptText {
                    expires_at_unix_ms: Some(_),
                    ..
                } => completed_script_entry_count += 1,
                MemoryCacheEntry::ScriptText {
                    expires_at_unix_ms: None,
                    ..
                } => pending_script_entry_count += 1,
                MemoryCacheEntry::RawSubresource { .. } => raw_subresource_entry_count += 1,
            }
        }
        SharedMemoryResourceCacheDiagnostics {
            entry_count: self.entries.len(),
            pending_script_entry_count,
            completed_script_entry_count,
            raw_subresource_entry_count,
            retained_bytes: self.retained_bytes,
            retained_bytes_limit: self.retained_bytes_limit,
            resource_body_bytes_limit: self.resource_body_bytes_limit,
        }
    }

    #[cfg(test)]
    fn contains_script_text(&self, key: &ScriptTextCacheKey) -> bool {
        self.entries
            .contains_key(&MemoryCacheKey::ScriptText(key.clone()))
    }

    #[cfg(test)]
    fn contains_raw_subresource(&self, key: &RawSubresourceCacheKey) -> bool {
        self.entries
            .contains_key(&MemoryCacheKey::RawSubresource(key.clone()))
    }
}

pub(in crate::network) fn script_text_request_is_memory_cacheable(request: &Request) -> bool {
    request.cache_mode().allows_memory_cache_store()
        // These entries retain a complete response including its redirect
        // history. A resumed fetch must assemble its own history in transport.
        && request.redirect_chain().is_empty()
        && request.subresource_request_metadata().is_some()
        && request.method.eq_ignore_ascii_case("GET")
        && request.body.is_none()
        && request.auth().is_none()
        && request.transport_follows_redirects()
}

pub(in crate::network) fn script_text_cache_key(request: &Request) -> ScriptTextCacheKey {
    let browser_context = &request.cookie_context.browser_context;
    ScriptTextCacheKey {
        page_cache_partition_id: 0,
        url: request.url.as_str().to_owned(),
        credentials_mode: request.credentials_mode.as_ref().to_owned(),
        request_origin: request
            .request_origin()
            .map(|origin| origin.ascii_serialization().to_owned()),
        request_mode: request.request_mode.as_ref().to_owned(),
        site_context: format!("{:?}", request.cookie_context.site_context),
        site_for_cookies_origin: script_cache_partition_url_component(
            browser_context.site_for_cookies_url.as_ref(),
            &request.url,
        ),
        top_frame_origin: script_cache_partition_url_component(
            browser_context
                .top_frame_origin_url
                .as_ref()
                .or(browser_context.site_for_cookies_url.as_ref()),
            &request.url,
        ),
        network_partition_key: request.network_partition_key().map(str::to_owned),
        storage_access_status: format!("{:?}", browser_context.storage_access_status),
        integrity: request
            .subresource_request_metadata()
            .and_then(|metadata| metadata.integrity.clone()),
        request_headers: request.request_headers.to_byte_strings(),
    }
}

fn script_cache_partition_url_component(url: Option<&Url>, fallback_url: &Url) -> String {
    url.map(moli_url::origin_ascii_serialization)
        .unwrap_or_else(|| moli_url::origin_ascii_serialization(fallback_url))
}

pub(in crate::network) fn raw_subresource_memory_cache_key(
    request: &Request,
) -> Option<RawSubresourceCacheKey> {
    if !raw_subresource_request_is_memory_cacheable(request) {
        return None;
    }
    Some(RawSubresourceCacheKey {
        page_cache_partition_id: 0,
        url: request.url.as_str().to_owned(),
        resource_type: raw_subresource_cache_resource_type_key(request.resource_type),
        credentials_mode: request.credentials_mode.as_ref().to_owned(),
        request_origin: request
            .request_origin()
            .map(|origin| origin.ascii_serialization().to_owned()),
        request_mode: request.request_mode.as_ref().to_owned(),
        network_partition_key: request.network_partition_key().map(str::to_owned),
        cookie_context: format!("{:?}", request.cookie_context),
    })
}

fn raw_subresource_cache_resource_type_key(resource_type: RequestResourceType) -> &'static str {
    match resource_type {
        RequestResourceType::Raw => "raw",
        RequestResourceType::CssStyleSheet => "stylesheet",
        RequestResourceType::Script
        | RequestResourceType::ParserBlockingScript
        | RequestResourceType::ClassicAsyncOrDeferScript
        | RequestResourceType::LatePreloadScript => "script",
        RequestResourceType::Image => "image",
        RequestResourceType::Font => "font",
        RequestResourceType::Media => "media",
        RequestResourceType::TextTrack => "text-track",
        _ => "other",
    }
}

fn raw_subresource_request_is_memory_cacheable(request: &Request) -> bool {
    request.cache_mode().allows_memory_cache_store()
        && request.redirect_chain().is_empty()
        && raw_subresource_memory_cacheable_resource_type(request)
        && request.method.eq_ignore_ascii_case("GET")
        && request.body.is_none()
        && request.auth().is_none()
        && request.transport_follows_redirects()
        && raw_subresource_memory_cacheable_headers(request)
}

fn raw_subresource_memory_cacheable_resource_type(request: &Request) -> bool {
    matches!(
        request.resource_type,
        RequestResourceType::Image
            | RequestResourceType::Font
            | RequestResourceType::Media
            | RequestResourceType::TextTrack
            | RequestResourceType::CssStyleSheet
    ) || matches!(
        (request.resource_type, request.browser_request_metadata()),
        (
            RequestResourceType::Raw,
            Some(
                BrowserRequestMetadata::Fetch
                    | BrowserRequestMetadata::JsonModule
                    | BrowserRequestMetadata::Manifest
                    | BrowserRequestMetadata::StyleModule
                    | BrowserRequestMetadata::Xhr
            )
        )
    )
}

fn raw_subresource_memory_cacheable_headers(request: &Request) -> bool {
    request.request_headers.is_empty()
        || request.browser_request_metadata().is_some_and(|metadata| {
            matches!(
                metadata,
                BrowserRequestMetadata::Fetch
                    | BrowserRequestMetadata::JsonModule
                    | BrowserRequestMetadata::Manifest
                    | BrowserRequestMetadata::StyleModule
                    | BrowserRequestMetadata::Xhr
            ) && request
                .request_headers
                .iter()
                .all(|(name, _)| browser_cache_ignored_request_header(name))
        })
}

fn browser_cache_ignored_request_header(name: &str) -> bool {
    matches!(
        name.to_ascii_lowercase().as_str(),
        "accept" | "accept-language" | "sec-fetch-dest" | "sec-fetch-mode" | "sec-fetch-site"
    )
}

pub(in crate::network) fn raw_subresource_memory_cache_expiry(
    request: &Request,
    response: &RawResponse,
) -> Option<u64> {
    let policy = cacheable_response_parts_policy(
        &request.url,
        &response.final_url,
        response.status,
        &response.headers,
        response.redirected,
    )?;
    let expires_at = policy.expires_at_unix_ms?;
    (expires_at > unix_now_ms()).then_some(expires_at)
}

fn script_text_memory_cache_expiry(request: &Request, response: &Response) -> Option<u64> {
    let policy = cacheable_response_parts_policy(
        &request.url,
        &response.final_url,
        response.status,
        &response.headers,
        response.redirected,
    )?;
    let expires_at = policy.expires_at_unix_ms?;
    (expires_at > unix_now_ms()).then_some(expires_at)
}

fn script_text_retained_bytes(key: &ScriptTextCacheKey, response: &Response) -> usize {
    script_text_key_retained_bytes(key)
        .saturating_add(response_head_retained_bytes(
            response.final_url.as_str(),
            &response.headers,
        ))
        .saturating_add(response.body_text().len())
        .saturating_add(response.body_bytes().len())
}

fn raw_subresource_retained_bytes(key: &RawSubresourceCacheKey, response: &RawResponse) -> usize {
    raw_subresource_key_retained_bytes(key)
        .saturating_add(response_head_retained_bytes(
            response.final_url.as_str(),
            &response.headers,
        ))
        .saturating_add(response.body_bytes().len())
}

fn response_head_retained_bytes(final_url: &str, headers: &[(String, Vec<u8>)]) -> usize {
    headers
        .iter()
        .fold(final_url.len(), |bytes, (name, value)| {
            bytes.saturating_add(name.len()).saturating_add(value.len())
        })
}

fn script_text_key_retained_bytes(key: &ScriptTextCacheKey) -> usize {
    let request_headers = key
        .request_headers
        .iter()
        .fold(0usize, |bytes, (name, value)| {
            bytes.saturating_add(name.len()).saturating_add(value.len())
        });
    key.url
        .len()
        .saturating_add(key.credentials_mode.len())
        .saturating_add(key.request_origin.as_deref().map_or(0, str::len))
        .saturating_add(key.request_mode.len())
        .saturating_add(key.site_context.len())
        .saturating_add(key.site_for_cookies_origin.len())
        .saturating_add(key.top_frame_origin.len())
        .saturating_add(key.network_partition_key.as_deref().map_or(0, str::len))
        .saturating_add(key.storage_access_status.len())
        .saturating_add(key.integrity.as_deref().map_or(0, str::len))
        .saturating_add(request_headers)
}

fn raw_subresource_key_retained_bytes(key: &RawSubresourceCacheKey) -> usize {
    key.url
        .len()
        .saturating_add(key.resource_type.len())
        .saturating_add(key.credentials_mode.len())
        .saturating_add(key.request_origin.as_deref().map_or(0, str::len))
        .saturating_add(key.request_mode.len())
        .saturating_add(key.network_partition_key.as_deref().map_or(0, str::len))
        .saturating_add(key.cookie_context.len())
}

#[cfg(test)]
mod tests {
    use std::sync::atomic::{AtomicUsize, Ordering};

    use moli_fetch::{ResponseHead, ScriptFetchRequestMetadata};

    use super::*;

    fn script_request(url: &str) -> Request {
        Request::get(url)
            .expect("script request URL")
            .with_script_fetch_metadata(ScriptFetchRequestMetadata::default())
    }

    fn response(url: &str, body: &str) -> Response {
        Response::from_head_and_text_body(
            ResponseHead {
                status_text: None,
                final_url: Url::parse(url).expect("response URL"),
                status: 200,
                headers: vec![("cache-control".to_owned(), b"max-age=60".to_vec())],
                request_cookie_report: None,
                cookie_set_reports: Vec::new(),
                redirected: false,
                redirect_chain: Vec::new(),
                from_cache: false,
                negotiated_http_version: None,
            },
            body.to_owned(),
        )
    }

    fn raw_response(url: &str, body: &[u8]) -> RawResponse {
        RawResponse::from_head_and_body(
            ResponseHead {
                status_text: None,
                final_url: Url::parse(url).expect("response URL"),
                status: 200,
                headers: vec![("cache-control".to_owned(), b"max-age=60".to_vec())],
                request_cookie_report: None,
                cookie_set_reports: Vec::new(),
                redirected: false,
                redirect_chain: Vec::new(),
                from_cache: false,
                negotiated_http_version: None,
            },
            body.to_vec(),
        )
    }

    fn insert_script(
        cache: &mut SharedMemoryResourceCache,
        request: &Request,
        response: Response,
    ) -> SharedScriptTextLoad {
        let key = script_text_cache_key(request);
        let ScriptTextCacheLookup::Owner(load) = cache.lookup_script_text(key.clone()) else {
            panic!("new script key should own its load");
        };
        let result = Ok(response);
        cache.complete_script_text(&key, &load, request, &result);
        load.finish(result);
        load
    }

    #[test]
    fn cancelling_one_shared_script_consumer_preserves_its_sibling() {
        let load = ScriptTextLoad::pending();
        let delivered = Arc::new(AtomicUsize::new(0));
        let first_delivered = Arc::clone(&delivered);
        let first = load
            .wait_callback(Box::new(move |_| {
                first_delivered.fetch_add(1, Ordering::Relaxed);
            }))
            .expect("first pending consumer");
        let second_delivered = Arc::clone(&delivered);
        let second = load
            .wait_callback(Box::new(move |_| {
                second_delivered.fetch_add(1, Ordering::Relaxed);
            }))
            .expect("second pending consumer");
        let transport_cancel = moli_fetch::FetchCancelHandle::new();
        load.attach_transport_cancel(transport_cancel.clone());

        first.cancel();
        assert!(!transport_cancel.is_cancelled());
        load.finish(Err("terminal".to_owned()));

        assert_eq!(delivered.load(Ordering::Relaxed), 1);
        drop(second);
    }

    #[test]
    fn cancelling_last_shared_script_consumer_cancels_transport() {
        let load = ScriptTextLoad::pending();
        let first = load
            .wait_callback(Box::new(|_| {}))
            .expect("first pending consumer");
        let second = load
            .wait_callback(Box::new(|_| {}))
            .expect("second pending consumer");
        let transport_cancel = moli_fetch::FetchCancelHandle::new();
        load.attach_transport_cancel(transport_cancel.clone());

        first.cancel();
        assert!(!transport_cancel.is_cancelled());
        second.cancel();

        assert!(transport_cancel.is_cancelled());
    }

    #[test]
    fn completed_script_entries_are_evicted_in_lru_order() {
        let first_request = script_request("https://cache.test/first.js");
        let second_request = script_request("https://cache.test/second.js");
        let first_response = response(first_request.url.as_str(), &"a".repeat(256));
        let second_response = response(second_request.url.as_str(), &"b".repeat(256));
        let first_key = script_text_cache_key(&first_request);
        let second_key = script_text_cache_key(&second_request);
        let first_weight = script_text_retained_bytes(&first_key, &first_response);
        let second_weight = script_text_retained_bytes(&second_key, &second_response);
        let mut cache =
            SharedMemoryResourceCache::with_limits(first_weight.max(second_weight), usize::MAX);

        insert_script(&mut cache, &first_request, first_response);
        insert_script(&mut cache, &second_request, second_response);

        assert!(!cache.contains_script_text(&first_key));
        assert!(cache.contains_script_text(&second_key));
        assert!(cache.retained_bytes <= cache.retained_bytes_limit);
    }

    #[test]
    fn script_cache_hit_refreshes_lru_position() {
        let requests = [
            script_request("https://cache.test/first.js"),
            script_request("https://cache.test/second.js"),
            script_request("https://cache.test/third.js"),
        ];
        let responses = [
            response(requests[0].url.as_str(), &"a".repeat(128)),
            response(requests[1].url.as_str(), &"b".repeat(128)),
            response(requests[2].url.as_str(), &"c".repeat(128)),
        ];
        let keys: [ScriptTextCacheKey; 3] =
            std::array::from_fn(|index| script_text_cache_key(&requests[index]));
        let weights = [
            script_text_retained_bytes(&keys[0], &responses[0]),
            script_text_retained_bytes(&keys[1], &responses[1]),
            script_text_retained_bytes(&keys[2], &responses[2]),
        ];
        let mut cache = SharedMemoryResourceCache::with_limits(
            weights[0]
                .saturating_add(weights[1])
                .max(weights[0].saturating_add(weights[2])),
            usize::MAX,
        );

        insert_script(&mut cache, &requests[0], responses[0].clone());
        insert_script(&mut cache, &requests[1], responses[1].clone());
        assert!(matches!(
            cache.lookup_script_text(keys[0].clone()),
            ScriptTextCacheLookup::CompletedHit(_)
        ));
        insert_script(&mut cache, &requests[2], responses[2].clone());

        assert!(cache.contains_script_text(&keys[0]));
        assert!(!cache.contains_script_text(&keys[1]));
        assert!(cache.contains_script_text(&keys[2]));
    }

    #[test]
    fn oversized_script_completes_waiters_without_becoming_retained() {
        let request = script_request("https://cache.test/large.js");
        let key = script_text_cache_key(&request);
        let mut cache = SharedMemoryResourceCache::with_limits(1024, 32);
        let ScriptTextCacheLookup::Owner(load) = cache.lookup_script_text(key.clone()) else {
            panic!("new script key should own its load");
        };
        let result = Ok(response(request.url.as_str(), &"x".repeat(64)));

        cache.complete_script_text(&key, &load, &request, &result);
        load.finish(result);

        assert!(!cache.contains_script_text(&key));
        assert!(load.try_result().is_some());
    }

    #[test]
    fn decoded_script_limit_is_independent_from_original_byte_length() {
        let request = script_request("https://cache.test/expanded.js");
        let key = script_text_cache_key(&request);
        let mut cache = SharedMemoryResourceCache::with_limits(1024, 32);
        let ScriptTextCacheLookup::Owner(load) = cache.lookup_script_text(key.clone()) else {
            panic!("new script key should own its load");
        };
        let response = Response::from_head_and_body(
            ResponseHead {
                status_text: None,
                final_url: request.url.clone(),
                status: 200,
                headers: vec![("cache-control".to_owned(), b"max-age=60".to_vec())],
                request_cookie_report: None,
                cookie_set_reports: Vec::new(),
                redirected: false,
                redirect_chain: Vec::new(),
                from_cache: false,
                negotiated_http_version: None,
            },
            "x".repeat(64),
            vec![b'x'; 16],
        );
        let result = Ok(response);

        cache.complete_script_text(&key, &load, &request, &result);
        load.finish(result);

        assert!(!cache.contains_script_text(&key));
        assert!(load.try_result().is_some());
    }

    #[test]
    fn raw_and_script_entries_share_one_retained_byte_budget() {
        let script_request = script_request("https://cache.test/app.js");
        let script_response = response(script_request.url.as_str(), &"s".repeat(128));
        let script_key = script_text_cache_key(&script_request);
        let script_weight = script_text_retained_bytes(&script_key, &script_response);
        let raw_request = Request::get("https://cache.test/app.css")
            .expect("raw request")
            .with_page_network_policy()
            .with_resource_type(RequestResourceType::CssStyleSheet);
        let raw_key =
            raw_subresource_memory_cache_key(&raw_request).expect("cacheable raw request key");
        let raw_response = raw_response(raw_request.url.as_str(), &[b'r'; 128]);
        let raw_weight = raw_subresource_retained_bytes(&raw_key, &raw_response);
        let mut cache =
            SharedMemoryResourceCache::with_limits(script_weight.max(raw_weight), usize::MAX);

        insert_script(&mut cache, &script_request, script_response);
        cache.insert_raw_subresource(raw_key.clone(), raw_response, u64::MAX);

        assert!(!cache.contains_script_text(&script_key));
        assert!(cache.contains_raw_subresource(&raw_key));
        assert!(cache.retained_bytes <= cache.retained_bytes_limit);
    }

    #[test]
    fn expired_script_entry_is_not_returned_as_a_completed_hit() {
        let request = script_request("https://cache.test/expired.js");
        let key = script_text_cache_key(&request);
        let mut cache = SharedMemoryResourceCache::with_limits(usize::MAX, usize::MAX);
        let ScriptTextCacheLookup::Owner(load) = cache.lookup_script_text(key.clone()) else {
            panic!("new script key should own its load");
        };
        let result = Ok(response(request.url.as_str(), "expired"));
        cache.remove_entry(&MemoryCacheKey::ScriptText(key.clone()));
        cache.insert_entry(
            MemoryCacheKey::ScriptText(key.clone()),
            MemoryCacheEntry::ScriptText {
                load: Arc::clone(&load),
                expires_at_unix_ms: Some(0),
                retained_bytes: 0,
            },
        );
        load.finish(result);

        assert!(matches!(
            cache.lookup_script_text(key),
            ScriptTextCacheLookup::Owner(_)
        ));
    }

    #[test]
    fn diagnostics_report_one_shared_bounded_cache() {
        let script_request = script_request("https://cache.test/app.js");
        let script_response = response(script_request.url.as_str(), &"s".repeat(128));
        let raw_request = Request::get("https://cache.test/app.css")
            .expect("raw request")
            .with_page_network_policy()
            .with_resource_type(RequestResourceType::CssStyleSheet);
        let raw_key =
            raw_subresource_memory_cache_key(&raw_request).expect("cacheable raw request key");
        let raw_response = raw_response(raw_request.url.as_str(), &[b'r'; 128]);
        let mut cache = SharedMemoryResourceCache::with_limits(1024 * 1024, 4096);

        insert_script(&mut cache, &script_request, script_response);
        cache.insert_raw_subresource(raw_key, raw_response, u64::MAX);

        let diagnostics = cache.diagnostics();
        assert_eq!(diagnostics.entry_count, 2);
        assert_eq!(diagnostics.pending_script_entry_count, 0);
        assert_eq!(diagnostics.completed_script_entry_count, 1);
        assert_eq!(diagnostics.raw_subresource_entry_count, 1);
        assert!(diagnostics.retained_bytes > 0);
        assert!(diagnostics.retained_bytes <= diagnostics.retained_bytes_limit);
        assert_eq!(diagnostics.resource_body_bytes_limit, 4096);
    }

    #[test]
    fn insertion_prunes_expired_entries_before_lru_eviction() {
        let expired_request = script_request("https://cache.test/expired.js");
        let fresh_request = script_request("https://cache.test/fresh.js");
        let expired_key = script_text_cache_key(&expired_request);
        let fresh_key = script_text_cache_key(&fresh_request);
        let mut cache = SharedMemoryResourceCache::with_limits(usize::MAX, usize::MAX);

        let ScriptTextCacheLookup::Owner(expired_load) =
            cache.lookup_script_text(expired_key.clone())
        else {
            panic!("new expired script key should own its load");
        };
        cache.remove_entry(&MemoryCacheKey::ScriptText(expired_key.clone()));
        cache.insert_entry(
            MemoryCacheKey::ScriptText(expired_key.clone()),
            MemoryCacheEntry::ScriptText {
                load: expired_load,
                expires_at_unix_ms: Some(0),
                retained_bytes: 128,
            },
        );

        insert_script(
            &mut cache,
            &fresh_request,
            response(fresh_request.url.as_str(), "fresh"),
        );

        assert!(!cache.contains_script_text(&expired_key));
        assert!(cache.contains_script_text(&fresh_key));
        assert_eq!(
            cache.retained_bytes,
            cache
                .entries
                .values()
                .map(MemoryCacheEntry::retained_bytes)
                .sum::<usize>()
        );
    }
}