--- a/servo/components/style/gecko/generated/pseudo_element_definition.rs
+++ b/servo/components/style/gecko/generated/pseudo_element_definition.rs
@@ -135,39 +135,39 @@ pub enum PseudoElement {
         RubyBase,
         /// :-moz-ruby-base-container
         RubyBaseContainer,
         /// :-moz-ruby-text
         RubyText,
         /// :-moz-ruby-text-container
         RubyTextContainer,
         /// :-moz-tree-column
-        MozTreeColumn(Box<[String]>),
+        MozTreeColumn(Box<[Atom]>),
         /// :-moz-tree-row
-        MozTreeRow(Box<[String]>),
+        MozTreeRow(Box<[Atom]>),
         /// :-moz-tree-separator
-        MozTreeSeparator(Box<[String]>),
+        MozTreeSeparator(Box<[Atom]>),
         /// :-moz-tree-cell
-        MozTreeCell(Box<[String]>),
+        MozTreeCell(Box<[Atom]>),
         /// :-moz-tree-indentation
-        MozTreeIndentation(Box<[String]>),
+        MozTreeIndentation(Box<[Atom]>),
         /// :-moz-tree-line
-        MozTreeLine(Box<[String]>),
+        MozTreeLine(Box<[Atom]>),
         /// :-moz-tree-twisty
-        MozTreeTwisty(Box<[String]>),
+        MozTreeTwisty(Box<[Atom]>),
         /// :-moz-tree-image
-        MozTreeImage(Box<[String]>),
+        MozTreeImage(Box<[Atom]>),
         /// :-moz-tree-cell-text
-        MozTreeCellText(Box<[String]>),
+        MozTreeCellText(Box<[Atom]>),
         /// :-moz-tree-checkbox
-        MozTreeCheckbox(Box<[String]>),
+        MozTreeCheckbox(Box<[Atom]>),
         /// :-moz-tree-progressmeter
-        MozTreeProgressmeter(Box<[String]>),
+        MozTreeProgressmeter(Box<[Atom]>),
         /// :-moz-tree-drop-feedback
-        MozTreeDropFeedback(Box<[String]>),
+        MozTreeDropFeedback(Box<[Atom]>),
         /// :-moz-svg-marker-anon-child
         MozSVGMarkerAnonChild,
         /// :-moz-svg-outer-svg-anon-child
         MozSVGOuterSVGAnonChild,
         /// :-moz-svg-foreign-content
         MozSVGForeignContent,
         /// :-moz-svg-text
         MozSVGText,
@@ -1631,17 +1631,17 @@ None
         None
     }
 
     /// Constructs a tree pseudo-element from the given name and arguments.
     /// "name" must start with "-moz-tree-".
     ///
     /// Returns `None` if the pseudo-element is not recognized.
     #[inline]
-    pub fn tree_pseudo_element(name: &str, args: Box<[String]>) -> Option<Self> {
+    pub fn tree_pseudo_element(name: &str, args: Box<[Atom]>) -> Option<Self> {
         use std::ascii::AsciiExt;
         debug_assert!(name.starts_with("-moz-tree-"));
         let tree_part = &name[10..];
             if tree_part.eq_ignore_ascii_case("column") {
                 return Some(PseudoElement::MozTreeColumn(args));
             }
             if tree_part.eq_ignore_ascii_case("row") {
                 return Some(PseudoElement::MozTreeRow(args));
@@ -1779,20 +1779,20 @@ impl ToCss for PseudoElement {
             PseudoElement::MozTreeImage(ref args) |
             PseudoElement::MozTreeCellText(ref args) |
             PseudoElement::MozTreeCheckbox(ref args) |
             PseudoElement::MozTreeProgressmeter(ref args) |
             PseudoElement::MozTreeDropFeedback(ref args) => {
                 dest.write_char('(')?;
                 let mut iter = args.iter();
                 if let Some(first) = iter.next() {
-                    serialize_identifier(first, dest)?;
+                    serialize_identifier(&first.to_string(), dest)?;
                     for item in iter {
                         dest.write_str(", ")?;
-                        serialize_identifier(item, dest)?;
+                        serialize_identifier(&item.to_string(), dest)?;
                     }
                 }
                 dest.write_char(')')
             }
             _ => Ok(()),
         }
     }
 }

--- a/servo/components/style/gecko/pseudo_element_definition.mako.rs
+++ b/servo/components/style/gecko/pseudo_element_definition.mako.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /// Gecko's pseudo-element definition.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum PseudoElement {
     % for pseudo in PSEUDOS:
         /// ${pseudo.value}
         % if pseudo.is_tree_pseudo_element():
-        ${pseudo.capitalized()}(Box<[String]>),
+        ${pseudo.capitalized()}(Box<[Atom]>),
         % else:
         ${pseudo.capitalized()},
         % endif
     % endfor
 }
 
 /// Important: If you change this, you should also update Gecko's
 /// nsCSSPseudoElements::IsEagerlyCascadedInServo.
