Skip to content

armgit / moli

Public Imported from GitHub
0

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

10.6 KB
Raw Blame
use super::*;
use crate::web_api_interfaces;
use crate::{
    native_bridge::{JsContextHost, ResourceTimingBufferId, SharedResourceTimingBufferRegistry},
    util::{context_host_ptr_from_global_bridge, get_private_value, set_private_value},
    webidl,
};
use moli_webapi_declare::WebApiFunctionTemplate;

const RESOURCE_TIMING_BUFFER_FULL_EVENT: &str = "resourcetimingbufferfull";

#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "Performance.setResourceTimingBufferSize")]
struct SetResourceTimingBufferSizeArgs {
    #[webidl(required)]
    max_size: u32,
}

#[derive(WebApiFunctionTemplate)]
#[webapi(interface = web_api_interfaces::Performance, enumerable, receiver)]
struct PerformanceResourceTimingBufferMembersDeclaration {
    #[webapi(method, length = 0, callback = clear_resource_timings_callback)]
    clear_resource_timings: (),

    #[webapi(method, length = 1, callback = set_resource_timing_buffer_size_callback)]
    set_resource_timing_buffer_size: (),

    #[webapi(
        accessor_property,
        getter = on_resource_timing_buffer_full_getter,
        setter = on_resource_timing_buffer_full_setter,
        enumerable
    )]
    onresourcetimingbufferfull: (),
}

pub(super) fn install_resource_timing_buffer_template_bindings<'s>(
    scope: &mut v8::PinScope<'s, '_, ()>,
    template: v8::Local<'s, v8::FunctionTemplate>,
) {
    PerformanceResourceTimingBufferMembersDeclaration::initialize_prototype_template(
        scope,
        template.prototype_template(scope),
    );
}

pub(super) fn initialize_resource_timing_buffer_state<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
) {
    if resource_timing_buffer_id(scope, performance).is_some() {
        return;
    }
    let registry = resource_timing_buffer_registry(scope)
        .expect("Performance must belong to a page or worker context");
    let (buffer_id, finalizer) =
        registry.create_resource_timing_buffer(DEFAULT_RESOURCE_TIMING_BUFFER_SIZE);
    let id = v8::BigInt::new_from_u64(scope, buffer_id.raw());
    set_private_value(
        scope,
        performance,
        PERFORMANCE_RESOURCE_TIMING_BUFFER_ID_SLOT,
        id.into(),
    );
    crate::v8_finalizer::track_context_owned_v8_finalizer(scope, performance, move || {
        finalizer.finalize();
    });
}

pub(super) fn add_resource_timing_entry<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
    entry: v8::Local<'s, v8::Object>,
) {
    initialize_resource_timing_buffer_state(scope, performance);
    let Some((host_ptr, buffer_id)) = resource_timing_buffer_context(scope, performance) else {
        return;
    };
    if unsafe { &*host_ptr }.resource_timing_buffer_can_add_immediately(buffer_id) {
        append_resource_timing_to_primary(scope, host_ptr, performance, entry, buffer_id);
        return;
    }

    if unsafe { &*host_ptr }.mark_resource_timing_buffer_full_task_pending(buffer_id) {
        queue_resource_timing_buffer_full_task(scope, host_ptr, performance, buffer_id);
    }
    unsafe { &*host_ptr }
        .push_secondary_resource_timing_entry(buffer_id, v8::Global::new(scope, entry));
}

fn clear_resource_timings_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let performance = args.this();
    // Resource Timing §3.4 intentionally clears only the primary buffer and
    // its current size here. The pending flag and secondary buffer survive so
    // the already-queued buffer-full task can process overflow entries; see
    // WPT resource-timing/buffer-full-add-then-clear.html.
    clear_primary_resource_timings(scope, performance);
    rv.set_undefined();
}

fn set_resource_timing_buffer_size_callback<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let performance = args.this();
    let Some(parsed) = webidl::parse_args::<SetResourceTimingBufferSizeArgs>(scope, &args) else {
        return;
    };
    initialize_resource_timing_buffer_state(scope, performance);
    if let Some(registry) = resource_timing_buffer_registry(scope)
        && let Some(buffer_id) = resource_timing_buffer_id(scope, performance)
    {
        registry.set_resource_timing_buffer_size_limit(buffer_id, parsed.max_size);
    }
    rv.set_undefined();
}

fn on_resource_timing_buffer_full_getter<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    mut rv: v8::ReturnValue<'_, v8::Value>,
) {
    let performance = args.this();
    let handler = get_private_value(
        scope,
        performance,
        PERFORMANCE_ON_RESOURCE_TIMING_BUFFER_FULL_SLOT,
    )
    .filter(|value| value.is_object())
    .unwrap_or_else(|| v8::null(scope).into());
    rv.set(handler);
}

fn on_resource_timing_buffer_full_setter<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    args: v8::FunctionCallbackArguments<'s>,
    _rv: v8::ReturnValue<'_, v8::Value>,
) {
    let performance = args.this();
    simple_object_event_set_handler(
        scope,
        performance,
        RESOURCE_TIMING_BUFFER_FULL_EVENT,
        PERFORMANCE_ON_RESOURCE_TIMING_BUFFER_FULL_SLOT,
        args.get(0),
    );
}

