summaryrefslogtreecommitdiffstats
path: root/servo/components/style/rule_cache.rs
diff options
context:
space:
mode:
Diffstat (limited to 'servo/components/style/rule_cache.rs')
-rw-r--r--servo/components/style/rule_cache.rs187
1 files changed, 187 insertions, 0 deletions
diff --git a/servo/components/style/rule_cache.rs b/servo/components/style/rule_cache.rs
new file mode 100644
index 0000000000..604a92b724
--- /dev/null
+++ b/servo/components/style/rule_cache.rs
@@ -0,0 +1,187 @@
+/* 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/. */
+
+//! A cache from rule node to computed values, in order to cache reset
+//! properties.
+
+use crate::logical_geometry::WritingMode;
+use crate::properties::{ComputedValues, StyleBuilder};
+use crate::rule_tree::StrongRuleNode;
+use crate::selector_parser::PseudoElement;
+use crate::shared_lock::StylesheetGuards;
+use crate::values::computed::NonNegativeLength;
+use fxhash::FxHashMap;
+use servo_arc::Arc;
+use smallvec::SmallVec;
+
+/// The conditions for caching and matching a style in the rule cache.
+#[derive(Clone, Debug, Default)]
+pub struct RuleCacheConditions {
+ uncacheable: bool,
+ font_size: Option<NonNegativeLength>,
+ writing_mode: Option<WritingMode>,
+}
+
+impl RuleCacheConditions {
+ /// Sets the style as depending in the font-size value.
+ pub fn set_font_size_dependency(&mut self, font_size: NonNegativeLength) {
+ debug_assert!(self.font_size.map_or(true, |f| f == font_size));
+ self.font_size = Some(font_size);
+ }
+
+ /// Sets the style as uncacheable.
+ pub fn set_uncacheable(&mut self) {
+ self.uncacheable = true;
+ }
+
+ /// Sets the style as depending in the writing-mode value `writing_mode`.
+ pub fn set_writing_mode_dependency(&mut self, writing_mode: WritingMode) {
+ debug_assert!(self.writing_mode.map_or(true, |wm| wm == writing_mode));
+ self.writing_mode = Some(writing_mode);
+ }
+
+ /// Returns whether the current style's reset properties are cacheable.
+ fn cacheable(&self) -> bool {
+ !self.uncacheable
+ }
+
+ /// Returns whether `style` matches the conditions.
+ fn matches(&self, style: &StyleBuilder) -> bool {
+ if self.uncacheable {
+ return false;
+ }
+
+ if let Some(fs) = self.font_size {
+ if style.get_font().clone_font_size().computed_size != fs {
+ return false;
+ }
+ }
+
+ if let Some(wm) = self.writing_mode {
+ if style.writing_mode != wm {
+ return false;
+ }
+ }
+
+ true
+ }
+}
+
+/// A TLS cache from rules matched to computed values.
+pub struct RuleCache {
+ // FIXME(emilio): Consider using LRUCache or something like that?
+ map: FxHashMap<StrongRuleNode, SmallVec<[(RuleCacheConditions, Arc<ComputedValues>); 1]>>,
+}
+
+impl RuleCache {
+ /// Creates an empty `RuleCache`.
+ pub fn new() -> Self {
+ Self {
+ map: FxHashMap::default(),
+ }
+ }
+
+ /// Walk the rule tree and return a rule node for using as the key
+ /// for rule cache.
+ ///
+ /// It currently skips a rule node when it is neither from a style
+ /// rule, nor containing any declaration of reset property. We don't
+ /// skip style rule so that we don't need to walk a long way in the
+ /// worst case. Skipping declarations rule nodes should be enough
+ /// to address common cases that rule cache would fail to share
+ /// when using the rule node directly, like preshint, style attrs,
+ /// and animations.
+ fn get_rule_node_for_cache<'r>(
+ guards: &StylesheetGuards,
+ mut rule_node: Option<&'r StrongRuleNode>,
+ ) -> Option<&'r StrongRuleNode> {
+ while let Some(node) = rule_node {
+ match node.style_source() {
+ Some(s) => match s.as_declarations() {
+ Some(decls) => {
+ let cascade_level = node.cascade_level();
+ let decls = decls.read_with(cascade_level.guard(guards));
+ if decls.contains_any_reset() {
+ break;
+ }
+ },
+ None => break,
+ },
+ None => {},
+ }
+ rule_node = node.parent();
+ }
+ rule_node
+ }
+
+ /// Finds a node in the properties matched cache.
+ ///
+ /// This needs to receive a `StyleBuilder` with the `early` properties
+ /// already applied.
+ pub fn find(
+ &self,
+ guards: &StylesheetGuards,
+ builder_with_early_props: &StyleBuilder,
+ ) -> Option<&ComputedValues> {
+ // A pseudo-element with property restrictions can result in different
+ // computed values if it's also used for a non-pseudo.
+ if builder_with_early_props
+ .pseudo
+ .and_then(|p| p.property_restriction())
+ .is_some()
+ {
+ return None;
+ }
+
+ let rules = builder_with_early_props.rules.as_ref();
+ let rules = Self::get_rule_node_for_cache(guards, rules)?;
+ let cached_values = self.map.get(rules)?;
+
+ for &(ref conditions, ref values) in cached_values.iter() {
+ if conditions.matches(builder_with_early_props) {
+ debug!("Using cached reset style with conditions {:?}", conditions);
+ return Some(&**values);
+ }
+ }
+ None
+ }
+
+ /// Inserts a node into the rules cache if possible.
+ ///
+ /// Returns whether the style was inserted into the cache.
+ pub fn insert_if_possible(
+ &mut self,
+ guards: &StylesheetGuards,
+ style: &Arc<ComputedValues>,
+ pseudo: Option<&PseudoElement>,
+ conditions: &RuleCacheConditions,
+ ) -> bool {
+ if !conditions.cacheable() {
+ return false;
+ }
+
+ // A pseudo-element with property restrictions can result in different
+ // computed values if it's also used for a non-pseudo.
+ if pseudo.and_then(|p| p.property_restriction()).is_some() {
+ return false;
+ }
+
+ let rules = style.rules.as_ref();
+ let rules = match Self::get_rule_node_for_cache(guards, rules) {
+ Some(r) => r.clone(),
+ None => return false,
+ };
+
+ debug!(
+ "Inserting cached reset style with conditions {:?}",
+ conditions
+ );
+ self.map
+ .entry(rules)
+ .or_insert_with(SmallVec::new)
+ .push((conditions.clone(), style.clone()));
+
+ true
+ }
+}