Skip to content

armgit / moli

Public Imported from GitHub
0

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

8.6 KB
Raw Blame
use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
};

use crate::{
    frame_owner_model::FrameDocumentTaskOwner,
    runtime::{PageOwnerTurnOutcome, RendererDocumentToken},
};

use super::{
    RendererPageMainDocumentTaskOwner, RendererPageNetworkingRoute, RendererPageNetworkingTask,
};

pub(crate) type RendererPageMainParserContinuationOwner = RendererPageMainDocumentTaskOwner;

/// Whether a parser-resume request created a new Networking task or merged
/// into the task already resident for the same exact parser owner.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum MainParserContinuationRequest {
    Enqueued,
    AlreadyQueued,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RendererPageMainParserContinuationRouteClosed;

/// Page-scoped route that can be bound to one exact main parser Document.
#[derive(Clone, Debug)]
pub(crate) struct RendererPageMainParserContinuationSender {
    networking: RendererPageNetworkingRoute,
    root_document: RendererDocumentToken,
}

impl RendererPageMainParserContinuationSender {
    pub(crate) fn new(
        networking: RendererPageNetworkingRoute,
        root_document: RendererDocumentToken,
    ) -> Self {
        Self {
            networking,
            root_document,
        }
    }

    pub(crate) fn bind_producer(
        &self,
        document_owner: FrameDocumentTaskOwner,
    ) -> RendererPageMainParserContinuationProducer {
        RendererPageMainParserContinuationProducer {
            networking: self.networking.clone(),
            owner: RendererPageMainDocumentTaskOwner::new(self.root_document, document_owner),
            admission: Arc::new(MainParserContinuationAdmission::default()),
        }
    }
}

/// Cloneable producer for one exact main parser.
///
/// Parser input, stylesheet state, and script fetch results remain in their
/// authoritative stores. This producer only coalesces the notification that
/// those stores are worth observing again.
#[derive(Clone, Debug)]
pub(crate) struct RendererPageMainParserContinuationProducer {
    networking: RendererPageNetworkingRoute,
    owner: RendererPageMainParserContinuationOwner,
    admission: Arc<MainParserContinuationAdmission>,
}

impl RendererPageMainParserContinuationProducer {
    pub(crate) fn request(
        &self,
    ) -> Result<MainParserContinuationRequest, RendererPageMainParserContinuationRouteClosed> {
        if self
            .admission
            .queued
            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
            .is_err()
        {
            return Ok(MainParserContinuationRequest::AlreadyQueued);
        }

        let task = RendererPageMainParserContinuationTask {
            owner: self.owner,
            permit: MainParserContinuationPermit::new(self.admission.clone()),
        };
        self.networking
            .send(RendererPageNetworkingTask::MainParserContinuation(task))
            .map(|()| MainParserContinuationRequest::Enqueued)
            .map_err(|_| RendererPageMainParserContinuationRouteClosed)
    }

    pub(crate) const fn owner(&self) -> RendererPageMainParserContinuationOwner {
        self.owner
    }
}

#[derive(Debug, Default)]
struct MainParserContinuationAdmission {
    queued: AtomicBool,
}

/// One resident Networking task for a main parser.
///
/// The task contains only an exact owner locator and a coalescing permit. It
/// never owns parser input, parser state, `PageVm`, or a phase-one runtime.
#[derive(Debug)]
pub(crate) struct RendererPageMainParserContinuationTask {
    owner: RendererPageMainParserContinuationOwner,
    permit: MainParserContinuationPermit,
}

impl RendererPageMainParserContinuationTask {
    pub(crate) const fn owner(&self) -> RendererPageMainParserContinuationOwner {
        self.owner
    }

    /// Release the resident-task permit at dequeue, before executing the task.
    ///
    /// A producer that observes new input while this task is executing must be
    /// able to queue the next bounded parser opportunity. Releasing only after
    /// execution would merge that request into a task that can no longer
    /// observe the newly arrived fact.
    pub(super) fn release_permit_at_dequeue(&mut self) {
        self.permit.release();
    }

