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 moli_owner_queue::{OwnerReadyTaskRoute, OwnerReadyTaskSource};

use crate::{
    resource_ready::{ReadyPageTask, RendererPageTaskReadyMetadata},
    runtime::{PageOwnerTurnOutcome, RendererDocumentToken},
    types::{
        ServiceWorkerClientFocusRequestCompletion, ServiceWorkerClientNavigateRequestCompletion,
        ServiceWorkerClientsOpenWindowRequestCompletion, ServiceWorkerControllerChangeCompletion,
        ServiceWorkerLifecycleNotification,
        ServiceWorkerNotificationActionNavigateRequestCompletion, ServiceWorkerReadyCompletion,
        ServiceWorkerRegisterCompletion, ServiceWorkerUnregisterCompletion,
    },
};

use super::{RendererOwnerWakeSender, RendererOwnerWakeSource, RendererPageTaskReadySignal};

/// Browser-context ServiceWorker callback delivered to one exact PageVm.
///
/// These callbacks correspond to Blink's internal-default ServiceWorker work.
/// Client `message` delivery deliberately has a separate task source because
/// Chromium exposes it as `kServiceWorkerClientMessage`.
#[derive(Debug)]
pub(crate) enum RendererServiceWorkerInternalTask {
    Register(ServiceWorkerRegisterCompletion),
    Ready(ServiceWorkerReadyCompletion),
    Unregister(ServiceWorkerUnregisterCompletion),
    Lifecycle(ServiceWorkerLifecycleNotification),
    ControllerChange(ServiceWorkerControllerChangeCompletion),
    ClientNavigateRequest(ServiceWorkerClientNavigateRequestCompletion),
    ClientFocusRequest(ServiceWorkerClientFocusRequestCompletion),
    ClientsOpenWindowRequest(ServiceWorkerClientsOpenWindowRequestCompletion),
    NotificationActionNavigateRequest(ServiceWorkerNotificationActionNavigateRequestCompletion),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RendererServiceWorkerInternalTaskKind {
    Register,
    Ready,
    Unregister,
    Lifecycle,
    ControllerChange,
    ClientNavigateRequest,
    ClientFocusRequest,
    ClientsOpenWindowRequest,
    NotificationActionNavigateRequest,
}

impl RendererServiceWorkerInternalTask {
    pub(crate) const fn kind(&self) -> RendererServiceWorkerInternalTaskKind {
        match self {
            Self::Register(_) => RendererServiceWorkerInternalTaskKind::Register,
            Self::Ready(_) => RendererServiceWorkerInternalTaskKind::Ready,
            Self::Unregister(_) => RendererServiceWorkerInternalTaskKind::Unregister,
            Self::Lifecycle(_) => RendererServiceWorkerInternalTaskKind::Lifecycle,
            Self::ControllerChange(_) => RendererServiceWorkerInternalTaskKind::ControllerChange,
            Self::ClientNavigateRequest(_) => {
                RendererServiceWorkerInternalTaskKind::ClientNavigateRequest
            }
            Self::ClientFocusRequest(_) => {
                RendererServiceWorkerInternalTaskKind::ClientFocusRequest
            }
            Self::ClientsOpenWindowRequest(_) => {
                RendererServiceWorkerInternalTaskKind::ClientsOpenWindowRequest
            }
            Self::NotificationActionNavigateRequest(_) => {
                RendererServiceWorkerInternalTaskKind::NotificationActionNavigateRequest
            }
        }
    }
}

#[derive(Debug)]
pub(crate) struct RendererPageServiceWorkerInternalTask {
    root_document: RendererDocumentToken,
    task: RendererServiceWorkerInternalTask,
}

impl RendererPageServiceWorkerInternalTask {
    fn new(root_document: RendererDocumentToken, task: RendererServiceWorkerInternalTask) -> Self {
        Self {
            root_document,
            task,
        }
    }

    pub(crate) const fn root_document(&self) -> RendererDocumentToken {
        self.root_document
    }

    pub(crate) const fn kind(&self) -> RendererServiceWorkerInternalTaskKind {
        self.task.kind()
    }

    pub(crate) fn into_task(self) -> RendererServiceWorkerInternalTask {
        self.task
    }
}

#[derive(Clone, Debug)]
pub(crate) struct RendererPageServiceWorkerInternalRoute {
    task_route: OwnerReadyTaskRoute<
        ReadyPageTask<RendererPageServiceWorkerInternalTask>,
        RendererPageTaskReadySignal,
    >,
}

impl RendererPageServiceWorkerInternalRoute {
    pub(crate) fn sender(
        &self,
        root_document: RendererDocumentToken,
    ) -> RendererPageServiceWorkerInternalSender {
        RendererPageServiceWorkerInternalSender {
            task_route: self.task_route.clone(),
            root_document,
        }
    }

    pub(crate) fn same_source_as(&self, source: &RendererPageServiceWorkerInternalSource) -> bool {
        self.task_route.same_source_as(&source.source)
    }
}

#[derive(Clone, Debug)]
pub(crate) struct RendererPageServiceWorkerInternalSender {
    task_route: OwnerReadyTaskRoute<
        ReadyPageTask<RendererPageServiceWorkerInternalTask>,
        RendererPageTaskReadySignal,
    >,
    root_document: RendererDocumentToken,
}

impl RendererPageServiceWorkerInternalSender {
    pub(crate) fn send(
        &self,
        task: RendererServiceWorkerInternalTask,
    ) -> Result<(), RendererPageServiceWorkerInternalRouteClosed> {
        self.task_route
            .send_and_signal_if_newly_ready(ReadyPageTask::new(
                RendererPageServiceWorkerInternalTask::new(self.root_document, task),
            ))
            .map_err(|_| RendererPageServiceWorkerInternalRouteClosed)
    }
}

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

#[derive(Debug)]
pub(crate) struct RendererPageServiceWorkerInternalSource {
    source: OwnerReadyTaskSource<
        ReadyPageTask<RendererPageServiceWorkerInternalTask>,
        RendererPageTaskReadySignal,
    >,
}

impl RendererPageServiceWorkerInternalSource {
    pub(crate) fn new(owner_wake: RendererOwnerWakeSender) -> Self {
        Self {
            source: OwnerReadyTaskSource::new(RendererPageTaskReadySignal::new(
                owner_wake,
                RendererOwnerWakeSource::ServiceWorkerInternalTask,
            )),
        }
    }

    pub(crate) fn route(&self) -> RendererPageServiceWorkerInternalRoute {
        RendererPageServiceWorkerInternalRoute {
            task_route: self.source.route(),
        }
    }

    pub(crate) fn next_ready_metadata(&mut self) -> Option<RendererPageTaskReadyMetadata> {
        self.source.front().map(ReadyPageTask::metadata)
    }

    pub(crate) fn next_ready_root_document(&mut self) -> Option<RendererDocumentToken> {
        self.source
            .front()
            .map(|ready| ready.value().root_document())
    }

    pub(crate) fn pop_front(
        &mut self,
    ) -> Option<(
        RendererPageTaskReadyMetadata,
        RendererPageServiceWorkerInternalTask,
    )> {
        self.source.pop_front().map(ReadyPageTask::into_parts)
    }

    pub(crate) fn has_ready_task(&mut self) -> bool {
        !self.source.is_empty()
    }

    pub(crate) fn clear(&mut self) {
        self.source.clear_local();
    }

    pub(crate) fn route_matches(&self, route: &RendererPageServiceWorkerInternalRoute) -> bool {
        route.same_source_as(self)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum ServiceWorkerInternalCallbackEffect {
    /// At least one lifecycle/controller event entered registered callback
    /// code. Selected completion must reconcile callback-created child and
    /// runtime work after the task checkpoint.
    CallbackBodyDispatched,
    /// The event-dispatch pass completed without entering callback code. The
    /// selected task still owns an ordinary checkpoint.
    NoCallbackBodyDispatched,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum PageServiceWorkerInternalTargetEffect {
    /// An exact current register/ready/unregister resolver was settled.
    PromiseSettledAtCurrentRoot,
    /// A lifecycle or controllerchange pass ran against the current root.
    EventDispatchPassCompletedAtCurrentRoot {
        callback_effect: ServiceWorkerInternalCallbackEffect,
    },
    /// A current client request updated browser/DOM-side state or published
    /// its typed completion without dispatching a Page callback.
    InternalActionAppliedAtCurrentRoot,
    /// The Page root remained current, but the task's exact pending request,
    /// Window client, or request context had already disappeared.
    CurrentRootTaskHadNoExactTarget,
    DiscardedStaleRoot {
        current_root: RendererDocumentToken,
    },
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct PageServiceWorkerInternalTurnAction {
    pub(crate) root_document: RendererDocumentToken,
    pub(crate) task_kind: RendererServiceWorkerInternalTaskKind,
    pub(crate) target_effect: PageServiceWorkerInternalTargetEffect,
}

pub(crate) type PageServiceWorkerInternalTurnOutcome =
    PageOwnerTurnOutcome<PageServiceWorkerInternalTurnAction>;