Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

style: Remove hashes from style rules and dependencies.

Browse source 
Dependencies are very numerous, and now we shouldn't be getting so many of them.

Style rules just don't need them, so it's a waste of memory.
This commit is contained in:
Emilio Cobos Álvarez 2017-07-13 03:57:44 +02:00
parent 9394ea9644
commit dee4aea264
No known key found for this signature in database
GPG key ID: 056B727BB9C1027C
8 changed files with 61 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

16
components/selectors/matching.rs
View file

@ -164,10 +164,10 @@ pub fn matches_selector_list<E>(selector_list: &SelectorList<E::Impl>,
-> bool
where E: Element
{
selector_list.0.iter().any(|selector_and_hashes| {
matches_selector(&selector_and_hashes.selector,
selector_list.0.iter().any(|selector| {
matches_selector(selector,
0,
&selector_and_hashes.hashes,
None,
element,
context,
&mut |_, _| {})
@ -371,7 +371,7 @@ enum SelectorMatchingResult {
#[inline(always)]
pub fn matches_selector<E, F>(selector: &Selector<E::Impl>,
offset: usize,
hashes: &AncestorHashes,
hashes: Option<&AncestorHashes>,
element: &E,
context: &mut MatchingContext,
flags_setter: &mut F)
@ -380,9 +380,11 @@ pub fn matches_selector<E, F>(selector: &Selector<E::Impl>,
F: FnMut(&E, ElementSelectorFlags),
{
// Use the bloom filter to fast-reject.
if let Some(filter) = context.bloom_filter {
if !may_match::<E>(hashes, filter) {
return false;
if let Some(hashes) = hashes {
if let Some(filter) = context.bloom_filter {
if !may_match::<E>(hashes, filter) {
return false;
}
}
}

24
components/selectors/parser.rs
View file

@ -197,7 +197,7 @@ impl<Impl: SelectorImpl> SelectorAndHashes<Impl> {
}
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct SelectorList<Impl: SelectorImpl>(pub Vec<SelectorAndHashes<Impl>>);
pub struct SelectorList<Impl: SelectorImpl>(pub Vec<Selector<Impl>>);
impl<Impl: SelectorImpl> SelectorList<Impl> {
/// Parse a comma-separated list of Selectors.
@ -207,13 +207,13 @@ impl<Impl: SelectorImpl> SelectorList<Impl> {
pub fn parse<'i, 't, P, E>(parser: &P, input: &mut CssParser<'i, 't>)
-> Result<Self, ParseError<'i, SelectorParseError<'i, E>>>
where P: Parser<'i, Impl=Impl, Error=E> {
input.parse_comma_separated(|input| parse_selector(parser, input).map(SelectorAndHashes::new))
input.parse_comma_separated(|input| parse_selector(parser, input))
.map(SelectorList)
}
/// Creates a SelectorList from a Vec of selectors. Used in tests.
pub fn from_vec(v: Vec<Selector<Impl>>) -> Self {
SelectorList(v.into_iter().map(SelectorAndHashes::new).collect())
SelectorList(v)
}
}
@ -761,10 +761,10 @@ impl<Impl: SelectorImpl> ToCss for SelectorList<Impl> {
let mut iter = self.0.iter();
let first = iter.next()
.expect("Empty SelectorList, should contain at least one selector");
first.selector.to_css(dest)?;
for selector_and_hashes in iter {
first.to_css(dest)?;
for selector in iter {
dest.write_str(", ")?;
selector_and_hashes.selector.to_css(dest)?;
selector.to_css(dest)?;
}
Ok(())
}
@ -1761,7 +1761,7 @@ pub mod tests {
let result = SelectorList::parse(parser, &mut CssParser::new(&mut parser_input));
if let Ok(ref selectors) = result {
assert_eq!(selectors.0.len(), 1);
assert_eq!(selectors.0[0].selector.to_css_string(), input);
assert_eq!(selectors.0[0].to_css_string(), input);
}
result
}
@ -2066,7 +2066,7 @@ pub mod tests {
#[test]
fn test_pseudo_iter() {
let selector = &parse("q::before").unwrap().0[0].selector;
let selector = &parse("q::before").unwrap().0[0];
assert!(!selector.is_universal());
let mut iter = selector.iter();
assert_eq!(iter.next(), Some(&Component::PseudoElement(PseudoElement::Before)));
@ -2080,13 +2080,13 @@ pub mod tests {
#[test]
fn test_universal() {
let selector = &parse("*|*::before").unwrap().0[0].selector;
let selector = &parse("*|*::before").unwrap().0[0];
assert!(selector.is_universal());
}
#[test]
fn test_empty_pseudo_iter() {
let selector = &parse("::before").unwrap().0[0].selector;
let selector = &parse("::before").unwrap().0[0];
assert!(selector.is_universal());
let mut iter = selector.iter();
assert_eq!(iter.next(), Some(&Component::PseudoElement(PseudoElement::Before)));
@ -2112,11 +2112,11 @@ pub mod tests {
#[test]
fn visitor() {
let mut test_visitor = TestVisitor { seen: vec![], };
parse(":not(:hover) ~ label").unwrap().0[0].selector.visit(&mut test_visitor);
parse(":not(:hover) ~ label").unwrap().0[0].visit(&mut test_visitor);
assert!(test_visitor.seen.contains(&":hover".into()));
let mut test_visitor = TestVisitor { seen: vec![], };
parse("::before:hover").unwrap().0[0].selector.visit(&mut test_visitor);
parse("::before:hover").unwrap().0[0].visit(&mut test_visitor);
assert!(test_visitor.seen.contains(&":hover".into()));
}
}

47
components/style/invalidation/element/invalidation_map.rs
View file

@ -10,8 +10,8 @@ use element_state::ElementState;
use selector_map::{MaybeCaseInsensitiveHashMap, SelectorMap, SelectorMapEntry};
use selector_parser::SelectorImpl;
use selectors::attr::NamespaceConstraint;
use selectors::parser::{AncestorHashes, Combinator, Component};
use selectors::parser::{Selector, SelectorAndHashes, SelectorIter, SelectorMethods};
use selectors::parser::{Combinator, Component};
use selectors::parser::{Selector, SelectorIter, SelectorMethods};
use selectors::visitor::SelectorVisitor;
use smallvec::SmallVec;
@ -59,10 +59,6 @@ pub struct Dependency {
/// The dependency selector.
#[cfg_attr(feature = "servo", ignore_heap_size_of = "Arc")]
pub selector: Selector<SelectorImpl>,
/// The ancestor hashes associated with the above selector at the given
/// offset.
#[cfg_attr(feature = "servo", ignore_heap_size_of = "No heap data")]
pub hashes: AncestorHashes,
/// The offset into the selector that we should match on.
pub selector_offset: usize,
}
@ -188,10 +184,10 @@ impl InvalidationMap {
/// Adds a selector to this `InvalidationMap`.
pub fn note_selector(
&mut self,
selector_and_hashes: &SelectorAndHashes<SelectorImpl>,
selector: &Selector<SelectorImpl>,
quirks_mode: QuirksMode)
{
self.collect_invalidations_for(selector_and_hashes, quirks_mode)
self.collect_invalidations_for(selector, quirks_mode)
}
/// Clears this map, leaving it empty.
@ -206,13 +202,12 @@ impl InvalidationMap {
fn collect_invalidations_for(
&mut self,
selector_and_hashes: &SelectorAndHashes<SelectorImpl>,
selector: &Selector<SelectorImpl>,
quirks_mode: QuirksMode)
{
debug!("InvalidationMap::collect_invalidations_for({:?})",
selector_and_hashes.selector);
debug!("InvalidationMap::collect_invalidations_for({:?})", selector);
let mut iter = selector_and_hashes.selector.iter();
let mut iter = selector.iter();
let mut combinator;
let mut index = 0;
@ -241,22 +236,6 @@ impl InvalidationMap {
index += 1; // Account for the simple selector.
}
// Reuse the bloom hashes if this is the base selector. Otherwise,
// rebuild them.
let mut hashes = None;
let mut get_hashes = || -> AncestorHashes {
if hashes.is_none() {
hashes = Some(if sequence_start == 0 {
selector_and_hashes.hashes.clone()
} else {
let seq_iter = selector_and_hashes.selector.iter_from(sequence_start);
AncestorHashes::from_iter(seq_iter)
});
}
hashes.clone().unwrap()
};
self.has_id_attribute_selectors |= compound_visitor.has_id_attribute_selectors;
self.has_class_attribute_selectors |= compound_visitor.has_class_attribute_selectors;
@ -265,9 +244,8 @@ impl InvalidationMap {
.entry(class, quirks_mode)
.or_insert_with(SelectorMap::new)
.insert(Dependency {
selector: selector_and_hashes.selector.clone(),
selector: selector.clone(),
selector_offset: sequence_start,
hashes: get_hashes(),
}, quirks_mode);
}
@ -276,9 +254,8 @@ impl InvalidationMap {
.entry(id, quirks_mode)
.or_insert_with(SelectorMap::new)
.insert(Dependency {
selector: selector_and_hashes.selector.clone(),
selector: selector.clone(),
selector_offset: sequence_start,
hashes: get_hashes(),
}, quirks_mode);
}
@ -286,9 +263,8 @@ impl InvalidationMap {
self.state_affecting_selectors
.insert(StateDependency {
dep: Dependency {
selector: selector_and_hashes.selector.clone(),
selector: selector.clone(),
selector_offset: sequence_start,
hashes: get_hashes(),
},
state: compound_visitor.state,
}, quirks_mode);
@ -297,9 +273,8 @@ impl InvalidationMap {
if compound_visitor.other_attributes {
self.other_attribute_affecting_selectors
.insert(Dependency {
selector: selector_and_hashes.selector.clone(),
selector: selector.clone(),
selector_offset: sequence_start,
hashes: get_hashes(),
}, quirks_mode);
}

8
components/style/invalidation/element/invalidator.rs
View file

@ -762,14 +762,14 @@ impl<'a, 'b: 'a, E> InvalidationCollector<'a, 'b, E>
let matched_then =
matches_selector(&dependency.selector,
dependency.selector_offset,
&dependency.hashes,
None,
&self.wrapper,
&mut then_context,
&mut |_, _| {});
let matches_now =
matches_selector(&dependency.selector,
dependency.selector_offset,
&dependency.hashes,
None,
&self.element,
&mut now_context,
&mut |_, _| {});
@ -802,7 +802,7 @@ impl<'a, 'b: 'a, E> InvalidationCollector<'a, 'b, E>
let matched_then =
matches_selector(&dependency.selector,
dependency.selector_offset,
&dependency.hashes,
None,
&self.wrapper,
&mut then_context,
&mut |_, _| {});
@ -811,7 +811,7 @@ impl<'a, 'b: 'a, E> InvalidationCollector<'a, 'b, E>
let matches_now =
matches_selector(&dependency.selector,
dependency.selector_offset,
&dependency.hashes,
None,
&self.element,
&mut now_context,
&mut |_, _| {});

4
components/style/invalidation/stylesheets.rs
View file

@ -282,8 +282,8 @@ impl StylesheetInvalidationSet {
match *rule {
Style(ref lock) => {
let style_rule = lock.read_with(guard);
for selector_and_hashes in &style_rule.selectors.0 {
self.collect_scopes(&selector_and_hashes.selector);
for selector in &style_rule.selectors.0 {
self.collect_scopes(selector);
if self.fully_invalid {
return;
}

2
components/style/selector_map.rs
View file

@ -202,7 +202,7 @@ impl SelectorMap<Rule> {
for rule in rules {
if matches_selector(&rule.selector,
0,
&rule.hashes,
Some(&rule.hashes),
element,
context,
flags_setter) {

31
components/style/stylist.rs
View file

@ -27,7 +27,7 @@ use selectors::attr::NamespaceConstraint;
use selectors::bloom::BloomFilter;
use selectors::matching::{ElementSelectorFlags, matches_selector, MatchingContext, MatchingMode};
use selectors::matching::VisitedHandlingMode;
use selectors::parser::{AncestorHashes, Combinator, Component, Selector, SelectorAndHashes};
use selectors::parser::{AncestorHashes, Combinator, Component, Selector};
use selectors::parser::{SelectorIter, SelectorMethods};
use selectors::sink::Push;
use selectors::visitor::SelectorVisitor;
@ -478,10 +478,10 @@ impl Stylist {
CssRule::Style(ref locked) => {
let style_rule = locked.read_with(&guard);
self.num_declarations += style_rule.block.read_with(&guard).len();
for selector_and_hashes in &style_rule.selectors.0 {
for selector in &style_rule.selectors.0 {
self.num_selectors += 1;
let map = if let Some(pseudo) = selector_and_hashes.selector.pseudo_element() {
let map = if let Some(pseudo) = selector.pseudo_element() {
self.pseudos_map
.entry(pseudo.canonical())
.or_insert_with(PerPseudoElementSelectorMap::new)
@ -490,25 +490,26 @@ impl Stylist {
self.element_map.borrow_for_origin(&origin)
};
let hashes = AncestorHashes::new(&selector);
map.insert(
Rule::new(selector_and_hashes.selector.clone(),
selector_and_hashes.hashes.clone(),
Rule::new(selector.clone(),
hashes.clone(),
locked.clone(),
self.rules_source_order),
self.quirks_mode);
self.invalidation_map.note_selector(selector_and_hashes, self.quirks_mode);
if needs_revalidation(&selector_and_hashes.selector) {
self.invalidation_map.note_selector(selector, self.quirks_mode);
if needs_revalidation(&selector) {
self.selectors_for_cache_revalidation.insert(
RevalidationSelectorAndHashes::new(&selector_and_hashes),
RevalidationSelectorAndHashes::new(&selector, &hashes),
self.quirks_mode);
}
selector_and_hashes.selector.visit(&mut AttributeAndStateDependencyVisitor {
selector.visit(&mut AttributeAndStateDependencyVisitor {
attribute_dependencies: &mut self.attribute_dependencies,
style_attribute_dependency: &mut self.style_attribute_dependency,
state_dependencies: &mut self.state_dependencies,
});
selector_and_hashes.selector.visit(&mut MappedIdVisitor {
selector.visit(&mut MappedIdVisitor {
mapped_ids: &mut self.mapped_ids,
});
}
@ -1302,7 +1303,7 @@ impl Stylist {
*element, self.quirks_mode, &mut |selector_and_hashes| {
results.push(matches_selector(&selector_and_hashes.selector,
selector_and_hashes.selector_offset,
&selector_and_hashes.hashes,
Some(&selector_and_hashes.hashes),
element,
&mut matching_context,
flags_setter));
@ -1431,12 +1432,12 @@ struct RevalidationSelectorAndHashes {
}
impl RevalidationSelectorAndHashes {
fn new(selector_and_hashes: &SelectorAndHashes<SelectorImpl>) -> Self {
fn new(selector: &Selector<SelectorImpl>, hashes: &AncestorHashes) -> Self {
// We basically want to check whether the first combinator is a
// pseudo-element combinator. If it is, we want to use the offset one
// past it. Otherwise, our offset is 0.
let mut index = 0;
let mut iter = selector_and_hashes.selector.iter();
let mut iter = selector.iter();
// First skip over the first ComplexSelector. We can't check what sort
// of combinator we have until we do that.
@ -1450,9 +1451,9 @@ impl RevalidationSelectorAndHashes {
};
RevalidationSelectorAndHashes {
selector: selector_and_hashes.selector.clone(),
selector: selector.clone(),
selector_offset: offset,
hashes: selector_and_hashes.hashes.clone(),
hashes: hashes.clone(),
}
}
}