From a7882cfeb9e5ecb7fdc2d91f9c6ddae42d730660 Mon Sep 17 00:00:00 2001 From: "J. Ryan Stinnett" Date: Thu, 4 May 2017 18:54:20 -0500 Subject: [PATCH] Match and cascade visited styles To support visited styles, we match and cascade a separate set of styles any time we notice that an element has a relevant link. The visited rules and values are held in `ComputedStyle` alongside the regular rules and values, which simplifies supporting various APIs like `cascade_primary_and_pseudos` which expect easy access to previously matched rules. To simplify passing the additional values around, an additional reference to the visited `ComputedValues` is placed inside the regular `ComputedValues`. MozReview-Commit-ID: 2ebbjcfkfWf --- components/selectors/matching.rs | 24 +- components/style/animation.rs | 3 + components/style/data.rs | 167 ++++++- components/style/matching.rs | 473 +++++++++++++----- components/style/properties/gecko.mako.rs | 25 + .../style/properties/properties.mako.rs | 38 ++ components/style/rule_tree/mod.rs | 15 + components/style/stylist.rs | 8 + ports/geckolib/glue.rs | 9 + 9 files changed, 621 insertions(+), 141 deletions(-) diff --git a/components/selectors/matching.rs b/components/selectors/matching.rs index 439308754fe..521bcb3b815 100644 --- a/components/selectors/matching.rs +++ b/components/selectors/matching.rs @@ -75,7 +75,7 @@ impl ElementSelectorFlags { /// /// There are two modes of selector matching. The difference is only noticeable /// in presence of pseudo-elements. -#[derive(Debug, PartialEq)] +#[derive(Debug, PartialEq, Copy, Clone)] pub enum MatchingMode { /// Don't ignore any pseudo-element selectors. Normal, @@ -108,13 +108,14 @@ pub enum VisitedHandlingMode { /// Data associated with the matching process for a element. This context is /// used across many selectors for an element, so it's not appropriate for /// transient data that applies to only a single selector. +#[derive(Clone)] pub struct MatchingContext<'a> { /// Output that records certains relations between elements noticed during /// matching (and also extended after matching). pub relations: StyleRelations, - /// The matching mode we should use when matching selectors. + /// Input with the matching mode we should use when matching selectors. pub matching_mode: MatchingMode, - /// The bloom filter used to fast-reject selectors. + /// Input with the bloom filter used to fast-reject selectors. pub bloom_filter: Option<&'a BloomFilter>, /// Input that controls how matching for links is handled. pub visited_handling: VisitedHandlingMode, @@ -122,7 +123,7 @@ pub struct MatchingContext<'a> { /// matching _any_ selector for this element. (This differs from /// `RelevantLinkStatus` which tracks the status for the _current_ selector /// only.) - relevant_link_found: bool, + pub relevant_link_found: bool, } impl<'a> MatchingContext<'a> { @@ -139,6 +140,21 @@ impl<'a> MatchingContext<'a> { relevant_link_found: false, } } + + /// Constructs a new `MatchingContext` for use in visited matching. + pub fn new_for_visited(matching_mode: MatchingMode, + bloom_filter: Option<&'a BloomFilter>, + visited_handling: VisitedHandlingMode) + -> Self + { + Self { + relations: StyleRelations::empty(), + matching_mode: matching_mode, + bloom_filter: bloom_filter, + visited_handling: visited_handling, + relevant_link_found: false, + } + } } pub fn matches_selector_list(selector_list: &[Selector], diff --git a/components/style/animation.rs b/components/style/animation.rs index 4761fde0f28..8d670964ec8 100644 --- a/components/style/animation.rs +++ b/components/style/animation.rs @@ -475,6 +475,8 @@ fn compute_style_for_animation_step(context: &SharedStyleContext, guard.declarations().iter().rev().map(|&(ref decl, _importance)| decl) }; + // This currently ignores visited styles, which seems acceptable, + // as existing browsers don't appear to animate visited styles. let computed = properties::apply_declarations(context.stylist.device(), /* is_root = */ false, @@ -482,6 +484,7 @@ fn compute_style_for_animation_step(context: &SharedStyleContext, previous_style, previous_style, /* cascade_info = */ None, + /* visited_style = */ None, &*context.error_reporter, font_metrics_provider, CascadeFlags::empty(), diff --git a/components/style/data.rs b/components/style/data.rs index a0d694b9518..e2cd53abbd9 100644 --- a/components/style/data.rs +++ b/components/style/data.rs @@ -11,6 +11,7 @@ use properties::longhands::display::computed_value as display; use restyle_hints::{HintComputationContext, RestyleReplacements, RestyleHint}; use rule_tree::StrongRuleNode; use selector_parser::{EAGER_PSEUDO_COUNT, PseudoElement, RestyleDamage}; +use selectors::matching::VisitedHandlingMode; use shared_lock::{Locked, StylesheetGuards}; use std::fmt; use stylearc::Arc; @@ -29,6 +30,21 @@ pub struct ComputedStyle { /// matched rules. This can only be none during a transient interval of /// the styling algorithm, and callers can safely unwrap it. pub values: Option>, + + /// The rule node representing the ordered list of rules matched for this + /// node if visited, only computed if there's a relevant link for this + /// element. A element's "relevant link" is the element being matched if it + /// is a link or the nearest ancestor link. + visited_rules: Option, + + /// The element's computed values if visited, only computed if there's a + /// relevant link for this element. A element's "relevant link" is the + /// element being matched if it is a link or the nearest ancestor link. + /// + /// We also store a reference to this inside the regular ComputedValues to + /// avoid refactoring all APIs to become aware of multiple ComputedValues + /// objects. + visited_values: Option>, } impl ComputedStyle { @@ -37,6 +53,8 @@ impl ComputedStyle { ComputedStyle { rules: rules, values: Some(values), + visited_rules: None, + visited_values: None, } } @@ -46,6 +64,8 @@ impl ComputedStyle { ComputedStyle { rules: rules, values: None, + visited_rules: None, + visited_values: None, } } @@ -55,9 +75,58 @@ impl ComputedStyle { self.values.as_ref().unwrap() } - /// Mutable version of the above. - pub fn values_mut(&mut self) -> &mut Arc { - self.values.as_mut().unwrap() + /// Whether there are any visited rules. + pub fn has_visited_rules(&self) -> bool { + self.visited_rules.is_some() + } + + /// Gets a reference to the visited rule node, if any. + pub fn get_visited_rules(&self) -> Option<&StrongRuleNode> { + self.visited_rules.as_ref() + } + + /// Gets a reference to the visited rule node. Panic if the element does not + /// have visited rule node. + pub fn visited_rules(&self) -> &StrongRuleNode { + self.get_visited_rules().unwrap() + } + + /// Sets the visited rule node, and returns whether it changed. + pub fn set_visited_rules(&mut self, rules: StrongRuleNode) -> bool { + if let Some(ref old_rules) = self.visited_rules { + if *old_rules == rules { + return false + } + } + self.visited_rules = Some(rules); + true + } + + /// Takes the visited rule node. + pub fn take_visited_rules(&mut self) -> Option { + self.visited_rules.take() + } + + /// Gets a reference to the visited computed values. Panic if the element + /// does not have visited computed values. + pub fn visited_values(&self) -> &Arc { + self.visited_values.as_ref().unwrap() + } + + /// Sets the visited computed values. + pub fn set_visited_values(&mut self, values: Arc) { + self.visited_values = Some(values); + } + + /// Take the visited computed values. + pub fn take_visited_values(&mut self) -> Option> { + self.visited_values.take() + } + + /// Clone the visited computed values Arc. Used to store a reference to the + /// visited values inside the regular values. + pub fn clone_visited_values(&self) -> Option> { + self.visited_values.clone() } } @@ -106,7 +175,7 @@ impl EagerPseudoStyles { } /// Removes a pseudo-element style if it exists, and returns it. - pub fn take(&mut self, pseudo: &PseudoElement) -> Option { + fn take(&mut self, pseudo: &PseudoElement) -> Option { let result = match self.0.as_mut() { None => return None, Some(arr) => arr[pseudo.eager_index()].take(), @@ -131,15 +200,93 @@ impl EagerPseudoStyles { v } - /// Sets the rule node for a given pseudo-element, which must already have an entry. + /// Adds the unvisited rule node for a given pseudo-element, which may or + /// may not exist. /// - /// Returns true if the rule node changed. - pub fn set_rules(&mut self, pseudo: &PseudoElement, rules: StrongRuleNode) -> bool { + /// Returns true if the pseudo-element is new. + fn add_unvisited_rules(&mut self, + pseudo: &PseudoElement, + rules: StrongRuleNode) + -> bool { + if let Some(mut style) = self.get_mut(pseudo) { + style.rules = rules; + return false + } + self.insert(pseudo, ComputedStyle::new_partial(rules)); + true + } + + /// Remove the unvisited rule node for a given pseudo-element, which may or + /// may not exist. Since removing the rule node implies we don't need any + /// other data for the pseudo, take the entire pseudo if found. + /// + /// Returns true if the pseudo-element was removed. + fn remove_unvisited_rules(&mut self, pseudo: &PseudoElement) -> bool { + self.take(pseudo).is_some() + } + + /// Adds the visited rule node for a given pseudo-element. It is assumed to + /// already exist because unvisited styles should have been added first. + /// + /// Returns true if the pseudo-element is new. (Always false, but returns a + /// bool for parity with `add_unvisited_rules`.) + fn add_visited_rules(&mut self, + pseudo: &PseudoElement, + rules: StrongRuleNode) + -> bool { debug_assert!(self.has(pseudo)); let mut style = self.get_mut(pseudo).unwrap(); - let changed = style.rules != rules; - style.rules = rules; - changed + style.set_visited_rules(rules); + false + } + + /// Remove the visited rule node for a given pseudo-element, which may or + /// may not exist. + /// + /// Returns true if the psuedo-element was removed. (Always false, but + /// returns a bool for parity with `remove_unvisited_rules`.) + fn remove_visited_rules(&mut self, pseudo: &PseudoElement) -> bool { + if let Some(mut style) = self.get_mut(pseudo) { + style.take_visited_rules(); + } + false + } + + /// Adds a rule node for a given pseudo-element, which may or may not exist. + /// The type of rule node depends on the visited mode. + /// + /// Returns true if the pseudo-element is new. + pub fn add_rules(&mut self, + pseudo: &PseudoElement, + visited_handling: VisitedHandlingMode, + rules: StrongRuleNode) + -> bool { + match visited_handling { + VisitedHandlingMode::AllLinksUnvisited => { + self.add_unvisited_rules(&pseudo, rules) + }, + VisitedHandlingMode::RelevantLinkVisited => { + self.add_visited_rules(&pseudo, rules) + }, + } + } + + /// Removes a rule node for a given pseudo-element, which may or may not + /// exist. The type of rule node depends on the visited mode. + /// + /// Returns true if the psuedo-element was removed. + pub fn remove_rules(&mut self, + pseudo: &PseudoElement, + visited_handling: VisitedHandlingMode) + -> bool { + match visited_handling { + VisitedHandlingMode::AllLinksUnvisited => { + self.remove_unvisited_rules(&pseudo) + }, + VisitedHandlingMode::RelevantLinkVisited => { + self.remove_visited_rules(&pseudo) + }, + } } } diff --git a/components/style/matching.rs b/components/style/matching.rs index df5ac723097..2baf91cf731 100644 --- a/components/style/matching.rs +++ b/components/style/matching.rs @@ -17,11 +17,10 @@ use properties::{AnimationRules, CascadeFlags, ComputedValues, SKIP_ROOT_AND_ITE use properties::longhands::display::computed_value as display; use restyle_hints::{RESTYLE_CSS_ANIMATIONS, RESTYLE_CSS_TRANSITIONS, RestyleReplacements}; use restyle_hints::{RESTYLE_STYLE_ATTRIBUTE, RESTYLE_SMIL}; -use rule_tree::{CascadeLevel, RuleTree, StrongRuleNode}; +use rule_tree::{CascadeLevel, StrongRuleNode}; use selector_parser::{PseudoElement, RestyleDamage, SelectorImpl}; use selectors::matching::{ElementSelectorFlags, MatchingContext, MatchingMode, StyleRelations}; -use selectors::matching::AFFECTED_BY_PSEUDO_ELEMENTS; -use shared_lock::StylesheetGuards; +use selectors::matching::{VisitedHandlingMode, AFFECTED_BY_PSEUDO_ELEMENTS}; use sharing::{StyleSharingBehavior, StyleSharingResult}; use stylearc::Arc; use stylist::ApplicableDeclarationList; @@ -92,15 +91,6 @@ impl From for ChildCascadeRequirement { } } -/// The result status for match primary rules. -#[derive(Debug)] -pub struct RulesMatchedResult { - /// Indicate that the rule nodes are changed. - rule_nodes_changed: bool, - /// Indicate that there are any changes of important rules overriding animations. - important_rules_overriding_animation_changed: bool, -} - bitflags! { /// Flags that represent the result of replace_rules. pub flags RulesChanged: u8 { @@ -125,6 +115,87 @@ impl RulesChanged { } } +/// Determines which styles are being cascaded currently. +#[derive(PartialEq, Eq, Copy, Clone, Debug)] +pub enum CascadeVisitedMode { + /// Cascade the regular, unvisited styles. + Unvisited, + /// Cascade the styles used when an element's relevant link is visited. A + /// "relevant link" is the element being matched if it is a link or the + /// nearest ancestor link. + Visited, +} + +/// Various helper methods to ease navigating the style storage locations +/// depending on the current cascade mode. +impl CascadeVisitedMode { + /// Returns whether there is a rule node based on the cascade mode. + fn has_rules(&self, style: &ComputedStyle) -> bool { + match *self { + CascadeVisitedMode::Unvisited => true, + CascadeVisitedMode::Visited => style.has_visited_rules(), + } + } + + /// Returns the rule node based on the cascade mode. + fn rules<'a>(&self, style: &'a ComputedStyle) -> &'a StrongRuleNode { + match *self { + CascadeVisitedMode::Unvisited => &style.rules, + CascadeVisitedMode::Visited => style.visited_rules(), + } + } + + /// Returns the computed values based on the cascade mode. In visited mode, + /// visited values are only returned if they already exist. If they don't, + /// we fallback to the regular, unvisited styles. + fn values<'a>(&self, style: &'a ComputedStyle) -> &'a Arc { + let mut values = style.values(); + + if *self == CascadeVisitedMode::Visited && values.get_visited_style().is_some() { + values = values.visited_style(); + } + + values + } + + /// Set the computed values based on the cascade mode. + fn set_values(&self, style: &mut ComputedStyle, values: Arc) { + match *self { + CascadeVisitedMode::Unvisited => style.values = Some(values), + CascadeVisitedMode::Visited => style.set_visited_values(values), + } + } + + /// Take the computed values based on the cascade mode. + fn take_values(&self, style: &mut ComputedStyle) -> Option> { + match *self { + CascadeVisitedMode::Unvisited => style.values.take(), + CascadeVisitedMode::Visited => style.take_visited_values(), + } + } + + /// Returns whether there might be visited values that should be inserted + /// within the regular computed values based on the cascade mode. + fn visited_values_for_insertion(&self) -> bool { + *self == CascadeVisitedMode::Unvisited + } + + /// Returns whether animations should be processed based on the cascade + /// mode. At the moment, it appears we don't need to support animating + /// visited styles. + fn should_process_animations(&self) -> bool { + *self == CascadeVisitedMode::Unvisited + } + + /// Returns whether we should accumulate restyle damage based on the cascade + /// mode. At the moment, it appears we don't need to do so for visited + /// styles. TODO: Verify this is correct as part of + /// https://bugzilla.mozilla.org/show_bug.cgi?id=1364484. + fn should_accumulate_damage(&self) -> bool { + *self == CascadeVisitedMode::Unvisited + } +} + trait PrivateMatchMethods: TElement { /// Returns the closest parent element that doesn't have a display: contents /// style (and thus generates a box). @@ -158,7 +229,9 @@ trait PrivateMatchMethods: TElement { font_metrics_provider: &FontMetricsProvider, rule_node: &StrongRuleNode, primary_style: &ComputedStyle, - inherit_mode: InheritMode) + inherit_mode: InheritMode, + cascade_visited: CascadeVisitedMode, + visited_values_to_insert: Option>) -> Arc { let mut cascade_info = CascadeInfo::new(); let mut cascade_flags = CascadeFlags::empty(); @@ -173,7 +246,7 @@ trait PrivateMatchMethods: TElement { InheritMode::Normal => { parent_el = self.inheritance_parent(); parent_data = parent_el.as_ref().and_then(|e| e.borrow_data()); - let parent_values = parent_data.as_ref().map(|d| { + let parent_style = parent_data.as_ref().map(|d| { // Sometimes Gecko eagerly styles things without processing // pending restyles first. In general we'd like to avoid this, // but there can be good reasons (for example, needing to @@ -182,14 +255,13 @@ trait PrivateMatchMethods: TElement { // but not wanting to flush all of layout). debug_assert!(cfg!(feature = "gecko") || parent_el.unwrap().has_current_styles(d)); - d.styles().primary.values() + &d.styles().primary }); - - parent_values + parent_style.map(|s| cascade_visited.values(s)) } InheritMode::FromPrimaryStyle => { parent_el = Some(self.clone()); - Some(primary_style.values()) + Some(cascade_visited.values(primary_style)) } }; @@ -199,7 +271,7 @@ trait PrivateMatchMethods: TElement { if style_to_inherit_from.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.values()) + layout_parent_style = Some(cascade_visited.values(&layout_parent_data.styles().primary)); } let style_to_inherit_from = style_to_inherit_from.map(|x| &**x); @@ -227,6 +299,7 @@ trait PrivateMatchMethods: TElement { &shared_context.guards, style_to_inherit_from, layout_parent_style, + visited_values_to_insert, Some(&mut cascade_info), &*shared_context.error_reporter, font_metrics_provider, @@ -240,7 +313,8 @@ trait PrivateMatchMethods: TElement { fn cascade_internal(&self, context: &StyleContext, primary_style: &ComputedStyle, - eager_pseudo_style: Option<&ComputedStyle>) + eager_pseudo_style: Option<&ComputedStyle>, + cascade_visited: CascadeVisitedMode) -> Arc { if let Some(pseudo) = self.implemented_pseudo_element() { debug_assert!(eager_pseudo_style.is_none()); @@ -261,13 +335,26 @@ trait PrivateMatchMethods: TElement { let parent_data = parent.borrow_data().unwrap(); let pseudo_style = parent_data.styles().pseudos.get(&pseudo).unwrap(); - return pseudo_style.values().clone() + let values = cascade_visited.values(pseudo_style); + return values.clone() } } } + // Find possible visited computed styles to insert within the regular + // computed values we are about to create. + let visited_values_to_insert = if cascade_visited.visited_values_for_insertion() { + match eager_pseudo_style { + Some(ref s) => s.clone_visited_values(), + None => primary_style.clone_visited_values(), + } + } else { + None + }; + // Grab the rule node. - let rule_node = &eager_pseudo_style.unwrap_or(primary_style).rules; + let style = eager_pseudo_style.unwrap_or(primary_style); + let rule_node = cascade_visited.rules(style); let inherit_mode = if eager_pseudo_style.is_some() { InheritMode::FromPrimaryStyle } else { @@ -278,27 +365,43 @@ trait PrivateMatchMethods: TElement { &context.thread_local.font_metrics_provider, rule_node, primary_style, - inherit_mode) + inherit_mode, + cascade_visited, + visited_values_to_insert) } - /// Computes values and damage for the primary or pseudo style of an element, - /// setting them on the ElementData. + /// Computes values and damage for the primary style of an element, setting + /// them on the ElementData. fn cascade_primary(&self, context: &mut StyleContext, data: &mut ElementData, - important_rules_changed: bool) + important_rules_changed: bool, + cascade_visited: CascadeVisitedMode) -> ChildCascadeRequirement { + debug!("Cascade primary for {:?}, visited: {:?}", self, cascade_visited); + // Collect some values. let (mut styles, restyle) = data.styles_and_restyle_mut(); let mut primary_style = &mut styles.primary; - let mut old_values = primary_style.values.take(); + // If there was no relevant link, we won't have any visited rules, so + // there may not be anything do for the visited case. This early return + // is especially important for the `cascade_primary_and_pseudos` path + // since we rely on the state of some previous matching run. + if !cascade_visited.has_rules(primary_style) { + return ChildCascadeRequirement::CanSkipCascade + } + let mut old_values = cascade_visited.take_values(primary_style); // Compute the new values. - let mut new_values = self.cascade_internal(context, primary_style, None); + let mut new_values = self.cascade_internal(context, + primary_style, + None, + cascade_visited); // NB: Animations for pseudo-elements in Gecko are handled while // traversing the pseudo-elements themselves. - if !context.shared.traversal_flags.for_animation_only() { + if !context.shared.traversal_flags.for_animation_only() && + cascade_visited.should_process_animations() { self.process_animations(context, &mut old_values, &mut new_values, @@ -306,43 +409,60 @@ trait PrivateMatchMethods: TElement { important_rules_changed); } - let child_cascade_requirement = - self.accumulate_damage(&context.shared, - restyle, - old_values.as_ref().map(|v| v.as_ref()), - &new_values, - None); + let mut child_cascade_requirement = + ChildCascadeRequirement::CanSkipCascade; + if cascade_visited.should_accumulate_damage() { + child_cascade_requirement = + self.accumulate_damage(&context.shared, + restyle, + old_values.as_ref().map(|v| v.as_ref()), + &new_values, + None); + } // Set the new computed values. - primary_style.values = Some(new_values); + cascade_visited.set_values(primary_style, new_values); // Return whether the damage indicates we must cascade new inherited // values into children. child_cascade_requirement } + /// Computes values and damage for the eager pseudo-element styles of an + /// element, setting them on the ElementData. fn cascade_eager_pseudo(&self, context: &mut StyleContext, data: &mut ElementData, - pseudo: &PseudoElement) { + pseudo: &PseudoElement, + cascade_visited: CascadeVisitedMode) { debug_assert!(pseudo.is_eager()); let (mut styles, restyle) = data.styles_and_restyle_mut(); let mut pseudo_style = styles.pseudos.get_mut(pseudo).unwrap(); - let old_values = pseudo_style.values.take(); + // If there was no relevant link, we won't have any visited rules, so + // there may not be anything do for the visited case. This early return + // is especially important for the `cascade_primary_and_pseudos` path + // since we rely on the state of some previous matching run. + if !cascade_visited.has_rules(pseudo_style) { + return + } + let old_values = cascade_visited.take_values(pseudo_style); - let new_values = - self.cascade_internal(context, &styles.primary, Some(pseudo_style)); + let new_values = self.cascade_internal(context, + &styles.primary, + Some(pseudo_style), + cascade_visited); - self.accumulate_damage(&context.shared, - restyle, - old_values.as_ref().map(|v| &**v), - &new_values, - Some(pseudo)); + if cascade_visited.should_accumulate_damage() { + self.accumulate_damage(&context.shared, + restyle, + old_values.as_ref().map(|v| &**v), + &new_values, + Some(pseudo)); + } - pseudo_style.values = Some(new_values) + cascade_visited.set_values(pseudo_style, new_values); } - /// get_after_change_style removes the transition rules from the ComputedValues. /// If there is no transition rule in the ComputedValues, it returns None. #[cfg(feature = "gecko")] @@ -359,11 +479,15 @@ trait PrivateMatchMethods: TElement { return None; } + // This currently ignores visited styles, which seems acceptable, + // as existing browsers don't appear to transition visited styles. Some(self.cascade_with_rules(context.shared, &context.thread_local.font_metrics_provider, &without_transition_rules, primary_style, - InheritMode::Normal)) + InheritMode::Normal, + CascadeVisitedMode::Unvisited, + None)) } #[cfg(feature = "gecko")] @@ -593,17 +717,49 @@ trait PrivateMatchMethods: TElement { } } -fn compute_rule_node(rule_tree: &RuleTree, - applicable_declarations: &mut ApplicableDeclarationList, - guards: &StylesheetGuards) - -> StrongRuleNode -{ - let rules = applicable_declarations.drain().map(|d| (d.source, d.level)); - let rule_node = rule_tree.insert_ordered_rules_with_important(rules, guards); - rule_node +impl PrivateMatchMethods for E {} + +/// Collects the outputs of the primary matching process, including the rule +/// node and other associated data. +#[derive(Debug)] +pub struct MatchingResults { + /// Whether the rules changed. + rules_changed: bool, + /// Whether there are any changes of important rules overriding animations. + important_rules_overriding_animation_changed: bool, + /// Records certains relations between elements noticed during matching (and + /// also extended after matching). + relations: StyleRelations, + /// Whether we encountered a "relevant link" while matching _any_ selector + /// for this element. (This differs from `RelevantLinkStatus` which tracks + /// the status for the _current_ selector only.) + relevant_link_found: bool, } -impl PrivateMatchMethods for E {} +impl MatchingResults { + /// Create `MatchingResults` with only the basic required outputs. + fn new(rules_changed: bool, important_rules: bool) -> Self { + Self { + rules_changed: rules_changed, + important_rules_overriding_animation_changed: important_rules, + relations: StyleRelations::default(), + relevant_link_found: false, + } + } + + /// Create `MatchingResults` from the output fields of `MatchingContext`. + fn new_from_context(rules_changed: bool, + important_rules: bool, + context: MatchingContext) + -> Self { + Self { + rules_changed: rules_changed, + important_rules_overriding_animation_changed: important_rules, + relations: context.relations, + relevant_link_found: context.relevant_link_found, + } + } +} /// The public API that elements expose for selector matching. pub trait MatchMethods : TElement { @@ -615,27 +771,52 @@ pub trait MatchMethods : TElement { sharing: StyleSharingBehavior) -> ChildCascadeRequirement { + debug!("Match and cascade for {:?}", self); + // Perform selector matching for the primary style. - let mut relations = StyleRelations::empty(); - let result = self.match_primary(context, data, &mut relations); + let mut primary_results = + self.match_primary(context, data, VisitedHandlingMode::AllLinksUnvisited); + let important_rules_changed = + primary_results.important_rules_overriding_animation_changed; + + // If there's a relevant link involved, match and cascade primary styles + // as if the link is visited as well. This is done before the regular + // cascade because the visited ComputedValues are placed within the + // regular ComputedValues, which is immutable after the cascade. + let relevant_link_found = primary_results.relevant_link_found; + if relevant_link_found { + self.match_primary(context, data, VisitedHandlingMode::RelevantLinkVisited); + self.cascade_primary(context, data, important_rules_changed, + CascadeVisitedMode::Visited); + } // Cascade properties and compute primary values. let child_cascade_requirement = - self.cascade_primary( - context, - data, - result.important_rules_overriding_animation_changed - ); + self.cascade_primary(context, data, important_rules_changed, + CascadeVisitedMode::Unvisited); // Match and cascade eager pseudo-elements. if !data.styles().is_display_none() { - let _pseudo_rule_nodes_changed = self.match_pseudos(context, data); - self.cascade_pseudos(context, data); + self.match_pseudos(context, data, VisitedHandlingMode::AllLinksUnvisited); + + // If there's a relevant link involved, match and cascade eager + // pseudo-element styles as if the link is visited as well. + // This runs after matching for regular styles because matching adds + // each pseudo as needed to the PseudoMap, and this runs before + // cascade for regular styles because the visited ComputedValues + // are placed within the regular ComputedValues, which is immutable + // after the cascade. + if relevant_link_found { + self.match_pseudos(context, data, VisitedHandlingMode::RelevantLinkVisited); + self.cascade_pseudos(context, data, CascadeVisitedMode::Visited); + } + + self.cascade_pseudos(context, data, CascadeVisitedMode::Unvisited); } // If we have any pseudo elements, indicate so in the primary StyleRelations. if !data.styles().pseudos.is_empty() { - relations |= AFFECTED_BY_PSEUDO_ELEMENTS; + primary_results.relations |= AFFECTED_BY_PSEUDO_ELEMENTS; } // If the style is shareable, add it to the LRU cache. @@ -655,7 +836,7 @@ pub trait MatchMethods : TElement { .style_sharing_candidate_cache .insert_if_possible(self, data.styles().primary.values(), - relations, + primary_results.relations, revalidation_match_results); } @@ -669,22 +850,34 @@ pub trait MatchMethods : TElement { important_rules_changed: bool) -> ChildCascadeRequirement { + // If there's a relevant link involved, cascade styles as if the link is + // visited as well. This is done before the regular cascade because the + // visited ComputedValues are placed within the regular ComputedValues, + // which is immutable after the cascade. If there aren't any visited + // rules, these calls will return without cascading. + self.cascade_primary(context, &mut data, important_rules_changed, + CascadeVisitedMode::Visited); let child_cascade_requirement = - self.cascade_primary(context, &mut data, important_rules_changed); - self.cascade_pseudos(context, &mut data); + self.cascade_primary(context, &mut data, important_rules_changed, + CascadeVisitedMode::Unvisited); + self.cascade_pseudos(context, &mut data, CascadeVisitedMode::Visited); + self.cascade_pseudos(context, &mut data, CascadeVisitedMode::Unvisited); child_cascade_requirement } - /// Runs selector matching to (re)compute the primary rule node for this element. + /// Runs selector matching to (re)compute the primary rule node for this + /// element. /// - /// Returns RulesMatchedResult which indicates whether the primary rule node changed - /// and whether the change includes important rules. + /// Returns `MatchingResults` with the new rules and other associated data + /// from the matching process. fn match_primary(&self, context: &mut StyleContext, data: &mut ElementData, - relations: &mut StyleRelations) - -> RulesMatchedResult + visited_handling: VisitedHandlingMode) + -> MatchingResults { + debug!("Match primary for {:?}, visited: {:?}", self, visited_handling); + let implemented_pseudo = self.implemented_pseudo_element(); if let Some(ref pseudo) = implemented_pseudo { // We don't expect to match against a non-canonical pseudo-element. @@ -731,10 +924,16 @@ pub trait MatchMethods : TElement { data.important_rules_are_different(&rules, &context.shared.guards); - return RulesMatchedResult { - rule_nodes_changed: data.set_primary_rules(rules), - important_rules_overriding_animation_changed: important_rules_changed, + let rules_changed = match visited_handling { + VisitedHandlingMode::AllLinksUnvisited => { + data.set_primary_rules(rules) + }, + VisitedHandlingMode::RelevantLinkVisited => { + data.styles_mut().primary.set_visited_rules(rules) + }, }; + + return MatchingResults::new(rules_changed, important_rules_changed) } } @@ -742,6 +941,18 @@ pub trait MatchMethods : TElement { let stylist = &context.shared.stylist; let style_attribute = self.style_attribute(); + + let map = &mut context.thread_local.selector_flags; + let mut set_selector_flags = |element: &Self, flags: ElementSelectorFlags| { + self.apply_selector_flags(map, element, flags); + }; + + let bloom_filter = context.thread_local.bloom_filter.filter(); + let mut matching_context = + MatchingContext::new_for_visited(MatchingMode::Normal, + Some(bloom_filter), + visited_handling); + { let smil_override = data.get_smil_override(); let animation_rules = if self.may_have_animations() { @@ -749,15 +960,6 @@ pub trait MatchMethods : TElement { } else { AnimationRules(None, None) }; - let bloom = context.thread_local.bloom_filter.filter(); - - let map = &mut context.thread_local.selector_flags; - let mut set_selector_flags = |element: &Self, flags: ElementSelectorFlags| { - self.apply_selector_flags(map, element, flags); - }; - - let mut matching_context = - MatchingContext::new(MatchingMode::Normal, Some(bloom)); // Compute the primary rule node. stylist.push_applicable_declarations(self, @@ -768,14 +970,12 @@ pub trait MatchMethods : TElement { &mut applicable_declarations, &mut matching_context, &mut set_selector_flags); - - *relations = matching_context.relations; } - let primary_rule_node = - compute_rule_node::(stylist.rule_tree(), - &mut applicable_declarations, - &context.shared.guards); + let primary_rule_node = stylist.rule_tree().compute_rule_node( + &mut applicable_declarations, + &context.shared.guards + ); if log_enabled!(Trace) { trace!("Matched rules:"); @@ -794,25 +994,32 @@ pub trait MatchMethods : TElement { &context.shared.guards ); - RulesMatchedResult { - rule_nodes_changed: data.set_primary_rules(primary_rule_node), - important_rules_overriding_animation_changed: important_rules_changed, - } + let rules_changed = match visited_handling { + VisitedHandlingMode::AllLinksUnvisited => { + data.set_primary_rules(primary_rule_node) + }, + VisitedHandlingMode::RelevantLinkVisited => { + data.styles_mut().primary.set_visited_rules(primary_rule_node) + }, + }; + + MatchingResults::new_from_context(rules_changed, + important_rules_changed, + matching_context) } /// Runs selector matching to (re)compute eager pseudo-element rule nodes /// for this element. - /// - /// Returns whether any of the pseudo rule nodes changed (including, but not - /// limited to, cases where we match different pseudos altogether). fn match_pseudos(&self, context: &mut StyleContext, - data: &mut ElementData) - -> bool + data: &mut ElementData, + visited_handling: VisitedHandlingMode) { + debug!("Match pseudos for {:?}, visited: {:?}", self, visited_handling); + if self.implemented_pseudo_element().is_some() { // Element pseudos can't have any other pseudo. - return false; + return; } let mut applicable_declarations = ApplicableDeclarationList::new(); @@ -826,18 +1033,23 @@ pub trait MatchMethods : TElement { // at us later in the closure. let stylist = &context.shared.stylist; let guards = &context.shared.guards; - let rule_tree = stylist.rule_tree(); - let bloom_filter = context.thread_local.bloom_filter.filter(); + let bloom_filter = context.thread_local.bloom_filter.filter(); let mut matching_context = - MatchingContext::new(MatchingMode::ForStatelessPseudoElement, - Some(bloom_filter)); + MatchingContext::new_for_visited(MatchingMode::ForStatelessPseudoElement, + Some(bloom_filter), + visited_handling); // Compute rule nodes for eagerly-cascaded pseudo-elements. let mut matches_different_pseudos = false; - let mut rule_nodes_changed = false; SelectorImpl::each_eagerly_cascaded_pseudo_element(|pseudo| { - let mut pseudos = &mut data.styles_mut().pseudos; + // For pseudo-elements, we only try to match visited rules if there + // are also unvisited rules. (This matches Gecko's behavior.) + if visited_handling == VisitedHandlingMode::RelevantLinkVisited && + !data.styles().pseudos.has(&pseudo) { + return + } + debug_assert!(applicable_declarations.is_empty()); // NB: We handle animation rules for ::before and ::after when // traversing them. @@ -850,32 +1062,32 @@ pub trait MatchMethods : TElement { &mut matching_context, &mut set_selector_flags); + let pseudos = &mut data.styles_mut().pseudos; if !applicable_declarations.is_empty() { - let new_rules = - compute_rule_node::(rule_tree, - &mut applicable_declarations, - &guards); - if pseudos.has(&pseudo) { - rule_nodes_changed = pseudos.set_rules(&pseudo, new_rules); - } else { - pseudos.insert(&pseudo, ComputedStyle::new_partial(new_rules)); - matches_different_pseudos = true; - } - } else if pseudos.take(&pseudo).is_some() { - matches_different_pseudos = true; + let rules = stylist.rule_tree().compute_rule_node( + &mut applicable_declarations, + &guards + ); + matches_different_pseudos |= pseudos.add_rules( + &pseudo, + visited_handling, + rules + ); + } else { + matches_different_pseudos |= pseudos.remove_rules( + &pseudo, + visited_handling + ); } }); if matches_different_pseudos { - rule_nodes_changed = true; if let Some(r) = data.get_restyle_mut() { // Any changes to the matched pseudo-elements trigger // reconstruction. r.damage |= RestyleDamage::reconstruct(); } } - - rule_nodes_changed } /// Applies selector flags to an element, deferring mutations of the parent @@ -1126,8 +1338,11 @@ pub trait MatchMethods : TElement { /// Performs the cascade for the element's eager pseudos. fn cascade_pseudos(&self, context: &mut StyleContext, - mut data: &mut ElementData) + mut data: &mut ElementData, + cascade_visited: CascadeVisitedMode) { + debug!("Cascade pseudos for {:?}, visited: {:?}", self, + cascade_visited); // Note that we've already set up the map of matching pseudo-elements // in match_pseudos (and handled the damage implications of changing // which pseudos match), so now we can just iterate what we have. This @@ -1135,7 +1350,7 @@ pub trait MatchMethods : TElement { // let us pass the mutable |data| to the cascade function. let matched_pseudos = data.styles().pseudos.keys(); for pseudo in matched_pseudos { - self.cascade_eager_pseudo(context, data, &pseudo); + self.cascade_eager_pseudo(context, data, &pseudo, cascade_visited); } } @@ -1156,11 +1371,15 @@ pub trait MatchMethods : TElement { return relevant_style.values.as_ref().unwrap().clone(); } + // This currently ignores visited styles, which seems acceptable, + // as existing browsers don't appear to animate visited styles. self.cascade_with_rules(shared_context, font_metrics_provider, &without_animation_rules, primary_style, - InheritMode::Normal) + InheritMode::Normal, + CascadeVisitedMode::Unvisited, + None) } } diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs index bd390fc4273..4485405d7a2 100644 --- a/components/style/properties/gecko.mako.rs +++ b/components/style/properties/gecko.mako.rs @@ -100,6 +100,11 @@ pub struct ComputedValues { pub font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, /// The cached system font. See longhand/font.mako.rs pub cached_system_font: Option, + + /// The element's computed values if visited, only computed if there's a + /// relevant link for this element. A element's "relevant link" is the + /// element being matched if it is a link or the nearest ancestor link. + visited_style: Option>, } impl ComputedValues { @@ -107,6 +112,7 @@ impl ComputedValues { writing_mode: WritingMode, root_font_size: Au, font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + visited_style: Option>, % for style_struct in data.style_structs: ${style_struct.ident}: Arc, % endfor @@ -117,6 +123,7 @@ impl ComputedValues { root_font_size: root_font_size, cached_system_font: None, font_size_keyword: font_size_keyword, + visited_style: visited_style, % for style_struct in data.style_structs: ${style_struct.ident}: ${style_struct.ident}, % endfor @@ -130,6 +137,7 @@ impl ComputedValues { root_font_size: longhands::font_size::get_initial_value(), // FIXME(bz): Also seems dubious? font_size_keyword: Some((Default::default(), 1.)), cached_system_font: None, + visited_style: None, % for style_struct in data.style_structs: ${style_struct.ident}: style_structs::${style_struct.name}::default(pres_context), % endfor @@ -168,6 +176,23 @@ impl ComputedValues { } % endfor + /// Gets a reference to the visited computed values, if any. + pub fn get_visited_style(&self) -> Option<<&Arc> { + self.visited_style.as_ref() + } + + /// Gets a reference to the visited computed values. Panic if the element + /// does not have visited computed values. + pub fn visited_style(&self) -> &Arc { + self.get_visited_style().unwrap() + } + + /// Clone the visited computed values Arc. Used for inheriting parent styles + /// in StyleBuilder::for_inheritance. + pub fn clone_visited_style(&self) -> Option> { + self.visited_style.clone() + } + pub fn custom_properties(&self) -> Option> { self.custom_properties.clone() } diff --git a/components/style/properties/properties.mako.rs b/components/style/properties/properties.mako.rs index d61f4205773..9e7e37f06ce 100644 --- a/components/style/properties/properties.mako.rs +++ b/components/style/properties/properties.mako.rs @@ -1743,6 +1743,11 @@ pub struct ComputedValues { pub root_font_size: Au, /// The keyword behind the current font-size property, if any pub font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + + /// The element's computed values if visited, only computed if there's a + /// relevant link for this element. A element's "relevant link" is the + /// element being matched if it is a link or the nearest ancestor link. + visited_style: Option>, } #[cfg(feature = "servo")] @@ -1752,6 +1757,7 @@ impl ComputedValues { writing_mode: WritingMode, root_font_size: Au, font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + visited_style: Option>, % for style_struct in data.active_style_structs(): ${style_struct.ident}: Arc, % endfor @@ -1761,6 +1767,7 @@ impl ComputedValues { writing_mode: writing_mode, root_font_size: root_font_size, font_size_keyword: font_size_keyword, + visited_style: visited_style, % for style_struct in data.active_style_structs(): ${style_struct.ident}: ${style_struct.ident}, % endfor @@ -1796,6 +1803,23 @@ impl ComputedValues { } % endfor + /// Gets a reference to the visited computed values, if any. + pub fn get_visited_style(&self) -> Option<<&Arc> { + self.visited_style.as_ref() + } + + /// Gets a reference to the visited computed values. Panic if the element + /// does not have visited computed values. + pub fn visited_style(&self) -> &Arc { + self.get_visited_style().unwrap() + } + + /// Clone the visited computed values Arc. Used for inheriting parent styles + /// in StyleBuilder::for_inheritance. + pub fn clone_visited_style(&self) -> Option> { + self.visited_style.clone() + } + /// Get the custom properties map if necessary. /// /// Cloning the Arc here is fine because it only happens in the case where @@ -2183,6 +2207,10 @@ pub struct StyleBuilder<'a> { pub root_font_size: Au, /// The keyword behind the current font-size property, if any. pub font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + /// The element's style if visited, only computed if there's a relevant link + /// for this element. A element's "relevant link" is the element being + /// matched if it is a link or the nearest ancestor link. + visited_style: Option>, % for style_struct in data.active_style_structs(): ${style_struct.ident}: StyleStructRef<'a, style_structs::${style_struct.name}>, % endfor @@ -2195,6 +2223,7 @@ impl<'a> StyleBuilder<'a> { writing_mode: WritingMode, root_font_size: Au, font_size_keyword: Option<(longhands::font_size::KeywordSize, f32)>, + visited_style: Option>, % for style_struct in data.active_style_structs(): ${style_struct.ident}: &'a Arc, % endfor @@ -2204,6 +2233,7 @@ impl<'a> StyleBuilder<'a> { writing_mode: writing_mode, root_font_size: root_font_size, font_size_keyword: font_size_keyword, + visited_style: visited_style, % for style_struct in data.active_style_structs(): ${style_struct.ident}: StyleStructRef::Borrowed(${style_struct.ident}), % endfor @@ -2223,6 +2253,7 @@ impl<'a> StyleBuilder<'a> { parent.writing_mode, parent.root_font_size, parent.font_size_keyword, + parent.clone_visited_style(), % for style_struct in data.active_style_structs(): % if style_struct.inherited: parent.${style_struct.name_lower}_arc(), @@ -2296,6 +2327,7 @@ impl<'a> StyleBuilder<'a> { self.writing_mode, self.root_font_size, self.font_size_keyword, + self.visited_style, % for style_struct in data.active_style_structs(): self.${style_struct.ident}.build(), % endfor @@ -2339,6 +2371,7 @@ mod lazy_static_module { writing_mode: WritingMode::empty(), root_font_size: longhands::font_size::get_initial_value(), font_size_keyword: Some((Default::default(), 1.)), + visited_style: None, }; } } @@ -2392,6 +2425,7 @@ pub fn cascade(device: &Device, guards: &StylesheetGuards, parent_style: Option<<&ComputedValues>, layout_parent_style: Option<<&ComputedValues>, + visited_style: Option>, cascade_info: Option<<&mut CascadeInfo>, error_reporter: &ParseErrorReporter, font_metrics_provider: &FontMetricsProvider, @@ -2438,6 +2472,7 @@ pub fn cascade(device: &Device, iter_declarations, inherited_style, layout_parent_style, + visited_style, cascade_info, error_reporter, font_metrics_provider, @@ -2453,6 +2488,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device, iter_declarations: F, inherited_style: &ComputedValues, layout_parent_style: &ComputedValues, + visited_style: Option>, mut cascade_info: Option<<&mut CascadeInfo>, error_reporter: &ParseErrorReporter, font_metrics_provider: &FontMetricsProvider, @@ -2483,6 +2519,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device, WritingMode::empty(), inherited_style.root_font_size, inherited_style.font_size_keyword, + visited_style, % for style_struct in data.active_style_structs(): % if style_struct.inherited: inherited_style.${style_struct.name_lower}_arc(), @@ -2496,6 +2533,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device, WritingMode::empty(), inherited_style.root_font_size, inherited_style.font_size_keyword, + visited_style, % for style_struct in data.active_style_structs(): inherited_style.${style_struct.name_lower}_arc(), % endfor diff --git a/components/style/rule_tree/mod.rs b/components/style/rule_tree/mod.rs index 866eb9adab9..bb13836c2a6 100644 --- a/components/style/rule_tree/mod.rs +++ b/components/style/rule_tree/mod.rs @@ -16,6 +16,7 @@ use std::ptr; use std::sync::atomic::{AtomicPtr, AtomicUsize, Ordering}; use stylearc::Arc; use stylesheets::StyleRule; +use stylist::ApplicableDeclarationList; use thread_state; /// The rule tree, the structure servo uses to preserve the results of selector @@ -215,6 +216,18 @@ impl RuleTree { current } + /// Given a list of applicable declarations, insert the rules and return the + /// corresponding rule node. + pub fn compute_rule_node(&self, + applicable_declarations: &mut ApplicableDeclarationList, + guards: &StylesheetGuards) + -> StrongRuleNode + { + let rules = applicable_declarations.drain().map(|d| (d.source, d.level)); + let rule_node = self.insert_ordered_rules_with_important(rules, guards); + rule_node + } + /// Insert the given rules, that must be in proper order by specifity, and /// return the corresponding rule node representing the last inserted one. pub fn insert_ordered_rules<'a, I>(&self, iter: I) -> StrongRuleNode @@ -632,6 +645,8 @@ struct WeakRuleNode { /// A strong reference to a rule node. #[derive(Debug, PartialEq)] pub struct StrongRuleNode { + // TODO: Mark this as NonZero once stable to save space inside Option. + // https://github.com/rust-lang/rust/issues/27730 ptr: *mut RuleNode, } diff --git a/components/style/stylist.rs b/components/style/stylist.rs index a453588c469..4b80faaf459 100644 --- a/components/style/stylist.rs +++ b/components/style/stylist.rs @@ -568,6 +568,7 @@ impl Stylist { parent.map(|p| &**p), parent.map(|p| &**p), None, + None, &RustLogReporter, font_metrics, cascade_flags, @@ -639,6 +640,7 @@ impl Stylist { // 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"). + // Bug 1364242: We need to add visited support for lazy pseudos let computed = properties::cascade(&self.device, &rule_node, @@ -646,6 +648,7 @@ impl Stylist { Some(parent_style), Some(parent_style), None, + None, &RustLogReporter, font_metrics, CascadeFlags::empty(), @@ -695,6 +698,7 @@ impl Stylist { } }; + // Bug 1364242: We need to add visited support for lazy pseudos let mut declarations = ApplicableDeclarationList::new(); let mut matching_context = MatchingContext::new(MatchingMode::ForStatelessPseudoElement, None); @@ -1048,6 +1052,9 @@ impl Stylist { let rule_node = self.rule_tree.insert_ordered_rules(v.into_iter().map(|a| (a.source, a.level))); + // This currently ignores visited styles. It appears to be used for + // font styles in via Servo_StyleSet_ResolveForDeclarations. + // It is unclear if visited styles are meaningful for this case. let metrics = get_metrics_provider_for_product(); Arc::new(properties::cascade(&self.device, &rule_node, @@ -1055,6 +1062,7 @@ impl Stylist { Some(parent_style), Some(parent_style), None, + None, &RustLogReporter, &metrics, CascadeFlags::empty(), diff --git a/ports/geckolib/glue.rs b/ports/geckolib/glue.rs index 96913fd482c..401cdac1a1f 100644 --- a/ports/geckolib/glue.rs +++ b/ports/geckolib/glue.rs @@ -1313,6 +1313,15 @@ pub extern "C" fn Servo_ComputedValues_Inherit( style.into_strong() } +#[no_mangle] +pub extern "C" fn Servo_ComputedValues_GetVisitedStyle(values: ServoComputedValuesBorrowed) + -> ServoComputedValuesStrong { + match ComputedValues::as_arc(&values).get_visited_style() { + Some(v) => v.clone().into_strong(), + None => Strong::null(), + } +} + /// See the comment in `Device` to see why it's ok to pass an owned reference to /// the pres context (hint: the context outlives the StyleSet, that holds the /// device alive).