Skip to content

armgit / moli

Public Imported from GitHub
0

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

20.1 KB
Raw Blame
//! Completion of one selected main-parser continuation.
//!
//! Parser continuation execution owns ordered script work. This component
//! owns the bounded handoff from that work to parser completion: it consumes a
//! one-shot drained-queue permit, asks the lifecycle authority to claim the
//! exact DOMContentLoaded successor, closes the selected parser task's
//! checkpoint boundary, and only then hands that already-claimed successor to
//! the lifecycle coordinator. The coordinator applies it to the surviving
//! exact Document or stale-rejects it after replacement.
//! It is not a scheduler lane and stores no durable lifecycle state.

use anyhow::Result;

use crate::PageVmInitStage;
use crate::frame_owner_model::FrameDocumentTaskOwner;
use crate::network::ResourceRequestClient;
use crate::page_task_queue::{PostParseLifecycleWork, PostParsePageOwnedWork};
use crate::runtime::{PendingDocumentLifecycleTurn, RendererDocumentLifecycleIdentity};
use crate::script_vm::{
    MainDocumentLifecycleBodyKind, ParserFinishDomContentLoadedTask, PostParsePageOwnedTask,
};

use super::super::document_lifecycle_turn::{
    DocumentLifecycleTurnAction, DocumentLifecycleTurnOutcome,
};
use super::PageVm;
use super::parser_continuation::{MainParserContinuationCompletion, MainParserQueueSettlement};
use super::parser_task_completion::MainParserContinuationTaskEffect;

/// One-shot authority to attempt the exact DOMContentLoaded successor of a
/// drained parser-deferred queue.
///
/// The permit proves only that the exact ordered parser queue became empty. It
/// carries no checkpoint policy and is never stored as a second parser-
/// completion authority.
#[derive(Debug)]
pub(in crate::runtime) struct MainParserFinishPermit {
    owner: FrameDocumentTaskOwner,
}

impl MainParserFinishPermit {
    pub(super) const fn new(owner: FrameDocumentTaskOwner) -> Self {
        Self { owner }
    }

    pub(in crate::runtime) const fn owner(&self) -> FrameDocumentTaskOwner {
        self.owner
    }
}

/// Whether parse-time parser completion retained the original Document.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(in crate::runtime) enum ParseTimeMainParserBoundaryOutcome {
    CurrentDocumentRetained,
    DocumentReplaced,
}

#[derive(Debug)]
pub(super) enum SelectedPostParsePageOwnedCompletion {
    Ordinary,
    MainDocumentPostParse(crate::page_task_queue::MainDocumentPostParseExecution),
    MainParser(MainParserContinuationCompletion),
}

struct ParserCompletion;

