Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use std::collections::HashSet;
pub(super) mod adopted;
pub(super) mod imports;
pub(super) mod inline;
pub(super) mod linked;
mod shared_cache;
pub(super) mod store;
mod style_element;
use crate::{
document_runtime::DomHandle,
dom::native::{DomHost, DomStylesheetOwnerChange, DomStylesheetOwnerChangeKind},
};
use self::adopted::AdoptedStyleSheetInstallation;
use self::store::StyloStylesheetSource;
use super::{
MoliStyleEngine, source_dirty::StyleSourceDirtyReason, source_id::StyleScopeId,
source_owner::stylesheet_source_base_url, source_scope_plan::StyleSourceScopeCleanupPlan,
};
impl MoliStyleEngine {
#[cfg(test)]
pub(crate) fn inline_style_base_url_count_for_document_for_test(
&self,
document: DomHandle,
) -> usize {
self.world_for_document(document)
.inline_style_metadata
.len()
}
#[cfg(test)]
pub(crate) fn adopted_style_sheet_source_owner_counts_for_document_for_test(
&self,
document: DomHandle,
) -> (usize, usize) {
let world = self.world_for_document(document);
(
world
.adopted_style_sheet_sources
.borrow()
.document_source_owner_count(),
world
.adopted_style_sheet_sources
.borrow()
.shadow_root_source_owner_count(),
)
}
#[cfg(test)]
pub(crate) fn document_adopted_style_sheet_source_ids_for_test(
&self,
document: DomHandle,
) -> Vec<super::StyleSourceId> {
self.world_for_document(document)
.adopted_style_sheet_sources
.borrow()
.document_source_ids(document)
}
#[cfg(test)]
pub(crate) fn shadow_root_adopted_style_sheet_source_ids_for_test(
&self,
host: &DomHost,
root: DomHandle,
) -> Vec<super::StyleSourceId> {
self.owner_document_world(host, root)
.map(|world| {
world
.adopted_style_sheet_sources
.borrow()
.shadow_root_source_ids(root)
})
.unwrap_or_default()
}
#[cfg(test)]
pub(crate) fn linked_stylesheet_owner_registry_counts_for_document_for_test(
&self,
document: DomHandle,
) -> (usize, usize) {
self.world_for_document(document)
.linked_stylesheet_sources
.borrow()
.counts_for_test()
}
#[cfg(test)]
pub(crate) fn set_document_adopted_style_sheet_sources(
&mut self,
document: DomHandle,
sources: Vec<StyloStylesheetSource>,
) {
let world = self.world_for_document(document);
let previous_source_ids = world
.adopted_style_sheet_sources
.borrow()
.document_source_ids(document);
if world
.adopted_style_sheet_sources
.borrow_mut()
.set_document_sources(document, sources)
{
let next_source_ids = world
.adopted_style_sheet_sources
.borrow()
.document_source_ids(document);
self.invalidate_document_stylesheet_set_for_document(
document,
previous_source_ids.into_iter().chain(next_source_ids),
);
}
}
pub(crate) fn set_document_adopted_style_sheet_installations(
&mut self,
document: DomHandle,
installations: Vec<AdoptedStyleSheetInstallation>,
) {
let world = self.world_for_document(document);
let previous_source_ids = world
.adopted_style_sheet_sources
.borrow()
.document_source_ids(document);
if world
.adopted_style_sheet_sources
.borrow_mut()
.set_document_installations(document, installations)
{
let next_source_ids = world
.adopted_style_sheet_sources
.borrow()
.document_source_ids(document);
self.invalidate_document_stylesheet_set_for_document(
document,
previous_source_ids.into_iter().chain(next_source_ids),
);
}
}
pub(crate) fn adopted_style_sheet_sources_for_document(
&self,
document: DomHandle,
) -> Vec<StyloStylesheetSource> {
self.world_for_document(document)
.adopted_style_sheet_sources
.borrow()
.document_sources_or_empty_owned(document)
}
#[cfg(test)]
pub(crate) fn document_adopted_style_sheet_tracks_document_for_test(
&self,
document: DomHandle,
) -> bool {
self.world_for_document(document)
.adopted_style_sheet_sources
.borrow()
.tracks_document(document)
}
#[cfg(test)]
pub(crate) fn set_owner_style_sheet_text_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
css_text: String,
) {
let parser_base = stylesheet_source_base_url(host, owner);
self.set_owner_style_sheet_source_with_parser_base(host, owner, css_text, parser_base);
}
#[cfg(test)]
fn set_owner_style_sheet_source_with_parser_base(
&mut self,
host: &DomHost,
owner: DomHandle,
css_text: String,
parser_base: url::Url,
) {
let Some(document) = owner_document_for_source_owner(host, owner) else {
return;
};
let previous_documents = self.move_owner_style_sheet_source_to_document(document, owner);
let world = self.world_for_document(document);
if world
.owner_style_sheet_sources
.borrow_mut()
.set_source(owner, css_text, parser_base)
{
let previous_linked_documents = self.linked_stylesheet_owner_documents(owner);
self.remove_linked_stylesheet_owner_from_documents(
host,
owner,
previous_linked_documents,
);
self.invalidate_owner_stylesheet_set_for_owner_with_host(host, owner);
}
for previous_document in previous_documents {
self.mark_document_stylesheet_set_dirty(previous_document);
}
}
pub(crate) fn owner_style_sheet_text_with_host(
&self,
host: &DomHost,
owner: DomHandle,
) -> Option<String> {
self.owner_document_world(host, owner)?
.owner_style_sheet_sources
.borrow()
.text_owned(owner)
}
pub(crate) fn owner_style_sheet_source_with_host(
&self,
host: &DomHost,
owner: DomHandle,
) -> Option<StyloStylesheetSource> {
self.owner_document_world(host, owner)?
.owner_style_sheet_sources
.borrow()
.source(owner)
}
pub(crate) fn install_owner_live_stylesheet_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
stylesheet: crate::live_stylesheet::LiveStylesheetRef,
) -> bool {
let Some(world) = self.owner_document_world(host, owner) else {
return false;
};
let installed = world
.owner_style_sheet_sources
.borrow_mut()
.install_live_stylesheet(owner, stylesheet);
if installed {
self.invalidate_owner_stylesheet_set_for_owner_with_host(host, owner);
}
installed
}
pub(crate) fn refresh_owner_live_stylesheet_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
stylesheet_id: crate::live_stylesheet::StylesheetId,
) -> bool {
let Some(world) = self.owner_document_world(host, owner) else {
return false;
};
let refreshed = world
.owner_style_sheet_sources
.borrow_mut()
.refresh_live_stylesheet(owner, stylesheet_id);
if refreshed {
self.invalidate_owner_stylesheet_set_for_owner_with_host(host, owner);
}
refreshed
}
pub(crate) fn owner_live_stylesheet_with_host(
&self,
host: &DomHost,
owner: DomHandle,
) -> Option<crate::live_stylesheet::LiveStylesheetRef> {
self.owner_document_world(host, owner)?
.owner_style_sheet_sources
.borrow()
.live_stylesheet(owner)
}
pub(crate) fn owner_style_sheet_processing_source(
&self,
owner: DomHandle,
) -> Option<std::sync::Arc<super::OwnerStyleSheetSource>> {
let document = self
.owner_stylesheet_source_documents
.borrow()
.get(&owner)
.copied()?;
self.world_for_document(document)
.owner_style_sheet_sources
.borrow()
.processing_source(owner)
}
pub(crate) fn set_owner_style_sheet_csp_suppressed_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
suppressed: bool,
) -> bool {
let Some(world) = self.owner_document_world(host, owner) else {
return false;
};
let changed = world
.owner_style_sheet_sources
.borrow_mut()
.set_csp_suppressed(owner, suppressed);
if changed {
self.invalidate_owner_stylesheet_set_for_owner_with_host(host, owner);
}
changed
}
#[cfg(test)]
pub(crate) fn record_stylesheet_source_for_url_for_document_for_test(
&mut self,
document: DomHandle,
url: &url::Url,
source: StyloStylesheetSource,
) {
self.world_for_document(document)
.linked_stylesheet_sources
.borrow_mut()
.record_source_for_url(url, source);
}
#[cfg(test)]
pub(crate) fn install_linked_stylesheet_source_for_owners_for_test(
&mut self,
host: &DomHost,
url: &url::Url,
source: StyloStylesheetSource,
owners: &[DomHandle],
) {
if owners.is_empty() {
return;
}
for &owner in owners {
self.install_linked_stylesheet_source_with_host(host, owner, url, source.clone());
}
}
#[cfg(test)]
pub(crate) fn install_linked_stylesheet_source_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
request_url: &url::Url,
source: StyloStylesheetSource,
) {
self.install_linked_stylesheet_source_and_live_owner_with_host(
host,
owner,
request_url,
source,
None,
);
}
pub(crate) fn install_linked_stylesheet_source_and_live_owner_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
request_url: &url::Url,
source: StyloStylesheetSource,
live_stylesheet: Option<crate::live_stylesheet::LiveStylesheetRef>,
) {
let Some(document) = owner_document_for_source_owner(host, owner) else {
return;
};
let previous_documents = self.linked_stylesheet_owner_documents(owner);
for previous_document in previous_documents
.iter()
.copied()
.filter(|previous| *previous != document)
{
self.remove_linked_stylesheet_owner_from_document(previous_document, owner);
}
let world = self.world_for_document(document);
let sheet_url = source.sheet_url().clone();
let origin_clean = source.origin_clean();
let (binding_changed, source_changed, live_source_changed) = {
let mut sources = world.linked_stylesheet_sources.borrow_mut();
let binding_changed = sources.bind_owner(owner, request_url.clone());
let source_changed = sources.record_source_for_url(request_url, source).changed();
let live_source_changed =
sources.set_owner_live_stylesheet(owner, live_stylesheet, &sheet_url, origin_clean);
(binding_changed, source_changed, live_source_changed)
};
self.linked_stylesheet_owner_documents
.borrow_mut()
.insert(owner, document);
if binding_changed
|| source_changed
|| live_source_changed
|| previous_documents != [document]
{
self.invalidate_linked_stylesheet_owner_lifecycle_change(
host,
owner,
previous_documents,
Some(document),
);
}
}
#[cfg(test)]
pub(crate) fn install_cached_linked_stylesheet_source_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
request_url: &url::Url,
) -> bool {
let Some(document) = owner_document_for_source_owner(host, owner) else {
return false;
};
let Some(source) = self
.world_for_document(document)
.linked_stylesheet_sources
.borrow()
.source_for_url(request_url)
else {
return false;
};
self.install_linked_stylesheet_source_with_host(host, owner, request_url, source);
true
}
pub(crate) fn cached_linked_stylesheet_source_with_host(
&self,
host: &DomHost,
owner: DomHandle,
request_url: &url::Url,
) -> Option<StyloStylesheetSource> {
let document = owner_document_for_source_owner(host, owner)?;
self.world_for_document(document)
.linked_stylesheet_sources
.borrow()
.source_for_url(request_url)
}
#[cfg(test)]
pub(crate) fn install_recorded_linked_stylesheet_source_for_test(
&mut self,
host: &DomHost,
owner: DomHandle,
request_url: &url::Url,
) -> bool {
self.install_cached_linked_stylesheet_source_with_host(host, owner, request_url)
}
pub(crate) fn apply_stylesheet_owner_changes_with_host(
&mut self,
host: &DomHost,
changes: &[DomStylesheetOwnerChange],
) {
for change in changes {
let owner = change.owner();
if host.is_inline_style_sheet_owner(owner) {
self.apply_style_element_change_with_host(host, change);
continue;
}
if !host.is_html_element_named(owner, "link") {
continue;
}
if matches!(
change.kind(),
DomStylesheetOwnerChangeKind::Attribute {
namespace: None,
local_name,
} if local_name == "title"
) {
// Title changes sheet-set eligibility, not the fetched resource.
// Preserve the source binding while invalidating style results.
let previous_documents = self.linked_stylesheet_owner_documents(owner);
self.invalidate_linked_stylesheet_owner_lifecycle_change(
host,
owner,
previous_documents,
owner_document_for_source_owner(host, owner),
);
continue;
}
if let DomStylesheetOwnerChangeKind::Attribute {
namespace,
local_name,
} = change.kind()
&& (namespace.is_some()
|| !crate::document_runtime::attribute_reprocesses_connected_stylesheet(
local_name,
))
{
continue;
}
let previous_documents = self.linked_stylesheet_owner_documents(owner);
self.remove_linked_stylesheet_owner_from_documents(host, owner, previous_documents);
}
}
#[cfg(test)]
pub(crate) fn stylesheet_text_for_url_for_document_for_test(
&self,
document: DomHandle,
url: &url::Url,
) -> Option<String> {
self.stylesheet_source_for_url_for_document_for_test(document, url)
.map(|source| source.serialized_css_text().to_string())
}
#[cfg(test)]
pub(crate) fn stylesheet_source_for_url_for_document_for_test(
&self,
document: DomHandle,
url: &url::Url,
) -> Option<StyloStylesheetSource> {
self.world_for_document(document)
.linked_stylesheet_sources
.borrow()
.source_for_url(url)
}
pub(crate) fn linked_stylesheet_source_for_owner_with_host(
&self,
host: &DomHost,
owner: DomHandle,
) -> Option<StyloStylesheetSource> {
self.owner_document_world(host, owner)?
.linked_stylesheet_sources
.borrow()
.source_for_owner(host, owner)
}
pub(crate) fn linked_live_stylesheet_with_host(
&self,
host: &DomHost,
owner: DomHandle,
) -> Option<crate::live_stylesheet::LiveStylesheetRef> {
self.owner_document_world(host, owner)?
.linked_stylesheet_sources
.borrow()
.live_stylesheet(owner)
}
pub(crate) fn refresh_linked_live_stylesheet_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
stylesheet_id: crate::live_stylesheet::StylesheetId,
) -> bool {
let Some(document) = owner_document_for_source_owner(host, owner) else {
return false;
};
let refreshed = self
.world_for_document(document)
.linked_stylesheet_sources
.borrow_mut()
.refresh_live_stylesheet(owner, stylesheet_id);
if refreshed {
self.invalidate_linked_stylesheet_owner_lifecycle_change(
host,
owner,
vec![document],
Some(document),
);
}
refreshed
}
pub(crate) fn ensure_inline_style_base_url_with_host(
&self,
host: &DomHost,
handle: DomHandle,
base_url: url::Url,
) {
let Some(document) = owner_document_for_source_owner(host, handle) else {
return;
};
self.move_inline_style_metadata_to_document(handle, document);
let world = self.world_for_document(document);
world
.inline_style_metadata
.ensure_base_url(handle, base_url);
self.inline_style_metadata_documents
.borrow_mut()
.insert(handle, document);
}
pub(crate) fn set_inline_style_base_url_with_host(
&self,
host: &DomHost,
handle: DomHandle,
base_url: url::Url,
) {
let Some(document) = owner_document_for_source_owner(host, handle) else {
return;
};
self.move_inline_style_metadata_to_document(handle, document);
self.world_for_document(document)
.inline_style_metadata
.set_base_url(handle, base_url);
self.inline_style_metadata_documents
.borrow_mut()
.insert(handle, document);
}
pub(crate) fn inline_style_base_url_with_host(
&self,
host: &DomHost,
handle: DomHandle,
) -> Option<url::Url> {
self.owner_document_world(host, handle)?
.inline_style_metadata
.base_url(handle)
}
pub(crate) fn clear_inline_style_base_url_with_host(&self, host: &DomHost, handle: DomHandle) {
let indexed_document = self
.inline_style_metadata_documents
.borrow()
.get(&handle)
.copied();
if let Some(document) = indexed_document {
let world = self.world_for_document(document);
world.inline_style_metadata.clear_base_url(handle);
self.remove_inline_style_metadata_document_if_empty(document, handle);
}
if let Some(world) = self.owner_document_world(host, handle) {
world.inline_style_metadata.clear_base_url(handle);
self.remove_inline_style_metadata_document_if_empty(world.document, handle);
}
}
pub(crate) fn set_inline_style_resolution_text_with_host(
&self,
host: &DomHost,
handle: DomHandle,
text: String,
) {
let Some(document) = owner_document_for_source_owner(host, handle) else {
return;
};
self.move_inline_style_metadata_to_document(handle, document);
self.world_for_document(document)
.inline_style_metadata
.set_resolution_text(handle, text);
self.inline_style_metadata_documents
.borrow_mut()
.insert(handle, document);
}
pub(crate) fn clear_inline_style_resolution_text_with_host(
&self,
host: &DomHost,
handle: DomHandle,
) {
let indexed_document = self
.inline_style_metadata_documents
.borrow()
.get(&handle)
.copied();
if let Some(document) = indexed_document {
let world = self.world_for_document(document);
world.inline_style_metadata.clear_resolution_text(handle);
self.remove_inline_style_metadata_document_if_empty(document, handle);
}
if let Some(world) = self.owner_document_world(host, handle) {
world.inline_style_metadata.clear_resolution_text(handle);
self.remove_inline_style_metadata_document_if_empty(world.document, handle);
}
}
pub(crate) fn set_inline_style_csp_state_with_host(
&self,
host: &DomHost,
handle: DomHandle,
state: super::InlineStyleCspState,
) -> bool {
let Some(document) = owner_document_for_source_owner(host, handle) else {
return false;
};
self.move_inline_style_metadata_to_document(handle, document);
let changed = self
.world_for_document(document)
.inline_style_metadata
.set_csp_state(handle, state);
if state == super::InlineStyleCspState::Unchecked {
self.remove_inline_style_metadata_document_if_empty(document, handle);
} else {
self.inline_style_metadata_documents
.borrow_mut()
.insert(handle, document);
}
changed
}
pub(crate) fn inline_style_csp_state_with_host(
&self,
host: &DomHost,
handle: DomHandle,
) -> super::InlineStyleCspState {
// This is a metadata lookup performed while resolving CSSOM property
// names. In particular, a held declaration from a retired iframe may
// reach it; a read must not recreate that Document's heavyweight world.
self.active_owner_document_world(host, handle)
.map(|world| world.inline_style_metadata.csp_state(handle))
.unwrap_or_default()
}
pub(crate) fn migrate_inline_style_metadata_subtree_with_host(
&self,
host: &DomHost,
root: DomHandle,
) {
let mut stack = vec![root];
while let Some(handle) = stack.pop() {
self.migrate_inline_style_metadata_to_current_owner_document_with_host(host, handle);
let mut child = host.first_child(handle);
while let Some(current) = child {
stack.push(current);
child = host.next_sibling(current);
}
if let Some(shadow_root) = host.shadow_root_handle(handle) {
stack.push(shadow_root);
}
}
}
#[cfg(test)]
pub(crate) fn set_shadow_root_adopted_style_sheet_sources_with_host(
&mut self,
host: &DomHost,
root: DomHandle,
sources: Vec<StyloStylesheetSource>,
) {
let Some(world) = self.owner_document_world(host, root) else {
return;
};
let previous_source_ids = world
.adopted_style_sheet_sources
.borrow()
.shadow_root_source_ids(root);
if world
.adopted_style_sheet_sources
.borrow_mut()
.set_shadow_root_sources(root, sources)
{
let next_source_ids = world
.adopted_style_sheet_sources
.borrow()
.shadow_root_source_ids(root);
self.invalidate_shadow_root_stylesheet_set_for_owner_with_host(
host,
root,
previous_source_ids.into_iter().chain(next_source_ids),
);
}
}
pub(crate) fn set_shadow_root_adopted_style_sheet_installations_with_host(
&mut self,
host: &DomHost,
root: DomHandle,
installations: Vec<AdoptedStyleSheetInstallation>,
) {
let Some(world) = self.owner_document_world(host, root) else {
return;
};
let previous_source_ids = world
.adopted_style_sheet_sources
.borrow()
.shadow_root_source_ids(root);
if world
.adopted_style_sheet_sources
.borrow_mut()
.set_shadow_root_installations(root, installations)
{
let next_source_ids = world
.adopted_style_sheet_sources
.borrow()
.shadow_root_source_ids(root);
self.invalidate_shadow_root_stylesheet_set_for_owner_with_host(
host,
root,
previous_source_ids.into_iter().chain(next_source_ids),
);
}
}
pub(crate) fn shadow_root_adopted_style_sheet_sources_with_host(
&self,
host: &DomHost,
root: DomHandle,
) -> Vec<StyloStylesheetSource> {
let Some(world) = self.owner_document_world(host, root) else {
return Vec::new();
};
world
.adopted_style_sheet_sources
.borrow()
.shadow_root_sources_or_empty_owned(root)
}
#[cfg(test)]
pub(crate) fn shadow_root_adopted_style_sheet_tracks_root_for_document_for_test(
&self,
document: DomHandle,
root: DomHandle,
) -> bool {
self.world_for_document(document)
.adopted_style_sheet_sources
.borrow()
.tracks_shadow_root(root)
}
pub(crate) fn mark_document_stylesheet_set_dirty(&mut self, document: DomHandle) {
let world = self.world_for_document(document);
world.document_state.bump_source_set_generation();
world.document_state.record_source_dirty_scope(
StyleScopeId::Document(document),
StyleSourceDirtyReason::DocumentStyleSheets,
std::iter::empty(),
[document],
);
}
fn invalidate_document_stylesheet_set_for_document(
&mut self,
document: DomHandle,
source_ids: impl IntoIterator<Item = super::StyleSourceId>,
) {
let plan = StyleSourceScopeCleanupPlan::document_adopted_stylesheets(document, source_ids);
self.apply_source_scope_cleanup_plan(plan);
}
fn invalidate_owner_stylesheet_set_for_owner_with_host(
&mut self,
host: &DomHost,
owner: DomHandle,
) {
let plan = StyleSourceScopeCleanupPlan::owner_stylesheet(host, owner);
self.apply_source_scope_cleanup_plan(plan);
}
fn invalidate_linked_stylesheet_set_for_owner_handles_with_host(
&mut self,
host: &DomHost,
owners: &[DomHandle],
) {
let plan =
StyleSourceScopeCleanupPlan::linked_stylesheet_owners(host, owners.iter().copied());
self.apply_source_scope_cleanup_plan(plan);
}
fn invalidate_shadow_root_stylesheet_set_for_owner_with_host(
&mut self,
host: &DomHost,
root: DomHandle,
source_ids: impl IntoIterator<Item = super::StyleSourceId>,
) {
let plan =
StyleSourceScopeCleanupPlan::shadow_root_adopted_stylesheets(host, root, source_ids);
self.apply_source_scope_cleanup_plan(plan);
}
fn apply_source_scope_cleanup_plan(&mut self, plan: StyleSourceScopeCleanupPlan) {
for document in plan.full_documents() {
self.mark_document_stylesheet_set_dirty(document);
}
let mut source_set_generation_bumped_documents = HashSet::new();
for entry in plan.scoped_entries_by_document() {
let document = entry.document();
let world = self.world_for_document(document);
if source_set_generation_bumped_documents.insert(document) {
world.document_state.bump_source_set_generation();
}
let roots = entry.roots().clone();
world.document_state.record_source_dirty_scope(
entry.scope_id(),
entry.reason(),
entry.source_ids(),
roots.iter().copied(),
);
}
}
fn remove_linked_stylesheet_owner_from_document(
&self,
document: DomHandle,
owner: DomHandle,
) -> bool {
if self
.linked_stylesheet_owner_documents
.borrow()
.get(&owner)
.copied()
!= Some(document)
{
return false;
}
self.linked_stylesheet_owner_documents
.borrow_mut()
.remove(&owner);
self.world_for_document(document)
.linked_stylesheet_sources
.borrow_mut()
.remove_owner(owner)
}
fn move_owner_style_sheet_source_to_document(
&self,
document: DomHandle,
owner: DomHandle,
) -> Vec<DomHandle> {
let mut documents = Vec::new();
let previous_document = self
.owner_stylesheet_source_documents
.borrow()
.get(&owner)
.copied();
if let Some(previous_document) = previous_document
&& previous_document != document
&& self
.world_for_document(previous_document)
.owner_style_sheet_sources
.borrow_mut()
.remove_owner(owner)
{
documents.push(previous_document);
}
self.owner_stylesheet_source_documents
.borrow_mut()
.insert(owner, document);
documents
}
fn remove_owner_style_sheet_source(&mut self, owner: DomHandle) {
let Some(document) = self
.owner_stylesheet_source_documents
.borrow_mut()
.remove(&owner)
else {
return;
};
if self
.world_for_document(document)
.owner_style_sheet_sources
.borrow_mut()
.remove_owner(owner)
{
self.mark_document_stylesheet_set_dirty(document);
}
}
fn migrate_inline_style_metadata_to_current_owner_document_with_host(
&self,
host: &DomHost,
handle: DomHandle,
) {
let Some(document) = owner_document_for_source_owner(host, handle) else {
return;
};
self.move_inline_style_metadata_to_document(handle, document);
}
fn move_inline_style_metadata_to_document(&self, handle: DomHandle, document: DomHandle) {
let previous_document = self
.inline_style_metadata_documents
.borrow()
.get(&handle)
.copied();
if let Some(previous_document) = previous_document
&& previous_document != document
{
let metadata = self
.world_for_document(previous_document)
.inline_style_metadata
.take(handle);
if let Some(metadata) = metadata {
self.world_for_document(document)
.inline_style_metadata
.merge_missing(handle, metadata);
self.inline_style_metadata_documents
.borrow_mut()
.insert(handle, document);
} else {
self.inline_style_metadata_documents
.borrow_mut()
.remove(&handle);
}
}
}
fn remove_inline_style_metadata_document_if_empty(
&self,
document: DomHandle,
handle: DomHandle,
) {
if self
.world_for_document(document)
.inline_style_metadata
.has_metadata(handle)
{
return;
}
let indexed_document = self
.inline_style_metadata_documents
.borrow()
.get(&handle)
.copied();
if indexed_document == Some(document) {
self.inline_style_metadata_documents
.borrow_mut()
.remove(&handle);
}
}
fn remove_linked_stylesheet_owner_from_documents(
&mut self,
host: &DomHost,
owner: DomHandle,
documents: Vec<DomHandle>,
) {
if documents.is_empty() {
return;
}
for document in &documents {
self.remove_linked_stylesheet_owner_from_document(*document, owner);
}
self.invalidate_linked_stylesheet_owner_lifecycle_change(
host,
owner,
documents,
owner_document_for_source_owner(host, owner),
);
}
fn linked_stylesheet_owner_documents(&self, owner: DomHandle) -> Vec<DomHandle> {
self.linked_stylesheet_owner_documents
.borrow()
.get(&owner)
.copied()
.into_iter()
.collect()
}
fn invalidate_linked_stylesheet_owner_lifecycle_change(
&mut self,
host: &DomHost,
owner: DomHandle,
previous_documents: Vec<DomHandle>,
scoped_cleanup_document: Option<DomHandle>,
) {
if scoped_cleanup_document.is_some() {
self.invalidate_linked_stylesheet_set_for_owner_handles_with_host(host, &[owner]);
}
for document in previous_documents {
if Some(document) == scoped_cleanup_document {
continue;
}
self.mark_document_stylesheet_set_dirty(document);
}
}
}
fn owner_document_for_source_owner(host: &DomHost, owner: DomHandle) -> Option<DomHandle> {
host.owner_document_handle(owner)
}