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

style: Use a more precise rule start for sanitization.

Browse source 
Differential Revision: https://phabricator.services.mozilla.com/D98710
This commit is contained in:
Emilio Cobos Álvarez 2020-12-04 15:41:24 +00:00
parent bd2566d391
commit 108f61928b
3 changed files with 21 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/style/stylesheets/mod.rs
View file

@ -405,8 +405,10 @@ impl CssRule {
allow_import_rules, allow_import_rules,
}; };
parse_one_rule(&mut input, &mut rule_parser) match parse_one_rule(&mut input, &mut rule_parser) {
.map_err(|_| rule_parser.dom_error.unwrap_or(RulesMutateError::Syntax)) Ok((_, rule)) => Ok(rule),
Err(_) => Err(rule_parser.dom_error.unwrap_or(RulesMutateError::Syntax)),
}
} }
} }

32
components/style/stylesheets/rule_parser.rs
View file

@ -27,7 +27,7 @@ use crate::values::computed::font::FamilyName;
use crate::values::{CssUrl, CustomIdent, KeyframesName}; use crate::values::{CssUrl, CustomIdent, KeyframesName};
use crate::{Namespace, Prefix}; use crate::{Namespace, Prefix};
use cssparser::{AtRuleParser, AtRuleType, Parser, QualifiedRuleParser, RuleListParser}; use cssparser::{AtRuleParser, AtRuleType, Parser, QualifiedRuleParser, RuleListParser};
use cssparser::{BasicParseError, BasicParseErrorKind, CowRcStr, ParserState}; use cssparser::{BasicParseError, BasicParseErrorKind, CowRcStr, SourcePosition, ParserState};
use selectors::SelectorList; use selectors::SelectorList;
use servo_arc::Arc; use servo_arc::Arc;
use style_traits::{ParseError, StyleParseErrorKind}; use style_traits::{ParseError, StyleParseErrorKind};
@ -178,7 +178,7 @@ pub enum AtRuleNonBlockPrelude {
impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> { impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
type PreludeNoBlock = AtRuleNonBlockPrelude; type PreludeNoBlock = AtRuleNonBlockPrelude;
type PreludeBlock = AtRuleBlockPrelude; type PreludeBlock = AtRuleBlockPrelude;
type AtRule = CssRule; type AtRule = (SourcePosition, CssRule);
type Error = StyleParseErrorKind<'i>; type Error = StyleParseErrorKind<'i>;
fn parse_prelude<'t>( fn parse_prelude<'t>(
@ -253,11 +253,10 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
prelude: AtRuleBlockPrelude, prelude: AtRuleBlockPrelude,
start: &ParserState, start: &ParserState,
input: &mut Parser<'i, 't>, input: &mut Parser<'i, 't>,
) -> Result<CssRule, ParseError<'i>> { ) -> Result<Self::AtRule, ParseError<'i>> {
AtRuleParser::parse_block(&mut self.nested(), prelude, start, input).map(|rule| { let rule = AtRuleParser::parse_block(&mut self.nested(), prelude, start, input)?;
self.state = State::Body; self.state = State::Body;
rule Ok((start.position(), rule))
})
} }
#[inline] #[inline]
@ -266,7 +265,7 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
prelude: AtRuleNonBlockPrelude, prelude: AtRuleNonBlockPrelude,
start: &ParserState, start: &ParserState,
) -> Self::AtRule { ) -> Self::AtRule {
match prelude { let rule = match prelude {
AtRuleNonBlockPrelude::Import(url, media) => { AtRuleNonBlockPrelude::Import(url, media) => {
let loader = self let loader = self
.loader .loader
@ -299,13 +298,15 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
source_location: start.source_location(), source_location: start.source_location(),
}))) })))
}, },
} };
(start.position(), rule)
} }
} }
impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser<'a> { impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser<'a> {
type Prelude = SelectorList<SelectorImpl>; type Prelude = SelectorList<SelectorImpl>;
type QualifiedRule = CssRule; type QualifiedRule = (SourcePosition, CssRule);
type Error = StyleParseErrorKind<'i>; type Error = StyleParseErrorKind<'i>;
#[inline] #[inline]
@ -326,13 +327,10 @@ impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser<'a> {
prelude: Self::Prelude, prelude: Self::Prelude,
start: &ParserState, start: &ParserState,
input: &mut Parser<'i, 't>, input: &mut Parser<'i, 't>,
) -> Result<CssRule, ParseError<'i>> { ) -> Result<Self::QualifiedRule, ParseError<'i>> {
QualifiedRuleParser::parse_block(&mut self.nested(), prelude, start, input).map( let rule = QualifiedRuleParser::parse_block(&mut self.nested(), prelude, start, input)?;
|result| { self.state = State::Body;
self.state = State::Body; Ok((start.position(), rule))
result
},
)
} }
} }

5
components/style/stylesheets/stylesheet.rs
View file

@ -503,19 +503,18 @@ impl Stylesheet {
let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser); let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser);
loop { loop {
let rule_start = iter.input.position().byte_index();
let result = match iter.next() { let result = match iter.next() {
Some(result) => result, Some(result) => result,
None => break, None => break,
}; };
match result { match result {
Ok(rule) => { Ok((rule_start, rule)) => {
if let Some(ref mut data) = sanitization_data { if let Some(ref mut data) = sanitization_data {
if !data.kind.allows(&rule) { if !data.kind.allows(&rule) {
continue; continue;
} }
let end = iter.input.position().byte_index(); let end = iter.input.position().byte_index();
data.output.push_str(&css[rule_start..end]); data.output.push_str(&css[rule_start.byte_index()..end]);
} }
// Use a fallible push here, and if it fails, just fall // Use a fallible push here, and if it fails, just fall
// out of the loop. This will cause the page to be // out of the loop. This will cause the page to be