Update cssparser

components/style/Cargo.toml

@@ -22,7 +22,7 @@ servo = ["serde", "serde/unstable", "serde_macros", "heapsize", "heapsize_plugin
 [dependencies]
 app_units = "0.3"
 bitflags = "0.7"
-cssparser = "0.6"
+cssparser = "0.7"
 deque = "0.3.1"
 encoding = "0.2"
 euclid = "0.10.1"

components/style/font_face.rs

@@ -119,7 +119,7 @@ impl<'a, 'b> AtRuleParser for FontFaceRuleParser<'a, 'b> {
 impl<'a, 'b> DeclarationParser for FontFaceRuleParser<'a, 'b> {
     type Declaration = FontFaceDescriptorDeclaration;
 
-    fn parse_value(&self, name: &str, input: &mut Parser) -> Result<FontFaceDescriptorDeclaration, ()> {
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<FontFaceDescriptorDeclaration, ()> {
         match_ignore_ascii_case! { name,
             "font-family" => {
                 Ok(FontFaceDescriptorDeclaration::Family(try!(

components/style/keyframes.rs

@@ -232,7 +232,7 @@ impl<'a> QualifiedRuleParser for KeyframeListParser<'a> {
     type Prelude = KeyframeSelector;
     type QualifiedRule = Arc<Keyframe>;
 
-    fn parse_prelude(&self, input: &mut Parser) -> Result<Self::Prelude, ()> {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<Self::Prelude, ()> {
         let start = input.position();
         match input.parse_comma_separated(|input| KeyframePercentage::parse(input)) {
             Ok(percentages) => Ok(KeyframeSelector(percentages)),
@@ -244,7 +244,7 @@ impl<'a> QualifiedRuleParser for KeyframeListParser<'a> {
         }
     }
 
-    fn parse_block(&self, prelude: Self::Prelude, input: &mut Parser)
+    fn parse_block(&mut self, prelude: Self::Prelude, input: &mut Parser)
                    -> Result<Self::QualifiedRule, ()> {
         let mut declarations = Vec::new();
         let parser = KeyframeDeclarationParser {
@@ -286,7 +286,7 @@ impl<'a, 'b> AtRuleParser for KeyframeDeclarationParser<'a, 'b> {
 impl<'a, 'b> DeclarationParser for KeyframeDeclarationParser<'a, 'b> {
     type Declaration = Vec<PropertyDeclaration>;
 
-    fn parse_value(&self, name: &str, input: &mut Parser) -> Result<Vec<PropertyDeclaration>, ()> {
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<Vec<PropertyDeclaration>, ()> {
         let mut results = Vec::new();
         match PropertyDeclaration::parse(name, self.context, input, &mut results, true) {
             PropertyDeclarationParseResult::ValidOrIgnoredDeclaration => {}

components/style/properties/properties.mako.rs

@@ -544,7 +544,7 @@ impl<'a, 'b> AtRuleParser for PropertyDeclarationParser<'a, 'b> {
 impl<'a, 'b> DeclarationParser for PropertyDeclarationParser<'a, 'b> {
     type Declaration = (Vec<PropertyDeclaration>, Importance);
 
-    fn parse_value(&self, name: &str, input: &mut Parser)
+    fn parse_value(&mut self, name: &str, input: &mut Parser)
                    -> Result<(Vec<PropertyDeclaration>, Importance), ()> {
         let mut results = vec![];
         try!(input.parse_until_before(Delimiter::Bang, |input| {

components/style/stylesheets.rs

@@ -427,7 +427,7 @@ impl<'a> AtRuleParser for TopLevelRuleParser<'a> {
     type Prelude = AtRulePrelude;
     type AtRule = CSSRule;
 
-    fn parse_prelude(&self, name: &str, input: &mut Parser)
+    fn parse_prelude(&mut self, name: &str, input: &mut Parser)
                      -> Result<AtRuleType<AtRulePrelude, CSSRule>, ()> {
         match_ignore_ascii_case! { name,
             "import" => {
@@ -460,12 +460,12 @@ impl<'a> AtRuleParser for TopLevelRuleParser<'a> {
         }
 
         self.state.set(State::Body);
-        AtRuleParser::parse_prelude(&NestedRuleParser { context: &self.context }, name, input)
+        AtRuleParser::parse_prelude(&mut NestedRuleParser { context: &self.context }, name, input)
     }
 
     #[inline]
-    fn parse_block(&self, prelude: AtRulePrelude, input: &mut Parser) -> Result<CSSRule, ()> {
-        AtRuleParser::parse_block(&NestedRuleParser { context: &self.context }, prelude, input)
+    fn parse_block(&mut self, prelude: AtRulePrelude, input: &mut Parser) -> Result<CSSRule, ()> {
+        AtRuleParser::parse_block(&mut NestedRuleParser { context: &self.context }, prelude, input)
     }
 }
 
@@ -475,14 +475,15 @@ impl<'a> QualifiedRuleParser for TopLevelRuleParser<'a> {
     type QualifiedRule = CSSRule;
 
     #[inline]
-    fn parse_prelude(&self, input: &mut Parser) -> Result<Vec<Selector<TheSelectorImpl>>, ()> {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<Vec<Selector<TheSelectorImpl>>, ()> {
         self.state.set(State::Body);
-        QualifiedRuleParser::parse_prelude(&NestedRuleParser { context: &self.context }, input)
+        QualifiedRuleParser::parse_prelude(&mut NestedRuleParser { context: &self.context }, input)
     }
 
     #[inline]
-    fn parse_block(&self, prelude: Vec<Selector<TheSelectorImpl>>, input: &mut Parser) -> Result<CSSRule, ()> {
-        QualifiedRuleParser::parse_block(&NestedRuleParser { context: &self.context },
+    fn parse_block(&mut self, prelude: Vec<Selector<TheSelectorImpl>>, input: &mut Parser)
+                   -> Result<CSSRule, ()> {
+        QualifiedRuleParser::parse_block(&mut NestedRuleParser { context: &self.context },
                                          prelude, input)
     }
 }
@@ -497,7 +498,7 @@ impl<'a, 'b> AtRuleParser for NestedRuleParser<'a, 'b> {
     type Prelude = AtRulePrelude;
     type AtRule = CSSRule;
 
-    fn parse_prelude(&self, name: &str, input: &mut Parser)
+    fn parse_prelude(&mut self, name: &str, input: &mut Parser)
                      -> Result<AtRuleType<AtRulePrelude, CSSRule>, ()> {
         match_ignore_ascii_case! { name,
             "media" => {
@@ -527,7 +528,7 @@ impl<'a, 'b> AtRuleParser for NestedRuleParser<'a, 'b> {
         }
     }
 
-    fn parse_block(&self, prelude: AtRulePrelude, input: &mut Parser) -> Result<CSSRule, ()> {
+    fn parse_block(&mut self, prelude: AtRulePrelude, input: &mut Parser) -> Result<CSSRule, ()> {
         match prelude {
             AtRulePrelude::FontFace => {
                 Ok(CSSRule::FontFace(Arc::new(try!(parse_font_face_block(self.context, input)))))
@@ -555,11 +556,12 @@ impl<'a, 'b> QualifiedRuleParser for NestedRuleParser<'a, 'b> {
     type Prelude = Vec<Selector<TheSelectorImpl>>;
     type QualifiedRule = CSSRule;
 
-    fn parse_prelude(&self, input: &mut Parser) -> Result<Vec<Selector<TheSelectorImpl>>, ()> {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<Vec<Selector<TheSelectorImpl>>, ()> {
         parse_selector_list(&self.context.selector_context, input)
     }
 
-    fn parse_block(&self, prelude: Vec<Selector<TheSelectorImpl>>, input: &mut Parser) -> Result<CSSRule, ()> {
+    fn parse_block(&mut self, prelude: Vec<Selector<TheSelectorImpl>>, input: &mut Parser)
+                   -> Result<CSSRule, ()> {
         Ok(CSSRule::Style(Arc::new(StyleRule {
             selectors: prelude,
             declarations: Arc::new(parse_property_declaration_list(self.context, input))

components/style/viewport.rs

@@ -225,7 +225,7 @@ impl<'a, 'b> AtRuleParser for ViewportRuleParser<'a, 'b> {
 impl<'a, 'b> DeclarationParser for ViewportRuleParser<'a, 'b> {
     type Declaration = Vec<ViewportDescriptorDeclaration>;
 
-    fn parse_value(&self, name: &str, input: &mut Parser) -> Result<Vec<ViewportDescriptorDeclaration>, ()> {
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<Vec<ViewportDescriptorDeclaration>, ()> {
         macro_rules! declaration {
             ($declaration:ident($parse:path)) => {
                 declaration!($declaration(value: try!($parse(input)),