Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
#[cfg(debug_assertions)]
use std::thread::ThreadId;
use std::{
cell::RefCell,
collections::HashMap,
fmt,
sync::Arc,
sync::atomic::{AtomicU64, Ordering},
time::Instant,
};
use super::native_bridge::element::ClientRect;
use crate::DocumentStartScript;
#[cfg(test)]
use crate::dom::native::NativeDom;
use crate::{
dom::NodeId,
network::{ResourceRequestClient, context::DocumentResourceLoader},
};
use anyhow::{Result, anyhow, ensure};
use parking_lot::Mutex;
use serde_json::{Value, json};
use tracing::debug;
use url::Url;
use super::{
document_runtime::DocumentProcessingAction,
document_script_scheduler::DocumentScriptScheduler,
local_executor::{JsLocalExecutor, is_on_named_owner_execution_lane_for},
native_bridge::PendingRuntimeBindingCall,
page_task_queue::PageTaskQueue,
planning::PreparedScript,
script_vm::ScriptVm,
types::{ScriptExecutionReport, ScriptRun, SubresourceResponseWaitCriteria},
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RendererPageStateCapturePolicy {
FullReport,
ProtocolTurn,
}
mod access;
mod auxiliary_page;
mod browser_context_runtime;
mod captured_document_environment;
pub use captured_document_environment::RendererCapturedDocumentEnvironment;
mod document_lifecycle;
mod document_lifecycle_turn;
mod document_replacement;
mod javascript_dialog;
mod lifecycle_decision;
mod main_document_ready_gate;
mod navigation;
mod nested_main;
mod owner;
mod owner_deadline_index;
pub use auxiliary_page::RendererPendingAuxiliaryPage;
pub(crate) use auxiliary_page::{
RendererAuxiliaryPageAllocator, RendererRelatedInitialEmptyPageInit,
};
mod owner_local;
mod owner_local_store;
mod owner_maintenance;
pub(crate) use document_replacement::RendererDocumentReplacement;
pub use document_replacement::{
RendererDocumentPreparationTarget, RendererPageReplacementError,
RendererPageReplacementFailureDisposition, RendererPageReplacementReservationRequest,
RendererPageReplacementTarget,
};
mod page;
mod page_commands;
mod page_context_cancel;
mod page_creation_progress;
mod page_css;
pub(crate) mod page_dom;
mod page_dom_snapshot;
mod page_dump;
mod page_entry_residence;
mod page_generated_dom;
mod page_geometry;
mod page_network;
mod page_print;
mod page_screenshot;
mod page_settings;
mod page_state;
mod page_surface;
mod page_turn_scheduler;
mod page_vm;
pub(crate) use page_vm::dom_agent_state::RendererDomAgentState;
mod phase_one;
mod protocol_output;
mod script_preloads;
mod service_worker_run;
pub(crate) use self::script_preloads::{
BufferedScriptPreloadKey, BufferedScriptPreloadRequest, DocumentScriptPreloadStore,
IncrementalBufferedScriptPreloadScanner,
};
pub use self::page_creation_progress::{RendererPageCreationPhase, RendererPageCreationProgress};
pub use self::page_surface::{
RendererElementClickError, RendererElementClickTarget, RendererPreparedPointerClick,
};
pub(crate) use self::browser_context_runtime::RendererOutputTransportSenderSlot;
pub(in crate::runtime) use self::document_lifecycle_turn::PendingDocumentLifecycleTurn;
pub(crate) use self::page_turn_scheduler::{
PageOwnerBlockedReason, PageOwnerTurnOutcome, PageOwnerTurnReadiness,
};
pub(crate) use self::page_vm::AuthorizedCurrentBroadcastChannelDelivery;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildClassicScriptSourceLoad;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildDocumentLifecycle;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildDocumentScriptReady;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildHostLoad;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildNavigationCommit;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildParserModuleRootStart;
pub(crate) use self::page_vm::AuthorizedCurrentPageChildRealmMaterialization;
pub(crate) use self::page_vm::AuthorizedCurrentPageDedicatedWorkerClientEvent;
pub(crate) use self::page_vm::AuthorizedCurrentPageElementToggleEvent;
pub(crate) use self::page_vm::AuthorizedCurrentPageFileEntryFileCallback;
pub(crate) use self::page_vm::AuthorizedCurrentPageFileReadingTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageHashChangeDelivery;
pub(crate) use self::page_vm::AuthorizedCurrentPageHistoryTraversal;
pub(crate) use self::page_vm::AuthorizedCurrentPageImageLoadEvent;
pub(crate) use self::page_vm::AuthorizedCurrentPageIndexedDbTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageMediaElementEvent;
pub(crate) use self::page_vm::AuthorizedCurrentPageMessagePortDelivery;
pub(crate) use self::page_vm::AuthorizedCurrentPageMiscPlatformApiTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageModuleReaction;
pub(crate) use self::page_vm::AuthorizedCurrentPageNavigationApiTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageOpfsTask;
pub(crate) use self::page_vm::AuthorizedCurrentPagePopupLoadEvent;
pub(crate) use self::page_vm::AuthorizedCurrentPageRenderingUpdate;
pub(crate) use self::page_vm::AuthorizedCurrentPageServiceWorkerClientMessage;
pub(crate) use self::page_vm::AuthorizedCurrentPageServiceWorkerInternalTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageSharedWorkerClientEvent;
pub(crate) use self::page_vm::AuthorizedCurrentPageStorageEventDelivery;
pub(crate) use self::page_vm::AuthorizedCurrentPageTextTrackDefaultMode;
pub(crate) use self::page_vm::AuthorizedCurrentPageTextTrackLoad;
pub(crate) use self::page_vm::AuthorizedCurrentPageUserInteractionTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageViewTransitionUpdate;
pub(crate) use self::page_vm::AuthorizedCurrentPageWebCryptoTask;
pub(crate) use self::page_vm::AuthorizedCurrentPageWindowMessage;
#[cfg(test)]
pub(crate) use self::page_vm::PageDomManipulationTestFamily;
pub(crate) use self::page_vm::backend_node_registry::SharedRendererBackendNodeRegistry;
#[cfg(test)]
pub(crate) use self::page_vm::backend_node_registry::new_shared_renderer_backend_node_registry;
#[cfg(test)]
pub(crate) use self::page_vm::test_support::PageVmTaskExecutorTestHarness;
#[cfg(test)]
pub(crate) use self::page_vm::{IntoPageTaskCompletion, PageTaskCompletion};
pub(super) const MAX_PENDING_LOCATION_NAVIGATION_TURNS: usize = 32;
/// Opaque identity of the exact frontend Runtime command that produced one
/// renderer-side effect.
///
/// Protocol creates the command and can compare this value with its own
/// one-shot response barrier. Renderer only propagates it across the bounded
/// owner transition that surfaced the effect; it must never infer command
/// ownership from a Page, Document, wake source, or time window.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct RendererRuntimeCommandCausalIdentity {
inspector_session_id: Option<String>,
call_id: i32,
}
impl RendererRuntimeCommandCausalIdentity {
pub fn new(inspector_session_id: Option<String>, call_id: i32) -> Self {
Self {
inspector_session_id,
call_id,
}
}
pub fn inspector_session_id(&self) -> Option<&str> {
self.inspector_session_id.as_deref()
}
pub fn call_id(&self) -> i32 {
self.call_id
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RendererOwnerResourceActivitySource {
AsyncSubresource,
/// Parser-blocking classic script source fetches can pause page creation
/// before the page is installed. CDP must surface their Fetch pause before
/// deferred main-document load completion can make progress.
ParserBlockingScriptFetchInterception,
WebSocket,
/// User-visible worker lifecycle/message completions.
Worker,
/// Worker fetch/XHR subresource records that bridge back into CDP-visible Network state.
WorkerSubresource,
/// Worker fetch/XHR request-stage pauses that bridge back into Fetch.requestPaused.
WorkerFetchInterception,
/// Worker fetch/XHR cancellations that produce terminal Network and continue output.
WorkerFetchCancellation,
/// Worker fetch/XHR continue results that can produce response/auth/completion follow-up.
WorkerContinueEvent,
/// Worker WebSocket lifecycle/frame records that bridge back into CDP-visible Network state.
WorkerWebSocket,
ChildDocument,
ChildClassicScript,
ChildBlockingStylesheet,
Stylesheet,
PopupDocument,
ModuleGraphFetch,
ServiceWorker,
WebCryptoTask,
StorageIo,
DocumentWriteExternalScript,
MainParserDeferredClassicSource,
MessagePort,
BroadcastChannel,
StorageEvent,
SharedWorker,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RendererOwnerRuntimeActivitySource {
/// Broad output attribution for an already-selected runtime action whose
/// concrete task identity stays inside the renderer. This is not a Page
/// task source and grants protocol code no execution authority.
SelectedTaskOutput,
/// A host timer callback already selected and settled by the Page owner.
Timer,
/// One task from the HTML navigation-and-traversal task source.
NavigationAndTraversal,
/// One task from the HTML rendering task source.
RenderingUpdate,
/// One task from the HTML media-element event task source.
MediaElementEvent,
/// One runtime-visible task from the HTML DOM-manipulation task source.
DomManipulation,
/// One runtime-visible callback from the HTML networking task source.
Networking,
/// One selection/select/dialog event from the HTML user-interaction task source.
UserInteraction,
/// One directory-reader callback from the HTML file-reading task source.
FileReading,
/// One callback from the HTML miscellaneous-platform API task source.
MiscPlatformApi,
/// A Window.postMessage delivery already settled by the Page owner.
WindowMessage,
/// An IndexedDB request/transaction task already settled by the Page owner.
IndexedDb,
/// A document-owned task from the HTML internal-loading task source.
InternalLoading,
DocumentReplacement,
/// Module promise/reaction records that were produced by V8 callbacks.
ModuleReaction,
/// A foreground continuation posted by V8 for this page's isolate.
V8ForegroundTask,
/// The post-DOMContentLoaded lifecycle driver advanced load-stage work.
DocumentLifecycleTurn,
/// A child LocalWindow default realm is ready to be materialized.
ChildRealmMaterialization,
}
#[cfg(test)]
use self::access::{
OwnerLocalRuntimeAccessPath, OwnerLocalRuntimeEntryPath, ScriptExecutionDomainPath,
ScriptExecutionLanePath, is_on_parse_time_scaffold_lane, is_on_script_execution_domain_for,
owner_local_runtime_access_path, owner_local_runtime_entry_path, script_execution_domain_path,
script_execution_lane_path,
};
pub(crate) use self::browser_context_runtime::ServiceWorkerControlState;
pub(crate) use self::browser_context_runtime::{
ClipboardPresentationStyle, ClipboardSnapshot, RendererStoragePartitionIdentity,
RendererWorkerContextRuntime,
};
pub use self::browser_context_runtime::{
DetachedParserScriptFetchContinuation, RendererAuxiliaryNavigationKind,
RendererAuxiliaryWindow, RendererBrowserContextRuntime, RendererBrowserContextRuntimeOwner,
RendererBrowserContextRuntimeOwnerAccess, RendererBrowsingContextGroup,
RendererBrowsingContextName, RendererReservedServiceWorkerClient,
RendererServiceWorkerMainResourceFetch,
};
pub(crate) use self::document_lifecycle::{
RendererDocumentLifecycleDriveAdmission, RendererDocumentLifecycleJournalHandle,
RendererDocumentLifecycleTransition,
};
pub use self::document_lifecycle::{
RendererDocumentLifecycleEvent, RendererDocumentLifecycleEventKind,
RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,
RendererDocumentLifecycleSnapshot, RendererDocumentLifecycleWaitOutcome,
RendererDocumentLifecycleWaiter, RendererDocumentTerminationReason, RendererDocumentToken,
RendererFrameToken, RendererLifecycleEpoch, RendererLifecycleEventStamp,
RendererLifecycleStartReason, RendererLifecycleTerminationStamp, RendererPageCreationArtifacts,
};
pub(crate) use self::javascript_dialog::{
RendererJavaScriptDialogBroker, RendererJavaScriptDialogRuntime, RendererJavaScriptDialogWatch,
};
pub use self::javascript_dialog::{
RendererJavaScriptDialogCompletion, RendererJavaScriptDialogResult,
};
pub use self::lifecycle_decision::{
RendererLifecycleDecider, RendererLifecycleDecision, RendererLifecycleSnapshot,
};
use self::owner::RendererOwnerState;
pub use self::owner::{
RendererOwnerCommand, RendererOwnerHandle, RendererOwnerReply,
RendererPreparedDocumentCommitConfiguration,
};
pub use self::owner_local::RendererPageReplacementCommit;
pub use self::owner_local::RendererPageTestingHandle;
pub use self::owner_local::{
RendererPageCommandPending, RendererPageHandle, RendererRuntimeInspectorSessionDetachGuard,
};
pub(crate) use self::owner_local_store::RendererPageToken;
pub use self::page::{
JsRuntime, JsRuntimeOwner, PendingHtmlPage, PreparedRendererDocument, RendererDocumentOptions,
};
use self::page::{PageVmNavigationResponse, PageVmStateCapture};
pub(crate) use self::page_context_cancel::{
RendererPageContextCancelReason, RendererPageContextCancelReceiver,
RendererPageContextCancelSender, renderer_page_context_cancel_channel,
};
pub use self::page_print::{
RendererPdfOptions, RendererPrintToPdfReply, RendererPrintToPdfRequest,
};
pub use self::page_screenshot::{
RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
RendererCapturedScreencastFrame, RendererCapturedScreenshot, RendererScreenshotClip,
RendererScreenshotFormat, RendererScreenshotRegion, RendererVisualStateToken,
};
pub(super) use self::page_state::RendererPageEntry;
pub use self::page_state::RendererPageRecord;
pub(crate) use self::page_state::RendererPageSlotHandle;
pub use self::page_state::{RendererPageState, RendererPageStateRevision};
use self::page_surface::RendererPageTable;
pub use self::page_surface::{
CompletedWorkerRuntimeInspectorCommandDispatch, DevToolsSessionKey,
PendingWorkerRuntimeInspectorSessionResponse, RendererAccessibilityPayloadsForObjectId,
RendererActivityDiagnostics, RendererAgentAttachmentId, RendererAutofillAddressField,
RendererAutofillCreditCard, RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
RendererAuxiliaryDocumentResponse, RendererCommandTurnCompletion, RendererCommandTurnOutput,
RendererCountEntry, RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
RendererDevToolsAgentToken, RendererDocumentBoxModel, RendererDocumentChildNodeSnapshotEvent,
RendererDocumentChildNodeSnapshotEvents, RendererDocumentChildNodeSnapshots,
RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,
RendererDocumentIsolateAccountingDiagnostics, RendererDocumentNodeAttributesResolution,
RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,
RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,
RendererDocumentNodeTextResolution, RendererDocumentQuerySelectorNode,
RendererDocumentQuerySelectorResolution,
RendererDocumentQuerySelectorWithChildNodeSnapshotEvents,
RendererDocumentSourcedSameDocumentNavigation,
RendererDocumentSourcedTopLevelLocationNavigation, RendererDomAttributeMutation,
RendererDomAttributeMutationOutcome, RendererDomBidiNodeBindingResolution,
RendererDomBidiNodeSharedIdResolution, RendererDomDebuggerDomBreakpointResolution,
RendererDomDebuggerEventListener, RendererDomDebuggerEventListenerBreakpoint,
RendererDomDebuggerEventListenersResolution, RendererDomDebuggerXhrBreakpoint, RendererDomEdit,
RendererDomEditOutcome, RendererDomFocusOutcome, RendererDomFrontendNodeBindingResolution,
RendererDomMutationEvent, RendererDomMutationEventBatch, RendererDomNodeCreationStackFrame,
RendererDomNodeCreationStackTrace, RendererDomNodeReference,
RendererDomNodeStackTraceResolution, RendererDomSearchRegistration,
RendererDomSearchResultNode, RendererDomSearchResultsResolution,
RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,
RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererGeometryQuad,
RendererInputDispatchOutcome, RendererInspectorProtocolConfiguration,
RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,
RendererJavaScriptDialogId, RendererJavaScriptDialogSource, RendererLayoutMetrics,
RendererMainDocumentCommit, RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
RendererMoliMemoryScopeDiagnostics, RendererMoliRuntimeMemoryDiagnostics,
RendererNavigationInitiator, RendererPageCommand, RendererPageCommandPostResponseContinuation,
RendererPageCookieFacadeSnapshotReply, RendererPageCreationDiagnostics,
RendererPageDiagnosticsSnapshot, RendererPageDumpFormat, RendererPageDumpOptions,
RendererPageDumpStripOptions, RendererPageReply, RendererPageView,
RendererPendingDownloadActivation, RendererPendingDownloadResponse,
RendererPendingFileChooserActivation, RendererPendingJavaScriptDialog,
RendererPendingPopupActivation, RendererPendingSameDocumentNavigation,
RendererPendingTopLevelHistoryTraversal, RendererPendingWindowOpenEvent,
RendererPerformanceMetricSnapshot, RendererPointerEventProperties,
RendererPopupActivationSource, RendererPopupDisposition, RendererResourceTextSearchOutcome,
RendererRuntimeCommandOutput, RendererRuntimeEvaluationResult, RendererRuntimeHeapSpaceUsage,
RendererRuntimeHeapUsage, RendererRuntimeInspectorAsyncCompletion,
RendererRuntimeInspectorMessage, RendererRuntimeInspectorMessageBatch,
RendererRuntimeInspectorProtocolMessage, RendererRuntimeInspectorProtocolMessageValueMut,
RendererRuntimeInspectorResponseChannel, RendererRuntimeInspectorResponseSender,
RendererRuntimeObservableSourceItem, RendererRuntimeObservableSourceSummary,
RendererRuntimeRealmInfo, RendererRuntimeRemoteObject, RendererRuntimeRemoteObjectResolution,
RendererScriptExecutionMemoryDiagnostics, RendererScriptSourceMemoryDiagnostics,
RendererScrollIntoViewResult, RendererServiceWorkerConsoleMessage,
RendererServiceWorkerExceptionMessage, RendererServiceWorkerFetchDiagnostic,
RendererServiceWorkerFetchDiagnosticResult, RendererServiceWorkerTargetEvent,
RendererServiceWorkerTargetInfo, RendererServiceWorkerVersionStatus,
RendererSetDocumentContentResult, RendererSharedWorkerConsoleMessage,
RendererSharedWorkerTargetEvent, RendererSharedWorkerTargetInfo, RendererStyleSheetHeader,
RendererStyleSheetInventoryUpdate, RendererStyleSheetPayload, RendererSyntheticResponseBody,
RendererTextSearchMatch, RendererTouchPoint, RendererWindowDocumentSource,
RuntimeConsoleMessageSnapshot,
};
pub(crate) use self::page_surface::{
RendererCommandTurnOutputRecorder, RendererDevToolsSessionOutputHost,
RendererInspectorPageCommand, RendererRuntimeCommandOutputRecorder,
RendererRuntimeCommandOutputSettlement, RendererRuntimeInspectorResponsePublication,
RendererRuntimeInspectorSessionResponseSettlement, RendererRuntimeObservableSourceQueue,
};
pub use self::page_surface::{
RendererPopupActivationParts, RendererRuntimeInspectorMessageResponseOrder,
};
pub(crate) use self::page_vm::PageVm;
use self::page_vm::PageVmDropTracker;
pub(crate) use self::page_vm::PageVmEnvConfig;
pub(crate) use self::page_vm::PageVmRuntimeHooks;
#[cfg(test)]
pub(crate) use self::page_vm::deferred_page_vm_drop_pending_count_for_testing;
pub(crate) use self::page_vm::{
AuthorizedCurrentChildDocumentLoadCompletion, AuthorizedCurrentChildDynamicImportOwnerAction,
AuthorizedCurrentChildModuleDependencyFetchStart, AuthorizedCurrentChildModuleFetchCompletion,
AuthorizedCurrentChildModuleScriptTerminal, AuthorizedCurrentChildModulepreloadEventAction,
AuthorizedCurrentChildModulepreloadStartTask,
AuthorizedCurrentDocumentWriteExternalScriptLoadCompletion,
AuthorizedCurrentMainDynamicImportGraphFetchCompletion,
AuthorizedCurrentMainParserModuleGraphFetchCompletion,
AuthorizedCurrentMainRuntimeModuleGraphFetchCompletion,
AuthorizedCurrentPopupClassicScriptLoadCompletion,
AuthorizedCurrentPopupDocumentLoadCompletion, AuthorizedLiveMainModulepreloadFetchCompletion,
CurrentChildDocumentLoadApplication,
};
pub(in crate::runtime) use self::page_vm::{
PageVmCommittedNavigationBootstrap, PageVmDocumentCommitPreparation,
PageVmPreparedFollowedNavigationCommit, PageVmValidatedFollowedNavigationCommit,
};
pub use self::page_vm::{
RendererMainDocumentResource, RendererResourceContentBody, RendererResourceSearchRequest,
};
pub use self::phase_one::ExternalRawDocumentBodyStream;
use self::phase_one::PendingPhaseOneResidence;
pub(in crate::runtime) use self::phase_one::{
PhaseOneResidenceAdmission, PhaseOneRestoreRequirement,
};
pub(crate) use self::protocol_output::{PendingRendererOutputRecord, RendererTurnOutputJournal};
pub use self::protocol_output::{
RendererCdpCall, RendererDocumentTitleChanged, RendererNativeCommandReadyResponse,
RendererNativeCommandResponseGuard, RendererNativeCommandTerminal, RendererNativeOperation,
RendererNativeOperationStep, RendererNativeProtocolError, RendererNativeProtocolNotification,
RendererNativeProtocolResponse, RendererNativeProtocolStateUpdate, RendererOutputCursor,
RendererOutputFence, RendererOutputFenceLeaseId, RendererOutputItem, RendererOutputPublication,
RendererOutputPublicationOrdering, RendererOutputRecord, RendererOutputResidenceIdentity,
RendererOutputStreamCloseReason, RendererOutputStreamControl, RendererOutputStreamEpoch,
RendererOutputStreamIdentity, RendererOutputTransportDiagnostics,
RendererOutputTransportMessage, RendererOutputTransportReceiver,
RendererOutputTransportSendError, RendererOutputTransportSender, RendererOwnerAction,
RendererProtocolObservation, renderer_output_transport_channel,
};
pub use self::service_worker_run::RendererServiceWorkerRunIdentity;
pub use crate::devtools::command::{
RendererDevToolsIoCommandEnvelope, RendererDevToolsMainCommandEnvelope,
RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
RendererInspectorIngressTicket,
};
pub(crate) use crate::devtools::command::{
RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload,
RendererDevToolsMainNestedDispatch, RendererInspectorPauseCommandEffect,
};
pub use crate::devtools::ingress::io::{
RendererRuntimeInspectorIoCommandClaim, RendererRuntimeInspectorIoCommandRoute,
};
pub use crate::devtools::ingress::main::{
RendererRuntimeInspectorMainCommandCompletion, RendererRuntimeInspectorMainCommandRoute,
};
pub(crate) use crate::renderer::PageVmInitStage;
pub(crate) use crate::service_worker_runtime::{
MaterializedServiceWorkerFetchResponseHead, ServiceWorkerClientFocus,
ServiceWorkerClientFocusError, ServiceWorkerClientFocusResult, ServiceWorkerClientId,
ServiceWorkerClientMessage, ServiceWorkerClientNavigate, ServiceWorkerClientNavigateError,
ServiceWorkerClientNavigateResult, ServiceWorkerClientQuery, ServiceWorkerClientQueryKind,
ServiceWorkerClientQueryOptions, ServiceWorkerClientQueryResult, ServiceWorkerClientQueryType,
ServiceWorkerClientSnapshot, ServiceWorkerClientsOpenWindow,
ServiceWorkerClientsOpenWindowError, ServiceWorkerClientsOpenWindowResult,
ServiceWorkerCloseNotification, ServiceWorkerEventId, ServiceWorkerFetchCompletion,
ServiceWorkerFetchEvent, ServiceWorkerFetchResponse, ServiceWorkerFetchResult,
ServiceWorkerFetchStreamChunk, ServiceWorkerFetchStreamStarted, ServiceWorkerGetNotifications,
ServiceWorkerGetNotificationsResult, ServiceWorkerLifecycleCompletion,
ServiceWorkerLifecycleEvent, ServiceWorkerLifecycleEventKind, ServiceWorkerMessageCompletion,
ServiceWorkerMessageEvent, ServiceWorkerNavigationPreloadFailure,
ServiceWorkerNavigationPreloadResponseStarted, ServiceWorkerNavigationPreloadState,
ServiceWorkerNavigationPreloadStateError, ServiceWorkerNavigationPreloadStreamChunk,
ServiceWorkerNavigationPreloadStreamFinished, ServiceWorkerNotificationCompletion,
ServiceWorkerNotificationEvent, ServiceWorkerNotificationMetadata,
ServiceWorkerNotificationSnapshot, ServiceWorkerPeriodicSyncCompletion,
ServiceWorkerPeriodicSyncEvent, ServiceWorkerPeriodicSyncGetTags,
ServiceWorkerPeriodicSyncGetTagsResult, ServiceWorkerPeriodicSyncRegistration,
ServiceWorkerPeriodicSyncRegistrationResult, ServiceWorkerPeriodicSyncUnregistration,
ServiceWorkerPeriodicSyncUnregistrationResult, ServiceWorkerPushCompletion,
ServiceWorkerPushEvent, ServiceWorkerPushGetSubscription,
ServiceWorkerPushGetSubscriptionResult, ServiceWorkerPushSubscribe,
ServiceWorkerPushSubscribeResult, ServiceWorkerPushSubscriptionSnapshot,
ServiceWorkerPushUnsubscribe, ServiceWorkerPushUnsubscribeResult, ServiceWorkerRegistrationId,
ServiceWorkerShowNotification, ServiceWorkerShowNotificationResult,
ServiceWorkerSyncCompletion, ServiceWorkerSyncEvent, ServiceWorkerSyncGetTags,
ServiceWorkerSyncGetTagsResult, ServiceWorkerSyncRegistration,
ServiceWorkerSyncRegistrationResult, ServiceWorkerVersionId, ServiceWorkerWorkerMessage,
service_worker_exposed_client_id,
};
pub(crate) use nested_main::dispatch_nested_main_page_command;
static NEXT_RENDERER_OWNER_LOCAL_HOST_ID: AtomicU64 = AtomicU64::new(1);
/// Stable process-local identity of one browser-context renderer runtime.
///
/// Page owners are replaceable execution lanes, so their
/// [`RendererOwnerLocalHostId`] cannot identify browser-context-scoped
/// SharedWorker and ServiceWorker output. Worker output streams use this
/// identity to route directly to the owning BrowserContext without pretending
/// to belong to an arbitrary live Page.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RendererBrowserContextRuntimeId(u64);
impl RendererBrowserContextRuntimeId {
pub(crate) fn new(raw: u64) -> Self {
Self(raw)
}
pub fn new_for_testing(raw: u64) -> Self {
Self(raw)
}
pub fn as_u64(self) -> u64 {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RendererOwnerLocalHostId(u64);
impl RendererOwnerLocalHostId {
fn new(raw: u64) -> Self {
Self(raw)
}
pub fn new_for_testing(raw: u64) -> Self {
Self(raw)
}
pub fn as_u64(self) -> u64 {
self.0
}
}
thread_local! {
static PAGE_VM_DROP_TRACKER: RefCell<PageVmDropTracker> =
RefCell::new(PageVmDropTracker::default());
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
pub struct PageId(u64);
impl PageId {
fn new(raw: u64) -> Self {
Self(raw)
}
pub fn as_u64(self) -> u64 {
self.0
}
pub fn new_for_testing(raw: u64) -> Self {
Self(raw)
}
}
/// Opaque owner-local reservation for one renderer Page identity.
///
/// The reservation is allocated before a queued full-body build or prepared
/// document can enter parser or author-script execution. This lets external
/// observers bind work to the future Page without guessing from the currently
/// installed Page.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct RendererPageReservationToken {
local_host_id: RendererOwnerLocalHostId,
page_id: PageId,
replacement: Option<RendererPageReplacementAdmission>,
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
struct RendererPageReplacementAdmission {
expected_vm_creation_id: u64,
reservation_nonce: u64,
}
impl RendererPageReservationToken {
fn new(local_host_id: RendererOwnerLocalHostId, page_id: PageId) -> Self {
Self {
local_host_id,
page_id,
replacement: None,
}
}
fn for_replacement(
token: RendererPageToken,
expected_vm_creation_id: u64,
reservation_nonce: u64,
) -> Self {
Self {
local_host_id: token.local_host_id,
page_id: token.page_id,
replacement: Some(RendererPageReplacementAdmission {
expected_vm_creation_id,
reservation_nonce,
}),
}
}
pub fn local_host_id(self) -> RendererOwnerLocalHostId {
self.local_host_id
}
pub fn page_id(self) -> PageId {
self.page_id
}
}
/// Typed authority to consume one matching prepared document and enter its
/// renderer bootstrap.
#[derive(Debug)]
pub struct RendererDocumentCommitPermit {
prepared_document: RendererPageReservationToken,
}
impl RendererDocumentCommitPermit {
fn new(prepared_document: RendererPageReservationToken) -> Self {
Self { prepared_document }
}
fn prepared_document(&self) -> RendererPageReservationToken {
self.prepared_document
}
}
#[cfg(test)]
pub(in crate::runtime) enum PageVmNavigationTurnOutcome {
Completed(Box<PageVm>),
TriggeredNavigation,
}
pub(in crate::runtime) enum PageVmFollowedNavigationBuildOutcome {
ContinuePostParseLifecycle {
page_vm: PageVm,
page_tasks: Vec<crate::page_task_queue::PostParsePageOwnedWork>,
stage: PageVmInitStage,
started: Instant,
},
Download(RendererPendingDownloadActivation),
PendingPhaseOne(PageVmPendingPhaseOneNavigation),
TriggeredNavigation {
page_vm: PageVm,
stage: PageVmInitStage,
},
}
pub(in crate::runtime) enum PageVmFollowNavigationTurnOutcome {
Completed,
PostParseLifecycle {
target_stage: PageVmInitStage,
outcome: page_vm::DocumentLifecycleTurnOutcome,
},
Download(RendererPendingDownloadActivation),
TriggeredNavigation {
stage: PageVmInitStage,
},
}
pub(in crate::runtime) struct PageVmPendingPhaseOneNavigation {
pub(super) residence: PendingPhaseOneResidence,
pub(super) metadata: PageVmFollowedNavigationMetadata,
}
impl PageVmPendingPhaseOneNavigation {
pub(super) fn new(
residence: PendingPhaseOneResidence,
metadata: PageVmFollowedNavigationMetadata,
) -> Self {
Self {
residence,
metadata,
}
}
pub(super) fn page_vm(&self) -> &PageVm {
self.residence.page_vm()
}
pub(super) fn page_vm_mut(&mut self) -> &mut PageVm {
self.residence.page_vm_mut()
}
pub(super) fn owner_wake_token(&self) -> Option<RendererPageToken> {
self.residence.owner_wake_token()
}
pub(super) const fn phase_one_restore_requirement(&self) -> PhaseOneRestoreRequirement {
self.residence.restore_requirement()
}
pub(super) fn has_ready_streaming_input(&mut self) -> bool {
self.residence.has_ready_streaming_input()
}
pub(super) fn attach_committed_response(&mut self) {
self.metadata
.attach_committed_response(self.residence.page_vm_mut());
}
pub(super) fn into_parts(self) -> (PendingPhaseOneResidence, PageVmFollowedNavigationMetadata) {
(self.residence, self.metadata)
}
}
#[derive(Default)]
pub(in crate::runtime) struct PageVmFollowedNavigationMetadata {
pub(super) committed_navigation_response: Option<PageVmNavigationResponse>,
pub(super) service_worker_client_navigate:
Option<crate::types::ServiceWorkerClientNavigateContinuation>,
pub(super) abort_reserved_service_worker_client_id: Option<ServiceWorkerClientId>,
pub(super) abort_navigation_initiator_url: Option<Url>,
}
impl PageVmFollowedNavigationMetadata {
fn attach_committed_response(&mut self, page_vm: &mut PageVm) {
if let Some(response) = self.committed_navigation_response.take() {
page_vm::attach_navigation_response_to_page_vm(page_vm, response);
}
}
fn complete_service_worker_follow(&mut self, page_vm: &mut PageVm) {
if let Some(continuation) = self.service_worker_client_navigate.take() {
page_vm
.vm_mut()
.complete_pending_service_worker_client_navigate_after_follow(continuation);
}
}
fn reject(
&mut self,
live_page_vm: Option<&mut PageVm>,
browser_context_runtime: &RendererBrowserContextRuntime,
message: String,
) {
if let Some(client_id) = self.abort_reserved_service_worker_client_id.take() {
browser_context_runtime.unregister_service_worker_client(client_id);
}
if let Some(page_vm) = live_page_vm
&& let Some(url) = self.abort_navigation_initiator_url.as_ref()
{
page_vm
.vm_mut()
.restore_top_level_location_runtime_state(url);
}
if let Some(continuation) = self.service_worker_client_navigate.take() {
browser_context_runtime
.service_worker_runtime()
.enqueue_client_navigate_completed(
crate::types::ServiceWorkerClientNavigateCompletion {
request_id: continuation.request_id,
source_version_id: continuation.source_version_id,
source_run: continuation.source_run,
result: Err(
crate::service_worker_runtime::ServiceWorkerClientNavigateError::type_error(
message,
),
),
},
);
}
}
}
pub(super) enum PageVmNetworkIdleWaitAdvance {
Completed,
TriggeredNavigation,
Progressed {
state: PageVmNetworkIdleWaitState,
},
Waiting {
sleep_for: std::time::Duration,
state: PageVmNetworkIdleWaitState,
},
}
pub(super) enum PageVmSubresourceResponseWaitAdvance {
Completed,
TriggeredNavigation,
Progressed,
Waiting { sleep_for: std::time::Duration },
}
#[derive(Default)]
pub(super) struct PageVmNetworkIdleWaitState {
quiet_since: Option<Instant>,
observed_activity_epoch: Option<u64>,
}
#[derive(Default)]
pub(super) struct PageVmDomStableWaitState {
last_snapshot: Option<String>,
stable_since: Option<Instant>,
saw_post_domcontentloaded_runtime_work: bool,
saw_long_pending_timeout_for_observation: bool,
}
pub(super) enum PageVmDomStableWaitAdvance {
Completed,
TriggeredNavigation,
Progressed {
state: PageVmDomStableWaitState,
},
Waiting {
sleep_for: std::time::Duration,
state: PageVmDomStableWaitState,
},
}
pub(super) enum PageVmCommandWaitAdvance {
Completed {
node: crate::runtime::page_surface::RendererDocumentQuerySelectorNode,
},
Progressed,
Waiting {
sleep_for: std::time::Duration,
},
}
pub(super) enum PageVmScriptTruthyWaitAdvance {
Completed,
Progressed {
pending_call: Option<crate::script_vm::PendingRuntimeEvaluateCall>,
},
Waiting {
sleep_for: std::time::Duration,
pending_call: Option<crate::script_vm::PendingRuntimeEvaluateCall>,
},
}
pub(super) enum PageVmRuntimeExpressionAwaitAdvance {
Completed {
payload: RendererRuntimeEvaluationResult,
},
Progressed {
pending_call: Option<crate::script_vm::PendingRuntimeEvaluateCall>,
},
Waiting {
sleep_for: std::time::Duration,
pending_call: Option<crate::script_vm::PendingRuntimeEvaluateCall>,
},
}
#[cfg(test)]
mod tests;
pub(crate) use page_surface::AuxiliaryDocumentResponseReceiver;