summaryrefslogtreecommitdiffstats
path: root/servo/components/style/style_resolver.rs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--servo/components/style/style_resolver.rs585
1 files changed, 585 insertions, 0 deletions
diff --git a/servo/components/style/style_resolver.rs b/servo/components/style/style_resolver.rs
new file mode 100644
index 0000000000..5c940ad2be
--- /dev/null
+++ b/servo/components/style/style_resolver.rs
@@ -0,0 +1,585 @@
+/* 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/. */
+
+//! Style resolution for a given element or pseudo-element.
+
+use crate::applicable_declarations::ApplicableDeclarationList;
+use crate::computed_value_flags::ComputedValueFlags;
+use crate::context::{CascadeInputs, ElementCascadeInputs, StyleContext};
+use crate::data::{EagerPseudoStyles, ElementStyles};
+use crate::dom::TElement;
+use crate::matching::MatchMethods;
+use crate::properties::longhands::display::computed_value::T as Display;
+use crate::properties::{ComputedValues, FirstLineReparenting};
+use crate::rule_tree::StrongRuleNode;
+use crate::selector_parser::{PseudoElement, SelectorImpl};
+use crate::stylist::RuleInclusion;
+use log::Level::Trace;
+use selectors::matching::{
+ MatchingContext, MatchingForInvalidation, MatchingMode, NeedsSelectorFlags, VisitedHandlingMode,
+};
+use servo_arc::Arc;
+
+/// Whether pseudo-elements should be resolved or not.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PseudoElementResolution {
+ /// Only resolve pseudo-styles if possibly applicable.
+ IfApplicable,
+ /// Force pseudo-element resolution.
+ Force,
+}
+
+/// A struct that takes care of resolving the style of a given element.
+pub struct StyleResolverForElement<'a, 'ctx, 'le, E>
+where
+ 'ctx: 'a,
+ 'le: 'ctx,
+ E: TElement + MatchMethods + 'le,
+{
+ element: E,
+ context: &'a mut StyleContext<'ctx, E>,
+ rule_inclusion: RuleInclusion,
+ pseudo_resolution: PseudoElementResolution,
+ _marker: ::std::marker::PhantomData<&'le E>,
+}
+
+struct MatchingResults {
+ rule_node: StrongRuleNode,
+ flags: ComputedValueFlags,
+}
+
+/// A style returned from the resolver machinery.
+pub struct ResolvedStyle(pub Arc<ComputedValues>);
+
+/// The primary style of an element or an element-backed pseudo-element.
+pub struct PrimaryStyle {
+ /// The style itself.
+ pub style: ResolvedStyle,
+ /// Whether the style was reused from another element via the rule node (see
+ /// `StyleSharingCache::lookup_by_rules`).
+ pub reused_via_rule_node: bool,
+}
+
+/// A set of style returned from the resolver machinery.
+pub struct ResolvedElementStyles {
+ /// Primary style.
+ pub primary: PrimaryStyle,
+ /// Pseudo styles.
+ pub pseudos: EagerPseudoStyles,
+}
+
+impl ResolvedElementStyles {
+ /// Convenience accessor for the primary style.
+ pub fn primary_style(&self) -> &Arc<ComputedValues> {
+ &self.primary.style.0
+ }
+
+ /// Convenience mutable accessor for the style.
+ pub fn primary_style_mut(&mut self) -> &mut Arc<ComputedValues> {
+ &mut self.primary.style.0
+ }
+}
+
+impl PrimaryStyle {
+ /// Convenience accessor for the style.
+ pub fn style(&self) -> &ComputedValues {
+ &*self.style.0
+ }
+}
+
+impl From<ResolvedElementStyles> for ElementStyles {
+ fn from(r: ResolvedElementStyles) -> ElementStyles {
+ ElementStyles {
+ primary: Some(r.primary.style.0),
+ pseudos: r.pseudos,
+ }
+ }
+}
+
+fn with_default_parent_styles<E, F, R>(element: E, f: F) -> R
+where
+ E: TElement,
+ F: FnOnce(Option<&ComputedValues>, Option<&ComputedValues>) -> R,
+{
+ let parent_el = element.inheritance_parent();
+ let parent_data = parent_el.as_ref().and_then(|e| e.borrow_data());
+ let parent_style = parent_data.as_ref().map(|d| d.styles.primary());
+
+ let mut layout_parent_el = parent_el.clone();
+ let layout_parent_data;
+ let mut layout_parent_style = parent_style;
+ if parent_style.map_or(false, |s| s.is_display_contents()) {
+ layout_parent_el = Some(layout_parent_el.unwrap().layout_parent());
+ layout_parent_data = layout_parent_el.as_ref().unwrap().borrow_data().unwrap();
+ layout_parent_style = Some(layout_parent_data.styles.primary());
+ }
+
+ f(
+ parent_style.map(|x| &**x),
+ layout_parent_style.map(|s| &**s),
+ )
+}
+
+fn layout_parent_style_for_pseudo<'a>(
+ primary_style: &'a PrimaryStyle,
+ layout_parent_style: Option<&'a ComputedValues>,
+) -> Option<&'a ComputedValues> {
+ if primary_style.style().is_display_contents() {
+ layout_parent_style
+ } else {
+ Some(primary_style.style())
+ }
+}
+
+fn eager_pseudo_is_definitely_not_generated(
+ pseudo: &PseudoElement,
+ style: &ComputedValues,
+) -> bool {
+ if !pseudo.is_before_or_after() {
+ return false;
+ }
+
+ if !style
+ .flags
+ .intersects(ComputedValueFlags::DISPLAY_DEPENDS_ON_INHERITED_STYLE) &&
+ style.get_box().clone_display() == Display::None
+ {
+ return true;
+ }
+
+ if !style
+ .flags
+ .intersects(ComputedValueFlags::CONTENT_DEPENDS_ON_INHERITED_STYLE) &&
+ style.ineffective_content_property()
+ {
+ return true;
+ }
+
+ false
+}
+
+impl<'a, 'ctx, 'le, E> StyleResolverForElement<'a, 'ctx, 'le, E>
+where
+ 'ctx: 'a,
+ 'le: 'ctx,
+ E: TElement + MatchMethods + 'le,
+{
+ /// Trivially construct a new StyleResolverForElement.
+ pub fn new(
+ element: E,
+ context: &'a mut StyleContext<'ctx, E>,
+ rule_inclusion: RuleInclusion,
+ pseudo_resolution: PseudoElementResolution,
+ ) -> Self {
+ Self {
+ element,
+ context,
+ rule_inclusion,
+ pseudo_resolution,
+ _marker: ::std::marker::PhantomData,
+ }
+ }
+
+ /// Resolve just the style of a given element.
+ pub fn resolve_primary_style(
+ &mut self,
+ parent_style: Option<&ComputedValues>,
+ layout_parent_style: Option<&ComputedValues>,
+ ) -> PrimaryStyle {
+ let primary_results = self.match_primary(VisitedHandlingMode::AllLinksUnvisited);
+
+ let inside_link = parent_style.map_or(false, |s| s.visited_style().is_some());
+
+ let visited_rules = if self.context.shared.visited_styles_enabled &&
+ (inside_link || self.element.is_link())
+ {
+ let visited_matching_results =
+ self.match_primary(VisitedHandlingMode::RelevantLinkVisited);
+ Some(visited_matching_results.rule_node)
+ } else {
+ None
+ };
+
+ self.cascade_primary_style(
+ CascadeInputs {
+ rules: Some(primary_results.rule_node),
+ visited_rules,
+ flags: primary_results.flags,
+ },
+ parent_style,
+ layout_parent_style,
+ )
+ }
+
+ fn cascade_primary_style(
+ &mut self,
+ inputs: CascadeInputs,
+ parent_style: Option<&ComputedValues>,
+ layout_parent_style: Option<&ComputedValues>,
+ ) -> PrimaryStyle {
+ // Before doing the cascade, check the sharing cache and see if we can
+ // reuse the style via rule node identity.
+ let may_reuse = self.element.matches_user_and_content_rules() &&
+ parent_style.is_some() &&
+ inputs.rules.is_some() &&
+ // If this style was considered in any way for relative selector matching,
+ // we do not want to lose that fact by sharing a style with something that
+ // did not.
+ !inputs.flags.contains(ComputedValueFlags::CONSIDERED_RELATIVE_SELECTOR);
+
+ if may_reuse {
+ let cached = self.context.thread_local.sharing_cache.lookup_by_rules(
+ self.context.shared,
+ parent_style.unwrap(),
+ inputs.rules.as_ref().unwrap(),
+ inputs.visited_rules.as_ref(),
+ self.element,
+ );
+ if let Some(mut primary_style) = cached {
+ self.context.thread_local.statistics.styles_reused += 1;
+ primary_style.reused_via_rule_node |= true;
+ return primary_style;
+ }
+ }
+
+ // No style to reuse. Cascade the style, starting with visited style
+ // if necessary.
+ PrimaryStyle {
+ style: self.cascade_style_and_visited(
+ inputs,
+ parent_style,
+ layout_parent_style,
+ /* pseudo = */ None,
+ ),
+ reused_via_rule_node: false,
+ }
+ }
+
+ /// Resolve the style of a given element, and all its eager pseudo-elements.
+ pub fn resolve_style(
+ &mut self,
+ parent_style: Option<&ComputedValues>,
+ layout_parent_style: Option<&ComputedValues>,
+ ) -> ResolvedElementStyles {
+ let primary_style = self.resolve_primary_style(parent_style, layout_parent_style);
+
+ let mut pseudo_styles = EagerPseudoStyles::default();
+
+ if !self.element.is_pseudo_element() {
+ let layout_parent_style_for_pseudo =
+ layout_parent_style_for_pseudo(&primary_style, layout_parent_style);
+ SelectorImpl::each_eagerly_cascaded_pseudo_element(|pseudo| {
+ let pseudo_style = self.resolve_pseudo_style(
+ &pseudo,
+ &primary_style,
+ layout_parent_style_for_pseudo,
+ );
+
+ if let Some(style) = pseudo_style {
+ if !matches!(self.pseudo_resolution, PseudoElementResolution::Force) &&
+ eager_pseudo_is_definitely_not_generated(&pseudo, &style.0)
+ {
+ return;
+ }
+ pseudo_styles.set(&pseudo, style.0);
+ }
+ })
+ }
+
+ ResolvedElementStyles {
+ primary: primary_style,
+ pseudos: pseudo_styles,
+ }
+ }
+
+ /// Resolve an element's styles with the default inheritance parent/layout
+ /// parents.
+ pub fn resolve_style_with_default_parents(&mut self) -> ResolvedElementStyles {
+ with_default_parent_styles(self.element, |parent_style, layout_parent_style| {
+ self.resolve_style(parent_style, layout_parent_style)
+ })
+ }
+
+ /// Cascade a set of rules, using the default parent for inheritance.
+ pub fn cascade_style_and_visited_with_default_parents(
+ &mut self,
+ inputs: CascadeInputs,
+ ) -> ResolvedStyle {
+ with_default_parent_styles(self.element, |parent_style, layout_parent_style| {
+ self.cascade_style_and_visited(
+ inputs,
+ parent_style,
+ layout_parent_style,
+ /* pseudo = */ None,
+ )
+ })
+ }
+
+ /// Cascade a set of rules for pseudo element, using the default parent for inheritance.
+ pub fn cascade_style_and_visited_for_pseudo_with_default_parents(
+ &mut self,
+ inputs: CascadeInputs,
+ pseudo: &PseudoElement,
+ primary_style: &PrimaryStyle,
+ ) -> ResolvedStyle {
+ with_default_parent_styles(self.element, |_, layout_parent_style| {
+ let layout_parent_style_for_pseudo =
+ layout_parent_style_for_pseudo(primary_style, layout_parent_style);
+
+ self.cascade_style_and_visited(
+ inputs,
+ Some(primary_style.style()),
+ layout_parent_style_for_pseudo,
+ Some(pseudo),
+ )
+ })
+ }
+
+ fn cascade_style_and_visited(
+ &mut self,
+ inputs: CascadeInputs,
+ parent_style: Option<&ComputedValues>,
+ layout_parent_style: Option<&ComputedValues>,
+ pseudo: Option<&PseudoElement>,
+ ) -> ResolvedStyle {
+ debug_assert!(pseudo.map_or(true, |p| p.is_eager()));
+
+ let implemented_pseudo = self.element.implemented_pseudo_element();
+ let pseudo = pseudo.or(implemented_pseudo.as_ref());
+
+ let mut conditions = Default::default();
+ let values = self.context.shared.stylist.cascade_style_and_visited(
+ Some(self.element),
+ pseudo,
+ inputs,
+ &self.context.shared.guards,
+ parent_style,
+ layout_parent_style,
+ FirstLineReparenting::No,
+ Some(&self.context.thread_local.rule_cache),
+ &mut conditions,
+ );
+
+ self.context.thread_local.rule_cache.insert_if_possible(
+ &self.context.shared.guards,
+ &values,
+ pseudo,
+ &conditions,
+ );
+
+ ResolvedStyle(values)
+ }
+
+ /// Cascade the element and pseudo-element styles with the default parents.
+ pub fn cascade_styles_with_default_parents(
+ &mut self,
+ inputs: ElementCascadeInputs,
+ ) -> ResolvedElementStyles {
+ with_default_parent_styles(self.element, move |parent_style, layout_parent_style| {
+ let primary_style =
+ self.cascade_primary_style(inputs.primary, parent_style, layout_parent_style);
+
+ let mut pseudo_styles = EagerPseudoStyles::default();
+ if let Some(mut pseudo_array) = inputs.pseudos.into_array() {
+ let layout_parent_style_for_pseudo = if primary_style.style().is_display_contents()
+ {
+ layout_parent_style
+ } else {
+ Some(primary_style.style())
+ };
+
+ for (i, inputs) in pseudo_array.iter_mut().enumerate() {
+ if let Some(inputs) = inputs.take() {
+ let pseudo = PseudoElement::from_eager_index(i);
+
+ let style = self.cascade_style_and_visited(
+ inputs,
+ Some(primary_style.style()),
+ layout_parent_style_for_pseudo,
+ Some(&pseudo),
+ );
+
+ if !matches!(self.pseudo_resolution, PseudoElementResolution::Force) &&
+ eager_pseudo_is_definitely_not_generated(&pseudo, &style.0)
+ {
+ continue;
+ }
+
+ pseudo_styles.set(&pseudo, style.0);
+ }
+ }
+ }
+
+ ResolvedElementStyles {
+ primary: primary_style,
+ pseudos: pseudo_styles,
+ }
+ })
+ }
+
+ fn resolve_pseudo_style(
+ &mut self,
+ pseudo: &PseudoElement,
+ originating_element_style: &PrimaryStyle,
+ layout_parent_style: Option<&ComputedValues>,
+ ) -> Option<ResolvedStyle> {
+ let MatchingResults {
+ rule_node,
+ mut flags,
+ } = self.match_pseudo(
+ &originating_element_style.style.0,
+ pseudo,
+ VisitedHandlingMode::AllLinksUnvisited,
+ )?;
+
+ let mut visited_rules = None;
+ if originating_element_style.style().visited_style().is_some() {
+ visited_rules = self
+ .match_pseudo(
+ &originating_element_style.style.0,
+ pseudo,
+ VisitedHandlingMode::RelevantLinkVisited,
+ )
+ .map(|results| {
+ flags |= results.flags;
+ results.rule_node
+ });
+ }
+
+ Some(self.cascade_style_and_visited(
+ CascadeInputs {
+ rules: Some(rule_node),
+ visited_rules,
+ flags,
+ },
+ Some(originating_element_style.style()),
+ layout_parent_style,
+ Some(pseudo),
+ ))
+ }
+
+ fn match_primary(&mut self, visited_handling: VisitedHandlingMode) -> MatchingResults {
+ debug!(
+ "Match primary for {:?}, visited: {:?}",
+ self.element, visited_handling
+ );
+ let mut applicable_declarations = ApplicableDeclarationList::new();
+
+ let bloom_filter = self.context.thread_local.bloom_filter.filter();
+ let selector_caches = &mut self.context.thread_local.selector_caches;
+ let mut matching_context = MatchingContext::new_for_visited(
+ MatchingMode::Normal,
+ Some(bloom_filter),
+ selector_caches,
+ visited_handling,
+ self.context.shared.quirks_mode(),
+ NeedsSelectorFlags::Yes,
+ MatchingForInvalidation::No,
+ );
+
+ let stylist = &self.context.shared.stylist;
+ let implemented_pseudo = self.element.implemented_pseudo_element();
+ // Compute the primary rule node.
+ stylist.push_applicable_declarations(
+ self.element,
+ implemented_pseudo.as_ref(),
+ self.element.style_attribute(),
+ self.element.smil_override(),
+ self.element.animation_declarations(self.context.shared),
+ self.rule_inclusion,
+ &mut applicable_declarations,
+ &mut matching_context,
+ );
+
+ // FIXME(emilio): This is a hack for animations, and should go away.
+ self.element.unset_dirty_style_attribute();
+
+ let rule_node = stylist
+ .rule_tree()
+ .compute_rule_node(&mut applicable_declarations, &self.context.shared.guards);
+
+ if log_enabled!(Trace) {
+ trace!("Matched rules for {:?}:", self.element);
+ for rn in rule_node.self_and_ancestors() {
+ let source = rn.style_source();
+ if source.is_some() {
+ trace!(" > {:?}", source);
+ }
+ }
+ }
+
+ MatchingResults {
+ rule_node,
+ flags: matching_context.extra_data.cascade_input_flags,
+ }
+ }
+
+ fn match_pseudo(
+ &mut self,
+ originating_element_style: &ComputedValues,
+ pseudo_element: &PseudoElement,
+ visited_handling: VisitedHandlingMode,
+ ) -> Option<MatchingResults> {
+ debug!(
+ "Match pseudo {:?} for {:?}, visited: {:?}",
+ self.element, pseudo_element, visited_handling
+ );
+ debug_assert!(pseudo_element.is_eager());
+ debug_assert!(
+ !self.element.is_pseudo_element(),
+ "Element pseudos can't have any other eager pseudo."
+ );
+
+ let mut applicable_declarations = ApplicableDeclarationList::new();
+
+ let stylist = &self.context.shared.stylist;
+
+ if !self
+ .element
+ .may_generate_pseudo(pseudo_element, originating_element_style)
+ {
+ return None;
+ }
+
+ let bloom_filter = self.context.thread_local.bloom_filter.filter();
+ let selector_caches = &mut self.context.thread_local.selector_caches;
+
+ let mut matching_context = MatchingContext::<'_, E::Impl>::new_for_visited(
+ MatchingMode::ForStatelessPseudoElement,
+ Some(bloom_filter),
+ selector_caches,
+ visited_handling,
+ self.context.shared.quirks_mode(),
+ NeedsSelectorFlags::Yes,
+ MatchingForInvalidation::No,
+ );
+ matching_context.extra_data.originating_element_style = Some(originating_element_style);
+
+ // NB: We handle animation rules for ::before and ::after when
+ // traversing them.
+ stylist.push_applicable_declarations(
+ self.element,
+ Some(pseudo_element),
+ None,
+ None,
+ /* animation_declarations = */ Default::default(),
+ self.rule_inclusion,
+ &mut applicable_declarations,
+ &mut matching_context,
+ );
+
+ if applicable_declarations.is_empty() {
+ return None;
+ }
+
+ let rule_node = stylist
+ .rule_tree()
+ .compute_rule_node(&mut applicable_declarations, &self.context.shared.guards);
+
+ Some(MatchingResults {
+ rule_node,
+ flags: matching_context.extra_data.cascade_input_flags,
+ })
+ }
+}