    pub(crate) fn into_owner(self) -> RendererPageMainParserContinuationOwner {
        debug_assert!(
            !self.permit.armed,
            "main parser continuation permit must be released by Networking dequeue"
        );
        self.owner
    }
}

#[derive(Debug)]
struct MainParserContinuationPermit {
    admission: Arc<MainParserContinuationAdmission>,
    armed: bool,
}

impl MainParserContinuationPermit {
    fn new(admission: Arc<MainParserContinuationAdmission>) -> Self {
        Self {
            admission,
            armed: true,
        }
    }

    fn release(&mut self) {
        if self.armed {
            self.admission.queued.store(false, Ordering::Release);
            self.armed = false;
        }
    }
}

impl Drop for MainParserContinuationPermit {
    fn drop(&mut self) {
        // Queue teardown or stale-task disposal must not permanently leave the
        // producer in the queued state.
        self.release();
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum PageMainParserContinuationTargetEffect {
    AdmittedCurrentParser,
    DiscardedStaleOrInactiveParser,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct PageMainParserContinuationTurnAction {
    pub(crate) owner: RendererPageMainParserContinuationOwner,
    pub(crate) target_effect: PageMainParserContinuationTargetEffect,
}

pub(crate) type PageMainParserContinuationTurnOutcome =
    PageOwnerTurnOutcome<PageMainParserContinuationTurnAction>;

#[cfg(test)]
mod tests {
    use crate::{
        frame_owner_model::{
            DocumentId, FrameDocumentTaskOwner, FrameSchedulerLaneId, LocalWindowId,
        },
        page_task_queue::{
            PageRuntimeWakeSignal, RendererOwnerWakeSender, RendererPageNetworkingSource,
            RendererPageNetworkingTask,
        },
        runtime::{RendererDocumentToken, RendererPageToken},
    };

    use super::*;

    fn test_document_owner() -> FrameDocumentTaskOwner {
        FrameDocumentTaskOwner::new(FrameSchedulerLaneId(1), LocalWindowId(2), DocumentId(3))
    }

    fn fixture() -> (
        RendererPageNetworkingSource,
        RendererPageMainParserContinuationProducer,
    ) {
        let root_document =
            RendererDocumentToken::new_for_testing(crate::PageId::new_for_testing(11), 7);
        let (wake_tx, _wake_rx) = tokio::sync::mpsc::unbounded_channel();
        let source = RendererPageNetworkingSource::new_owner_attached(
            PageRuntimeWakeSignal::default(),
            RendererOwnerWakeSender::new(
                wake_tx,
                RendererPageToken::new_for_testing(root_document.page_id),
            ),
        );
        let producer = RendererPageMainParserContinuationSender::new(source.route(), root_document)
            .bind_producer(test_document_owner());
        (source, producer)
    }

    #[test]
    fn requests_coalesce_until_the_resident_task_is_dequeued() {
        let (mut source, producer) = fixture();

        assert_eq!(
            producer.request().expect("first request"),
            MainParserContinuationRequest::Enqueued
        );
        assert_eq!(
            producer.request().expect("coalesced request"),
            MainParserContinuationRequest::AlreadyQueued
        );

        let (_, task) = source.pop_front_task().expect("one continuation task");
        let RendererPageNetworkingTask::MainParserContinuation(task) = task else {
            panic!("continuation producer must use the Networking continuation variant");
        };
        // The permit is released by dequeue, before the selected task enters
        // its executor. A producer fact in that window must create another
        // resident task instead of being absorbed by the dequeued one.
        assert_eq!(
            producer
                .request()
                .expect("request before dequeued task executes"),
            MainParserContinuationRequest::Enqueued
        );
        assert!(source.has_ready_task());
        assert_eq!(task.into_owner(), producer.owner());
    }

    #[test]
    fn dropping_a_resident_task_releases_the_coalescing_permit() {
        let (mut source, producer) = fixture();
        assert_eq!(
            producer.request().expect("first request"),
            MainParserContinuationRequest::Enqueued
        );

        source.clear();

        assert_eq!(
            producer.request().expect("request after source clear"),
            MainParserContinuationRequest::Enqueued
        );
    }
}