impl ParserCompletion {
    fn exact_domcontentloaded_owner(
        work: PostParseLifecycleWork,
        expected_owner: FrameDocumentTaskOwner,
    ) -> std::result::Result<FrameDocumentTaskOwner, &'static str> {
        let PostParseLifecycleWork::DispatchDomContentLoaded { owner } = work else {
            return Err("parser-finish successor is not DOMContentLoaded work");
        };
        if owner != expected_owner {
            return Err("parser-finish DOMContentLoaded successor targets another Document");
        }
        Ok(owner)
    }

    fn finish_task(
        page_vm: &mut PageVm,
        task_effect: MainParserContinuationTaskEffect,
    ) -> Result<()> {
        page_vm.finish_main_parser_continuation_task(task_effect)
    }

    fn finish_task_with_replacement_admission(
        page_vm: &mut PageVm,
        task_effect: MainParserContinuationTaskEffect,
    ) -> Result<()> {
        let replacement_lifecycle_snapshot =
            page_vm.document_replacement_lifecycle_action_snapshot();
        let completion = Self::finish_task(page_vm, task_effect);
        let admission = page_vm.take_document_replacement_lifecycle_admission_after_action(
            replacement_lifecycle_snapshot,
        );
        match (completion, admission) {
            (Ok(()), Ok(_)) => Ok(()),
            (Err(completion_error), Ok(_)) => Err(completion_error),
            (Ok(_), Err(admission_error)) => Err(admission_error),
            (Err(completion_error), Err(admission_error)) => Err(anyhow::anyhow!(
                "parser task completion failed ({completion_error:#}) and its Document replacement admission also failed ({admission_error:#})"
            )),
        }
    }

    fn finish_without_direct_domcontentloaded(
        page_vm: &mut PageVm,
        completion: SelectedPostParsePageOwnedCompletion,
    ) -> Result<()> {
        match completion {
            SelectedPostParsePageOwnedCompletion::Ordinary => Ok(()),
            SelectedPostParsePageOwnedCompletion::MainDocumentPostParse(execution) => {
                page_vm.finish_main_document_post_parse_execution(execution)
            }
            SelectedPostParsePageOwnedCompletion::MainParser(completion) => {
                let (_, task_effect) = completion.into_parts();
                Self::finish_task(page_vm, task_effect)
            }
        }
    }

    async fn finish_parse_time_inner(
        page_vm: &mut PageVm,
        completion: MainParserContinuationCompletion,
    ) -> Result<()> {
        let (queue, task_effect) = completion.into_parts();
        let MainParserQueueSettlement::Drained(permit) = queue else {
            return Self::finish_task(page_vm, task_effect);
        };
        let owner = permit.owner();
        let claimed_dcl = {
            let PageVm {
                vm,
                page_task_queue,
                ..
            } = page_vm;
            vm.as_mut()
                .expect("PageVm must retain a live ScriptVm until drop")
                .claim_parse_time_domcontentloaded_after_main_parser_finish(page_task_queue, owner)
        };
        let Some(claimed_dcl) = claimed_dcl else {
            return Self::finish_task(page_vm, task_effect);
        };
        if claimed_dcl.owner() != owner {
            Self::finish_task(page_vm, task_effect)?;
            anyhow::bail!(
                "parse-time parser completion claimed DOMContentLoaded for another Document"
            );
        }
        let successor_owner = match Self::exact_domcontentloaded_owner(
            claimed_dcl.into_work(),
            owner,
        ) {
            Ok(owner) => owner,
            Err(message) => {
                let completion = Self::finish_task(page_vm, task_effect);
                return match completion {
                    Ok(()) => Err(anyhow::anyhow!(message)),
                    Err(completion_error) => Err(anyhow::anyhow!(
                        "parse-time parser successor was invalid and its task completion also failed ({completion_error:#})"
                    )),
                };
            }
        };
        // The parser continuation and DOMContentLoaded are distinct HTML task
        // boundaries even though this Chromium-compatible direct successor
        // deliberately does not reopen ordinary scheduler arbitration. Drain
        // terminal reactions first; the lifecycle coordinator then owns DCL's
        // separate task-end checkpoint.
        Self::finish_task(page_vm, task_effect)?;
        let run = super::main_document_lifecycle_completion::execute_parser_exact_domcontentloaded_on_owner_local_task(
            page_vm,
            successor_owner,
        )
        .await?;
        anyhow::ensure!(
            run.completion.kind() == MainDocumentLifecycleBodyKind::DomContentLoaded,
            "parse-time DOMContentLoaded successor lost its typed lifecycle execution"
        );
        Ok(())
    }

    async fn finish_parse_time(
        page_vm: &mut PageVm,
        completion: MainParserContinuationCompletion,
    ) -> Result<ParseTimeMainParserBoundaryOutcome> {
        let source_document = page_vm.document_lifecycle.identity();
        let replacement_lifecycle_snapshot =
            page_vm.document_replacement_lifecycle_action_snapshot();
        let execution = Self::finish_parse_time_inner(page_vm, completion).await;
        let admission = page_vm.take_document_replacement_lifecycle_admission_after_action(
            replacement_lifecycle_snapshot,
        );
        match (execution, admission) {
            (Ok(()), Ok(_)) => Ok(
                if page_vm.document_lifecycle.identity() == source_document {
                    ParseTimeMainParserBoundaryOutcome::CurrentDocumentRetained
                } else {
                    ParseTimeMainParserBoundaryOutcome::DocumentReplaced
                },
            ),
            (Err(execution_error), Ok(_)) => Err(execution_error),
            (Ok(()), Err(admission_error)) => Err(admission_error),
            (Err(execution_error), Err(admission_error)) => Err(anyhow::anyhow!(
                "parse-time parser completion failed ({execution_error:#}) and its Document replacement admission also failed ({admission_error:#})"
            )),
        }
    }
}

impl PageVm {
    pub(in crate::runtime) async fn finish_parse_time_main_parser_boundary(
        &mut self,
        completion: MainParserContinuationCompletion,
    ) -> Result<ParseTimeMainParserBoundaryOutcome> {
        ParserCompletion::finish_parse_time(self, completion).await
    }