@@ -202,17 +202,17 @@ impl PseudoElement {
         None
     }
 
     /// Constructs a tree pseudo-element from the given name and arguments.
     /// "name" must start with "-moz-tree-".
     ///
     /// Returns `None` if the pseudo-element is not recognized.
     #[inline]
-    pub fn tree_pseudo_element(name: &str, args: Box<[String]>) -> Option<Self> {
+    pub fn tree_pseudo_element(name: &str, args: Box<[Atom]>) -> Option<Self> {
         use std::ascii::AsciiExt;
         debug_assert!(name.starts_with("-moz-tree-"));
         let tree_part = &name[10..];
         % for pseudo in TREE_PSEUDOS:
             if tree_part.eq_ignore_ascii_case("${pseudo.value[11:]}") {
                 return Some(${pseudo_element_variant(pseudo, "args")});
             }
         % endfor
@@ -229,20 +229,20 @@ impl ToCss for PseudoElement {
             % endfor
         }
         match *self {
             ${" |\n            ".join("PseudoElement::{}(ref args)".format(pseudo.capitalized())
                                       for pseudo in TREE_PSEUDOS)} => {
                 dest.write_char('(')?;
                 let mut iter = args.iter();
                 if let Some(first) = iter.next() {
-                    serialize_identifier(first, dest)?;
+                    serialize_identifier(&first.to_string(), dest)?;
                     for item in iter {
                         dest.write_str(", ")?;
-                        serialize_identifier(item, dest)?;
+                        serialize_identifier(&item.to_string(), dest)?;
                     }
                 }
                 dest.write_char(')')
             }
             _ => Ok(()),
         }
     }
 }

--- a/servo/components/style/gecko/selector_parser.rs
+++ b/servo/components/style/gecko/selector_parser.rs
@@ -387,17 +387,17 @@ impl<'a, 'i> ::selectors::Parser<'i> for
                                            -> Result<PseudoElement, ParseError<'i>> {
         if name.starts_with("-moz-tree-") {
             // Tree pseudo-elements can have zero or more arguments,
             // separated by either comma or space.
             let mut args = Vec::new();
             loop {
                 let location = parser.current_source_location();
                 match parser.next() {
-                    Ok(&Token::Ident(ref ident)) => args.push(ident.as_ref().to_owned()),
+                    Ok(&Token::Ident(ref ident)) => args.push(Atom::from(ident.as_ref())),
                     Ok(&Token::Comma) => {},
                     Ok(t) => return Err(location.new_unexpected_token_error(t.clone())),
                     Err(BasicParseError { kind: BasicParseErrorKind::EndOfInput, .. }) => break,
                     _ => unreachable!("Parser::next() shouldn't return any other error"),
                 }
             }
             let args = args.into_boxed_slice();
             if let Some(pseudo) = PseudoElement::tree_pseudo_element(&name, args) {