mirror of
https://github.com/servo/servo.git
synced 2025-08-03 04:30:10 +01:00
Stop returning rule nodes from match_element and overhaul style calculation logic.
This commit is contained in:
parent
5873de3fb6
commit
0e3aeac922
4 changed files with 242 additions and 297 deletions
|
@ -76,13 +76,6 @@ impl fmt::Debug for ComputedStyle {
|
|||
type PseudoStylesInner = HashMap<PseudoElement, ComputedStyle,
|
||||
BuildHasherDefault<::fnv::FnvHasher>>;
|
||||
|
||||
/// The rule nodes for each of the pseudo-elements of an element.
|
||||
///
|
||||
/// TODO(emilio): Probably shouldn't be a `HashMap` by default, but a smaller
|
||||
/// array.
|
||||
pub type PseudoRuleNodes = HashMap<PseudoElement, StrongRuleNode,
|
||||
BuildHasherDefault<::fnv::FnvHasher>>;
|
||||
|
||||
/// A set of styles for a given element's pseudo-elements.
|
||||
///
|
||||
/// This is a map from pseudo-element to `ComputedStyle`.
|
||||
|
@ -97,19 +90,6 @@ impl PseudoStyles {
|
|||
pub fn empty() -> Self {
|
||||
PseudoStyles(HashMap::with_hasher(Default::default()))
|
||||
}
|
||||
|
||||
/// Gets the rules that the different pseudo-elements matched.
|
||||
///
|
||||
/// FIXME(emilio): We could in theory avoid creating these when we have
|
||||
/// support for just re-cascading an element. Then the input to
|
||||
/// `cascade_node` could be `MatchResults` or just `UseExistingStyle`.
|
||||
pub fn get_rules(&self) -> PseudoRuleNodes {
|
||||
let mut rules = HashMap::with_hasher(Default::default());
|
||||
for (pseudo, style) in &self.0 {
|
||||
rules.insert(pseudo.clone(), style.rules.clone());
|
||||
}
|
||||
rules
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for PseudoStyles {
|
||||
|
@ -467,7 +447,14 @@ impl ElementData {
|
|||
/// Gets a mutable reference to the element styles. Panic if the element has
|
||||
/// never been styled.
|
||||
pub fn styles_mut(&mut self) -> &mut ElementStyles {
|
||||
self.styles.as_mut().expect("Caling styles_mut() on unstyled ElementData")
|
||||
self.styles.as_mut().expect("Calling styles_mut() on unstyled ElementData")
|
||||
}
|
||||
|
||||
/// Borrows both styles and restyle mutably at the same time.
|
||||
pub fn styles_and_restyle_mut(&mut self) -> (&mut ElementStyles,
|
||||
Option<&mut RestyleData>) {
|
||||
(self.styles.as_mut().unwrap(),
|
||||
self.restyle.as_mut().map(|r| &mut **r))
|
||||
}
|
||||
|
||||
/// Sets the computed element styles.
|
||||
|
|
|
@ -13,7 +13,7 @@ use atomic_refcell::AtomicRefMut;
|
|||
use cache::LRUCache;
|
||||
use cascade_info::CascadeInfo;
|
||||
use context::{SequentialTask, SharedStyleContext, StyleContext};
|
||||
use data::{ComputedStyle, ElementData, ElementStyles, PseudoRuleNodes, PseudoStyles};
|
||||
use data::{ComputedStyle, ElementData, ElementStyles};
|
||||
use dom::{SendElement, TElement, TNode};
|
||||
use properties::{CascadeFlags, ComputedValues, SHAREABLE, SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP, cascade};
|
||||
use properties::longhands::display::computed_value as display;
|
||||
|
@ -22,11 +22,11 @@ use rule_tree::{CascadeLevel, StrongRuleNode};
|
|||
use selector_parser::{PseudoElement, RestyleDamage, SelectorImpl};
|
||||
use selectors::MatchAttr;
|
||||
use selectors::bloom::BloomFilter;
|
||||
use selectors::matching::{AFFECTED_BY_PSEUDO_ELEMENTS, AFFECTED_BY_STYLE_ATTRIBUTE};
|
||||
use selectors::matching::{ElementSelectorFlags, StyleRelations};
|
||||
use selectors::matching::AFFECTED_BY_PSEUDO_ELEMENTS;
|
||||
use servo_config::opts;
|
||||
use sink::ForgetfulSink;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::Entry;
|
||||
use std::slice::IterMut;
|
||||
use std::sync::Arc;
|
||||
use stylist::ApplicableDeclarationBlock;
|
||||
|
@ -61,22 +61,21 @@ fn create_common_style_affecting_attributes_from_element<E: TElement>(element: &
|
|||
flags
|
||||
}
|
||||
|
||||
/// The results of selector matching on an element.
|
||||
/// The results returned from running selector matching on an element.
|
||||
pub struct MatchResults {
|
||||
/// The rule node reference that represents the rules matched by the
|
||||
/// element.
|
||||
pub primary: StrongRuleNode,
|
||||
/// A set of style relations (different hints about what rules matched or
|
||||
/// could have matched).
|
||||
pub relations: StyleRelations,
|
||||
/// The results of selector-matching the pseudo-elements.
|
||||
pub per_pseudo: PseudoRuleNodes,
|
||||
/// could have matched). This is necessary if the style will be shared.
|
||||
/// If None, the style will not be shared.
|
||||
pub primary_relations: Option<StyleRelations>,
|
||||
/// Whether the rule nodes changed during selector matching.
|
||||
pub rule_nodes_changed: bool,
|
||||
}
|
||||
|
||||
impl MatchResults {
|
||||
/// Returns true if the primary rule node is shareable with other nodes.
|
||||
pub fn primary_is_shareable(&self) -> bool {
|
||||
relations_are_shareable(&self.relations)
|
||||
self.primary_relations.as_ref()
|
||||
.map_or(false, relations_are_shareable)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -434,7 +433,7 @@ pub enum StyleSharingResult {
|
|||
StyleWasShared(usize),
|
||||
}
|
||||
|
||||
/// Callers need to pass several boolean flags to cascade_node_pseudo_element.
|
||||
/// Callers need to pass several boolean flags to cascade_primary_or_pseudo.
|
||||
/// We encapsulate them in this struct to avoid mixing them up.
|
||||
///
|
||||
/// FIXME(pcwalton): Unify with `CascadeFlags`, perhaps?
|
||||
|
@ -444,18 +443,12 @@ struct CascadeBooleans {
|
|||
}
|
||||
|
||||
trait PrivateMatchMethods: TElement {
|
||||
/// Actually cascades style for a node or a pseudo-element of a node.
|
||||
///
|
||||
/// Note that animations only apply to nodes or ::before or ::after
|
||||
/// pseudo-elements.
|
||||
fn cascade_node_pseudo_element<'a>(&self,
|
||||
context: &StyleContext<Self>,
|
||||
parent_style: Option<&Arc<ComputedValues>>,
|
||||
old_style: Option<&Arc<ComputedValues>>,
|
||||
rule_node: &StrongRuleNode,
|
||||
possibly_expired_animations: &[PropertyAnimation],
|
||||
booleans: CascadeBooleans)
|
||||
-> Arc<ComputedValues> {
|
||||
fn cascade_internal(&self,
|
||||
context: &StyleContext<Self>,
|
||||
primary_style: &ComputedStyle,
|
||||
pseudo_style: &mut Option<(&PseudoElement, &mut ComputedStyle)>,
|
||||
booleans: &CascadeBooleans)
|
||||
-> Arc<ComputedValues> {
|
||||
let shared_context = context.shared;
|
||||
let mut cascade_info = CascadeInfo::new();
|
||||
let mut cascade_flags = CascadeFlags::empty();
|
||||
|
@ -466,53 +459,118 @@ trait PrivateMatchMethods: TElement {
|
|||
cascade_flags.insert(SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP)
|
||||
}
|
||||
|
||||
let this_style = match parent_style {
|
||||
Some(ref parent_style) => {
|
||||
cascade(shared_context.viewport_size,
|
||||
rule_node,
|
||||
Some(&***parent_style),
|
||||
&shared_context.default_computed_values,
|
||||
Some(&mut cascade_info),
|
||||
shared_context.error_reporter.clone(),
|
||||
cascade_flags)
|
||||
}
|
||||
None => {
|
||||
cascade(shared_context.viewport_size,
|
||||
rule_node,
|
||||
None,
|
||||
&shared_context.default_computed_values,
|
||||
Some(&mut cascade_info),
|
||||
shared_context.error_reporter.clone(),
|
||||
cascade_flags)
|
||||
// Grab the rule node.
|
||||
let rule_node = &pseudo_style.as_ref().map_or(primary_style, |p| &*p.1).rules;
|
||||
|
||||
// Grab the inherited values.
|
||||
let parent_el;
|
||||
let parent_data;
|
||||
let inherited_values_ = if pseudo_style.is_none() {
|
||||
parent_el = self.parent_element();
|
||||
parent_data = parent_el.as_ref().and_then(|x| x.borrow_data());
|
||||
let parent_values = 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
|
||||
// construct a frame for some small piece of newly-added
|
||||
// content in order to do something specific with that frame,
|
||||
// but not wanting to flush all of layout).
|
||||
debug_assert!(cfg!(feature = "gecko") || d.has_current_styles());
|
||||
d.styles().primary.values()
|
||||
});
|
||||
|
||||
// Propagate the "can be fragmented" bit. It would be nice to
|
||||
// encapsulate this better.
|
||||
if let Some(ref p) = parent_values {
|
||||
let can_be_fragmented =
|
||||
p.is_multicol() || parent_el.unwrap().as_node().can_be_fragmented();
|
||||
unsafe { self.as_node().set_can_be_fragmented(can_be_fragmented); }
|
||||
}
|
||||
|
||||
parent_values
|
||||
} else {
|
||||
Some(primary_style.values())
|
||||
};
|
||||
let inherited_values = inherited_values_.map(|x| &**x);
|
||||
|
||||
// Invoke the cascade algorithm.
|
||||
let values =
|
||||
Arc::new(cascade(shared_context.viewport_size,
|
||||
rule_node,
|
||||
inherited_values,
|
||||
&shared_context.default_computed_values,
|
||||
Some(&mut cascade_info),
|
||||
shared_context.error_reporter.clone(),
|
||||
cascade_flags));
|
||||
|
||||
cascade_info.finish(&self.as_node());
|
||||
values
|
||||
}
|
||||
|
||||
let mut this_style = Arc::new(this_style);
|
||||
/// Computes values and damage for the primary or pseudo style of an element,
|
||||
/// setting them on the ElementData.
|
||||
fn cascade_primary_or_pseudo<'a>(&self,
|
||||
context: &StyleContext<Self>,
|
||||
data: &mut ElementData,
|
||||
pseudo: Option<&PseudoElement>,
|
||||
possibly_expired_animations: &mut Vec<PropertyAnimation>,
|
||||
booleans: CascadeBooleans) {
|
||||
// Collect some values.
|
||||
let shared_context = context.shared;
|
||||
let (mut styles, restyle) = data.styles_and_restyle_mut();
|
||||
let mut primary_style = &mut styles.primary;
|
||||
let pseudos = &mut styles.pseudos;
|
||||
let mut pseudo_style = pseudo.map(|p| (p, pseudos.get_mut(p).unwrap()));
|
||||
let mut old_values =
|
||||
pseudo_style.as_mut().map_or_else(|| primary_style.values.take(), |p| p.1.values.take());
|
||||
|
||||
// Compute the new values.
|
||||
let mut new_values = self.cascade_internal(context, primary_style,
|
||||
&mut pseudo_style, &booleans);
|
||||
|
||||
// Handle animations.
|
||||
if booleans.animate {
|
||||
if let Some(ref mut old) = old_values {
|
||||
self.update_animations_for_cascade(shared_context, old,
|
||||
possibly_expired_animations);
|
||||
}
|
||||
|
||||
let new_animations_sender = &context.thread_local.new_animations_sender;
|
||||
let this_opaque = self.as_node().opaque();
|
||||
// Trigger any present animations if necessary.
|
||||
animation::maybe_start_animations(&shared_context,
|
||||
new_animations_sender,
|
||||
this_opaque, &this_style);
|
||||
this_opaque, &new_values);
|
||||
|
||||
// Trigger transitions if necessary. This will reset `this_style` back
|
||||
// Trigger transitions if necessary. This will reset `new_values` back
|
||||
// to its old value if it did trigger a transition.
|
||||
if let Some(ref style) = old_style {
|
||||
if let Some(ref values) = old_values {
|
||||
animation::start_transitions_if_applicable(
|
||||
new_animations_sender,
|
||||
this_opaque,
|
||||
self.as_node().to_unsafe(),
|
||||
&**style,
|
||||
&mut this_style,
|
||||
&**values,
|
||||
&mut new_values,
|
||||
&shared_context.timer,
|
||||
&possibly_expired_animations);
|
||||
}
|
||||
}
|
||||
|
||||
this_style
|
||||
// Accumulate restyle damage unless we've already maxed it out.
|
||||
if let Some(old) = old_values {
|
||||
let restyle = restyle.expect("Old values but no restyle?");
|
||||
if restyle.damage != RestyleDamage::rebuild_and_reflow() {
|
||||
let d = self.compute_restyle_damage(Some(&old), &new_values, pseudo);
|
||||
restyle.damage |= d;
|
||||
}
|
||||
}
|
||||
|
||||
// Set the new computed values.
|
||||
if let Some((_, ref mut style)) = pseudo_style {
|
||||
style.values = Some(new_values);
|
||||
} else {
|
||||
primary_style.values = Some(new_values);
|
||||
}
|
||||
}
|
||||
|
||||
fn update_animations_for_cascade(&self,
|
||||
|
@ -576,9 +634,10 @@ impl<E: TElement> PrivateMatchMethods for E {}
|
|||
|
||||
/// The public API that elements expose for selector matching.
|
||||
pub trait MatchMethods : TElement {
|
||||
/// Runs selector matching of this element, and returns the result.
|
||||
/// Runs selector matching to (re)compute rule nodes for this element.
|
||||
fn match_element(&self,
|
||||
context: &mut StyleContext<Self>)
|
||||
context: &mut StyleContext<Self>,
|
||||
data: &mut ElementData)
|
||||
-> MatchResults
|
||||
{
|
||||
let mut applicable_declarations =
|
||||
|
@ -588,6 +647,7 @@ pub trait MatchMethods : TElement {
|
|||
let style_attribute = self.style_attribute();
|
||||
let animation_rules = self.get_animation_rules(None);
|
||||
let mut flags = ElementSelectorFlags::empty();
|
||||
let mut rule_nodes_changed = false;
|
||||
|
||||
// Compute the primary rule node.
|
||||
let mut primary_relations =
|
||||
|
@ -599,10 +659,18 @@ pub trait MatchMethods : TElement {
|
|||
&mut applicable_declarations,
|
||||
&mut flags);
|
||||
let primary_rule_node = compute_rule_node(context, &mut applicable_declarations);
|
||||
if !data.has_styles() {
|
||||
data.set_styles(ElementStyles::new(ComputedStyle::new_partial(primary_rule_node)));
|
||||
rule_nodes_changed = true;
|
||||
} else if data.styles().primary.rules != primary_rule_node {
|
||||
data.styles_mut().primary.rules = primary_rule_node;
|
||||
rule_nodes_changed = true;
|
||||
}
|
||||
|
||||
// Compute the pseudo rule nodes.
|
||||
let mut per_pseudo: PseudoRuleNodes = HashMap::with_hasher(Default::default());
|
||||
// Compute rule nodes for eagerly-cascaded pseudo-elements.
|
||||
let mut matches_different_pseudos = false;
|
||||
SelectorImpl::each_eagerly_cascaded_pseudo_element(|pseudo| {
|
||||
let mut per_pseudo = &mut data.styles_mut().pseudos;
|
||||
debug_assert!(applicable_declarations.is_empty());
|
||||
let pseudo_animation_rules = self.get_animation_rules(Some(&pseudo));
|
||||
stylist.push_applicable_declarations(self,
|
||||
|
@ -613,13 +681,35 @@ pub trait MatchMethods : TElement {
|
|||
&mut flags);
|
||||
|
||||
if !applicable_declarations.is_empty() {
|
||||
let rule_node = compute_rule_node(context, &mut applicable_declarations);
|
||||
per_pseudo.insert(pseudo, rule_node);
|
||||
let new_rules = compute_rule_node(context, &mut applicable_declarations);
|
||||
match per_pseudo.entry(pseudo) {
|
||||
Entry::Occupied(mut e) => {
|
||||
if e.get().rules != new_rules {
|
||||
e.get_mut().rules = new_rules;
|
||||
rule_nodes_changed = true;
|
||||
}
|
||||
},
|
||||
Entry::Vacant(e) => {
|
||||
e.insert(ComputedStyle::new_partial(new_rules));
|
||||
matches_different_pseudos = true;
|
||||
}
|
||||
}
|
||||
} else if per_pseudo.remove(&pseudo).is_some() {
|
||||
matches_different_pseudos = true;
|
||||
}
|
||||
});
|
||||
|
||||
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::rebuild_and_reflow();
|
||||
}
|
||||
}
|
||||
|
||||
// If we have any pseudo elements, indicate so in the primary StyleRelations.
|
||||
if !per_pseudo.is_empty() {
|
||||
if !data.styles().pseudos.is_empty() {
|
||||
primary_relations |= AFFECTED_BY_PSEUDO_ELEMENTS;
|
||||
}
|
||||
|
||||
|
@ -640,63 +730,45 @@ pub trait MatchMethods : TElement {
|
|||
}
|
||||
|
||||
MatchResults {
|
||||
primary: primary_rule_node,
|
||||
relations: primary_relations,
|
||||
per_pseudo: per_pseudo,
|
||||
primary_relations: Some(primary_relations),
|
||||
rule_nodes_changed: rule_nodes_changed,
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the appropriate MatchResults from the current styles, to perform a
|
||||
/// recascade.
|
||||
///
|
||||
/// TODO(emilio): Stop using `MachResults`, use an enum, or something.
|
||||
fn match_results_from_current_style(&self, data: &ElementData) -> MatchResults {
|
||||
let rule_node = data.styles().primary.rules.clone();
|
||||
MatchResults {
|
||||
primary: rule_node,
|
||||
// FIXME(emilio): Same concern as below.
|
||||
relations: StyleRelations::empty(),
|
||||
// The per-pseudo rule-nodes haven't changed, but still need to be
|
||||
// recascaded.
|
||||
per_pseudo: data.styles().pseudos.get_rules(),
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/// Updates the rule nodes without re-running selector matching, using just
|
||||
/// the rule tree.
|
||||
/// the rule tree. Returns true if the rule nodes changed.
|
||||
fn cascade_with_replacements(&self,
|
||||
hint: RestyleHint,
|
||||
context: &StyleContext<Self>,
|
||||
data: &mut AtomicRefMut<ElementData>)
|
||||
-> MatchResults {
|
||||
let mut rule_node = data.styles().primary.rules.clone();
|
||||
-> bool {
|
||||
let primary_rules = &mut data.styles_mut().primary.rules;
|
||||
let mut rule_node_changed = false;
|
||||
|
||||
if hint.contains(RESTYLE_STYLE_ATTRIBUTE) {
|
||||
let style_attribute = self.style_attribute();
|
||||
|
||||
rule_node = context.shared.stylist.rule_tree
|
||||
let new_node = context.shared.stylist.rule_tree
|
||||
.update_rule_at_level(CascadeLevel::StyleAttributeNormal,
|
||||
style_attribute,
|
||||
rule_node);
|
||||
primary_rules);
|
||||
if let Some(n) = new_node {
|
||||
*primary_rules = n;
|
||||
rule_node_changed = true;
|
||||
}
|
||||
|
||||
rule_node = context.shared.stylist.rule_tree
|
||||
let new_node = context.shared.stylist.rule_tree
|
||||
.update_rule_at_level(CascadeLevel::StyleAttributeImportant,
|
||||
style_attribute,
|
||||
rule_node);
|
||||
primary_rules);
|
||||
if let Some(n) = new_node {
|
||||
*primary_rules = n;
|
||||
rule_node_changed = true;
|
||||
}
|
||||
}
|
||||
|
||||
MatchResults {
|
||||
primary: rule_node,
|
||||
// FIXME(emilio): This is ok, for now, we shouldn't need to fake
|
||||
// this.
|
||||
relations: AFFECTED_BY_STYLE_ATTRIBUTE,
|
||||
// The per-pseudo rule-nodes haven't changed, but still need to be
|
||||
// recomputed.
|
||||
//
|
||||
// TODO(emilio): We could probably optimize this quite a bit.
|
||||
per_pseudo: data.styles().pseudos.get_rules(),
|
||||
}
|
||||
// The per-pseudo rule nodes never change in this path.
|
||||
rule_node_changed
|
||||
}
|
||||
|
||||
/// Attempts to share a style with another node. This method is unsafe
|
||||
|
@ -867,165 +939,53 @@ pub trait MatchMethods : TElement {
|
|||
}
|
||||
}
|
||||
|
||||
/// Given the results of selector matching, run the CSS cascade and style
|
||||
/// the node, potentially starting any new transitions or animations.
|
||||
fn cascade_node(&self,
|
||||
context: &StyleContext<Self>,
|
||||
mut data: &mut AtomicRefMut<ElementData>,
|
||||
parent: Option<Self>,
|
||||
primary_rule_node: StrongRuleNode,
|
||||
pseudo_rule_nodes: PseudoRuleNodes,
|
||||
primary_is_shareable: bool)
|
||||
/// Run the CSS cascade and compute values for the element, potentially
|
||||
/// starting any new transitions or animations.
|
||||
fn cascade_element(&self,
|
||||
context: &StyleContext<Self>,
|
||||
mut data: &mut AtomicRefMut<ElementData>,
|
||||
primary_is_shareable: bool)
|
||||
{
|
||||
// Get our parent's style.
|
||||
let parent_data = parent.as_ref().map(|x| x.borrow_data().unwrap());
|
||||
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 construct a frame for
|
||||
// some small piece of newly-added content in order to do something
|
||||
// specific with that frame, but not wanting to flush all of
|
||||
// layout).
|
||||
debug_assert!(cfg!(feature = "gecko") || d.has_current_styles());
|
||||
d.styles().primary.values()
|
||||
});
|
||||
|
||||
let mut new_styles;
|
||||
let mut possibly_expired_animations = vec![];
|
||||
|
||||
let damage = {
|
||||
debug_assert!(!data.has_current_styles());
|
||||
let (old_primary, old_pseudos) = match data.get_styles_mut() {
|
||||
None => (None, None),
|
||||
Some(previous) => {
|
||||
// Update animations before the cascade. This may modify the
|
||||
// value of the old primary style.
|
||||
self.update_animations_for_cascade(&context.shared,
|
||||
previous.primary.values_mut(),
|
||||
&mut possibly_expired_animations);
|
||||
(Some(previous.primary.values()), Some(&mut previous.pseudos))
|
||||
}
|
||||
};
|
||||
// Cascade the primary style.
|
||||
self.cascade_primary_or_pseudo(context, data, None,
|
||||
&mut possibly_expired_animations,
|
||||
CascadeBooleans {
|
||||
shareable: primary_is_shareable,
|
||||
animate: true,
|
||||
});
|
||||
|
||||
let new_style =
|
||||
self.cascade_node_pseudo_element(context,
|
||||
parent_style,
|
||||
old_primary,
|
||||
&primary_rule_node,
|
||||
&possibly_expired_animations,
|
||||
CascadeBooleans {
|
||||
shareable: primary_is_shareable,
|
||||
animate: true,
|
||||
});
|
||||
// Check whether the primary style is display:none.
|
||||
let display_none = data.styles().primary.values().get_box().clone_display() ==
|
||||
display::T::none;
|
||||
|
||||
let primary = ComputedStyle::new(primary_rule_node, new_style);
|
||||
new_styles = ElementStyles::new(primary);
|
||||
|
||||
let damage =
|
||||
self.compute_damage_and_cascade_pseudos(old_primary,
|
||||
old_pseudos,
|
||||
&new_styles.primary.values(),
|
||||
&mut new_styles.pseudos,
|
||||
context,
|
||||
pseudo_rule_nodes,
|
||||
&mut possibly_expired_animations);
|
||||
|
||||
unsafe {
|
||||
self.as_node().set_can_be_fragmented(parent.map_or(false, |p| {
|
||||
p.as_node().can_be_fragmented() ||
|
||||
parent_style.unwrap().is_multicol()
|
||||
}));
|
||||
// Cascade each pseudo-element.
|
||||
//
|
||||
// Note that we've already set up the map of matching pseudo-elements
|
||||
// in match_element (and handled the damage implications of changing
|
||||
// which pseudos match), so now we can just iterate the map. This does
|
||||
// mean collecting the keys, so that the borrow checker will let us pass
|
||||
// the mutable |data| to the inner cascade function.
|
||||
let matched_pseudos: Vec<PseudoElement> =
|
||||
data.styles().pseudos.keys().cloned().collect();
|
||||
for pseudo in matched_pseudos {
|
||||
// If the new primary style is display:none, we don't need pseudo
|
||||
// styles, but we still need to clear any stale values.
|
||||
if display_none {
|
||||
data.styles_mut().pseudos.get_mut(&pseudo).unwrap().values = None;
|
||||
continue;
|
||||
}
|
||||
|
||||
damage
|
||||
};
|
||||
|
||||
if data.has_styles() {
|
||||
data.restyle_mut().damage |= damage;
|
||||
// Only ::before and ::after are animatable.
|
||||
let animate = <Self as MatchAttr>::Impl::pseudo_is_before_or_after(&pseudo);
|
||||
self.cascade_primary_or_pseudo(context, data, Some(&pseudo),
|
||||
&mut possibly_expired_animations,
|
||||
CascadeBooleans {
|
||||
shareable: false,
|
||||
animate: animate,
|
||||
});
|
||||
}
|
||||
data.set_styles(new_styles);
|
||||
}
|
||||
|
||||
/// Given the old and new styling results, compute the final restyle damage.
|
||||
fn compute_damage_and_cascade_pseudos(
|
||||
&self,
|
||||
old_primary: Option<&Arc<ComputedValues>>,
|
||||
mut old_pseudos: Option<&mut PseudoStyles>,
|
||||
new_primary: &Arc<ComputedValues>,
|
||||
new_pseudos: &mut PseudoStyles,
|
||||
context: &StyleContext<Self>,
|
||||
mut pseudo_rule_nodes: PseudoRuleNodes,
|
||||
possibly_expired_animations: &mut Vec<PropertyAnimation>)
|
||||
-> RestyleDamage
|
||||
{
|
||||
// Compute the damage and sum up the damage related to pseudo-elements.
|
||||
let mut damage =
|
||||
self.compute_restyle_damage(old_primary, new_primary, None);
|
||||
|
||||
// If the new style is display:none, we don't need pseudo-elements styles.
|
||||
if new_primary.get_box().clone_display() == display::T::none {
|
||||
return damage;
|
||||
}
|
||||
|
||||
let rebuild_and_reflow = RestyleDamage::rebuild_and_reflow();
|
||||
|
||||
debug_assert!(new_pseudos.is_empty());
|
||||
<Self as MatchAttr>::Impl::each_eagerly_cascaded_pseudo_element(|pseudo| {
|
||||
let maybe_rule_node = pseudo_rule_nodes.remove(&pseudo);
|
||||
|
||||
// Grab the old pseudo style for analysis.
|
||||
let mut maybe_old_pseudo_style =
|
||||
old_pseudos.as_mut().and_then(|x| x.remove(&pseudo));
|
||||
|
||||
if maybe_rule_node.is_some() {
|
||||
let new_rule_node = maybe_rule_node.unwrap();
|
||||
|
||||
// We have declarations, so we need to cascade. Compute parameters.
|
||||
let animate = <Self as MatchAttr>::Impl::pseudo_is_before_or_after(&pseudo);
|
||||
if animate {
|
||||
if let Some(ref mut old_pseudo_style) = maybe_old_pseudo_style {
|
||||
// Update animations before the cascade. This may modify
|
||||
// the value of old_pseudo_style.
|
||||
self.update_animations_for_cascade(&context.shared,
|
||||
old_pseudo_style.values_mut(),
|
||||
possibly_expired_animations);
|
||||
}
|
||||
}
|
||||
|
||||
let new_pseudo_values =
|
||||
self.cascade_node_pseudo_element(context,
|
||||
Some(new_primary),
|
||||
maybe_old_pseudo_style.as_ref()
|
||||
.map(|s| s.values()),
|
||||
&new_rule_node,
|
||||
&possibly_expired_animations,
|
||||
CascadeBooleans {
|
||||
shareable: false,
|
||||
animate: animate,
|
||||
});
|
||||
|
||||
// Compute restyle damage unless we've already maxed it out.
|
||||
if damage != rebuild_and_reflow {
|
||||
damage = damage | match maybe_old_pseudo_style {
|
||||
None => rebuild_and_reflow,
|
||||
Some(ref old) => self.compute_restyle_damage(Some(old.values()),
|
||||
&new_pseudo_values,
|
||||
Some(&pseudo)),
|
||||
};
|
||||
}
|
||||
|
||||
// Insert the new entry into the map.
|
||||
let new_pseudo_style = ComputedStyle::new(new_rule_node, new_pseudo_values);
|
||||
let existing = new_pseudos.insert(pseudo, new_pseudo_style);
|
||||
debug_assert!(existing.is_none());
|
||||
} else {
|
||||
if maybe_old_pseudo_style.is_some() {
|
||||
damage = rebuild_and_reflow;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
damage
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -183,12 +183,13 @@ impl RuleTree {
|
|||
|
||||
/// Replaces a rule in a given level (if present) for another rule.
|
||||
///
|
||||
/// Returns the resulting node that represents the new path.
|
||||
/// Returns the resulting node that represents the new path, or None if
|
||||
/// the old path is still valid.
|
||||
pub fn update_rule_at_level(&self,
|
||||
level: CascadeLevel,
|
||||
pdb: Option<&Arc<RwLock<PropertyDeclarationBlock>>>,
|
||||
path: StrongRuleNode)
|
||||
-> StrongRuleNode {
|
||||
path: &StrongRuleNode)
|
||||
-> Option<StrongRuleNode> {
|
||||
debug_assert!(level.is_unique_per_element());
|
||||
// TODO(emilio): Being smarter with lifetimes we could avoid a bit of
|
||||
// the refcount churn.
|
||||
|
@ -231,7 +232,7 @@ impl RuleTree {
|
|||
|
||||
if is_here_already {
|
||||
debug!("Picking the fast path in rule replacement");
|
||||
return path;
|
||||
return None;
|
||||
}
|
||||
}
|
||||
current = current.parent().unwrap().clone();
|
||||
|
@ -262,7 +263,7 @@ impl RuleTree {
|
|||
|
||||
// Now the rule is in the relevant place, push the children as
|
||||
// necessary.
|
||||
self.insert_ordered_rules_from(current, children.into_iter().rev())
|
||||
Some(self.insert_ordered_rules_from(current, children.into_iter().rev()))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -501,7 +502,7 @@ struct WeakRuleNode {
|
|||
}
|
||||
|
||||
/// A strong reference to a rule node.
|
||||
#[derive(Debug)]
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub struct StrongRuleNode {
|
||||
ptr: *mut RuleNode,
|
||||
}
|
||||
|
|
|
@ -10,7 +10,7 @@ use atomic_refcell::{AtomicRefCell, AtomicRefMut};
|
|||
use context::{SharedStyleContext, StyleContext, ThreadLocalStyleContext};
|
||||
use data::{ElementData, ElementStyles, StoredRestyleHint};
|
||||
use dom::{NodeInfo, TElement, TNode};
|
||||
use matching::MatchMethods;
|
||||
use matching::{MatchMethods, MatchResults};
|
||||
use restyle_hints::{RESTYLE_DESCENDANTS, RESTYLE_SELF};
|
||||
use selector_parser::RestyleDamage;
|
||||
use servo_config::opts;
|
||||
|
@ -339,12 +339,9 @@ fn resolve_style_internal<E, F>(context: &mut StyleContext<E>, element: E, ensur
|
|||
}
|
||||
|
||||
// Compute our style.
|
||||
let match_results = element.match_element(context);
|
||||
let shareable = match_results.primary_is_shareable();
|
||||
element.cascade_node(context, &mut data, element.parent_element(),
|
||||
match_results.primary,
|
||||
match_results.per_pseudo,
|
||||
shareable);
|
||||
let match_results = element.match_element(context, &mut data);
|
||||
element.cascade_element(context, &mut data,
|
||||
match_results.primary_is_shareable());
|
||||
|
||||
// Conservatively mark us as having dirty descendants, since there might
|
||||
// be other unstyled siblings we miss when walking straight up the parent
|
||||
|
@ -504,8 +501,6 @@ fn compute_style<E, D>(_traversal: &D,
|
|||
}
|
||||
}
|
||||
|
||||
// TODO(emilio): Make cascade_input less expensive to compute in the cases
|
||||
// we don't need to run selector matching.
|
||||
let match_results = match kind {
|
||||
MatchAndCascade => {
|
||||
// Ensure the bloom filter is up to date.
|
||||
|
@ -522,38 +517,40 @@ fn compute_style<E, D>(_traversal: &D,
|
|||
|
||||
context.thread_local.bloom_filter.assert_complete(element);
|
||||
|
||||
// Perform the CSS selector matching.
|
||||
context.thread_local.statistics.elements_matched += 1;
|
||||
|
||||
element.match_element(context)
|
||||
// Perform CSS selector matching.
|
||||
context.thread_local.statistics.elements_matched += 1;
|
||||
element.match_element(context, &mut data)
|
||||
}
|
||||
CascadeWithReplacements(hint) => {
|
||||
element.cascade_with_replacements(hint, context, &mut data)
|
||||
let rule_nodes_changed =
|
||||
element.cascade_with_replacements(hint, context, &mut data);
|
||||
MatchResults {
|
||||
primary_relations: None,
|
||||
rule_nodes_changed: rule_nodes_changed,
|
||||
}
|
||||
}
|
||||
CascadeOnly => {
|
||||
// TODO(emilio): Stop doing this work, and teach cascade_node about
|
||||
// the current style instead.
|
||||
element.match_results_from_current_style(&*data)
|
||||
MatchResults {
|
||||
primary_relations: None,
|
||||
rule_nodes_changed: false,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Perform the CSS cascade.
|
||||
// Cascade properties and compute values.
|
||||
let shareable = match_results.primary_is_shareable();
|
||||
unsafe {
|
||||
element.cascade_node(context, &mut data,
|
||||
element.parent_element(),
|
||||
match_results.primary,
|
||||
match_results.per_pseudo,
|
||||
shareable);
|
||||
element.cascade_element(context, &mut data, shareable);
|
||||
}
|
||||
|
||||
// If the style is shareable, add it to the LRU cache.
|
||||
if shareable {
|
||||
// Add ourselves to the LRU cache.
|
||||
context.thread_local
|
||||
.style_sharing_candidate_cache
|
||||
.insert_if_possible(&element,
|
||||
data.styles().primary.values(),
|
||||
match_results.relations);
|
||||
match_results.primary_relations.unwrap());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue