From 108f61928b0dee6712ee0f9015e32938885f98a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= <emilio@crisal.io>
Date: Fri, 4 Dec 2020 15:41:24 +0000
Subject: [PATCH] style: Use a more precise rule start for sanitization.

Differential Revision: https://phabricator.services.mozilla.com/D98710
---
 components/style/stylesheets/mod.rs         |  6 ++--
 components/style/stylesheets/rule_parser.rs | 32 ++++++++++-----------
 components/style/stylesheets/stylesheet.rs  |  5 ++--
 3 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/components/style/stylesheets/mod.rs b/components/style/stylesheets/mod.rs
index 2daa9f3c547..4c1e996fd5d 100644
--- a/components/style/stylesheets/mod.rs
+++ b/components/style/stylesheets/mod.rs
@@ -405,8 +405,10 @@ impl CssRule {
             allow_import_rules,
         };
 
-        parse_one_rule(&mut input, &mut rule_parser)
-            .map_err(|_| rule_parser.dom_error.unwrap_or(RulesMutateError::Syntax))
+        match parse_one_rule(&mut input, &mut rule_parser) {
+            Ok((_, rule)) => Ok(rule),
+            Err(_) => Err(rule_parser.dom_error.unwrap_or(RulesMutateError::Syntax)),
+        }
     }
 }
 
diff --git a/components/style/stylesheets/rule_parser.rs b/components/style/stylesheets/rule_parser.rs
index f0624cd9784..4150f9936f1 100644
--- a/components/style/stylesheets/rule_parser.rs
+++ b/components/style/stylesheets/rule_parser.rs
@@ -27,7 +27,7 @@ use crate::values::computed::font::FamilyName;
 use crate::values::{CssUrl, CustomIdent, KeyframesName};
 use crate::{Namespace, Prefix};
 use cssparser::{AtRuleParser, AtRuleType, Parser, QualifiedRuleParser, RuleListParser};
-use cssparser::{BasicParseError, BasicParseErrorKind, CowRcStr, ParserState};
+use cssparser::{BasicParseError, BasicParseErrorKind, CowRcStr, SourcePosition, ParserState};
 use selectors::SelectorList;
 use servo_arc::Arc;
 use style_traits::{ParseError, StyleParseErrorKind};
@@ -178,7 +178,7 @@ pub enum AtRuleNonBlockPrelude {
 impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
     type PreludeNoBlock = AtRuleNonBlockPrelude;
     type PreludeBlock = AtRuleBlockPrelude;
-    type AtRule = CssRule;
+    type AtRule = (SourcePosition, CssRule);
     type Error = StyleParseErrorKind<'i>;
 
     fn parse_prelude<'t>(
@@ -253,11 +253,10 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
         prelude: AtRuleBlockPrelude,
         start: &ParserState,
         input: &mut Parser<'i, 't>,
-    ) -> Result<CssRule, ParseError<'i>> {
-        AtRuleParser::parse_block(&mut self.nested(), prelude, start, input).map(|rule| {
-            self.state = State::Body;
-            rule
-        })
+    ) -> Result<Self::AtRule, ParseError<'i>> {
+        let rule = AtRuleParser::parse_block(&mut self.nested(), prelude, start, input)?;
+        self.state = State::Body;
+        Ok((start.position(), rule))
     }
 
     #[inline]
@@ -266,7 +265,7 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
         prelude: AtRuleNonBlockPrelude,
         start: &ParserState,
     ) -> Self::AtRule {
-        match prelude {
+        let rule = match prelude {
             AtRuleNonBlockPrelude::Import(url, media) => {
                 let loader = self
                     .loader
@@ -299,13 +298,15 @@ impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a> {
                     source_location: start.source_location(),
                 })))
             },
-        }
+        };
+
+        (start.position(), rule)
     }
 }
 
 impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser<'a> {
     type Prelude = SelectorList<SelectorImpl>;
-    type QualifiedRule = CssRule;
+    type QualifiedRule = (SourcePosition, CssRule);
     type Error = StyleParseErrorKind<'i>;
 
     #[inline]
@@ -326,13 +327,10 @@ impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser<'a> {
         prelude: Self::Prelude,
         start: &ParserState,
         input: &mut Parser<'i, 't>,
-    ) -> Result<CssRule, ParseError<'i>> {
-        QualifiedRuleParser::parse_block(&mut self.nested(), prelude, start, input).map(
-            |result| {
-                self.state = State::Body;
-                result
-            },
-        )
+    ) -> Result<Self::QualifiedRule, ParseError<'i>> {
+        let rule = QualifiedRuleParser::parse_block(&mut self.nested(), prelude, start, input)?;
+        self.state = State::Body;
+        Ok((start.position(), rule))
     }
 }
 
diff --git a/components/style/stylesheets/stylesheet.rs b/components/style/stylesheets/stylesheet.rs
index e5b0c073f2f..8a9fd7db7cd 100644
--- a/components/style/stylesheets/stylesheet.rs
+++ b/components/style/stylesheets/stylesheet.rs
@@ -503,19 +503,18 @@ impl Stylesheet {
             let mut iter = RuleListParser::new_for_stylesheet(&mut input, rule_parser);
 
             loop {
-                let rule_start = iter.input.position().byte_index();
                 let result = match iter.next() {
                     Some(result) => result,
                     None => break,
                 };
                 match result {
-                    Ok(rule) => {
+                    Ok((rule_start, rule)) => {
                         if let Some(ref mut data) = sanitization_data {
                             if !data.kind.allows(&rule) {
                                 continue;
                             }
                             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
                         // out of the loop.  This will cause the page to be