    async fn execute_domcontentloaded_after_main_parser_finish_on_named_owner_lane(
        &mut self,
        mut task: ParserFinishDomContentLoadedTask,
    ) -> Result<PostParsePageOwnedTask> {
        let owner = task.owner();
        let work = task.take_work_for_execution();
        let PostParsePageOwnedWork::Lifecycle(work) = work else {
            anyhow::bail!("parser-finish successor is not lifecycle work");
        };
        let successor_owner = match ParserCompletion::exact_domcontentloaded_owner(*work, owner) {
            Ok(owner) => owner,
            Err(message) => anyhow::bail!(message),
        };

        let run = super::main_document_lifecycle_completion::execute_parser_exact_domcontentloaded_on_owner_local_task(
            self,
            successor_owner,
        )
        .await?;
        anyhow::ensure!(
            run.completion.kind() == MainDocumentLifecycleBodyKind::DomContentLoaded,
            "DOMContentLoaded direct successor lost its typed lifecycle execution"
        );
        Ok(task.into_completed_task())
    }

    pub(super) async fn execute_and_complete_selected_post_parse_page_owned_task(
        &mut self,
        loader: &ResourceRequestClient,
        pending_document_lifecycle_turn: &mut Option<PendingDocumentLifecycleTurn>,
        document: RendererDocumentLifecycleIdentity,
        stage: PageVmInitStage,
        mut task: Box<PostParsePageOwnedTask>,
    ) -> Result<DocumentLifecycleTurnOutcome> {
        let replacement_lifecycle_snapshot = self.document_replacement_lifecycle_action_snapshot();
        let execution = self
            .execute_post_parse_page_owned_task_on_named_owner_lane(
                loader,
                task.take_work_for_execution(),
            )
            .await;
        // Generic post-parse callbacks must finish their old-realm task before
        // a synchronous `document.open()` replacement is admitted. MainParser
        // completion remains below because its exact-DCL handoff has its own
        // replacement-aware coordinator.
        let execution = match execution {
            Ok(SelectedPostParsePageOwnedCompletion::MainDocumentPostParse(execution)) => self
                .finish_main_document_post_parse_execution(execution)
                .map(|()| SelectedPostParsePageOwnedCompletion::Ordinary),
            other => other,
        };
        let admission = self.take_document_replacement_lifecycle_admission_after_action(
            replacement_lifecycle_snapshot,
        );
        let completion = match (execution, admission) {
            (Ok(completion), Ok(_)) => completion,
            (Err(execution_error), Ok(_)) => return Err(execution_error),
            (Ok(completion), Err(admission_error)) => {
                if let Err(checkpoint_error) =
                    ParserCompletion::finish_without_direct_domcontentloaded(self, completion)
                {
                    return Err(anyhow::anyhow!(
                        "Document replacement admission failed ({admission_error:#}) and parser task-end checkpoint also failed ({checkpoint_error:#})"
                    ));
                }
                return Err(admission_error);
            }
            (Err(execution_error), Err(admission_error)) => {
                return Err(anyhow::anyhow!(
                    "lifecycle action failed ({execution_error:#}) and its Document replacement admission also failed ({admission_error:#})"
                ));
            }
        };

        if self.vm().has_pending_location_navigation() {
            ParserCompletion::finish_without_direct_domcontentloaded(self, completion)?;
            pending_document_lifecycle_turn
                .as_mut()
                .expect("post-parse lifecycle state should remain installed")
                .completed_task = Some(*task);
            if let Some(outcome) = self.transition_lifecycle_for_pending_top_level_navigation(
                pending_document_lifecycle_turn,
                document,
                stage,
            ) {
                return Ok(outcome);
            }
            unreachable!("pending top-level navigation must transition the lifecycle turn");
        }

        match completion {
            SelectedPostParsePageOwnedCompletion::Ordinary => {
                pending_document_lifecycle_turn
                    .as_mut()
                    .expect("post-parse lifecycle state should remain installed")
                    .completed_task = Some(*task);
            }
            SelectedPostParsePageOwnedCompletion::MainDocumentPostParse(execution) => {
                self.finish_main_document_post_parse_execution(execution)?;
                pending_document_lifecycle_turn
                    .as_mut()
                    .expect("post-parse lifecycle state should remain installed")
                    .completed_task = Some(*task);
            }
            SelectedPostParsePageOwnedCompletion::MainParser(completion) => {
                let (queue, task_effect) = completion.into_parts();
                let has_sealed_main_parser_script_queue =
                    matches!(&queue, MainParserQueueSettlement::Pending)
                        && self
                            .vm()
                            .document_runtime
                            .main_parser_deferred_scripts_owner()
                            .is_some();
                pending_document_lifecycle_turn
                    .as_mut()
                    .expect("post-parse lifecycle state should remain installed")
                    .has_sealed_main_parser_script_queue = has_sealed_main_parser_script_queue;
                let MainParserQueueSettlement::Drained(permit) = queue else {
                    ParserCompletion::finish_task_with_replacement_admission(self, task_effect)?;
                    pending_document_lifecycle_turn
                        .as_mut()
                        .expect("post-parse lifecycle state should remain installed")
                        .completed_task = Some(*task);
                    return self.outcome_after_exact_post_parse_action(
                        pending_document_lifecycle_turn,
                        document,
                        stage,
                        DocumentLifecycleTurnAction::Progressed,
                        false,
                    );
                };

                let owner = permit.owner();
                let permit_is_current = self.document_lifecycle.identity() == document
                    && self.vm().current_main_document_task_owner() == Some(owner);
                if !permit_is_current {
                    ParserCompletion::finish_task_with_replacement_admission(self, task_effect)?;
                    pending_document_lifecycle_turn
                        .as_mut()
                        .expect("post-parse lifecycle state should remain installed")
                        .completed_task = Some(*task);
                    return self.outcome_after_exact_post_parse_action(
                        pending_document_lifecycle_turn,
                        document,
                        stage,
                        DocumentLifecycleTurnAction::Progressed,
                        false,
                    );
                }

                let claimed_dcl_result = {
                    let driver = pending_document_lifecycle_turn
                        .as_ref()
                        .expect("post-parse lifecycle state should remain installed")
                        .driver;
                    let PageVm {
                        vm,
                        page_task_queue,
                        report,
                        ..
                    } = self;
                    vm.as_mut()
                        .expect("PageVm must retain a live ScriptVm until drop")
                        .claim_domcontentloaded_after_main_parser_finish(
                            page_task_queue,
                            report,
                            driver,
                            *task,
                            owner,
                        )
                        .await
                        .map_err(anyhow::Error::msg)
                };
                let claimed_dcl = match claimed_dcl_result {
                    Ok(claimed_dcl) => claimed_dcl,
                    Err(claim_error) => {
                        let completion = ParserCompletion::finish_task_with_replacement_admission(
                            self,
                            task_effect,
                        );
                        return match completion {
                            Ok(()) => Err(claim_error),
                            Err(completion_error) => Err(anyhow::anyhow!(
                                "parser-finish DOMContentLoaded claim failed ({claim_error:#}) and its parser task completion also failed ({completion_error:#})"
                            )),
                        };
                    }
                };
                if let Some(dcl_task) = claimed_dcl {
                    ParserCompletion::finish_task_with_replacement_admission(self, task_effect)?;
                    let replacement_lifecycle_snapshot =
                        self.document_replacement_lifecycle_action_snapshot();
                    let execution = self
                        .execute_domcontentloaded_after_main_parser_finish_on_named_owner_lane(
                            dcl_task,
                        )
                        .await;
                    let admission = self
                        .take_document_replacement_lifecycle_admission_after_action(
                            replacement_lifecycle_snapshot,
                        );
                    let completed_dcl_task = match (execution, admission) {
                        (Ok(task), Ok(_)) => task,
                        (Err(execution_error), Ok(_)) => return Err(execution_error),
                        (Ok(_), Err(admission_error)) => return Err(admission_error),
                        (Err(execution_error), Err(admission_error)) => {
                            return Err(anyhow::anyhow!(
                                "parser-finish DOMContentLoaded action failed ({execution_error:#}) and its Document replacement admission also failed ({admission_error:#})"
                            ));
                        }
                    };
                    pending_document_lifecycle_turn
                        .as_mut()
                        .expect("post-parse lifecycle state should remain installed")
                        .completed_task = Some(completed_dcl_task);
                    if let Some(outcome) = self
                        .transition_lifecycle_for_pending_top_level_navigation(
                            pending_document_lifecycle_turn,
                            document,
                            stage,
                        )
                    {
                        return Ok(outcome);
                    }
                } else {
                    ParserCompletion::finish_task_with_replacement_admission(self, task_effect)?;
                }
            }
        }

        self.outcome_after_exact_post_parse_action(
            pending_document_lifecycle_turn,
            document,
            stage,
            DocumentLifecycleTurnAction::Progressed,
            false,
        )
    }
}