diff options
Diffstat (limited to '')
| -rw-r--r-- | servo/components/style/stylist.rs | 3347 |
1 files changed, 3347 insertions, 0 deletions
diff --git a/servo/components/style/stylist.rs b/servo/components/style/stylist.rs new file mode 100644 index 0000000000..81f30ee2a3 --- /dev/null +++ b/servo/components/style/stylist.rs @@ -0,0 +1,3347 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! Selector matching. + +use crate::applicable_declarations::{ + ApplicableDeclarationBlock, ApplicableDeclarationList, CascadePriority, +}; +use crate::context::{CascadeInputs, QuirksMode}; +use crate::dom::{TElement, TShadowRoot}; +#[cfg(feature = "gecko")] +use crate::gecko_bindings::structs::{ServoStyleSetSizes, StyleRuleInclusion}; +use crate::invalidation::element::invalidation_map::InvalidationMap; +use crate::invalidation::media_queries::{ + EffectiveMediaQueryResults, MediaListKey, ToMediaListKey, +}; +use crate::invalidation::stylesheets::RuleChangeKind; +use crate::media_queries::Device; +use crate::properties::{self, CascadeMode, ComputedValues}; +use crate::properties::{AnimationDeclarations, PropertyDeclarationBlock}; +use crate::rule_cache::{RuleCache, RuleCacheConditions}; +use crate::rule_collector::{containing_shadow_ignoring_svg_use, RuleCollector}; +use crate::rule_tree::{CascadeLevel, RuleTree, StrongRuleNode, StyleSource}; +use crate::selector_map::{PrecomputedHashMap, PrecomputedHashSet, SelectorMap, SelectorMapEntry}; +use crate::selector_parser::{PerPseudoElementMap, PseudoElement, SelectorImpl, SnapshotMap}; +use crate::shared_lock::{Locked, SharedRwLockReadGuard, StylesheetGuards}; +use crate::stylesheet_set::{DataValidity, DocumentStylesheetSet, SheetRebuildKind}; +use crate::stylesheet_set::{DocumentStylesheetFlusher, SheetCollectionFlusher}; +use crate::stylesheets::container_rule::ContainerCondition; +use crate::stylesheets::import_rule::ImportLayer; +use crate::stylesheets::keyframes_rule::KeyframesAnimation; +use crate::stylesheets::layer_rule::{LayerName, LayerOrder}; +use crate::stylesheets::viewport_rule::{self, MaybeNew, ViewportRule}; +#[cfg(feature = "gecko")] +use crate::stylesheets::{ + CounterStyleRule, FontFaceRule, FontFeatureValuesRule, FontPaletteValuesRule, PageRule, +}; +use crate::stylesheets::{ + CssRule, EffectiveRulesIterator, Origin, OriginSet, PerOrigin, PerOriginIter, +}; +use crate::stylesheets::{StyleRule, StylesheetContents, StylesheetInDocument}; +use crate::AllocErr; +use crate::{Atom, LocalName, Namespace, ShrinkIfNeeded, WeakAtom}; +use dom::{DocumentState, ElementState}; +use fxhash::FxHashMap; +use malloc_size_of::MallocSizeOf; +#[cfg(feature = "gecko")] +use malloc_size_of::{MallocShallowSizeOf, MallocSizeOfOps, MallocUnconditionalShallowSizeOf}; +use selectors::attr::{CaseSensitivity, NamespaceConstraint}; +use selectors::bloom::BloomFilter; +use selectors::matching::VisitedHandlingMode; +use selectors::matching::{matches_selector, MatchingContext, MatchingMode, NeedsSelectorFlags}; +use selectors::parser::{ + AncestorHashes, Combinator, Component, Selector, SelectorIter, SelectorList, +}; +use selectors::visitor::{SelectorListKind, SelectorVisitor}; +use selectors::NthIndexCache; +use servo_arc::{Arc, ArcBorrow}; +use smallbitvec::SmallBitVec; +use smallvec::SmallVec; +use std::borrow::Cow; +use std::cmp::Ordering; +use std::hash::{Hash, Hasher}; +use std::sync::Mutex; +use std::{mem, ops}; +use style_traits::viewport::ViewportConstraints; + +/// The type of the stylesheets that the stylist contains. +#[cfg(feature = "servo")] +pub type StylistSheet = crate::stylesheets::DocumentStyleSheet; + +/// The type of the stylesheets that the stylist contains. +#[cfg(feature = "gecko")] +pub type StylistSheet = crate::gecko::data::GeckoStyleSheet; + +#[derive(Debug, Clone)] +struct StylesheetContentsPtr(Arc<StylesheetContents>); + +impl PartialEq for StylesheetContentsPtr { + #[inline] + fn eq(&self, other: &Self) -> bool { + Arc::ptr_eq(&self.0, &other.0) + } +} + +impl Eq for StylesheetContentsPtr {} + +impl Hash for StylesheetContentsPtr { + fn hash<H: Hasher>(&self, state: &mut H) { + let contents: &StylesheetContents = &*self.0; + (contents as *const StylesheetContents).hash(state) + } +} + +type StyleSheetContentList = Vec<StylesheetContentsPtr>; + +/// A key in the cascade data cache. +#[derive(Debug, Hash, Default, PartialEq, Eq)] +struct CascadeDataCacheKey { + media_query_results: Vec<MediaListKey>, + contents: StyleSheetContentList, +} + +unsafe impl Send for CascadeDataCacheKey {} +unsafe impl Sync for CascadeDataCacheKey {} + +trait CascadeDataCacheEntry: Sized { + /// Returns a reference to the cascade data. + fn cascade_data(&self) -> &CascadeData; + /// Rebuilds the cascade data for the new stylesheet collection. The + /// collection is guaranteed to be dirty. + fn rebuild<S>( + device: &Device, + quirks_mode: QuirksMode, + collection: SheetCollectionFlusher<S>, + guard: &SharedRwLockReadGuard, + old_entry: &Self, + ) -> Result<Arc<Self>, AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static; + /// Measures heap memory usage. + #[cfg(feature = "gecko")] + fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes); +} + +struct CascadeDataCache<Entry> { + entries: FxHashMap<CascadeDataCacheKey, Arc<Entry>>, +} + +impl<Entry> CascadeDataCache<Entry> +where + Entry: CascadeDataCacheEntry, +{ + fn new() -> Self { + Self { + entries: Default::default(), + } + } + + fn len(&self) -> usize { + self.entries.len() + } + + // FIXME(emilio): This may need to be keyed on quirks-mode too, though for + // UA sheets there aren't class / id selectors on those sheets, usually, so + // it's probably ok... For the other cache the quirks mode shouldn't differ + // so also should be fine. + fn lookup<'a, S>( + &'a mut self, + device: &Device, + quirks_mode: QuirksMode, + collection: SheetCollectionFlusher<S>, + guard: &SharedRwLockReadGuard, + old_entry: &Entry, + ) -> Result<Option<Arc<Entry>>, AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static, + { + use std::collections::hash_map::Entry as HashMapEntry; + debug!("StyleSheetCache::lookup({})", self.len()); + + if !collection.dirty() { + return Ok(None); + } + + let mut key = CascadeDataCacheKey::default(); + for sheet in collection.sheets() { + CascadeData::collect_applicable_media_query_results_into( + device, + sheet, + guard, + &mut key.media_query_results, + &mut key.contents, + ) + } + + let new_entry; + match self.entries.entry(key) { + HashMapEntry::Vacant(e) => { + debug!("> Picking the slow path (not in the cache)"); + new_entry = Entry::rebuild(device, quirks_mode, collection, guard, old_entry)?; + e.insert(new_entry.clone()); + }, + HashMapEntry::Occupied(mut e) => { + // Avoid reusing our old entry (this can happen if we get + // invalidated due to CSSOM mutations and our old stylesheet + // contents were already unique, for example). + if !std::ptr::eq(&**e.get(), old_entry) { + if log_enabled!(log::Level::Debug) { + debug!("cache hit for:"); + for sheet in collection.sheets() { + debug!(" > {:?}", sheet); + } + } + // The line below ensures the "committed" bit is updated + // properly. + collection.each(|_, _| true); + return Ok(Some(e.get().clone())); + } + + debug!("> Picking the slow path due to same entry as old"); + new_entry = Entry::rebuild(device, quirks_mode, collection, guard, old_entry)?; + e.insert(new_entry.clone()); + }, + } + + Ok(Some(new_entry)) + } + + /// Returns all the cascade datas that are not being used (that is, that are + /// held alive just by this cache). + /// + /// We return them instead of dropping in place because some of them may + /// keep alive some other documents (like the SVG documents kept alive by + /// URL references), and thus we don't want to drop them while locking the + /// cache to not deadlock. + fn take_unused(&mut self) -> SmallVec<[Arc<Entry>; 3]> { + let mut unused = SmallVec::new(); + self.entries.retain(|_key, value| { + // is_unique() returns false for static references, but we never + // have static references to UserAgentCascadeDatas. If we did, it + // may not make sense to put them in the cache in the first place. + if !value.is_unique() { + return true; + } + unused.push(value.clone()); + false + }); + unused + } + + fn take_all(&mut self) -> FxHashMap<CascadeDataCacheKey, Arc<Entry>> { + mem::take(&mut self.entries) + } + + #[cfg(feature = "gecko")] + fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + sizes.mOther += self.entries.shallow_size_of(ops); + for (_key, arc) in self.entries.iter() { + // These are primary Arc references that can be measured + // unconditionally. + sizes.mOther += arc.unconditional_shallow_size_of(ops); + arc.add_size_of(ops, sizes); + } + } +} + +/// Measure heap usage of UA_CASCADE_DATA_CACHE. +#[cfg(feature = "gecko")] +pub fn add_size_of_ua_cache(ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + UA_CASCADE_DATA_CACHE + .lock() + .unwrap() + .add_size_of(ops, sizes); +} + +lazy_static! { + /// A cache of computed user-agent data, to be shared across documents. + static ref UA_CASCADE_DATA_CACHE: Mutex<UserAgentCascadeDataCache> = + Mutex::new(UserAgentCascadeDataCache::new()); +} + +impl CascadeDataCacheEntry for UserAgentCascadeData { + fn cascade_data(&self) -> &CascadeData { + &self.cascade_data + } + + fn rebuild<S>( + device: &Device, + quirks_mode: QuirksMode, + collection: SheetCollectionFlusher<S>, + guard: &SharedRwLockReadGuard, + _old: &Self, + ) -> Result<Arc<Self>, AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static, + { + // TODO: Maybe we should support incremental rebuilds, though they seem + // uncommon and rebuild() doesn't deal with + // precomputed_pseudo_element_decls for now so... + let mut new_data = Self { + cascade_data: CascadeData::new(), + precomputed_pseudo_element_decls: PrecomputedPseudoElementDeclarations::default(), + }; + + for sheet in collection.sheets() { + new_data.cascade_data.add_stylesheet( + device, + quirks_mode, + sheet, + guard, + SheetRebuildKind::Full, + Some(&mut new_data.precomputed_pseudo_element_decls), + )?; + } + + new_data.cascade_data.did_finish_rebuild(); + + Ok(Arc::new(new_data)) + } + + #[cfg(feature = "gecko")] + fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + self.cascade_data.add_size_of(ops, sizes); + sizes.mPrecomputedPseudos += self.precomputed_pseudo_element_decls.size_of(ops); + } +} + +type UserAgentCascadeDataCache = CascadeDataCache<UserAgentCascadeData>; + +type PrecomputedPseudoElementDeclarations = PerPseudoElementMap<Vec<ApplicableDeclarationBlock>>; + +#[derive(Default)] +struct UserAgentCascadeData { + cascade_data: CascadeData, + + /// Applicable declarations for a given non-eagerly cascaded pseudo-element. + /// + /// These are eagerly computed once, and then used to resolve the new + /// computed values on the fly on layout. + /// + /// These are only filled from UA stylesheets. + precomputed_pseudo_element_decls: PrecomputedPseudoElementDeclarations, +} + +/// All the computed information for all the stylesheets that apply to the +/// document. +#[derive(Default)] +#[cfg_attr(feature = "servo", derive(MallocSizeOf))] +pub struct DocumentCascadeData { + #[cfg_attr( + feature = "servo", + ignore_malloc_size_of = "Arc, owned by UserAgentCascadeDataCache" + )] + user_agent: Arc<UserAgentCascadeData>, + user: CascadeData, + author: CascadeData, + per_origin: PerOrigin<()>, +} + +/// An iterator over the cascade data of a given document. +pub struct DocumentCascadeDataIter<'a> { + iter: PerOriginIter<'a, ()>, + cascade_data: &'a DocumentCascadeData, +} + +impl<'a> Iterator for DocumentCascadeDataIter<'a> { + type Item = (&'a CascadeData, Origin); + + fn next(&mut self) -> Option<Self::Item> { + let (_, origin) = self.iter.next()?; + Some((self.cascade_data.borrow_for_origin(origin), origin)) + } +} + +impl DocumentCascadeData { + /// Borrows the cascade data for a given origin. + #[inline] + pub fn borrow_for_origin(&self, origin: Origin) -> &CascadeData { + match origin { + Origin::UserAgent => &self.user_agent.cascade_data, + Origin::Author => &self.author, + Origin::User => &self.user, + } + } + + fn iter_origins(&self) -> DocumentCascadeDataIter { + DocumentCascadeDataIter { + iter: self.per_origin.iter_origins(), + cascade_data: self, + } + } + + fn iter_origins_rev(&self) -> DocumentCascadeDataIter { + DocumentCascadeDataIter { + iter: self.per_origin.iter_origins_rev(), + cascade_data: self, + } + } + + /// Rebuild the cascade data for the given document stylesheets, and + /// optionally with a set of user agent stylesheets. Returns Err(..) + /// to signify OOM. + fn rebuild<'a, S>( + &mut self, + device: &Device, + quirks_mode: QuirksMode, + mut flusher: DocumentStylesheetFlusher<'a, S>, + guards: &StylesheetGuards, + ) -> Result<(), AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static, + { + // First do UA sheets. + { + let origin_flusher = flusher.flush_origin(Origin::UserAgent); + // Dirty check is just a minor optimization (no need to grab the + // lock if nothing has changed). + if origin_flusher.dirty() { + let mut ua_cache = UA_CASCADE_DATA_CACHE.lock().unwrap(); + let new_data = ua_cache.lookup( + device, + quirks_mode, + origin_flusher, + guards.ua_or_user, + &self.user_agent, + )?; + if let Some(new_data) = new_data { + self.user_agent = new_data; + } + let _unused_entries = ua_cache.take_unused(); + // See the comments in take_unused() as for why the following + // line. + std::mem::drop(ua_cache); + } + } + + // Now do the user sheets. + self.user.rebuild( + device, + quirks_mode, + flusher.flush_origin(Origin::User), + guards.ua_or_user, + )?; + + // And now the author sheets. + self.author.rebuild( + device, + quirks_mode, + flusher.flush_origin(Origin::Author), + guards.author, + )?; + + Ok(()) + } + + /// Measures heap usage. + #[cfg(feature = "gecko")] + pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + self.user.add_size_of(ops, sizes); + self.author.add_size_of(ops, sizes); + } +} + +/// Whether author styles are enabled. +/// +/// This is used to support Gecko. +#[allow(missing_docs)] +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq)] +pub enum AuthorStylesEnabled { + Yes, + No, +} + +/// A wrapper over a DocumentStylesheetSet that can be `Sync`, since it's only +/// used and exposed via mutable methods in the `Stylist`. +#[cfg_attr(feature = "servo", derive(MallocSizeOf))] +struct StylistStylesheetSet(DocumentStylesheetSet<StylistSheet>); +// Read above to see why this is fine. +unsafe impl Sync for StylistStylesheetSet {} + +impl StylistStylesheetSet { + fn new() -> Self { + StylistStylesheetSet(DocumentStylesheetSet::new()) + } +} + +impl ops::Deref for StylistStylesheetSet { + type Target = DocumentStylesheetSet<StylistSheet>; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl ops::DerefMut for StylistStylesheetSet { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +/// This structure holds all the selectors and device characteristics +/// for a given document. The selectors are converted into `Rule`s +/// and sorted into `SelectorMap`s keyed off stylesheet origin and +/// pseudo-element (see `CascadeData`). +/// +/// This structure is effectively created once per pipeline, in the +/// LayoutThread corresponding to that pipeline. +#[cfg_attr(feature = "servo", derive(MallocSizeOf))] +pub struct Stylist { + /// Device that the stylist is currently evaluating against. + /// + /// This field deserves a bigger comment due to the different use that Gecko + /// and Servo give to it (that we should eventually unify). + /// + /// With Gecko, the device is never changed. Gecko manually tracks whether + /// the device data should be reconstructed, and "resets" the state of the + /// device. + /// + /// On Servo, on the other hand, the device is a really cheap representation + /// that is recreated each time some constraint changes and calling + /// `set_device`. + device: Device, + + /// Viewport constraints based on the current device. + viewport_constraints: Option<ViewportConstraints>, + + /// The list of stylesheets. + stylesheets: StylistStylesheetSet, + + /// A cache of CascadeDatas for AuthorStylesheetSets (i.e., shadow DOM). + author_data_cache: CascadeDataCache<CascadeData>, + + /// If true, the quirks-mode stylesheet is applied. + #[cfg_attr(feature = "servo", ignore_malloc_size_of = "defined in selectors")] + quirks_mode: QuirksMode, + + /// Selector maps for all of the style sheets in the stylist, after + /// evalutaing media rules against the current device, split out per + /// cascade level. + cascade_data: DocumentCascadeData, + + /// Whether author styles are enabled. + author_styles_enabled: AuthorStylesEnabled, + + /// The rule tree, that stores the results of selector matching. + rule_tree: RuleTree, + + /// The total number of times the stylist has been rebuilt. + num_rebuilds: usize, +} + +/// What cascade levels to include when styling elements. +#[derive(Clone, Copy, PartialEq)] +pub enum RuleInclusion { + /// Include rules for style sheets at all cascade levels. This is the + /// normal rule inclusion mode. + All, + /// Only include rules from UA and user level sheets. Used to implement + /// `getDefaultComputedStyle`. + DefaultOnly, +} + +#[cfg(feature = "gecko")] +impl From<StyleRuleInclusion> for RuleInclusion { + fn from(value: StyleRuleInclusion) -> Self { + match value { + StyleRuleInclusion::All => RuleInclusion::All, + StyleRuleInclusion::DefaultOnly => RuleInclusion::DefaultOnly, + } + } +} + +type AncestorSelectorList<'a> = Cow<'a, SelectorList<SelectorImpl>>; + +/// A struct containing state from ancestor rules like @layer / @import / +/// @container / nesting. +struct ContainingRuleState<'a> { + layer_name: LayerName, + layer_id: LayerId, + container_condition_id: ContainerConditionId, + ancestor_selector_lists: SmallVec<[AncestorSelectorList<'a>; 2]>, +} + +impl<'a> Default for ContainingRuleState<'a> { + fn default() -> Self { + Self { + layer_name: LayerName::new_empty(), + layer_id: LayerId::root(), + container_condition_id: ContainerConditionId::none(), + ancestor_selector_lists: Default::default(), + } + } +} + +struct SavedContainingRuleState { + ancestor_selector_lists_len: usize, + layer_name_len: usize, + layer_id: LayerId, + container_condition_id: ContainerConditionId, +} + +impl<'a> ContainingRuleState<'a> { + fn save(&self) -> SavedContainingRuleState { + SavedContainingRuleState { + ancestor_selector_lists_len: self.ancestor_selector_lists.len(), + layer_name_len: self.layer_name.0.len(), + layer_id: self.layer_id, + container_condition_id: self.container_condition_id, + } + } + + fn restore(&mut self, saved: &SavedContainingRuleState) { + debug_assert!(self.layer_name.0.len() >= saved.layer_name_len); + debug_assert!(self.ancestor_selector_lists.len() >= saved.ancestor_selector_lists_len); + self.ancestor_selector_lists + .truncate(saved.ancestor_selector_lists_len); + self.layer_name.0.truncate(saved.layer_name_len); + self.layer_id = saved.layer_id; + self.container_condition_id = saved.container_condition_id; + } +} + +impl Stylist { + /// Construct a new `Stylist`, using given `Device` and `QuirksMode`. + /// If more members are added here, think about whether they should + /// be reset in clear(). + #[inline] + pub fn new(device: Device, quirks_mode: QuirksMode) -> Self { + Self { + viewport_constraints: None, + device, + quirks_mode, + stylesheets: StylistStylesheetSet::new(), + author_data_cache: CascadeDataCache::new(), + cascade_data: Default::default(), + author_styles_enabled: AuthorStylesEnabled::Yes, + rule_tree: RuleTree::new(), + num_rebuilds: 0, + } + } + + /// Returns the document cascade data. + #[inline] + pub fn cascade_data(&self) -> &DocumentCascadeData { + &self.cascade_data + } + + /// Returns whether author styles are enabled or not. + #[inline] + pub fn author_styles_enabled(&self) -> AuthorStylesEnabled { + self.author_styles_enabled + } + + /// Iterate through all the cascade datas from the document. + #[inline] + pub fn iter_origins(&self) -> DocumentCascadeDataIter { + self.cascade_data.iter_origins() + } + + /// Does what the name says, to prevent author_data_cache to grow without + /// bound. + pub fn remove_unique_author_data_cache_entries(&mut self) { + self.author_data_cache.take_unused(); + } + + /// Rebuilds (if needed) the CascadeData given a sheet collection. + pub fn rebuild_author_data<S>( + &mut self, + old_data: &CascadeData, + collection: SheetCollectionFlusher<S>, + guard: &SharedRwLockReadGuard, + ) -> Result<Option<Arc<CascadeData>>, AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static, + { + self.author_data_cache + .lookup(&self.device, self.quirks_mode, collection, guard, old_data) + } + + /// Iterate over the extra data in origin order. + #[inline] + pub fn iter_extra_data_origins(&self) -> ExtraStyleDataIterator { + ExtraStyleDataIterator(self.cascade_data.iter_origins()) + } + + /// Iterate over the extra data in reverse origin order. + #[inline] + pub fn iter_extra_data_origins_rev(&self) -> ExtraStyleDataIterator { + ExtraStyleDataIterator(self.cascade_data.iter_origins_rev()) + } + + /// Returns the number of selectors. + pub fn num_selectors(&self) -> usize { + self.cascade_data + .iter_origins() + .map(|(d, _)| d.num_selectors) + .sum() + } + + /// Returns the number of declarations. + pub fn num_declarations(&self) -> usize { + self.cascade_data + .iter_origins() + .map(|(d, _)| d.num_declarations) + .sum() + } + + /// Returns the number of times the stylist has been rebuilt. + pub fn num_rebuilds(&self) -> usize { + self.num_rebuilds + } + + /// Returns the number of revalidation_selectors. + pub fn num_revalidation_selectors(&self) -> usize { + self.cascade_data + .iter_origins() + .map(|(data, _)| data.selectors_for_cache_revalidation.len()) + .sum() + } + + /// Returns the number of entries in invalidation maps. + pub fn num_invalidations(&self) -> usize { + self.cascade_data + .iter_origins() + .map(|(data, _)| data.invalidation_map.len()) + .sum() + } + + /// Returns whether the given DocumentState bit is relied upon by a selector + /// of some rule. + pub fn has_document_state_dependency(&self, state: DocumentState) -> bool { + self.cascade_data + .iter_origins() + .any(|(d, _)| d.document_state_dependencies.intersects(state)) + } + + /// Flush the list of stylesheets if they changed, ensuring the stylist is + /// up-to-date. + pub fn flush<E>( + &mut self, + guards: &StylesheetGuards, + document_element: Option<E>, + snapshots: Option<&SnapshotMap>, + ) -> bool + where + E: TElement, + { + if !self.stylesheets.has_changed() { + return false; + } + + self.num_rebuilds += 1; + + // Update viewport_constraints regardless of which origins' + // `CascadeData` we're updating. + self.viewport_constraints = None; + if viewport_rule::enabled() { + // TODO(emilio): This doesn't look so efficient. + // + // Presumably when we properly implement this we can at least have a + // bit on the stylesheet that says whether it contains viewport + // rules to skip it entirely? + // + // Processing it with the rest of rules seems tricky since it + // overrides the viewport size which may change the evaluation of + // media queries (or may not? how are viewport units in media + // queries defined?) + let cascaded_rule = ViewportRule { + declarations: viewport_rule::Cascade::from_stylesheets( + self.stylesheets.iter(), + guards, + &self.device, + ) + .finish(), + }; + + self.viewport_constraints = + ViewportConstraints::maybe_new(&self.device, &cascaded_rule, self.quirks_mode); + + if let Some(ref constraints) = self.viewport_constraints { + self.device.account_for_viewport_rule(constraints); + } + } + + let flusher = self.stylesheets.flush(document_element, snapshots); + + let had_invalidations = flusher.had_invalidations(); + + self.cascade_data + .rebuild(&self.device, self.quirks_mode, flusher, guards) + .unwrap_or_else(|_| warn!("OOM in Stylist::flush")); + + had_invalidations + } + + /// Insert a given stylesheet before another stylesheet in the document. + pub fn insert_stylesheet_before( + &mut self, + sheet: StylistSheet, + before_sheet: StylistSheet, + guard: &SharedRwLockReadGuard, + ) { + self.stylesheets + .insert_stylesheet_before(Some(&self.device), sheet, before_sheet, guard) + } + + /// Marks a given stylesheet origin as dirty, due to, for example, changes + /// in the declarations that affect a given rule. + /// + /// FIXME(emilio): Eventually it'd be nice for this to become more + /// fine-grained. + pub fn force_stylesheet_origins_dirty(&mut self, origins: OriginSet) { + self.stylesheets.force_dirty(origins) + } + + /// Sets whether author style is enabled or not. + pub fn set_author_styles_enabled(&mut self, enabled: AuthorStylesEnabled) { + self.author_styles_enabled = enabled; + } + + /// Returns whether we've recorded any stylesheet change so far. + pub fn stylesheets_have_changed(&self) -> bool { + self.stylesheets.has_changed() + } + + /// Appends a new stylesheet to the current set. + pub fn append_stylesheet(&mut self, sheet: StylistSheet, guard: &SharedRwLockReadGuard) { + self.stylesheets + .append_stylesheet(Some(&self.device), sheet, guard) + } + + /// Remove a given stylesheet to the current set. + pub fn remove_stylesheet(&mut self, sheet: StylistSheet, guard: &SharedRwLockReadGuard) { + self.stylesheets + .remove_stylesheet(Some(&self.device), sheet, guard) + } + + /// Notify of a change of a given rule. + pub fn rule_changed( + &mut self, + sheet: &StylistSheet, + rule: &CssRule, + guard: &SharedRwLockReadGuard, + change_kind: RuleChangeKind, + ) { + self.stylesheets + .rule_changed(Some(&self.device), sheet, rule, guard, change_kind) + } + + /// Appends a new stylesheet to the current set. + #[inline] + pub fn sheet_count(&self, origin: Origin) -> usize { + self.stylesheets.sheet_count(origin) + } + + /// Appends a new stylesheet to the current set. + #[inline] + pub fn sheet_at(&self, origin: Origin, index: usize) -> Option<&StylistSheet> { + self.stylesheets.get(origin, index) + } + + /// Returns whether for any of the applicable style rule data a given + /// condition is true. + pub fn any_applicable_rule_data<E, F>(&self, element: E, mut f: F) -> bool + where + E: TElement, + F: FnMut(&CascadeData) -> bool, + { + if f(&self.cascade_data.user_agent.cascade_data) { + return true; + } + + let mut maybe = false; + + let doc_author_rules_apply = + element.each_applicable_non_document_style_rule_data(|data, _| { + maybe = maybe || f(&*data); + }); + + if maybe || f(&self.cascade_data.user) { + return true; + } + + doc_author_rules_apply && f(&self.cascade_data.author) + } + + /// Computes the style for a given "precomputed" pseudo-element, taking the + /// universal rules and applying them. + pub fn precomputed_values_for_pseudo<E>( + &self, + guards: &StylesheetGuards, + pseudo: &PseudoElement, + parent: Option<&ComputedValues>, + ) -> Arc<ComputedValues> + where + E: TElement, + { + debug_assert!(pseudo.is_precomputed()); + + let rule_node = self.rule_node_for_precomputed_pseudo(guards, pseudo, vec![]); + + self.precomputed_values_for_pseudo_with_rule_node::<E>(guards, pseudo, parent, rule_node) + } + + /// Computes the style for a given "precomputed" pseudo-element with + /// given rule node. + /// + /// TODO(emilio): The type parameter could go away with a void type + /// implementing TElement. + pub fn precomputed_values_for_pseudo_with_rule_node<E>( + &self, + guards: &StylesheetGuards, + pseudo: &PseudoElement, + parent: Option<&ComputedValues>, + rules: StrongRuleNode, + ) -> Arc<ComputedValues> + where + E: TElement, + { + self.compute_pseudo_element_style_with_inputs::<E>( + CascadeInputs { + rules: Some(rules), + visited_rules: None, + flags: Default::default(), + }, + pseudo, + guards, + /* originating_element_style */ None, + parent, + /* element */ None, + ) + } + + /// Returns the rule node for a given precomputed pseudo-element. + /// + /// If we want to include extra declarations to this precomputed + /// pseudo-element, we can provide a vector of ApplicableDeclarationBlocks + /// to extra_declarations. This is useful for @page rules. + pub fn rule_node_for_precomputed_pseudo( + &self, + guards: &StylesheetGuards, + pseudo: &PseudoElement, + mut extra_declarations: Vec<ApplicableDeclarationBlock>, + ) -> StrongRuleNode { + let mut declarations_with_extra; + let declarations = match self + .cascade_data + .user_agent + .precomputed_pseudo_element_decls + .get(pseudo) + { + Some(declarations) => { + if !extra_declarations.is_empty() { + declarations_with_extra = declarations.clone(); + declarations_with_extra.append(&mut extra_declarations); + &*declarations_with_extra + } else { + &**declarations + } + }, + None => &[], + }; + + self.rule_tree.insert_ordered_rules_with_important( + declarations.into_iter().map(|a| a.clone().for_rule_tree()), + guards, + ) + } + + /// Returns the style for an anonymous box of the given type. + /// + /// TODO(emilio): The type parameter could go away with a void type + /// implementing TElement. + #[cfg(feature = "servo")] + pub fn style_for_anonymous<E>( + &self, + guards: &StylesheetGuards, + pseudo: &PseudoElement, + parent_style: &ComputedValues, + ) -> Arc<ComputedValues> + where + E: TElement, + { + self.precomputed_values_for_pseudo::<E>(guards, &pseudo, Some(parent_style)) + } + + /// Computes a pseudo-element style lazily during layout. + /// + /// This can only be done for a certain set of pseudo-elements, like + /// :selection. + /// + /// Check the documentation on lazy pseudo-elements in + /// docs/components/style.md + pub fn lazily_compute_pseudo_element_style<E>( + &self, + guards: &StylesheetGuards, + element: E, + pseudo: &PseudoElement, + rule_inclusion: RuleInclusion, + originating_element_style: &ComputedValues, + parent_style: &Arc<ComputedValues>, + is_probe: bool, + matching_fn: Option<&dyn Fn(&PseudoElement) -> bool>, + ) -> Option<Arc<ComputedValues>> + where + E: TElement, + { + let cascade_inputs = self.lazy_pseudo_rules( + guards, + element, + originating_element_style, + parent_style, + pseudo, + is_probe, + rule_inclusion, + matching_fn, + )?; + + Some(self.compute_pseudo_element_style_with_inputs( + cascade_inputs, + pseudo, + guards, + Some(originating_element_style), + Some(parent_style), + Some(element), + )) + } + + /// Computes a pseudo-element style lazily using the given CascadeInputs. + /// This can be used for truly lazy pseudo-elements or to avoid redoing + /// selector matching for eager pseudo-elements when we need to recompute + /// their style with a new parent style. + pub fn compute_pseudo_element_style_with_inputs<E>( + &self, + inputs: CascadeInputs, + pseudo: &PseudoElement, + guards: &StylesheetGuards, + originating_element_style: Option<&ComputedValues>, + parent_style: Option<&ComputedValues>, + element: Option<E>, + ) -> Arc<ComputedValues> + where + E: TElement, + { + // FIXME(emilio): The lack of layout_parent_style here could be + // worrying, but we're probably dropping the display fixup for + // pseudos other than before and after, so it's probably ok. + // + // (Though the flags don't indicate so!) + // + // It'd be fine to assert that this isn't called with a parent style + // where display contents is in effect, but in practice this is hard to + // do for stuff like :-moz-fieldset-content with a + // <fieldset style="display: contents">. That is, the computed value of + // display for the fieldset is "contents", even though it's not the used + // value, so we don't need to adjust in a different way anyway. + self.cascade_style_and_visited( + element, + Some(pseudo), + inputs, + guards, + originating_element_style, + parent_style, + parent_style, + parent_style, + /* rule_cache = */ None, + &mut RuleCacheConditions::default(), + ) + } + + /// Computes a style using the given CascadeInputs. This can be used to + /// compute a style any time we know what rules apply and just need to use + /// the given parent styles. + /// + /// parent_style is the style to inherit from for properties affected by + /// first-line ancestors. + /// + /// parent_style_ignoring_first_line is the style to inherit from for + /// properties not affected by first-line ancestors. + /// + /// layout_parent_style is the style used for some property fixups. It's + /// the style of the nearest ancestor with a layout box. + pub fn cascade_style_and_visited<E>( + &self, + element: Option<E>, + pseudo: Option<&PseudoElement>, + inputs: CascadeInputs, + guards: &StylesheetGuards, + originating_element_style: Option<&ComputedValues>, + parent_style: Option<&ComputedValues>, + parent_style_ignoring_first_line: Option<&ComputedValues>, + layout_parent_style: Option<&ComputedValues>, + rule_cache: Option<&RuleCache>, + rule_cache_conditions: &mut RuleCacheConditions, + ) -> Arc<ComputedValues> + where + E: TElement, + { + debug_assert!(pseudo.is_some() || element.is_some(), "Huh?"); + + // We need to compute visited values if we have visited rules or if our + // parent has visited values. + let visited_rules = match inputs.visited_rules.as_ref() { + Some(rules) => Some(rules), + None => { + if parent_style.and_then(|s| s.visited_style()).is_some() { + Some(inputs.rules.as_ref().unwrap_or(self.rule_tree.root())) + } else { + None + } + }, + }; + + // Read the comment on `precomputed_values_for_pseudo` to see why it's + // difficult to assert that display: contents nodes never arrive here + // (tl;dr: It doesn't apply for replaced elements and such, but the + // computed value is still "contents"). + // + // FIXME(emilio): We should assert that it holds if pseudo.is_none()! + properties::cascade::<E>( + &self.device, + pseudo, + inputs.rules.as_ref().unwrap_or(self.rule_tree.root()), + guards, + originating_element_style, + parent_style, + parent_style_ignoring_first_line, + layout_parent_style, + visited_rules, + inputs.flags, + self.quirks_mode, + rule_cache, + rule_cache_conditions, + element, + ) + } + + /// Computes the cascade inputs for a lazily-cascaded pseudo-element. + /// + /// See the documentation on lazy pseudo-elements in + /// docs/components/style.md + fn lazy_pseudo_rules<E>( + &self, + guards: &StylesheetGuards, + element: E, + originating_element_style: &ComputedValues, + parent_style: &Arc<ComputedValues>, + pseudo: &PseudoElement, + is_probe: bool, + rule_inclusion: RuleInclusion, + matching_fn: Option<&dyn Fn(&PseudoElement) -> bool>, + ) -> Option<CascadeInputs> + where + E: TElement, + { + debug_assert!(pseudo.is_lazy()); + + let mut nth_index_cache = Default::default(); + // No need to bother setting the selector flags when we're computing + // default styles. + let needs_selector_flags = if rule_inclusion == RuleInclusion::DefaultOnly { + NeedsSelectorFlags::No + } else { + NeedsSelectorFlags::Yes + }; + + let mut declarations = ApplicableDeclarationList::new(); + let mut matching_context = MatchingContext::<'_, E::Impl>::new( + MatchingMode::ForStatelessPseudoElement, + None, + &mut nth_index_cache, + self.quirks_mode, + needs_selector_flags, + ); + + matching_context.pseudo_element_matching_fn = matching_fn; + matching_context.extra_data.originating_element_style = Some(originating_element_style); + + self.push_applicable_declarations( + element, + Some(&pseudo), + None, + None, + /* animation_declarations = */ Default::default(), + rule_inclusion, + &mut declarations, + &mut matching_context, + ); + + if declarations.is_empty() && is_probe { + return None; + } + + let rules = self.rule_tree.compute_rule_node(&mut declarations, guards); + + let mut visited_rules = None; + if parent_style.visited_style().is_some() { + let mut declarations = ApplicableDeclarationList::new(); + let mut nth_index_cache = Default::default(); + + let mut matching_context = MatchingContext::<'_, E::Impl>::new_for_visited( + MatchingMode::ForStatelessPseudoElement, + None, + &mut nth_index_cache, + VisitedHandlingMode::RelevantLinkVisited, + self.quirks_mode, + needs_selector_flags, + ); + matching_context.pseudo_element_matching_fn = matching_fn; + matching_context.extra_data.originating_element_style = Some(originating_element_style); + + self.push_applicable_declarations( + element, + Some(&pseudo), + None, + None, + /* animation_declarations = */ Default::default(), + rule_inclusion, + &mut declarations, + &mut matching_context, + ); + if !declarations.is_empty() { + let rule_node = self.rule_tree.insert_ordered_rules_with_important( + declarations.drain(..).map(|a| a.for_rule_tree()), + guards, + ); + if rule_node != *self.rule_tree.root() { + visited_rules = Some(rule_node); + } + } + } + + Some(CascadeInputs { + rules: Some(rules), + visited_rules, + flags: matching_context.extra_data.cascade_input_flags, + }) + } + + /// Set a given device, which may change the styles that apply to the + /// document. + /// + /// Returns the sheet origins that were actually affected. + /// + /// This means that we may need to rebuild style data even if the + /// stylesheets haven't changed. + /// + /// Also, the device that arrives here may need to take the viewport rules + /// into account. + pub fn set_device(&mut self, mut device: Device, guards: &StylesheetGuards) -> OriginSet { + if viewport_rule::enabled() { + let cascaded_rule = { + let stylesheets = self.stylesheets.iter(); + + ViewportRule { + declarations: viewport_rule::Cascade::from_stylesheets( + stylesheets, + guards, + &device, + ) + .finish(), + } + }; + + self.viewport_constraints = + ViewportConstraints::maybe_new(&device, &cascaded_rule, self.quirks_mode); + + if let Some(ref constraints) = self.viewport_constraints { + device.account_for_viewport_rule(constraints); + } + } + + self.device = device; + self.media_features_change_changed_style(guards, &self.device) + } + + /// Returns whether, given a media feature change, any previously-applicable + /// style has become non-applicable, or vice-versa for each origin, using + /// `device`. + pub fn media_features_change_changed_style( + &self, + guards: &StylesheetGuards, + device: &Device, + ) -> OriginSet { + debug!("Stylist::media_features_change_changed_style {:?}", device); + + let mut origins = OriginSet::empty(); + let stylesheets = self.stylesheets.iter(); + + for (stylesheet, origin) in stylesheets { + if origins.contains(origin.into()) { + continue; + } + + let guard = guards.for_origin(origin); + let origin_cascade_data = self.cascade_data.borrow_for_origin(origin); + + let affected_changed = !origin_cascade_data.media_feature_affected_matches( + stylesheet, + guard, + device, + self.quirks_mode, + ); + + if affected_changed { + origins |= origin; + } + } + + origins + } + + /// Returns the viewport constraints that apply to this document because of + /// a @viewport rule. + pub fn viewport_constraints(&self) -> Option<&ViewportConstraints> { + self.viewport_constraints.as_ref() + } + + /// Returns the Quirks Mode of the document. + pub fn quirks_mode(&self) -> QuirksMode { + self.quirks_mode + } + + /// Sets the quirks mode of the document. + pub fn set_quirks_mode(&mut self, quirks_mode: QuirksMode) { + if self.quirks_mode == quirks_mode { + return; + } + self.quirks_mode = quirks_mode; + self.force_stylesheet_origins_dirty(OriginSet::all()); + } + + /// Returns the applicable CSS declarations for the given element. + pub fn push_applicable_declarations<E>( + &self, + element: E, + pseudo_element: Option<&PseudoElement>, + style_attribute: Option<ArcBorrow<Locked<PropertyDeclarationBlock>>>, + smil_override: Option<ArcBorrow<Locked<PropertyDeclarationBlock>>>, + animation_declarations: AnimationDeclarations, + rule_inclusion: RuleInclusion, + applicable_declarations: &mut ApplicableDeclarationList, + context: &mut MatchingContext<E::Impl>, + ) where + E: TElement, + { + RuleCollector::new( + self, + element, + pseudo_element, + style_attribute, + smil_override, + animation_declarations, + rule_inclusion, + applicable_declarations, + context, + ) + .collect_all(); + } + + /// Given an id, returns whether there might be any rules for that id in any + /// of our rule maps. + #[inline] + pub fn may_have_rules_for_id<E>(&self, id: &WeakAtom, element: E) -> bool + where + E: TElement, + { + // If id needs to be compared case-insensitively, the logic below + // wouldn't work. Just conservatively assume it may have such rules. + match self.quirks_mode().classes_and_ids_case_sensitivity() { + CaseSensitivity::AsciiCaseInsensitive => return true, + CaseSensitivity::CaseSensitive => {}, + } + + self.any_applicable_rule_data(element, |data| data.mapped_ids.contains(id)) + } + + /// Returns the registered `@keyframes` animation for the specified name. + #[inline] + pub fn get_animation<'a, E>(&'a self, name: &Atom, element: E) -> Option<&'a KeyframesAnimation> + where + E: TElement + 'a, + { + macro_rules! try_find_in { + ($data:expr) => { + if let Some(animation) = $data.animations.get(name) { + return Some(animation); + } + }; + } + + // NOTE(emilio): We implement basically what Blink does for this case, + // which is [1] as of this writing. + // + // See [2] for the spec discussion about what to do about this. WebKit's + // behavior makes a bit more sense off-hand, but it's way more complex + // to implement, and it makes value computation having to thread around + // the cascade level, which is not great. Also, it breaks if you inherit + // animation-name from an element in a different tree. + // + // See [3] for the bug to implement whatever gets resolved, and related + // bugs for a bit more context. + // + // FIXME(emilio): This should probably work for pseudo-elements (i.e., + // use rule_hash_target().shadow_root() instead of + // element.shadow_root()). + // + // [1]: https://cs.chromium.org/chromium/src/third_party/blink/renderer/ + // core/css/resolver/style_resolver.cc?l=1267&rcl=90f9f8680ebb4a87d177f3b0833372ae4e0c88d8 + // [2]: https://github.com/w3c/csswg-drafts/issues/1995 + // [3]: https://bugzil.la/1458189 + if let Some(shadow) = element.shadow_root() { + if let Some(data) = shadow.style_data() { + try_find_in!(data); + } + } + + // Use the same rules to look for the containing host as we do for rule + // collection. + if let Some(shadow) = containing_shadow_ignoring_svg_use(element) { + if let Some(data) = shadow.style_data() { + try_find_in!(data); + } + } else { + try_find_in!(self.cascade_data.author); + } + + try_find_in!(self.cascade_data.user); + try_find_in!(self.cascade_data.user_agent.cascade_data); + + None + } + + /// Computes the match results of a given element against the set of + /// revalidation selectors. + pub fn match_revalidation_selectors<E>( + &self, + element: E, + bloom: Option<&BloomFilter>, + nth_index_cache: &mut NthIndexCache, + needs_selector_flags: NeedsSelectorFlags, + ) -> SmallBitVec + where + E: TElement, + { + // NB: `MatchingMode` doesn't really matter, given we don't share style + // between pseudos. + let mut matching_context = MatchingContext::new( + MatchingMode::Normal, + bloom, + nth_index_cache, + self.quirks_mode, + needs_selector_flags, + ); + + // Note that, by the time we're revalidating, we're guaranteed that the + // candidate and the entry have the same id, classes, and local name. + // This means we're guaranteed to get the same rulehash buckets for all + // the lookups, which means that the bitvecs are comparable. We verify + // this in the caller by asserting that the bitvecs are same-length. + let mut results = SmallBitVec::new(); + + let matches_document_rules = + element.each_applicable_non_document_style_rule_data(|data, host| { + matching_context.with_shadow_host(Some(host), |matching_context| { + data.selectors_for_cache_revalidation.lookup( + element, + self.quirks_mode, + |selector_and_hashes| { + results.push(matches_selector( + &selector_and_hashes.selector, + selector_and_hashes.selector_offset, + Some(&selector_and_hashes.hashes), + &element, + matching_context, + )); + true + }, + ); + }) + }); + + for (data, origin) in self.cascade_data.iter_origins() { + if origin == Origin::Author && !matches_document_rules { + continue; + } + + data.selectors_for_cache_revalidation.lookup( + element, + self.quirks_mode, + |selector_and_hashes| { + results.push(matches_selector( + &selector_and_hashes.selector, + selector_and_hashes.selector_offset, + Some(&selector_and_hashes.hashes), + &element, + &mut matching_context, + )); + true + }, + ); + } + + results + } + + /// Computes styles for a given declaration with parent_style. + /// + /// FIXME(emilio): the lack of pseudo / cascade flags look quite dubious, + /// hopefully this is only used for some canvas font stuff. + /// + /// TODO(emilio): The type parameter can go away when + /// https://github.com/rust-lang/rust/issues/35121 is fixed. + pub fn compute_for_declarations<E>( + &self, + guards: &StylesheetGuards, + parent_style: &ComputedValues, + declarations: Arc<Locked<PropertyDeclarationBlock>>, + ) -> Arc<ComputedValues> + where + E: TElement, + { + let block = declarations.read_with(guards.author); + + // We don't bother inserting these declarations in the rule tree, since + // it'd be quite useless and slow. + // + // TODO(emilio): Now that we fixed bug 1493420, we should consider + // reversing this as it shouldn't be slow anymore, and should avoid + // generating two instantiations of apply_declarations. + properties::apply_declarations::<E, _>( + &self.device, + /* pseudo = */ None, + self.rule_tree.root(), + guards, + block.declaration_importance_iter().map(|(declaration, _)| { + ( + declaration, + CascadePriority::new( + CascadeLevel::same_tree_author_normal(), + LayerOrder::root(), + ), + ) + }), + /* originating_element_style */ None, + Some(parent_style), + Some(parent_style), + Some(parent_style), + CascadeMode::Unvisited { + visited_rules: None, + }, + Default::default(), + self.quirks_mode, + /* rule_cache = */ None, + &mut Default::default(), + /* element = */ None, + ) + } + + /// Accessor for a shared reference to the device. + #[inline] + pub fn device(&self) -> &Device { + &self.device + } + + /// Accessor for a mutable reference to the device. + #[inline] + pub fn device_mut(&mut self) -> &mut Device { + &mut self.device + } + + /// Accessor for a shared reference to the rule tree. + #[inline] + pub fn rule_tree(&self) -> &RuleTree { + &self.rule_tree + } + + /// Measures heap usage. + #[cfg(feature = "gecko")] + pub fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + self.cascade_data.add_size_of(ops, sizes); + self.author_data_cache.add_size_of(ops, sizes); + sizes.mRuleTree += self.rule_tree.size_of(ops); + + // We may measure other fields in the future if DMD says it's worth it. + } + + /// Shutdown the static data that this module stores. + pub fn shutdown() { + let _entries = UA_CASCADE_DATA_CACHE.lock().unwrap().take_all(); + } +} + +/// A vector that is sorted in layer order. +#[derive(Clone, Debug, Deref, MallocSizeOf)] +pub struct LayerOrderedVec<T>(Vec<(T, LayerId)>); +impl<T> Default for LayerOrderedVec<T> { + fn default() -> Self { + Self(Default::default()) + } +} + +/// A map that is sorted in layer order. +#[derive(Clone, Debug, Deref, MallocSizeOf)] +pub struct LayerOrderedMap<T>(PrecomputedHashMap<Atom, SmallVec<[(T, LayerId); 1]>>); +impl<T> Default for LayerOrderedMap<T> { + fn default() -> Self { + Self(Default::default()) + } +} + +impl<T: 'static> LayerOrderedVec<T> { + fn clear(&mut self) { + self.0.clear(); + } + fn push(&mut self, v: T, id: LayerId) { + self.0.push((v, id)); + } + fn sort(&mut self, layers: &[CascadeLayer]) { + self.0 + .sort_by_key(|&(_, ref id)| layers[id.0 as usize].order) + } +} + +impl<T: 'static> LayerOrderedMap<T> { + fn clear(&mut self) { + self.0.clear(); + } + fn try_insert(&mut self, name: Atom, v: T, id: LayerId) -> Result<(), AllocErr> { + self.try_insert_with(name, v, id, |_, _| Ordering::Equal) + } + fn try_insert_with( + &mut self, + name: Atom, + v: T, + id: LayerId, + cmp: impl Fn(&T, &T) -> Ordering, + ) -> Result<(), AllocErr> { + self.0.try_reserve(1)?; + let vec = self.0.entry(name).or_default(); + if let Some(&mut (ref mut val, ref last_id)) = vec.last_mut() { + if *last_id == id { + if cmp(&val, &v) != Ordering::Greater { + *val = v; + } + return Ok(()); + } + } + vec.push((v, id)); + Ok(()) + } + fn sort(&mut self, layers: &[CascadeLayer]) { + self.sort_with(layers, |_, _| Ordering::Equal) + } + fn sort_with(&mut self, layers: &[CascadeLayer], cmp: impl Fn(&T, &T) -> Ordering) { + for (_, v) in self.0.iter_mut() { + v.sort_by(|&(ref v1, ref id1), &(ref v2, ref id2)| { + let order1 = layers[id1.0 as usize].order; + let order2 = layers[id2.0 as usize].order; + order1.cmp(&order2).then_with(|| cmp(v1, v2)) + }) + } + } + /// Get an entry on the LayerOrderedMap by name. + pub fn get(&self, name: &Atom) -> Option<&T> { + let vec = self.0.get(name)?; + Some(&vec.last()?.0) + } +} + +/// Wrapper to allow better tracking of memory usage by page rule lists. +/// +/// This includes the layer ID for use with the named page table. +#[derive(Clone, Debug, MallocSizeOf)] +pub struct PageRuleData { + /// Layer ID for sorting page rules after matching. + pub layer: LayerId, + /// Page rule + #[ignore_malloc_size_of = "Arc, stylesheet measures as primary ref"] + pub rule: Arc<Locked<PageRule>>, +} + +/// Wrapper to allow better tracking of memory usage by page rule lists. +/// +/// This is meant to be used by the global page rule list which are already +/// sorted by layer ID, since all global page rules are less specific than all +/// named page rules that match a certain page. +#[derive(Clone, Debug, Deref, MallocSizeOf)] +pub struct PageRuleDataNoLayer( + #[ignore_malloc_size_of = "Arc, stylesheet measures as primary ref"] pub Arc<Locked<PageRule>>, +); + +/// Stores page rules indexed by page names. +#[derive(Clone, Debug, Default, MallocSizeOf)] +pub struct PageRuleMap { + /// Global, unnamed page rules. + pub global: LayerOrderedVec<PageRuleDataNoLayer>, + /// Named page rules + pub named: PrecomputedHashMap<Atom, SmallVec<[PageRuleData; 1]>>, +} + +impl PageRuleMap { + #[inline] + fn clear(&mut self) { + self.global.clear(); + self.named.clear(); + } +} + +impl MallocShallowSizeOf for PageRuleMap { + fn shallow_size_of(&self, ops: &mut MallocSizeOfOps) -> usize { + self.global.size_of(ops) + self.named.shallow_size_of(ops) + } +} + +/// This struct holds data which users of Stylist may want to extract +/// from stylesheets which can be done at the same time as updating. +#[derive(Clone, Debug, Default)] +#[cfg_attr(feature = "servo", derive(MallocSizeOf))] +pub struct ExtraStyleData { + /// A list of effective font-face rules and their origin. + #[cfg(feature = "gecko")] + pub font_faces: LayerOrderedVec<Arc<Locked<FontFaceRule>>>, + + /// A list of effective font-feature-values rules. + #[cfg(feature = "gecko")] + pub font_feature_values: LayerOrderedVec<Arc<FontFeatureValuesRule>>, + + /// A list of effective font-palette-values rules. + #[cfg(feature = "gecko")] + pub font_palette_values: LayerOrderedVec<Arc<FontPaletteValuesRule>>, + + /// A map of effective counter-style rules. + #[cfg(feature = "gecko")] + pub counter_styles: LayerOrderedMap<Arc<Locked<CounterStyleRule>>>, + + /// A map of effective page rules. + #[cfg(feature = "gecko")] + pub pages: PageRuleMap, +} + +#[cfg(feature = "gecko")] +impl ExtraStyleData { + /// Add the given @font-face rule. + fn add_font_face(&mut self, rule: &Arc<Locked<FontFaceRule>>, layer: LayerId) { + self.font_faces.push(rule.clone(), layer); + } + + /// Add the given @font-feature-values rule. + fn add_font_feature_values(&mut self, rule: &Arc<FontFeatureValuesRule>, layer: LayerId) { + self.font_feature_values.push(rule.clone(), layer); + } + + /// Add the given @font-palette-values rule. + fn add_font_palette_values(&mut self, rule: &Arc<FontPaletteValuesRule>, layer: LayerId) { + self.font_palette_values.push(rule.clone(), layer); + } + + /// Add the given @counter-style rule. + fn add_counter_style( + &mut self, + guard: &SharedRwLockReadGuard, + rule: &Arc<Locked<CounterStyleRule>>, + layer: LayerId, + ) -> Result<(), AllocErr> { + let name = rule.read_with(guard).name().0.clone(); + self.counter_styles.try_insert(name, rule.clone(), layer) + } + + /// Add the given @page rule. + fn add_page( + &mut self, + guard: &SharedRwLockReadGuard, + rule: &Arc<Locked<PageRule>>, + layer: LayerId, + ) -> Result<(), AllocErr> { + let page_rule = rule.read_with(guard); + if page_rule.selectors.0.is_empty() { + self.pages + .global + .push(PageRuleDataNoLayer(rule.clone()), layer); + } else { + // TODO: Handle pseudo-classes + self.pages.named.try_reserve(page_rule.selectors.0.len())?; + for name in page_rule.selectors.as_slice() { + let vec = self.pages.named.entry(name.0 .0.clone()).or_default(); + vec.try_reserve(1)?; + vec.push(PageRuleData { + layer, + rule: rule.clone(), + }); + } + } + Ok(()) + } + + fn sort_by_layer(&mut self, layers: &[CascadeLayer]) { + self.font_faces.sort(layers); + self.font_feature_values.sort(layers); + self.font_palette_values.sort(layers); + self.counter_styles.sort(layers); + self.pages.global.sort(layers); + } + + fn clear(&mut self) { + #[cfg(feature = "gecko")] + { + self.font_faces.clear(); + self.font_feature_values.clear(); + self.font_palette_values.clear(); + self.counter_styles.clear(); + self.pages.clear(); + } + } +} + +// Don't let a prefixed keyframes animation override +// a non-prefixed one. +fn compare_keyframes_in_same_layer(v1: &KeyframesAnimation, v2: &KeyframesAnimation) -> Ordering { + if v1.vendor_prefix.is_some() == v2.vendor_prefix.is_some() { + Ordering::Equal + } else if v2.vendor_prefix.is_some() { + Ordering::Greater + } else { + Ordering::Less + } +} + +/// An iterator over the different ExtraStyleData. +pub struct ExtraStyleDataIterator<'a>(DocumentCascadeDataIter<'a>); + +impl<'a> Iterator for ExtraStyleDataIterator<'a> { + type Item = (&'a ExtraStyleData, Origin); + + fn next(&mut self) -> Option<Self::Item> { + self.0.next().map(|d| (&d.0.extra_data, d.1)) + } +} + +#[cfg(feature = "gecko")] +impl MallocSizeOf for ExtraStyleData { + /// Measure heap usage. + fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize { + let mut n = 0; + n += self.font_faces.shallow_size_of(ops); + n += self.font_feature_values.shallow_size_of(ops); + n += self.font_palette_values.shallow_size_of(ops); + n += self.counter_styles.shallow_size_of(ops); + n += self.pages.shallow_size_of(ops); + n + } +} + +/// SelectorMapEntry implementation for use in our revalidation selector map. +#[cfg_attr(feature = "gecko", derive(MallocSizeOf))] +#[derive(Clone, Debug)] +struct RevalidationSelectorAndHashes { + #[cfg_attr( + feature = "gecko", + ignore_malloc_size_of = "CssRules have primary refs, we measure there" + )] + selector: Selector<SelectorImpl>, + selector_offset: usize, + hashes: AncestorHashes, +} + +impl RevalidationSelectorAndHashes { + fn new(selector: Selector<SelectorImpl>, hashes: AncestorHashes) -> Self { + let selector_offset = { + // We basically want to check whether the first combinator is a + // pseudo-element combinator. If it is, we want to use the offset + // one past it. Otherwise, our offset is 0. + let mut index = 0; + let mut iter = selector.iter(); + + // First skip over the first ComplexSelector. + // + // We can't check what sort of what combinator we have until we do + // that. + for _ in &mut iter { + index += 1; // Simple selector + } + + match iter.next_sequence() { + Some(Combinator::PseudoElement) => index + 1, // +1 for the combinator + _ => 0, + } + }; + + RevalidationSelectorAndHashes { + selector, + selector_offset, + hashes, + } + } +} + +impl SelectorMapEntry for RevalidationSelectorAndHashes { + fn selector(&self) -> SelectorIter<SelectorImpl> { + self.selector.iter_from(self.selector_offset) + } +} + +/// A selector visitor implementation that collects all the state the Stylist +/// cares about a selector. +struct StylistSelectorVisitor<'a> { + /// Whether we've past the rightmost compound selector, not counting + /// pseudo-elements. + passed_rightmost_selector: bool, + + /// Whether the selector needs revalidation for the style sharing cache. + needs_revalidation: &'a mut bool, + + /// Flags for which selector list-containing components the visitor is + /// inside of, if any + in_selector_list_of: SelectorListKind, + + /// The filter with all the id's getting referenced from rightmost + /// selectors. + mapped_ids: &'a mut PrecomputedHashSet<Atom>, + + /// The filter with the IDs getting referenced from the selector list of + /// :nth-child(... of <selector list>) selectors. + nth_of_mapped_ids: &'a mut PrecomputedHashSet<Atom>, + + /// The filter with the local names of attributes there are selectors for. + attribute_dependencies: &'a mut PrecomputedHashSet<LocalName>, + + /// The filter with the classes getting referenced from the selector list of + /// :nth-child(... of <selector list>) selectors. + nth_of_class_dependencies: &'a mut PrecomputedHashSet<Atom>, + + /// The filter with the local names of attributes there are selectors for + /// within the selector list of :nth-child(... of <selector list>) + /// selectors. + nth_of_attribute_dependencies: &'a mut PrecomputedHashSet<LocalName>, + + /// All the states selectors in the page reference. + state_dependencies: &'a mut ElementState, + + /// All the state selectors in the page reference within the selector list + /// of :nth-child(... of <selector list>) selectors. + nth_of_state_dependencies: &'a mut ElementState, + + /// All the document states selectors in the page reference. + document_state_dependencies: &'a mut DocumentState, +} + +fn component_needs_revalidation( + c: &Component<SelectorImpl>, + passed_rightmost_selector: bool, +) -> bool { + match *c { + Component::ID(_) => { + // TODO(emilio): This could also check that the ID is not already in + // the rule hash. In that case, we could avoid making this a + // revalidation selector too. + // + // See https://bugzilla.mozilla.org/show_bug.cgi?id=1369611 + passed_rightmost_selector + }, + Component::AttributeInNoNamespaceExists { .. } | + Component::AttributeInNoNamespace { .. } | + Component::AttributeOther(_) | + Component::Empty | + Component::Nth(_) | + Component::NthOf(_) => true, + Component::NonTSPseudoClass(ref p) => p.needs_cache_revalidation(), + _ => false, + } +} + +impl<'a> SelectorVisitor for StylistSelectorVisitor<'a> { + type Impl = SelectorImpl; + + fn visit_complex_selector(&mut self, combinator: Option<Combinator>) -> bool { + *self.needs_revalidation = + *self.needs_revalidation || combinator.map_or(false, |c| c.is_sibling()); + + // NOTE(emilio): this call happens before we visit any of the simple + // selectors in the next ComplexSelector, so we can use this to skip + // looking at them. + self.passed_rightmost_selector = self.passed_rightmost_selector || + !matches!(combinator, None | Some(Combinator::PseudoElement)); + + true + } + + fn visit_selector_list( + &mut self, + list_kind: SelectorListKind, + list: &[Selector<Self::Impl>], + ) -> bool { + let in_selector_list_of = self.in_selector_list_of | list_kind; + for selector in list { + let mut nested = StylistSelectorVisitor { + passed_rightmost_selector: false, + needs_revalidation: &mut *self.needs_revalidation, + in_selector_list_of, + mapped_ids: &mut *self.mapped_ids, + nth_of_mapped_ids: &mut *self.nth_of_mapped_ids, + attribute_dependencies: &mut *self.attribute_dependencies, + nth_of_class_dependencies: &mut *self.nth_of_class_dependencies, + nth_of_attribute_dependencies: &mut *self.nth_of_attribute_dependencies, + state_dependencies: &mut *self.state_dependencies, + nth_of_state_dependencies: &mut *self.nth_of_state_dependencies, + document_state_dependencies: &mut *self.document_state_dependencies, + }; + let _ret = selector.visit(&mut nested); + debug_assert!(_ret, "We never return false"); + } + true + } + + fn visit_attribute_selector( + &mut self, + _ns: &NamespaceConstraint<&Namespace>, + name: &LocalName, + lower_name: &LocalName, + ) -> bool { + if self.in_selector_list_of.in_nth_of() { + self.nth_of_attribute_dependencies.insert(name.clone()); + if name != lower_name { + self.nth_of_attribute_dependencies + .insert(lower_name.clone()); + } + } + + self.attribute_dependencies.insert(name.clone()); + if name != lower_name { + self.attribute_dependencies.insert(lower_name.clone()); + } + + true + } + + fn visit_simple_selector(&mut self, s: &Component<SelectorImpl>) -> bool { + *self.needs_revalidation = *self.needs_revalidation || + component_needs_revalidation(s, self.passed_rightmost_selector); + + match *s { + Component::NonTSPseudoClass(ref p) => { + self.state_dependencies.insert(p.state_flag()); + self.document_state_dependencies + .insert(p.document_state_flag()); + + if self.in_selector_list_of.in_nth_of() { + self.nth_of_state_dependencies.insert(p.state_flag()); + } + }, + Component::ID(ref id) => { + // We want to stop storing mapped ids as soon as we've moved off + // the rightmost ComplexSelector that is not a pseudo-element. + // + // That can be detected by a visit_complex_selector call with a + // combinator other than None and PseudoElement. + // + // Importantly, this call happens before we visit any of the + // simple selectors in that ComplexSelector. + // + // NOTE(emilio): See the comment regarding on when this may + // break in visit_complex_selector. + if !self.passed_rightmost_selector { + self.mapped_ids.insert(id.0.clone()); + } + + if self.in_selector_list_of.in_nth_of() { + self.nth_of_mapped_ids.insert(id.0.clone()); + } + }, + Component::Class(ref class) if self.in_selector_list_of.in_nth_of() => { + self.nth_of_class_dependencies.insert(class.0.clone()); + }, + _ => {}, + } + + true + } +} + +/// A set of rules for element and pseudo-elements. +#[derive(Clone, Debug, Default, MallocSizeOf)] +struct GenericElementAndPseudoRules<Map> { + /// Rules from stylesheets at this `CascadeData`'s origin. + element_map: Map, + + /// Rules from stylesheets at this `CascadeData`'s origin that correspond + /// to a given pseudo-element. + /// + /// FIXME(emilio): There are a bunch of wasted entries here in practice. + /// Figure out a good way to do a `PerNonAnonBox` and `PerAnonBox` (for + /// `precomputed_values_for_pseudo`) without duplicating a lot of code. + pseudos_map: PerPseudoElementMap<Box<Map>>, +} + +impl<Map: Default + MallocSizeOf> GenericElementAndPseudoRules<Map> { + #[inline(always)] + fn for_insertion(&mut self, pseudo_element: Option<&PseudoElement>) -> &mut Map { + debug_assert!( + pseudo_element.map_or(true, |pseudo| { + !pseudo.is_precomputed() && !pseudo.is_unknown_webkit_pseudo_element() + }), + "Precomputed pseudos should end up in precomputed_pseudo_element_decls, \ + and unknown webkit pseudos should be discarded before getting here" + ); + + match pseudo_element { + None => &mut self.element_map, + Some(pseudo) => self + .pseudos_map + .get_or_insert_with(pseudo, || Box::new(Default::default())), + } + } + + #[inline] + fn rules(&self, pseudo: Option<&PseudoElement>) -> Option<&Map> { + match pseudo { + Some(pseudo) => self.pseudos_map.get(pseudo).map(|p| &**p), + None => Some(&self.element_map), + } + } + + /// Measures heap usage. + #[cfg(feature = "gecko")] + fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + sizes.mElementAndPseudosMaps += self.element_map.size_of(ops); + + for elem in self.pseudos_map.iter() { + if let Some(ref elem) = *elem { + sizes.mElementAndPseudosMaps += <Box<_> as MallocSizeOf>::size_of(elem, ops); + } + } + } +} + +type ElementAndPseudoRules = GenericElementAndPseudoRules<SelectorMap<Rule>>; +type PartMap = PrecomputedHashMap<Atom, SmallVec<[Rule; 1]>>; +type PartElementAndPseudoRules = GenericElementAndPseudoRules<PartMap>; + +impl ElementAndPseudoRules { + // TODO(emilio): Should we retain storage of these? + fn clear(&mut self) { + self.element_map.clear(); + self.pseudos_map.clear(); + } + + fn shrink_if_needed(&mut self) { + self.element_map.shrink_if_needed(); + for pseudo in self.pseudos_map.iter_mut() { + if let Some(ref mut pseudo) = pseudo { + pseudo.shrink_if_needed(); + } + } + } +} + +impl PartElementAndPseudoRules { + // TODO(emilio): Should we retain storage of these? + fn clear(&mut self) { + self.element_map.clear(); + self.pseudos_map.clear(); + } +} + +/// The id of a given layer, a sequentially-increasing identifier. +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord)] +pub struct LayerId(u16); + +impl LayerId { + /// The id of the root layer. + pub const fn root() -> Self { + Self(0) + } +} + +#[derive(Clone, Debug, MallocSizeOf)] +struct CascadeLayer { + id: LayerId, + order: LayerOrder, + children: Vec<LayerId>, +} + +impl CascadeLayer { + const fn root() -> Self { + Self { + id: LayerId::root(), + order: LayerOrder::root(), + children: vec![], + } + } +} + +/// The id of a given container condition, a sequentially-increasing identifier +/// for a given style set. +#[derive(Clone, Copy, Debug, Eq, MallocSizeOf, PartialEq, PartialOrd, Ord)] +pub struct ContainerConditionId(u16); + +impl ContainerConditionId { + /// A special id that represents no container rule all. + pub const fn none() -> Self { + Self(0) + } +} + +#[derive(Clone, Debug, MallocSizeOf)] +struct ContainerConditionReference { + parent: ContainerConditionId, + #[ignore_malloc_size_of = "Arc"] + condition: Option<Arc<ContainerCondition>>, +} + +impl ContainerConditionReference { + const fn none() -> Self { + Self { + parent: ContainerConditionId::none(), + condition: None, + } + } +} + +/// Data resulting from performing the CSS cascade that is specific to a given +/// origin. +/// +/// FIXME(emilio): Consider renaming and splitting in `CascadeData` and +/// `InvalidationData`? That'd make `clear_cascade_data()` clearer. +#[derive(Debug, Clone, MallocSizeOf)] +pub struct CascadeData { + /// The data coming from normal style rules that apply to elements at this + /// cascade level. + normal_rules: ElementAndPseudoRules, + + /// The `:host` pseudo rules that are the rightmost selector (without + /// accounting for pseudo-elements). + host_rules: Option<Box<ElementAndPseudoRules>>, + + /// The data coming from ::slotted() pseudo-element rules. + /// + /// We need to store them separately because an element needs to match + /// ::slotted() pseudo-element rules in different shadow roots. + /// + /// In particular, we need to go through all the style data in all the + /// containing style scopes starting from the closest assigned slot. + slotted_rules: Option<Box<ElementAndPseudoRules>>, + + /// The data coming from ::part() pseudo-element rules. + /// + /// We need to store them separately because an element needs to match + /// ::part() pseudo-element rules in different shadow roots. + part_rules: Option<Box<PartElementAndPseudoRules>>, + + /// The invalidation map for these rules. + invalidation_map: InvalidationMap, + + /// The attribute local names that appear in attribute selectors. Used + /// to avoid taking element snapshots when an irrelevant attribute changes. + /// (We don't bother storing the namespace, since namespaced attributes are + /// rare.) + attribute_dependencies: PrecomputedHashSet<LocalName>, + + /// The classes that appear in the selector list of + /// :nth-child(... of <selector list>). Used to avoid restyling siblings of + /// an element when an irrelevant class changes. + nth_of_class_dependencies: PrecomputedHashSet<Atom>, + + /// The attributes that appear in the selector list of + /// :nth-child(... of <selector list>). Used to avoid restyling siblings of + /// an element when an irrelevant attribute changes. + nth_of_attribute_dependencies: PrecomputedHashSet<LocalName>, + + /// The element state bits that are relied on by selectors. Like + /// `attribute_dependencies`, this is used to avoid taking element snapshots + /// when an irrelevant element state bit changes. + state_dependencies: ElementState, + + /// The element state bits that are relied on by selectors that appear in + /// the selector list of :nth-child(... of <selector list>). + nth_of_state_dependencies: ElementState, + + /// The document state bits that are relied on by selectors. This is used + /// to tell whether we need to restyle the entire document when a document + /// state bit changes. + document_state_dependencies: DocumentState, + + /// The ids that appear in the rightmost complex selector of selectors (and + /// hence in our selector maps). Used to determine when sharing styles is + /// safe: we disallow style sharing for elements whose id matches this + /// filter, and hence might be in one of our selector maps. + mapped_ids: PrecomputedHashSet<Atom>, + + /// The IDs that appear in the selector list of + /// :nth-child(... of <selector list>). Used to avoid restyling siblings + /// of an element when an irrelevant ID changes. + nth_of_mapped_ids: PrecomputedHashSet<Atom>, + + /// Selectors that require explicit cache revalidation (i.e. which depend + /// on state that is not otherwise visible to the cache, like attributes or + /// tree-structural state like child index and pseudos). + #[ignore_malloc_size_of = "Arc"] + selectors_for_cache_revalidation: SelectorMap<RevalidationSelectorAndHashes>, + + /// A map with all the animations at this `CascadeData`'s origin, indexed + /// by name. + animations: LayerOrderedMap<KeyframesAnimation>, + + /// A map from cascade layer name to layer order. + layer_id: FxHashMap<LayerName, LayerId>, + + /// The list of cascade layers, indexed by their layer id. + layers: SmallVec<[CascadeLayer; 1]>, + + /// The list of container conditions, indexed by their id. + container_conditions: SmallVec<[ContainerConditionReference; 1]>, + + /// Effective media query results cached from the last rebuild. + effective_media_query_results: EffectiveMediaQueryResults, + + /// Extra data, like different kinds of rules, etc. + extra_data: ExtraStyleData, + + /// A monotonically increasing counter to represent the order on which a + /// style rule appears in a stylesheet, needed to sort them by source order. + rules_source_order: u32, + + /// The total number of selectors. + num_selectors: usize, + + /// The total number of declarations. + num_declarations: usize, +} + +impl CascadeData { + /// Creates an empty `CascadeData`. + pub fn new() -> Self { + Self { + normal_rules: ElementAndPseudoRules::default(), + host_rules: None, + slotted_rules: None, + part_rules: None, + invalidation_map: InvalidationMap::new(), + nth_of_mapped_ids: PrecomputedHashSet::default(), + nth_of_class_dependencies: PrecomputedHashSet::default(), + nth_of_attribute_dependencies: PrecomputedHashSet::default(), + nth_of_state_dependencies: ElementState::empty(), + attribute_dependencies: PrecomputedHashSet::default(), + state_dependencies: ElementState::empty(), + document_state_dependencies: DocumentState::empty(), + mapped_ids: PrecomputedHashSet::default(), + // NOTE: We disable attribute bucketing for revalidation because we + // rely on the buckets to match, but we don't want to just not share + // style across elements with different attributes. + // + // An alternative to this would be to perform a style sharing check + // like may_match_different_id_rules which would check that the + // attribute buckets match on all scopes. But that seems + // somewhat gnarly. + selectors_for_cache_revalidation: SelectorMap::new_without_attribute_bucketing(), + animations: Default::default(), + layer_id: Default::default(), + layers: smallvec::smallvec![CascadeLayer::root()], + container_conditions: smallvec::smallvec![ContainerConditionReference::none()], + extra_data: ExtraStyleData::default(), + effective_media_query_results: EffectiveMediaQueryResults::new(), + rules_source_order: 0, + num_selectors: 0, + num_declarations: 0, + } + } + + /// Rebuild the cascade data from a given SheetCollection, incrementally if + /// possible. + pub fn rebuild<'a, S>( + &mut self, + device: &Device, + quirks_mode: QuirksMode, + collection: SheetCollectionFlusher<S>, + guard: &SharedRwLockReadGuard, + ) -> Result<(), AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static, + { + if !collection.dirty() { + return Ok(()); + } + + let validity = collection.data_validity(); + + match validity { + DataValidity::Valid => {}, + DataValidity::CascadeInvalid => self.clear_cascade_data(), + DataValidity::FullyInvalid => self.clear(), + } + + let mut result = Ok(()); + + collection.each(|stylesheet, rebuild_kind| { + result = self.add_stylesheet( + device, + quirks_mode, + stylesheet, + guard, + rebuild_kind, + /* precomputed_pseudo_element_decls = */ None, + ); + result.is_ok() + }); + + self.did_finish_rebuild(); + + result + } + + /// Returns the invalidation map. + pub fn invalidation_map(&self) -> &InvalidationMap { + &self.invalidation_map + } + + /// Returns whether the given ElementState bit is relied upon by a selector + /// of some rule. + #[inline] + pub fn has_state_dependency(&self, state: ElementState) -> bool { + self.state_dependencies.intersects(state) + } + + /// Returns whether the given ElementState bit is relied upon by a selector + /// of some rule in the selector list of :nth-child(... of <selector list>). + #[inline] + pub fn has_nth_of_state_dependency(&self, state: ElementState) -> bool { + self.nth_of_state_dependencies.intersects(state) + } + + /// Returns whether the given attribute might appear in an attribute + /// selector of some rule. + #[inline] + pub fn might_have_attribute_dependency(&self, local_name: &LocalName) -> bool { + self.attribute_dependencies.contains(local_name) + } + + /// Returns whether the given ID might appear in an ID selector in the + /// selector list of :nth-child(... of <selector list>). + #[inline] + pub fn might_have_nth_of_id_dependency(&self, id: &Atom) -> bool { + self.nth_of_mapped_ids.contains(id) + } + + /// Returns whether the given class might appear in a class selector in the + /// selector list of :nth-child(... of <selector list>). + #[inline] + pub fn might_have_nth_of_class_dependency(&self, class: &Atom) -> bool { + self.nth_of_class_dependencies.contains(class) + } + + /// Returns whether the given attribute might appear in an attribute + /// selector in the selector list of :nth-child(... of <selector list>). + #[inline] + pub fn might_have_nth_of_attribute_dependency(&self, local_name: &LocalName) -> bool { + self.nth_of_attribute_dependencies.contains(local_name) + } + + /// Returns the normal rule map for a given pseudo-element. + #[inline] + pub fn normal_rules(&self, pseudo: Option<&PseudoElement>) -> Option<&SelectorMap<Rule>> { + self.normal_rules.rules(pseudo) + } + + /// Returns the host pseudo rule map for a given pseudo-element. + #[inline] + pub fn host_rules(&self, pseudo: Option<&PseudoElement>) -> Option<&SelectorMap<Rule>> { + self.host_rules.as_ref().and_then(|d| d.rules(pseudo)) + } + + /// Whether there's any host rule that could match in this scope. + pub fn any_host_rules(&self) -> bool { + self.host_rules.is_some() + } + + /// Returns the slotted rule map for a given pseudo-element. + #[inline] + pub fn slotted_rules(&self, pseudo: Option<&PseudoElement>) -> Option<&SelectorMap<Rule>> { + self.slotted_rules.as_ref().and_then(|d| d.rules(pseudo)) + } + + /// Whether there's any ::slotted rule that could match in this scope. + pub fn any_slotted_rule(&self) -> bool { + self.slotted_rules.is_some() + } + + /// Returns the parts rule map for a given pseudo-element. + #[inline] + pub fn part_rules(&self, pseudo: Option<&PseudoElement>) -> Option<&PartMap> { + self.part_rules.as_ref().and_then(|d| d.rules(pseudo)) + } + + /// Whether there's any ::part rule that could match in this scope. + pub fn any_part_rule(&self) -> bool { + self.part_rules.is_some() + } + + #[inline] + fn layer_order_for(&self, id: LayerId) -> LayerOrder { + self.layers[id.0 as usize].order + } + + pub(crate) fn container_condition_matches<E>( + &self, + mut id: ContainerConditionId, + stylist: &Stylist, + element: E, + context: &mut MatchingContext<E::Impl>, + ) -> bool + where + E: TElement, + { + loop { + let condition_ref = &self.container_conditions[id.0 as usize]; + let condition = match condition_ref.condition { + None => return true, + Some(ref c) => c, + }; + let matches = condition + .matches( + stylist.device(), + element, + context.extra_data.originating_element_style, + &mut context.extra_data.cascade_input_flags, + ) + .to_bool(/* unknown = */ false); + if !matches { + return false; + } + id = condition_ref.parent; + } + } + + fn did_finish_rebuild(&mut self) { + self.shrink_maps_if_needed(); + self.compute_layer_order(); + } + + fn shrink_maps_if_needed(&mut self) { + self.normal_rules.shrink_if_needed(); + if let Some(ref mut host_rules) = self.host_rules { + host_rules.shrink_if_needed(); + } + if let Some(ref mut slotted_rules) = self.slotted_rules { + slotted_rules.shrink_if_needed(); + } + self.invalidation_map.shrink_if_needed(); + self.attribute_dependencies.shrink_if_needed(); + self.nth_of_attribute_dependencies.shrink_if_needed(); + self.nth_of_class_dependencies.shrink_if_needed(); + self.nth_of_mapped_ids.shrink_if_needed(); + self.mapped_ids.shrink_if_needed(); + self.layer_id.shrink_if_needed(); + self.selectors_for_cache_revalidation.shrink_if_needed(); + } + + fn compute_layer_order(&mut self) { + debug_assert_ne!( + self.layers.len(), + 0, + "There should be at least the root layer!" + ); + if self.layers.len() == 1 { + return; // Nothing to do + } + let (first, remaining) = self.layers.split_at_mut(1); + let root = &mut first[0]; + let mut order = LayerOrder::first(); + compute_layer_order_for_subtree(root, remaining, &mut order); + + // NOTE(emilio): This is a bit trickier than it should to avoid having + // to clone() around layer indices. + fn compute_layer_order_for_subtree( + parent: &mut CascadeLayer, + remaining_layers: &mut [CascadeLayer], + order: &mut LayerOrder, + ) { + for child in parent.children.iter() { + debug_assert!( + parent.id < *child, + "Children are always registered after parents" + ); + let child_index = (child.0 - parent.id.0 - 1) as usize; + let (first, remaining) = remaining_layers.split_at_mut(child_index + 1); + let child = &mut first[child_index]; + compute_layer_order_for_subtree(child, remaining, order); + } + + if parent.id != LayerId::root() { + parent.order = *order; + order.inc(); + } + } + self.extra_data.sort_by_layer(&self.layers); + self.animations + .sort_with(&self.layers, compare_keyframes_in_same_layer); + } + + /// Collects all the applicable media query results into `results`. + /// + /// This duplicates part of the logic in `add_stylesheet`, which is + /// a bit unfortunate. + /// + /// FIXME(emilio): With a bit of smartness in + /// `media_feature_affected_matches`, we could convert + /// `EffectiveMediaQueryResults` into a vector without too much effort. + fn collect_applicable_media_query_results_into<S>( + device: &Device, + stylesheet: &S, + guard: &SharedRwLockReadGuard, + results: &mut Vec<MediaListKey>, + contents_list: &mut StyleSheetContentList, + ) where + S: StylesheetInDocument + 'static, + { + if !stylesheet.enabled() || !stylesheet.is_effective_for_device(device, guard) { + return; + } + + debug!(" + {:?}", stylesheet); + let contents = stylesheet.contents(); + results.push(contents.to_media_list_key()); + + // Safety: StyleSheetContents are reference-counted with Arc. + contents_list.push(StylesheetContentsPtr(unsafe { + Arc::from_raw_addrefed(contents) + })); + + for rule in stylesheet.effective_rules(device, guard) { + match *rule { + CssRule::Import(ref lock) => { + let import_rule = lock.read_with(guard); + debug!(" + {:?}", import_rule.stylesheet.media(guard)); + results.push(import_rule.to_media_list_key()); + }, + CssRule::Media(ref media_rule) => { + debug!(" + {:?}", media_rule.media_queries.read_with(guard)); + results.push(media_rule.to_media_list_key()); + }, + _ => {}, + } + } + } + + fn add_rule_list<'a, S>( + &mut self, + rules: std::slice::Iter<'a, CssRule>, + device: &'a Device, + quirks_mode: QuirksMode, + stylesheet: &S, + guard: &'a SharedRwLockReadGuard, + rebuild_kind: SheetRebuildKind, + containing_rule_state: &mut ContainingRuleState<'a>, + mut precomputed_pseudo_element_decls: Option<&mut PrecomputedPseudoElementDeclarations>, + ) -> Result<(), AllocErr> + where + S: StylesheetInDocument + 'static, + { + for rule in rules { + // Handle leaf rules first, as those are by far the most common + // ones, and are always effective, so we can skip some checks. + let mut handled = true; + let mut selectors_for_nested_rules = None; + match *rule { + CssRule::Style(ref locked) => { + let style_rule = locked.read_with(guard); + self.num_declarations += style_rule.block.read_with(&guard).len(); + + let has_nested_rules = style_rule.rules.is_some(); + let ancestor_selectors = containing_rule_state.ancestor_selector_lists.last(); + if has_nested_rules { + selectors_for_nested_rules = Some(if ancestor_selectors.is_some() { + Cow::Owned(SelectorList(Default::default())) + } else { + Cow::Borrowed(&style_rule.selectors) + }); + } + + for selector in &style_rule.selectors.0 { + self.num_selectors += 1; + + let pseudo_element = selector.pseudo_element(); + if let Some(pseudo) = pseudo_element { + if pseudo.is_precomputed() { + debug_assert!(selector.is_universal()); + debug_assert!(ancestor_selectors.is_none()); + debug_assert!(!has_nested_rules); + debug_assert_eq!(stylesheet.contents().origin, Origin::UserAgent); + debug_assert_eq!(containing_rule_state.layer_id, LayerId::root()); + + precomputed_pseudo_element_decls + .as_mut() + .expect("Expected precomputed declarations for the UA level") + .get_or_insert_with(pseudo, Vec::new) + .push(ApplicableDeclarationBlock::new( + StyleSource::from_rule(locked.clone()), + self.rules_source_order, + CascadeLevel::UANormal, + selector.specificity(), + LayerOrder::root(), + )); + continue; + } + if pseudo.is_unknown_webkit_pseudo_element() { + continue; + } + } + + let selector = match ancestor_selectors { + Some(s) => selector.replace_parent_selector(&s.0), + None => selector.clone(), + }; + + let hashes = AncestorHashes::new(&selector, quirks_mode); + + let rule = Rule::new( + selector, + hashes, + locked.clone(), + self.rules_source_order, + containing_rule_state.layer_id, + containing_rule_state.container_condition_id, + ); + + if let Some(Cow::Owned(ref mut nested_selectors)) = + selectors_for_nested_rules + { + nested_selectors.0.push(rule.selector.clone()) + } + + if rebuild_kind.should_rebuild_invalidation() { + self.invalidation_map + .note_selector(&rule.selector, quirks_mode)?; + let mut needs_revalidation = false; + let mut visitor = StylistSelectorVisitor { + needs_revalidation: &mut needs_revalidation, + passed_rightmost_selector: false, + in_selector_list_of: SelectorListKind::default(), + mapped_ids: &mut self.mapped_ids, + nth_of_mapped_ids: &mut self.nth_of_mapped_ids, + attribute_dependencies: &mut self.attribute_dependencies, + nth_of_class_dependencies: &mut self.nth_of_class_dependencies, + nth_of_attribute_dependencies: &mut self + .nth_of_attribute_dependencies, + state_dependencies: &mut self.state_dependencies, + nth_of_state_dependencies: &mut self.nth_of_state_dependencies, + document_state_dependencies: &mut self.document_state_dependencies, + }; + rule.selector.visit(&mut visitor); + + if needs_revalidation { + self.selectors_for_cache_revalidation.insert( + RevalidationSelectorAndHashes::new( + rule.selector.clone(), + rule.hashes.clone(), + ), + quirks_mode, + )?; + } + } + + // Part is special, since given it doesn't have any + // selectors inside, it's not worth using a whole + // SelectorMap for it. + if let Some(parts) = rule.selector.parts() { + // ::part() has all semantics, so we just need to + // put any of them in the selector map. + // + // We choose the last one quite arbitrarily, + // expecting it's slightly more likely to be more + // specific. + let map = self + .part_rules + .get_or_insert_with(|| Box::new(Default::default())) + .for_insertion(pseudo_element); + map.try_reserve(1)?; + let vec = map.entry(parts.last().unwrap().clone().0).or_default(); + vec.try_reserve(1)?; + vec.push(rule); + } else { + // NOTE(emilio): It's fine to look at :host and then at + // ::slotted(..), since :host::slotted(..) could never + // possibly match, as <slot> is not a valid shadow host. + let rules = if rule + .selector + .is_featureless_host_selector_or_pseudo_element() + { + self.host_rules + .get_or_insert_with(|| Box::new(Default::default())) + } else if rule.selector.is_slotted() { + self.slotted_rules + .get_or_insert_with(|| Box::new(Default::default())) + } else { + &mut self.normal_rules + } + .for_insertion(pseudo_element); + rules.insert(rule, quirks_mode)?; + } + } + self.rules_source_order += 1; + handled = !has_nested_rules; + }, + CssRule::Keyframes(ref keyframes_rule) => { + debug!("Found valid keyframes rule: {:?}", *keyframes_rule); + let keyframes_rule = keyframes_rule.read_with(guard); + let name = keyframes_rule.name.as_atom().clone(); + let animation = KeyframesAnimation::from_keyframes( + &keyframes_rule.keyframes, + keyframes_rule.vendor_prefix.clone(), + guard, + ); + self.animations.try_insert_with( + name, + animation, + containing_rule_state.layer_id, + compare_keyframes_in_same_layer, + )?; + }, + #[cfg(feature = "gecko")] + CssRule::FontFace(ref rule) => { + // NOTE(emilio): We don't care about container_condition_id + // because: + // + // Global, name-defining at-rules such as @keyframes or + // @font-face or @layer that are defined inside container + // queries are not constrained by the container query + // conditions. + // + // https://drafts.csswg.org/css-contain-3/#container-rule + // (Same elsewhere) + self.extra_data + .add_font_face(rule, containing_rule_state.layer_id); + }, + #[cfg(feature = "gecko")] + CssRule::FontFeatureValues(ref rule) => { + self.extra_data + .add_font_feature_values(rule, containing_rule_state.layer_id); + }, + #[cfg(feature = "gecko")] + CssRule::FontPaletteValues(ref rule) => { + self.extra_data + .add_font_palette_values(rule, containing_rule_state.layer_id); + }, + #[cfg(feature = "gecko")] + CssRule::CounterStyle(ref rule) => { + self.extra_data.add_counter_style( + guard, + rule, + containing_rule_state.layer_id, + )?; + }, + #[cfg(feature = "gecko")] + CssRule::Page(ref rule) => { + self.extra_data + .add_page(guard, rule, containing_rule_state.layer_id)?; + }, + // TODO: Handle CssRule::Property + CssRule::Viewport(..) => {}, + _ => { + handled = false; + }, + } + + if handled { + // Assert that there are no children, and that the rule is + // effective. + if cfg!(debug_assertions) { + let mut effective = false; + let children = EffectiveRulesIterator::children( + rule, + device, + quirks_mode, + guard, + &mut effective, + ); + debug_assert!(children.is_none()); + debug_assert!(effective); + } + continue; + } + + let mut effective = false; + let children = + EffectiveRulesIterator::children(rule, device, quirks_mode, guard, &mut effective); + + if !effective { + continue; + } + + fn maybe_register_layer(data: &mut CascadeData, layer: &LayerName) -> LayerId { + // TODO: Measure what's more common / expensive, if + // layer.clone() or the double hash lookup in the insert + // case. + if let Some(id) = data.layer_id.get(layer) { + return *id; + } + let id = LayerId(data.layers.len() as u16); + + let parent_layer_id = if layer.layer_names().len() > 1 { + let mut parent = layer.clone(); + parent.0.pop(); + + *data + .layer_id + .get_mut(&parent) + .expect("Parent layers should be registered before child layers") + } else { + LayerId::root() + }; + + data.layers[parent_layer_id.0 as usize].children.push(id); + data.layers.push(CascadeLayer { + id, + // NOTE(emilio): Order is evaluated after rebuild in + // compute_layer_order. + order: LayerOrder::first(), + children: vec![], + }); + + data.layer_id.insert(layer.clone(), id); + + id + } + + fn maybe_register_layers( + data: &mut CascadeData, + name: Option<&LayerName>, + containing_rule_state: &mut ContainingRuleState, + ) { + let anon_name; + let name = match name { + Some(name) => name, + None => { + anon_name = LayerName::new_anonymous(); + &anon_name + }, + }; + for name in name.layer_names() { + containing_rule_state.layer_name.0.push(name.clone()); + containing_rule_state.layer_id = + maybe_register_layer(data, &containing_rule_state.layer_name); + } + debug_assert_ne!(containing_rule_state.layer_id, LayerId::root()); + } + + let saved_containing_rule_state = containing_rule_state.save(); + match *rule { + CssRule::Import(ref lock) => { + let import_rule = lock.read_with(guard); + if rebuild_kind.should_rebuild_invalidation() { + self.effective_media_query_results + .saw_effective(import_rule); + } + match import_rule.layer { + ImportLayer::Named(ref name) => { + maybe_register_layers(self, Some(name), containing_rule_state) + }, + ImportLayer::Anonymous => { + maybe_register_layers(self, None, containing_rule_state) + }, + ImportLayer::None => {}, + } + }, + CssRule::Media(ref media_rule) => { + if rebuild_kind.should_rebuild_invalidation() { + self.effective_media_query_results + .saw_effective(&**media_rule); + } + }, + CssRule::LayerBlock(ref rule) => { + maybe_register_layers(self, rule.name.as_ref(), containing_rule_state); + }, + CssRule::LayerStatement(ref rule) => { + for name in &*rule.names { + maybe_register_layers(self, Some(name), containing_rule_state); + // Register each layer individually. + containing_rule_state.restore(&saved_containing_rule_state); + } + }, + CssRule::Style(..) => { + if let Some(s) = selectors_for_nested_rules { + containing_rule_state.ancestor_selector_lists.push(s); + } + }, + CssRule::Container(ref rule) => { + let id = ContainerConditionId(self.container_conditions.len() as u16); + self.container_conditions.push(ContainerConditionReference { + parent: containing_rule_state.container_condition_id, + condition: Some(rule.condition.clone()), + }); + containing_rule_state.container_condition_id = id; + }, + // We don't care about any other rule. + _ => {}, + } + + if let Some(children) = children { + self.add_rule_list( + children, + device, + quirks_mode, + stylesheet, + guard, + rebuild_kind, + containing_rule_state, + precomputed_pseudo_element_decls.as_deref_mut(), + )?; + } + + containing_rule_state.restore(&saved_containing_rule_state); + } + + Ok(()) + } + + // Returns Err(..) to signify OOM + fn add_stylesheet<S>( + &mut self, + device: &Device, + quirks_mode: QuirksMode, + stylesheet: &S, + guard: &SharedRwLockReadGuard, + rebuild_kind: SheetRebuildKind, + mut precomputed_pseudo_element_decls: Option<&mut PrecomputedPseudoElementDeclarations>, + ) -> Result<(), AllocErr> + where + S: StylesheetInDocument + 'static, + { + if !stylesheet.enabled() || !stylesheet.is_effective_for_device(device, guard) { + return Ok(()); + } + + let contents = stylesheet.contents(); + + if rebuild_kind.should_rebuild_invalidation() { + self.effective_media_query_results.saw_effective(contents); + } + + let mut state = ContainingRuleState::default(); + self.add_rule_list( + contents.rules(guard).iter(), + device, + quirks_mode, + stylesheet, + guard, + rebuild_kind, + &mut state, + precomputed_pseudo_element_decls.as_deref_mut(), + )?; + + Ok(()) + } + + /// Returns whether all the media-feature affected values matched before and + /// match now in the given stylesheet. + pub fn media_feature_affected_matches<S>( + &self, + stylesheet: &S, + guard: &SharedRwLockReadGuard, + device: &Device, + quirks_mode: QuirksMode, + ) -> bool + where + S: StylesheetInDocument + 'static, + { + use crate::invalidation::media_queries::PotentiallyEffectiveMediaRules; + + let effective_now = stylesheet.is_effective_for_device(device, guard); + + let effective_then = self + .effective_media_query_results + .was_effective(stylesheet.contents()); + + if effective_now != effective_then { + debug!( + " > Stylesheet {:?} changed -> {}, {}", + stylesheet.media(guard), + effective_then, + effective_now + ); + return false; + } + + if !effective_now { + return true; + } + + let mut iter = stylesheet.iter_rules::<PotentiallyEffectiveMediaRules>(device, guard); + + while let Some(rule) = iter.next() { + match *rule { + CssRule::Style(..) | + CssRule::Namespace(..) | + CssRule::FontFace(..) | + CssRule::Container(..) | + CssRule::CounterStyle(..) | + CssRule::Supports(..) | + CssRule::Keyframes(..) | + CssRule::Page(..) | + CssRule::Property(..) | + CssRule::Viewport(..) | + CssRule::Document(..) | + CssRule::LayerBlock(..) | + CssRule::LayerStatement(..) | + CssRule::FontPaletteValues(..) | + CssRule::FontFeatureValues(..) => { + // Not affected by device changes. + continue; + }, + CssRule::Import(ref lock) => { + let import_rule = lock.read_with(guard); + let effective_now = match import_rule.stylesheet.media(guard) { + Some(m) => m.evaluate(device, quirks_mode), + None => true, + }; + let effective_then = self + .effective_media_query_results + .was_effective(import_rule); + if effective_now != effective_then { + debug!( + " > @import rule {:?} changed {} -> {}", + import_rule.stylesheet.media(guard), + effective_then, + effective_now + ); + return false; + } + + if !effective_now { + iter.skip_children(); + } + }, + CssRule::Media(ref media_rule) => { + let mq = media_rule.media_queries.read_with(guard); + let effective_now = mq.evaluate(device, quirks_mode); + let effective_then = self + .effective_media_query_results + .was_effective(&**media_rule); + + if effective_now != effective_then { + debug!( + " > @media rule {:?} changed {} -> {}", + mq, effective_then, effective_now + ); + return false; + } + + if !effective_now { + iter.skip_children(); + } + }, + } + } + + true + } + + /// Clears the cascade data, but not the invalidation data. + fn clear_cascade_data(&mut self) { + self.normal_rules.clear(); + if let Some(ref mut slotted_rules) = self.slotted_rules { + slotted_rules.clear(); + } + if let Some(ref mut part_rules) = self.part_rules { + part_rules.clear(); + } + if let Some(ref mut host_rules) = self.host_rules { + host_rules.clear(); + } + self.animations.clear(); + self.layer_id.clear(); + self.layers.clear(); + self.layers.push(CascadeLayer::root()); + self.container_conditions.clear(); + self.container_conditions + .push(ContainerConditionReference::none()); + self.extra_data.clear(); + self.rules_source_order = 0; + self.num_selectors = 0; + self.num_declarations = 0; + } + + fn clear(&mut self) { + self.clear_cascade_data(); + self.invalidation_map.clear(); + self.attribute_dependencies.clear(); + self.nth_of_attribute_dependencies.clear(); + self.nth_of_class_dependencies.clear(); + self.state_dependencies = ElementState::empty(); + self.nth_of_state_dependencies = ElementState::empty(); + self.document_state_dependencies = DocumentState::empty(); + self.mapped_ids.clear(); + self.nth_of_mapped_ids.clear(); + self.selectors_for_cache_revalidation.clear(); + self.effective_media_query_results.clear(); + } +} + +impl CascadeDataCacheEntry for CascadeData { + fn cascade_data(&self) -> &CascadeData { + self + } + + fn rebuild<S>( + device: &Device, + quirks_mode: QuirksMode, + collection: SheetCollectionFlusher<S>, + guard: &SharedRwLockReadGuard, + old: &Self, + ) -> Result<Arc<Self>, AllocErr> + where + S: StylesheetInDocument + PartialEq + 'static, + { + debug_assert!(collection.dirty(), "We surely need to do something?"); + // If we're doing a full rebuild anyways, don't bother cloning the data. + let mut updatable_entry = match collection.data_validity() { + DataValidity::Valid | DataValidity::CascadeInvalid => old.clone(), + DataValidity::FullyInvalid => Self::new(), + }; + updatable_entry.rebuild(device, quirks_mode, collection, guard)?; + Ok(Arc::new(updatable_entry)) + } + + #[cfg(feature = "gecko")] + fn add_size_of(&self, ops: &mut MallocSizeOfOps, sizes: &mut ServoStyleSetSizes) { + self.normal_rules.add_size_of(ops, sizes); + if let Some(ref slotted_rules) = self.slotted_rules { + slotted_rules.add_size_of(ops, sizes); + } + if let Some(ref part_rules) = self.part_rules { + part_rules.add_size_of(ops, sizes); + } + if let Some(ref host_rules) = self.host_rules { + host_rules.add_size_of(ops, sizes); + } + sizes.mInvalidationMap += self.invalidation_map.size_of(ops); + sizes.mRevalidationSelectors += self.selectors_for_cache_revalidation.size_of(ops); + sizes.mOther += self.animations.size_of(ops); + sizes.mOther += self.effective_media_query_results.size_of(ops); + sizes.mOther += self.extra_data.size_of(ops); + } +} + +impl Default for CascadeData { + fn default() -> Self { + CascadeData::new() + } +} + +/// A rule, that wraps a style rule, but represents a single selector of the +/// rule. +#[derive(Clone, Debug, MallocSizeOf)] +pub struct Rule { + /// The selector this struct represents. We store this and the + /// any_{important,normal} booleans inline in the Rule to avoid + /// pointer-chasing when gathering applicable declarations, which + /// can ruin performance when there are a lot of rules. + #[ignore_malloc_size_of = "CssRules have primary refs, we measure there"] + pub selector: Selector<SelectorImpl>, + + /// The ancestor hashes associated with the selector. + pub hashes: AncestorHashes, + + /// The source order this style rule appears in. Note that we only use + /// three bytes to store this value in ApplicableDeclarationsBlock, so + /// we could repurpose that storage here if we needed to. + pub source_order: u32, + + /// The current layer id of this style rule. + pub layer_id: LayerId, + + /// The current @container rule id. + pub container_condition_id: ContainerConditionId, + + /// The actual style rule. + #[cfg_attr( + feature = "gecko", + ignore_malloc_size_of = "Secondary ref. Primary ref is in StyleRule under Stylesheet." + )] + #[cfg_attr(feature = "servo", ignore_malloc_size_of = "Arc")] + pub style_rule: Arc<Locked<StyleRule>>, +} + +impl SelectorMapEntry for Rule { + fn selector(&self) -> SelectorIter<SelectorImpl> { + self.selector.iter() + } +} + +impl Rule { + /// Returns the specificity of the rule. + pub fn specificity(&self) -> u32 { + self.selector.specificity() + } + + /// Turns this rule into an `ApplicableDeclarationBlock` for the given + /// cascade level. + pub fn to_applicable_declaration_block( + &self, + level: CascadeLevel, + cascade_data: &CascadeData, + ) -> ApplicableDeclarationBlock { + let source = StyleSource::from_rule(self.style_rule.clone()); + ApplicableDeclarationBlock::new( + source, + self.source_order, + level, + self.specificity(), + cascade_data.layer_order_for(self.layer_id), + ) + } + + /// Creates a new Rule. + pub fn new( + selector: Selector<SelectorImpl>, + hashes: AncestorHashes, + style_rule: Arc<Locked<StyleRule>>, + source_order: u32, + layer_id: LayerId, + container_condition_id: ContainerConditionId, + ) -> Self { + Rule { + selector, + hashes, + style_rule, + source_order, + layer_id, + container_condition_id, + } + } +} + +// The size of this is critical to performance on the bloom-basic +// microbenchmark. +// When iterating over a large Rule array, we want to be able to fast-reject +// selectors (with the inline hashes) with as few cache misses as possible. +size_of_test!(Rule, 40); + +/// A function to be able to test the revalidation stuff. +pub fn needs_revalidation_for_testing(s: &Selector<SelectorImpl>) -> bool { + let mut needs_revalidation = false; + let mut mapped_ids = Default::default(); + let mut nth_of_mapped_ids = Default::default(); + let mut attribute_dependencies = Default::default(); + let mut nth_of_class_dependencies = Default::default(); + let mut nth_of_attribute_dependencies = Default::default(); + let mut state_dependencies = ElementState::empty(); + let mut nth_of_state_dependencies = ElementState::empty(); + let mut document_state_dependencies = DocumentState::empty(); + let mut visitor = StylistSelectorVisitor { + passed_rightmost_selector: false, + needs_revalidation: &mut needs_revalidation, + in_selector_list_of: SelectorListKind::default(), + mapped_ids: &mut mapped_ids, + nth_of_mapped_ids: &mut nth_of_mapped_ids, + attribute_dependencies: &mut attribute_dependencies, + nth_of_class_dependencies: &mut nth_of_class_dependencies, + nth_of_attribute_dependencies: &mut nth_of_attribute_dependencies, + state_dependencies: &mut state_dependencies, + nth_of_state_dependencies: &mut nth_of_state_dependencies, + document_state_dependencies: &mut document_state_dependencies, + }; + s.visit(&mut visitor); + needs_revalidation +} |