fn resource_timing_buffer_context<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
) -> Option<(*mut JsContextHost, ResourceTimingBufferId)> {
    let host_ptr = context_host_ptr_from_global_bridge(scope)?;
    resource_timing_buffer_id(scope, performance).map(|id| (host_ptr, id))
}

fn resource_timing_buffer_registry(
    scope: &mut v8::PinScope<'_, '_>,
) -> Option<SharedResourceTimingBufferRegistry> {
    if let Some(state) = crate::worker::get_worker_state(scope) {
        return Some(state.borrow().resource_timing_buffers.clone());
    }
    let host_ptr = context_host_ptr_from_global_bridge(scope)?;
    Some(unsafe { &*host_ptr }.resource_timing_buffer_registry())
}

fn resource_timing_buffer_id<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
) -> Option<ResourceTimingBufferId> {
    let value = get_private_value(
        scope,
        performance,
        PERFORMANCE_RESOURCE_TIMING_BUFFER_ID_SLOT,
    )?;
    let id = v8::Local::<v8::BigInt>::try_from(value).ok()?;
    let (raw, lossless) = id.u64_value();
    lossless
        .then(|| ResourceTimingBufferId::from_raw(raw))
        .flatten()
}

fn clear_primary_resource_timings<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
) {
    let Some(entries) = performance_slot_array(scope, performance, PERFORMANCE_ENTRIES_SLOT) else {
        return;
    };
    let retained = v8::Array::new(scope, 0);
    for index in 0..entries.length() {
        let Some(value) = entries.get_index(scope, index) else {
            continue;
        };
        let is_resource = v8::Local::<v8::Object>::try_from(value)
            .ok()
            .and_then(|entry| {
                performance_entry_slot_string(scope, entry, PERFORMANCE_ENTRY_TYPE_SLOT)
            })
            .as_deref()
            == Some("resource");
        if !is_resource {
            let _ = retained.set_index(scope, retained.length(), value);
        }
    }
    set_performance_slot_value(
        scope,
        performance,
        PERFORMANCE_ENTRIES_SLOT,
        retained.into(),
    );
    if let Some(registry) = resource_timing_buffer_registry(scope)
        && let Some(buffer_id) = resource_timing_buffer_id(scope, performance)
    {
        registry.clear_resource_timing_primary_buffer(buffer_id);
    }
}

fn append_resource_timing_to_primary<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    host_ptr: *mut JsContextHost,
    performance: v8::Local<'s, v8::Object>,
    entry: v8::Local<'s, v8::Object>,
    buffer_id: ResourceTimingBufferId,
) {
    if performance_slot_array(scope, performance, PERFORMANCE_ENTRIES_SLOT).is_none() {
        return;
    }
    super::entries::append_performance_entry(scope, performance, entry);
    unsafe { &*host_ptr }.note_resource_timing_primary_entry_added(buffer_id);
}

fn queue_resource_timing_buffer_full_task<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    host_ptr: *mut JsContextHost,
    performance: v8::Local<'s, v8::Object>,
    buffer_id: ResourceTimingBufferId,
) {
    let context = scope.get_current_context();
    let _ = unsafe { &mut *host_ptr }.queue_resource_timing_buffer_full_task(
        scope,
        context,
        performance,
        buffer_id,
    );
}

pub(crate) fn run_resource_timing_buffer_full_task<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
    buffer_id: ResourceTimingBufferId,
) {
    let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {
        return;
    };
    while let before @ 1.. = unsafe { &*host_ptr }.secondary_resource_timing_buffer_len(buffer_id) {
        if !unsafe { &*host_ptr }.resource_timing_buffer_can_add_to_primary(buffer_id) {
            dispatch_resource_timing_buffer_full_event(scope, performance);
        }
        copy_secondary_resource_timing_buffer(scope, host_ptr, performance, buffer_id);
        let after = unsafe { &*host_ptr }.secondary_resource_timing_buffer_len(buffer_id);
        if after >= before {
            unsafe { &*host_ptr }.clear_secondary_resource_timing_buffer(buffer_id);
            break;
        }
    }
    unsafe { &*host_ptr }.finish_resource_timing_buffer_full_task(buffer_id);
}

fn dispatch_resource_timing_buffer_full_event<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    performance: v8::Local<'s, v8::Object>,
) {
    let global = scope.get_current_context().global(scope);
    let Some(event_constructor) = global
        .get(scope, v8str(scope, "Event").into())
        .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
    else {
        return;
    };
    let Some(event) = event_constructor.new_instance(
        scope,
        &[v8str(scope, RESOURCE_TIMING_BUFFER_FULL_EVENT).into()],
    ) else {
        return;
    };
    mark_event_trusted(scope, event);
    let _ = dispatch_simple_event_target_event(
        scope,
        performance,
        RESOURCE_TIMING_BUFFER_FULL_EVENT,
        event,
    );
}

fn copy_secondary_resource_timing_buffer<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    host_ptr: *mut JsContextHost,
    performance: v8::Local<'s, v8::Object>,
    buffer_id: ResourceTimingBufferId,
) {
    while unsafe { &*host_ptr }.resource_timing_buffer_can_add_to_primary(buffer_id) {
        let Some(entry) = unsafe { &*host_ptr }.pop_secondary_resource_timing_entry(buffer_id)
        else {
            break;
        };
        let entry = v8::Local::new(scope, &entry);
        append_resource_timing_to_primary(scope, host_ptr, performance, entry, buffer_id);
    }
}