Files
moli/moli-parser/src/session.rs
T
ldm0 e3836bb52e fix(dom): initialize parser shadow registries incrementally
Carry newly created null and document-default registry associations through
parser handoffs instead of cloning every retained ShadowRoot after each parse.
Keep fragment, streaming, windowless and popup consumers on the same path.

Preserve the registry when attachShadow reuses a declarative root. Cover
stream notification ownership and cross-document default/null associations
with a fixture also exercised against native Chromium.
2026-11-21 20:03:38 +08:00

589 lines
22 KiB
Rust

use std::{
cell::{Cell, RefCell},
rc::Rc,
};
use html5ever::{
ParseOpts,
tendril::StrTendril,
tokenizer::{
BufferQueue, Tag, TagKind, Token, TokenSink, TokenSinkResult, Tokenizer, TokenizerOpts,
},
tree_builder::{Tracer, TreeBuilder, TreeBuilderOpts, TreeSink},
};
use markup5ever::TokenizerResult;
use moli_dom::native::NativeNodeId;
use moli_script::script_element_nonce_is_nonceable;
use super::{
ParserSourcePosition,
html::{
DocumentSink, HtmlFragmentContext, ParseHandle, ParserFinishDiscoverySignals,
ParserInputQueue,
},
html_input::InputStack,
live_target::ParserStreamHtmlTreeSinkTarget,
};
pub(super) struct HtmlTreeSinkSession {
pub(super) parser: HtmlParserSession,
pub(super) script_input: ParserInputQueue,
}
pub(super) struct HtmlParserSession {
tokenizer: Tokenizer<EmbedderPausingTreeBuilder>,
input: RefCell<InputStack>,
}
pub(super) enum HtmlParserSessionResult {
InputDrained,
OwnerInterrupted,
Script(ParseHandle),
}
// html5ever carries tokenizer pauses through Script(Handle). Keep the pause
// reason separate from the tree builder's DOM handles at this adapter boundary.
enum TokenizerPause {
Handoff(ParseHandle),
OwnerInterrupted,
}
struct EmbedderPausingTreeBuilder {
inner: TreeBuilder<ParseHandle, DocumentSink>,
fragment_context: Option<NativeNodeId>,
// Retain a callback's Break until html5ever accepts a pause result. This is
// an undelivered notification, not a copy of the owner's current run state;
// it must survive both later Continue callbacks and input chunk boundaries.
deferred_owner_interruption: Cell<bool>,
}
#[derive(Default)]
struct OpenFormControlTracer {
handles: RefCell<Vec<NativeNodeId>>,
fragment_context: Option<NativeNodeId>,
}
impl Tracer for OpenFormControlTracer {
type Handle = ParseHandle;
fn trace_handle(&self, node: &ParseHandle) {
let is_blocking_control = node.element_name.as_ref().is_some_and(|name| {
AsRef::<str>::as_ref(&name.ns) == "http://www.w3.org/1999/xhtml"
&& matches!(AsRef::<str>::as_ref(&name.local), "select" | "textarea")
});
if !is_blocking_control {
return;
}
let Some(node_id) = node.dom_node_id() else {
return;
};
// html5ever also traces the fragment context for GC. It is an existing
// element, not an unclosed control created by this parser.
if Some(node_id) == self.fragment_context {
return;
}
let mut handles = self.handles.borrow_mut();
if !handles.contains(&node_id) {
handles.push(node_id);
}
}
}
impl EmbedderPausingTreeBuilder {
fn new(sink: DocumentSink, opts: TreeBuilderOpts) -> Self {
Self {
inner: TreeBuilder::new(sink, opts),
fragment_context: None,
deferred_owner_interruption: Cell::new(false),
}
}
fn new_for_fragment(
sink: DocumentSink,
context_handle: ParseHandle,
opts: TreeBuilderOpts,
) -> Self {
let fragment_context = context_handle.dom_node_id();
Self {
inner: TreeBuilder::new_for_fragment(sink, context_handle, None, opts),
fragment_context,
deferred_owner_interruption: Cell::new(false),
}
}
fn sink(&self) -> &DocumentSink {
&self.inner.sink
}
fn begin_tree_builder_finish(&self) {
let tracer = OpenFormControlTracer {
fragment_context: self.fragment_context,
..OpenFormControlTracer::default()
};
self.inner.trace_handles(&tracer);
self.inner
.sink
.begin_tree_builder_finish(&tracer.handles.into_inner());
}
}
impl EmbedderPausingTreeBuilder {
fn process_token_before_callbacks(
&self,
token: Token,
line_number: u64,
) -> TokenSinkResult<ParseHandle> {
if !matches!(
&token,
Token::CharacterTokens(_) | Token::NullCharacterToken | Token::ParseError(_)
) {
self.sink().flush_pending_text();
}
let current_script_nonceable = match &token {
Token::TagToken(tag)
if tag.kind == TagKind::StartTag && AsRef::<str>::as_ref(&tag.name) == "script" =>
{
let nonce = tag
.attrs
.iter()
.find(|attribute| {
attribute.name.ns.is_empty()
&& AsRef::<str>::as_ref(&attribute.name.local) == "nonce"
})
.map(|attribute| attribute.value.as_ref());
Some(script_element_nonce_is_nonceable(
nonce,
tag.had_duplicate_attributes,
tag.attrs.iter().map(|attribute| {
(
AsRef::<str>::as_ref(&attribute.name.local),
attribute.value.as_ref(),
)
}),
))
}
_ => None,
};
let in_foreign_content = self
.inner
.adjusted_current_node_present_but_not_in_html_namespace();
let foreign_end_tag = match &token {
Token::TagToken(tag) if in_foreign_content && tag.kind == TagKind::EndTag => {
Some(tag.name.clone())
}
_ => None,
};
let self_closing_foreign_start_tag = match &token {
Token::TagToken(tag)
if in_foreign_content && tag.kind == TagKind::StartTag && tag.self_closing =>
{
Some(tag.name.clone())
}
_ => None,
};
let previous_script_nonceable = self
.inner
.sink
.replace_current_script_nonceable(current_script_nonceable);
let result = self.inner.process_token(token, line_number);
self.inner
.sink
.replace_current_script_nonceable(previous_script_nonceable);
// Encoding notices are advisory for this already-decoded input. A tag
// such as <link rel=stylesheet charset=utf-8> can also require an
// embedder pause, which must be returned at this tag boundary. Leaving
// it pending would expose it on a later character or error token,
// where html5ever requires Continue and would otherwise panic.
if !matches!(
result,
TokenSinkResult::Continue | TokenSinkResult::EncodingIndicator(_)
) {
return result;
}
let svg_script_handoff = if let Some(local_name) = foreign_end_tag {
// html5ever truncates its foreign-content open-element stack
// directly, bypassing TreeSink::pop(). Keep the parser target's
// mirror synchronized and expose closed SVG scripts below.
self.inner
.sink
.note_foreign_end_tag_processed(local_name.as_ref())
} else if let Some(local_name) = self_closing_foreign_start_tag {
self.inner
.sink
.note_self_closing_foreign_element_processed(local_name.as_ref())
} else {
None
};
if let Some(script) = svg_script_handoff {
// html5ever 0.39 has an explicit FIXME for </script> in SVG and
// does not return TokenSinkResult::Script for it. Preserve the
// ordinary tokenizer pause contract at this narrow adapter.
return TokenSinkResult::Script(ParseHandle::new(script, None));
}
result
}
fn flush_text_at_input_boundary(&self) {
self.sink().flush_pending_text();
if self.sink().take_committed_dom_mutations()
&& self.sink().finish_parser_dom_mutations().is_break()
{
// As with a character-token callback, retain the notification
// until html5ever can safely pause at a tag token.
self.deferred_owner_interruption.set(true);
}
}
}
impl TokenSink for EmbedderPausingTreeBuilder {
type Handle = TokenizerPause;
fn process_tag_token_with_position(
&self,
tag: Tag,
line_number: u64,
column_number: u64,
) -> TokenSinkResult<Self::Handle> {
let previous = self
.sink()
.replace_current_tag_position(Some(ParserSourcePosition {
line: line_number,
column: column_number,
}));
let result = self.process_token(Token::TagToken(tag), line_number);
self.sink().replace_current_tag_position(previous);
result
}
fn process_token(&self, token: Token, line_number: u64) -> TokenSinkResult<Self::Handle> {
// html5ever requires character, comment, doctype and EOF tokens to
// return Continue. A parser mutation callback may make a stylesheet or
// custom-element pause visible only after one of those tokens. Retain
// the sink-owned pause until a tag token can yield it safely.
let can_pause = matches!(&token, Token::TagToken(_));
let commits_text = !matches!(
&token,
Token::CharacterTokens(_) | Token::NullCharacterToken | Token::ParseError(_)
);
let result = self.process_token_before_callbacks(token, line_number);
let committed_dom = self.sink().take_committed_dom_mutations();
let finish_mutations = commits_text || committed_dom;
if finish_mutations {
// Processing this token can itself drain html5ever's pending
// table characters into a foster-parented insertion point.
self.sink().flush_pending_text();
self.sink().take_committed_dom_mutations();
}
// A callback can execute script or inspect the live DOM. Buffered
// character fragments must not expose a stale, partially committed run.
let current_owner_interruption =
finish_mutations && self.sink().finish_parser_dom_mutations().is_break();
let deferred_owner_interruption = self.deferred_owner_interruption.replace(false);
let owner_interrupted = current_owner_interruption || deferred_owner_interruption;
if !can_pause {
self.deferred_owner_interruption.set(owner_interrupted);
return TokenSinkResult::Continue;
}
if owner_interrupted {
// A nested parser invocation already handed its blocker to the
// owner. Stop this outer feed before it consumes another token.
return TokenSinkResult::Script(TokenizerPause::OwnerInterrupted);
}
if matches!(
&result,
TokenSinkResult::Continue | TokenSinkResult::EncodingIndicator(_)
) {
if let Some(placeholder) = self
.sink()
.pending_custom_element_construction_handoff_placeholder()
{
// html5ever has no custom-element pause result. The stream
// distinguishes this handle using sink-owned state.
return TokenSinkResult::Script(TokenizerPause::Handoff(ParseHandle::new(
placeholder,
None,
)));
}
if let Some(stylesheet) = self.sink().pending_blocking_stylesheet_pause() {
// Query after mutation callbacks so the handle matches
// the queue entry consumed by the stream layer.
return TokenSinkResult::Script(TokenizerPause::Handoff(ParseHandle::new(
stylesheet, None,
)));
}
}
match result {
TokenSinkResult::Continue => TokenSinkResult::Continue,
TokenSinkResult::Script(handle) => {
TokenSinkResult::Script(TokenizerPause::Handoff(handle))
}
TokenSinkResult::Plaintext => TokenSinkResult::Plaintext,
TokenSinkResult::RawData(kind) => TokenSinkResult::RawData(kind),
TokenSinkResult::EncodingIndicator(label) => TokenSinkResult::EncodingIndicator(label),
}
}
fn end(&self) {
self.sink().flush_pending_text();
self.inner.end();
self.sink().take_committed_dom_mutations();
let _ = self.sink().finish_parser_dom_mutations();
}
fn adjusted_current_node_present_but_not_in_html_namespace(&self) -> bool {
self.inner
.adjusted_current_node_present_but_not_in_html_namespace()
}
}
impl HtmlParserSession {
pub(super) fn initialize_text_document(&self) {
// Parse only the browser-owned shell. Response bytes enter the tokenizer
// after it has switched to plaintext, so tags and entities stay literal.
self.process(StrTendril::from(concat!(
"<html><head></head><body>",
"<pre style=\"word-wrap: break-word; white-space: pre-wrap;\">\n"
)));
// Text documents have no doctype but always use no-quirks mode.
self.sink()
.set_quirks_mode(html5ever::tree_builder::QuirksMode::NoQuirks);
self.tokenizer.set_plaintext_state();
}
fn new(sink: DocumentSink, opts: ParseOpts) -> Self {
let tree_builder = EmbedderPausingTreeBuilder::new(sink, opts.tree_builder);
Self {
tokenizer: Tokenizer::new(tree_builder, opts.tokenizer),
input: RefCell::default(),
}
}
pub(super) fn new_fragment(
sink: DocumentSink,
opts: ParseOpts,
context_handle: ParseHandle,
context_element_allows_scripting: bool,
) -> Self {
let tree_builder =
EmbedderPausingTreeBuilder::new_for_fragment(sink, context_handle, opts.tree_builder);
let tokenizer_options = TokenizerOpts {
initial_state: Some(
tree_builder
.inner
.tokenizer_state_for_context_elem(context_element_allows_scripting),
),
..opts.tokenizer
};
Self {
tokenizer: Tokenizer::new(tree_builder, tokenizer_options),
input: RefCell::default(),
}
}
pub(super) fn process(&self, input: StrTendril) {
self.input.borrow_mut().push_back(input);
let input = self.input.borrow().current();
while let HtmlParserSessionResult::Script(_) =
feed_with_definitive_encoding(&self.tokenizer, &input)
{
// Non-pump callers intentionally parse through embedder pauses. They have no
// runtime owner to notify, so parser-side custom-element handoffs and
// blocking-stylesheet pauses must be discarded before continuing.
self.discard_parser_side_embedder_yield();
}
self.tokenizer.sink.flush_text_at_input_boundary();
}
pub(super) fn push_back(&self, input: StrTendril) {
self.input.borrow_mut().push_back(input);
}
pub(super) fn begin_inserted_input(&self, input: StrTendril) {
if input.is_empty() {
return;
}
self.tokenizer.sink.flush_text_at_input_boundary();
// Without segment provenance from html5ever, any later token can span
// inserted input and the original tail after this insertion frame is
// restored. Prefer permanent unknown locations over reporting
// plausible but incorrect document lines.
self.tokenizer.sink.sink().mark_source_positions_unknown();
self.input.borrow_mut().begin_inserted(input);
}
pub(super) fn append_to_current_inserted_input(&self, input: StrTendril) -> bool {
self.input.borrow_mut().append_to_current_inserted(input)
}
pub(super) fn current_input_insertion_point(&self) -> Rc<BufferQueue> {
self.input.borrow().current()
}
pub(super) fn append_at_current_insertion_point(&self, input: StrTendril) {
self.tokenizer.sink.sink().mark_source_positions_unknown();
self.input.borrow_mut().push_back(input);
}
pub(super) fn has_buffered_input(&self) -> bool {
self.input.borrow().has_input()
}
pub(super) fn buffered_input_len(&self) -> usize {
self.input.borrow().len()
}
pub(super) fn snapshot_buffered_input(&self) -> String {
self.input.borrow().snapshot()
}
pub(super) fn feed(&self) -> HtmlParserSessionResult {
let input = self.input.borrow().current();
let result = feed_with_definitive_encoding(&self.tokenizer, &input);
self.tokenizer.sink.flush_text_at_input_boundary();
if matches!(result, HtmlParserSessionResult::InputDrained)
&& self.input.borrow().is_current(&input)
{
// The restored parent is intentionally consumed by the next parser
// step so each insertion depth keeps an explicit input boundary.
self.input.borrow_mut().restore_parent_if_current_empty();
}
result
}
pub(super) fn sink(&self) -> &DocumentSink {
self.tokenizer.sink.sink()
}
pub(super) fn finish(self) -> ParserStreamHtmlTreeSinkTarget {
let Self { tokenizer, input } = self;
let input_buffer = input.into_inner().into_buffer();
while let HtmlParserSessionResult::Script(_) =
feed_with_definitive_encoding(&tokenizer, &input_buffer)
{
tokenizer
.sink
.sink()
.pop_pending_custom_element_construction_handoff();
tokenizer
.sink
.sink()
.pop_pending_blocking_stylesheet_pause();
}
debug_assert!(input_buffer.is_empty());
tokenizer.sink.begin_tree_builder_finish();
tokenizer.end();
tokenizer.sink.inner.sink.finish()
}
pub(super) fn finish_live_runtime_dom_sink_parser(self) -> ParserFinishDiscoverySignals {
let Self { tokenizer, input } = self;
let input_buffer = input.into_inner().into_buffer();
while let HtmlParserSessionResult::Script(_) =
feed_with_definitive_encoding(&tokenizer, &input_buffer)
{
tokenizer
.sink
.sink()
.pop_pending_custom_element_construction_handoff();
tokenizer
.sink
.sink()
.pop_pending_blocking_stylesheet_pause();
}
debug_assert!(input_buffer.is_empty());
tokenizer.sink.begin_tree_builder_finish();
tokenizer.end();
let sink = tokenizer.sink.sink();
sink.finish_construction();
ParserFinishDiscoverySignals {
parser_created_registry_associations: sink
.take_parser_stream_custom_element_registry_associations(),
discovered_preload_link_candidates: sink.drain_discovered_preload_link_candidates(),
discovered_parser_meta_csp_candidates: sink
.drain_discovered_parser_meta_csp_candidates(),
discovered_stylesheet_inputs: sink.drain_discovered_stylesheet_inputs(),
}
}
fn discard_parser_side_embedder_yield(&self) {
self.tokenizer
.sink
.sink()
.pop_pending_custom_element_construction_handoff();
self.tokenizer
.sink
.sink()
.pop_pending_blocking_stylesheet_pause();
}
}
fn feed_with_definitive_encoding(
tokenizer: &Tokenizer<EmbedderPausingTreeBuilder>,
input_buffer: &BufferQueue,
) -> HtmlParserSessionResult {
loop {
match tokenizer.feed(input_buffer) {
// Moli resolves the document encoding from the response and byte-level
// meta prescan before creating this Unicode parser session. The tree
// builder cannot change that definitive decoding, so continue past its
// advisory notification without exposing a false parser pause.
TokenizerResult::EncodingIndicator(_) => {}
TokenizerResult::Done => return HtmlParserSessionResult::InputDrained,
TokenizerResult::Script(TokenizerPause::Handoff(handle)) => {
return HtmlParserSessionResult::Script(handle);
}
TokenizerResult::Script(TokenizerPause::OwnerInterrupted) => {
return HtmlParserSessionResult::OwnerInterrupted;
}
}
}
}
pub(super) fn new_html_tree_sink_session(
target: ParserStreamHtmlTreeSinkTarget,
options: ParseOpts,
) -> HtmlTreeSinkSession {
let sink = DocumentSink::new(target);
let parser = HtmlParserSession::new(sink, options);
let script_input = ParserInputQueue::default();
HtmlTreeSinkSession {
parser,
script_input,
}
}
pub(super) fn new_fragment_html_tree_sink_session(
target: ParserStreamHtmlTreeSinkTarget,
context: HtmlFragmentContext,
scripting_enabled: bool,
) -> HtmlTreeSinkSession {
let sink = DocumentSink::new(target);
let context_handle = context.into_parse_handle();
let parser = HtmlParserSession::new_fragment(
sink,
html_parse_opts_with_scripting(scripting_enabled),
context_handle,
scripting_enabled,
);
let script_input = ParserInputQueue::default();
HtmlTreeSinkSession {
parser,
script_input,
}
}
pub(super) fn html_parse_opts_with_scripting(scripting_enabled: bool) -> ParseOpts {
ParseOpts {
tokenizer: TokenizerOpts {
track_tag_positions: true,
..TokenizerOpts::default()
},
tree_builder: TreeBuilderOpts {
scripting_enabled,
..TreeBuilderOpts::default()
},
}
}