Auto merge of #12815 - emilio:stylo-atoms, r=bholley

stylo: Use atoms as the pseudo-element back-end.

<!-- Please describe your changes on the following line: -->

A bit of work left, and we can uber-optimize this (left comments, will fill follow-ups), but this is a decent refactor so I thought I'd rather get some feedback on it.

r? @bholley (not formally yet, maybe, but some feedback is appreciated).

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: -->
- [x] `./mach build -d` does not report any errors
- [x] `./mach test-tidy` does not report any errors

<!-- Either: -->
- [x] These changes do not require tests because geckolib only...

<!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. -->

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/12815)
<!-- Reviewable:end -->

4 files changed, 378 insertions, 289 deletions

diff --git a/components/style/gecko_selector_impl.rs b/components/style/gecko_selector_impl.rs
index 055bf5f7ff6..7002483e95b 100644
--- a/components/style/gecko_selector_impl.rs
+++ b/components/style/gecko_selector_impl.rs
@@ -12,104 +12,85 @@ use stylesheets::Stylesheet;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct GeckoSelectorImpl;
 
+/// NOTE: The boolean field represents whether this element is an anonymous box.
+///
+/// This is just for convenience, instead of recomputing it. Also, note that
+/// Atom is always a static atom, so if space is a concern, we can use the
+/// raw pointer and use the lower bit to represent it without space overhead.
+///
+/// FIXME(emilio): we know all these atoms are static. Patches are starting to
+/// pile up, but a further potential optimisation is generating bindings without
+/// `-no-gen-bitfield-methods` (that was removed to compile on stable, but it no
+/// longer depends on it), and using the raw *mut nsIAtom (properly asserting
+/// we're a static atom).
+///
+/// This should allow us to avoid random FFI overhead when cloning/dropping
+/// pseudos.
+///
+/// Also, we can further optimize PartialEq and hash comparing/hashing only the
+/// atoms.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum PseudoElement {
-    Before,
-    After,
-
-    Backdrop,
-    FirstLetter,
-    FirstLine,
-    MozSelection,
-    MozFocusInner,
-    MozFocusOuter,
-    MozListBullet,
-    MozListNumber,
-    MozMathAnonymous,
-    MozNumberWrapper,
-    MozNumberText,
-    MozNumberSpinBox,
-    MozNumberSpinUp,
-    MozNumberSpinDown,
-    MozProgressBar,
-    MozRangeTrack,
-    MozRangeProgress,
-    MozRangeThumb,
-    MozMeterBar,
-    MozPlaceholder,
-    MozColorSwatch,
-
-    AnonBox(AnonBoxPseudoElement),
-}
+pub struct PseudoElement(Atom, bool);
 
-// https://mxr.mozilla.org/mozilla-central/source/layout/style/nsCSSAnonBoxList.h
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub enum AnonBoxPseudoElement {
-    MozText,
-    MozOtherNonElement,
-    MozAnonymousBlock,
-    MozAnonymousPositionedBlock,
-    MozMathMLAnonymousBlock,
-    MozXULAnonymousBlock,
-
-    MozHorizontalFramesetBorder,
-    MozVerticalFramesetBorder,
-    MozLineFrame,
-    MozButtonContent,
-    MozButtonLabel,
-    MozCellContent,
-    MozDropdownList,
-    MozFieldsetContent,
-    MozFramesetBlank,
-    MozDisplayComboboxControlFrame,
-
-    MozHTMLCanvasContent,
-    MozInlineTable,
-    MozTable,
-    MozTableCell,
-    MozTableColumnGroup,
-    MozTableColumn,
-    MozTableWrapper,
-    MozTableRowGroup,
-    MozTableRow,
-
-    MozCanvas,
-    MozPageBreak,
-    MozPage,
-    MozPageContent,
-    MozPageSequence,
-    MozScrolledContent,
-    MozScrolledCanvas,
-    MozScrolledPageSequence,
-    MozColumnContent,
-    MozViewport,
-    MozViewportScroll,
-    MozAnonymousFlexItem,
-    MozAnonymousGridItem,
-
-    MozRuby,
-    MozRubyBase,
-    MozRubyBaseContainer,
-    MozRubyText,
-    MozRubyTextContainer,
-
-    MozTreeColumn,
-    MozTreeRow,
-    MozTreeSeparator,
-    MozTreeCell,
-    MozTreeIndentation,
-    MozTreeLine,
-    MozTreeTwisty,
-    MozTreeImage,
-    MozTreeCellText,
-    MozTreeCheckbox,
-    MozTreeProgressMeter,
-    MozTreeDropFeedback,
-
-    MozSVGMarkerAnonChild,
-    MozSVGOuterSVGAnonChild,
-    MozSVGForeignContent,
-    MozSVGText,
+impl PseudoElement {
+    #[inline]
+    fn as_atom(&self) -> &Atom {
+        &self.0
+    }
+
+    #[inline]
+    fn is_anon_box(&self) -> bool {
+        self.1
+    }
+
+    #[inline]
+    pub fn from_atom_unchecked(atom: Atom, is_anon_box: bool) -> Self {
+        if cfg!(debug_assertions) {
+            // Do the check on debug regardless.
+            match Self::from_atom(&*atom, true) {
+                Some(pseudo) => {
+                    assert_eq!(pseudo.is_anon_box(), is_anon_box);
+                    return pseudo;
+                }
+                None => panic!("Unknown pseudo: {:?}", atom),
+            }
+        }
+
+        PseudoElement(atom, is_anon_box)
+    }
+
+    #[inline]
+    fn from_atom(atom: &WeakAtom, in_ua: bool) -> Option<Self> {
+        macro_rules! pseudo_element {
+            ($pseudo_str_with_colon:expr, $atom:expr, $is_anon_box:expr) => {{
+                if atom == &*$atom {
+                    return Some(PseudoElement($atom, $is_anon_box));
+                }
+            }}
+        }
+
+        include!("generated/gecko_pseudo_element_helper.rs");
+
+        None
+    }
+
+    #[inline]
+    fn from_slice(s: &str, in_ua_stylesheet: bool) -> Option<Self> {
+        use std::ascii::AsciiExt;
+        macro_rules! pseudo_element {
+            ($pseudo_str_with_colon:expr, $atom:expr, $is_anon_box:expr) => {{
+                if !$is_anon_box || in_ua_stylesheet {
+                    if s.eq_ignore_ascii_case(&$pseudo_str_with_colon[1..]) {
+                        return Some(PseudoElement($atom, $is_anon_box))
+                    }
+                }
+            }}
+        }
+
+        include!("generated/gecko_pseudo_element_helper.rs");
+
+        None
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -194,211 +175,44 @@ impl SelectorImpl for GeckoSelectorImpl {
 
     fn parse_pseudo_element(context: &ParserContext<Self>,
                             name: &str) -> Result<PseudoElement, ()> {
-        use self::AnonBoxPseudoElement::*;
-        use self::PseudoElement::*;
-
-        // The braces here are unfortunate, but they're needed for
-        // match_ignore_ascii_case! to work as expected.
-        match_ignore_ascii_case! { name,
-            "before" => { return Ok(Before) },
-            "after" => { return Ok(After) },
-            "first-line" => { return Ok(FirstLine) },
-            "backdrop" => { return Ok(Backdrop) },
-            "first-letter" => { return Ok(FirstLetter) },
-            "first-line" => { return Ok(FirstLine) },
-            "-moz-selection" => { return Ok(MozSelection) },
-            "-moz-focus-inner" => { return Ok(MozFocusInner) },
-            "-moz-focus-outer" => { return Ok(MozFocusOuter) },
-            "-moz-list-bullet" => { return Ok(MozListBullet) },
-            "-moz-list-number" => { return Ok(MozListNumber) },
-            "-moz-math-anonymous" => { return Ok(MozMathAnonymous) },
-            "-moz-number-wrapper" => { return Ok(MozNumberWrapper) },
-            "-moz-number-text" => { return Ok(MozNumberText) },
-            "-moz-number-spin-box" => { return Ok(MozNumberSpinBox) },
-            "-moz-number-spin-up" => { return Ok(MozNumberSpinUp) },
-            "-moz-number-spin-down" => { return Ok(MozNumberSpinDown) },
-            "-moz-progress-bar" => { return Ok(MozProgressBar) },
-            "-moz-range-track" => { return Ok(MozRangeTrack) },
-            "-moz-range-progress" => { return Ok(MozRangeProgress) },
-            "-moz-range-thumb" => { return Ok(MozRangeThumb) },
-            "-moz-metter-bar" => { return Ok(MozMeterBar) },
-            "-moz-placeholder" => { return Ok(MozPlaceholder) },
-            "-moz-color-swatch" => { return Ok(MozColorSwatch) },
-
-            _ => {}
-        }
-
-        if !context.in_user_agent_stylesheet {
-            return Err(())
+        match PseudoElement::from_slice(name, context.in_user_agent_stylesheet) {
+            Some(pseudo) => Ok(pseudo),
+            None => Err(()),
         }
-
-        Ok(AnonBox(match_ignore_ascii_case! { name,
-            "-moz-text" => MozText,
-            "-moz-other-non-element" => MozOtherNonElement,
-
-            "-moz-anonymous-block" => MozAnonymousBlock,
-            "-moz-anonymous-positioned-block" => MozAnonymousPositionedBlock,
-            "-moz-mathml-anonymous-block" => MozMathMLAnonymousBlock,
-            "-moz-xul-anonymous-block" => MozXULAnonymousBlock,
-
-            "-moz-hframeset-border" => MozHorizontalFramesetBorder,
-            "-moz-vframeset-border" => MozVerticalFramesetBorder,
-
-            "-moz-line-frame" => MozLineFrame,
-
-            "-moz-button-content" => MozButtonContent,
-            "-moz-buttonlabel" => MozButtonLabel,
-            "-moz-cell-content" => MozCellContent,
-            "-moz-dropdown-list" => MozDropdownList,
-            "-moz-fieldset-content" => MozFieldsetContent,
-            "-moz-frameset-blank" => MozFramesetBlank,
-            "-moz-display-comboboxcontrol-frame" => MozDisplayComboboxControlFrame,
-            "-moz-html-canvas-content" => MozHTMLCanvasContent,
-
-            "-moz-inline-table" => MozInlineTable,
-            "-moz-table" => MozTable,
-            "-moz-table-cell" => MozTableCell,
-            "-moz-table-column-group" => MozTableColumnGroup,
-            "-moz-table-column" => MozTableColumn,
-            "-moz-table-wrapper" => MozTableWrapper,
-            "-moz-table-row-group" => MozTableRowGroup,
-            "-moz-table-row" => MozTableRow,
-
-            "-moz-canvas" => MozCanvas,
-            "-moz-pagebreak" => MozPageBreak,
-            "-moz-page" => MozPage,
-            "-moz-pagecontent" => MozPageContent,
-            "-moz-page-sequence" => MozPageSequence,
-            "-moz-scrolled-content" => MozScrolledContent,
-            "-moz-scrolled-canvas" => MozScrolledCanvas,
-            "-moz-scrolled-page-sequence" => MozScrolledPageSequence,
-            "-moz-column-content" => MozColumnContent,
-            "-moz-viewport" => MozViewport,
-            "-moz-viewport-scroll" => MozViewportScroll,
-            "-moz-anonymous-flex-item" => MozAnonymousFlexItem,
-            "-moz-anonymous-grid-item" => MozAnonymousGridItem,
-            "-moz-ruby" => MozRuby,
-            "-moz-ruby-base" => MozRubyBase,
-            "-moz-ruby-base-container" => MozRubyBaseContainer,
-            "-moz-ruby-text" => MozRubyText,
-            "-moz-ruby-text-container" => MozRubyTextContainer,
-            "-moz-tree-column" => MozTreeColumn,
-            "-moz-tree-row" => MozTreeRow,
-            "-moz-tree-separator" => MozTreeSeparator,
-            "-moz-tree-cell" => MozTreeCell,
-            "-moz-tree-indentation" => MozTreeIndentation,
-            "-moz-tree-line" => MozTreeLine,
-            "-moz-tree-twisty" => MozTreeTwisty,
-            "-moz-tree-image" => MozTreeImage,
-            "-moz-tree-cell-text" => MozTreeCellText,
-            "-moz-tree-checkbox" => MozTreeCheckbox,
-            "-moz-tree-progressmeter" => MozTreeProgressMeter,
-            "-moz-tree-drop-feedback" => MozTreeDropFeedback,
-            "-moz-svg-marker-anon-child" => MozSVGMarkerAnonChild,
-            "-moz-svg-outer-svg-anon-child" => MozSVGOuterSVGAnonChild,
-            "-moz-svg-foreign-content" => MozSVGForeignContent,
-            "-moz-svg-text" => MozSVGText,
-
-            _ => return Err(())
-        }))
     }
 }
 
 impl GeckoSelectorImpl {
     #[inline]
     pub fn pseudo_element_cascade_type(pseudo: &PseudoElement) -> PseudoElementCascadeType {
-        match *pseudo {
-            PseudoElement::Before |
-            PseudoElement::After => PseudoElementCascadeType::Eager,
-            PseudoElement::AnonBox(_) => PseudoElementCascadeType::Precomputed,
-            _ => PseudoElementCascadeType::Lazy,
+        if Self::pseudo_is_before_or_after(pseudo) {
+            return PseudoElementCascadeType::Eager
+        }
+
+        if pseudo.is_anon_box() {
+            return PseudoElementCascadeType::Precomputed
         }
+
+        PseudoElementCascadeType::Lazy
     }
 
     #[inline]
     pub fn each_pseudo_element<F>(mut fun: F)
-        where F: FnMut(PseudoElement) {
-        use self::AnonBoxPseudoElement::*;
-        use self::PseudoElement::*;
-
-        fun(Before);
-        fun(After);
-        fun(FirstLine);
-
-        fun(AnonBox(MozText));
-        fun(AnonBox(MozOtherNonElement));
-        fun(AnonBox(MozAnonymousBlock));
-        fun(AnonBox(MozAnonymousPositionedBlock));
-        fun(AnonBox(MozMathMLAnonymousBlock));
-        fun(AnonBox(MozXULAnonymousBlock));
-
-        fun(AnonBox(MozHorizontalFramesetBorder));
-        fun(AnonBox(MozVerticalFramesetBorder));
-        fun(AnonBox(MozLineFrame));
-        fun(AnonBox(MozButtonContent));
-        fun(AnonBox(MozButtonLabel));
-        fun(AnonBox(MozCellContent));
-        fun(AnonBox(MozDropdownList));
-        fun(AnonBox(MozFieldsetContent));
-        fun(AnonBox(MozFramesetBlank));
-        fun(AnonBox(MozDisplayComboboxControlFrame));
-
-        fun(AnonBox(MozHTMLCanvasContent));
-        fun(AnonBox(MozInlineTable));
-        fun(AnonBox(MozTable));
-        fun(AnonBox(MozTableCell));
-        fun(AnonBox(MozTableColumnGroup));
-        fun(AnonBox(MozTableColumn));
-        fun(AnonBox(MozTableWrapper));
-        fun(AnonBox(MozTableRowGroup));
-        fun(AnonBox(MozTableRow));
-
-        fun(AnonBox(MozCanvas));
-        fun(AnonBox(MozPageBreak));
-        fun(AnonBox(MozPage));
-        fun(AnonBox(MozPageContent));
-        fun(AnonBox(MozPageSequence));
-        fun(AnonBox(MozScrolledContent));
-        fun(AnonBox(MozScrolledCanvas));
-        fun(AnonBox(MozScrolledPageSequence));
-        fun(AnonBox(MozColumnContent));
-        fun(AnonBox(MozViewport));
-        fun(AnonBox(MozViewportScroll));
-        fun(AnonBox(MozAnonymousFlexItem));
-        fun(AnonBox(MozAnonymousGridItem));
-
-        fun(AnonBox(MozRuby));
-        fun(AnonBox(MozRubyBase));
-        fun(AnonBox(MozRubyBaseContainer));
-        fun(AnonBox(MozRubyText));
-        fun(AnonBox(MozRubyTextContainer));
-
-        fun(AnonBox(MozTreeColumn));
-        fun(AnonBox(MozTreeRow));
-        fun(AnonBox(MozTreeSeparator));
-        fun(AnonBox(MozTreeCell));
-        fun(AnonBox(MozTreeIndentation));
-        fun(AnonBox(MozTreeLine));
-        fun(AnonBox(MozTreeTwisty));
-        fun(AnonBox(MozTreeImage));
-        fun(AnonBox(MozTreeCellText));
-        fun(AnonBox(MozTreeCheckbox));
-        fun(AnonBox(MozTreeProgressMeter));
-        fun(AnonBox(MozTreeDropFeedback));
-
-        fun(AnonBox(MozSVGMarkerAnonChild));
-        fun(AnonBox(MozSVGOuterSVGAnonChild));
-        fun(AnonBox(MozSVGForeignContent));
-        fun(AnonBox(MozSVGText));
+        where F: FnMut(PseudoElement)
+    {
+        macro_rules! pseudo_element {
+            ($pseudo_str_with_colon:expr, $atom:expr, $is_anon_box:expr) => {{
+                fun(PseudoElement($atom, $is_anon_box));
+            }}
+        }
+
+        include!("generated/gecko_pseudo_element_helper.rs")
     }
 
     #[inline]
     pub fn pseudo_is_before_or_after(pseudo: &PseudoElement) -> bool {
-        match *pseudo {
-            PseudoElement::Before |
-            PseudoElement::After => true,
-            _ => false,
-        }
+        *pseudo.as_atom() == atom!(":before") ||
+        *pseudo.as_atom() == atom!(":after")
     }
 
     #[inline]
diff --git a/components/style/generated/gecko_pseudo_element_helper.rs b/components/style/generated/gecko_pseudo_element_helper.rs
new file mode 100644
index 00000000000..3d69e042206
--- /dev/null
+++ b/components/style/generated/gecko_pseudo_element_helper.rs
@@ -0,0 +1,277 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Autogenerated file, DO NOT EDIT DIRECTLY */
+
+/*
+ * This file contains a helper macro invocation to aid Gecko's style system
+ * pseudo-element integration.
+ *
+ * This file is NOT INTENDED to be compiled as a standalone module.
+ *
+ * Also, it guarantees the property that normal pseudo-elements are processed
+ * before anonymous boxes.
+ *
+ * Expected usage is as follows:
+ *
+ * ```
+ * fn have_to_use_pseudo_elements() {
+ *     macro_rules pseudo_element! {
+ *         ($pseudo_str_with_colon:expr, $pseudo_atom:expr, $is_anon_box:true) => {{
+ *             // Stuff stuff stuff.
+ *         }}
+ *     }
+ *     include!("path/to/helper.rs")
+ * }
+ * ```
+ *
+ */
+{
+    pseudo_element!(":after",
+                    atom!(":after"),
+                    false);
+    pseudo_element!(":before",
+                    atom!(":before"),
+                    false);
+    pseudo_element!(":backdrop",
+                    atom!(":backdrop"),
+                    false);
+    pseudo_element!(":first-letter",
+                    atom!(":first-letter"),
+                    false);
+    pseudo_element!(":first-line",
+                    atom!(":first-line"),
+                    false);
+    pseudo_element!(":-moz-selection",
+                    atom!(":-moz-selection"),
+                    false);
+    pseudo_element!(":-moz-focus-inner",
+                    atom!(":-moz-focus-inner"),
+                    false);
+    pseudo_element!(":-moz-focus-outer",
+                    atom!(":-moz-focus-outer"),
+                    false);
+    pseudo_element!(":-moz-list-bullet",
+                    atom!(":-moz-list-bullet"),
+                    false);
+    pseudo_element!(":-moz-list-number",
+                    atom!(":-moz-list-number"),
+                    false);
+    pseudo_element!(":-moz-math-anonymous",
+                    atom!(":-moz-math-anonymous"),
+                    false);
+    pseudo_element!(":-moz-number-wrapper",
+                    atom!(":-moz-number-wrapper"),
+                    false);
+    pseudo_element!(":-moz-number-text",
+                    atom!(":-moz-number-text"),
+                    false);
+    pseudo_element!(":-moz-number-spin-box",
+                    atom!(":-moz-number-spin-box"),
+                    false);
+    pseudo_element!(":-moz-number-spin-up",
+                    atom!(":-moz-number-spin-up"),
+                    false);
+    pseudo_element!(":-moz-number-spin-down",
+                    atom!(":-moz-number-spin-down"),
+                    false);
+    pseudo_element!(":-moz-progress-bar",
+                    atom!(":-moz-progress-bar"),
+                    false);
+    pseudo_element!(":-moz-range-track",
+                    atom!(":-moz-range-track"),
+                    false);
+    pseudo_element!(":-moz-range-progress",
+                    atom!(":-moz-range-progress"),
+                    false);
+    pseudo_element!(":-moz-range-thumb",
+                    atom!(":-moz-range-thumb"),
+                    false);
+    pseudo_element!(":-moz-meter-bar",
+                    atom!(":-moz-meter-bar"),
+                    false);
+    pseudo_element!(":-moz-placeholder",
+                    atom!(":-moz-placeholder"),
+                    false);
+    pseudo_element!(":-moz-color-swatch",
+                    atom!(":-moz-color-swatch"),
+                    false);
+    pseudo_element!(":-moz-text",
+                    atom!(":-moz-text"),
+                    true);
+    pseudo_element!(":-moz-other-non-element",
+                    atom!(":-moz-other-non-element"),
+                    true);
+    pseudo_element!(":-moz-anonymous-block",
+                    atom!(":-moz-anonymous-block"),
+                    true);
+    pseudo_element!(":-moz-anonymous-positioned-block",
+                    atom!(":-moz-anonymous-positioned-block"),
+                    true);
+    pseudo_element!(":-moz-mathml-anonymous-block",
+                    atom!(":-moz-mathml-anonymous-block"),
+                    true);
+    pseudo_element!(":-moz-xul-anonymous-block",
+                    atom!(":-moz-xul-anonymous-block"),
+                    true);
+    pseudo_element!(":-moz-hframeset-border",
+                    atom!(":-moz-hframeset-border"),
+                    true);
+    pseudo_element!(":-moz-vframeset-border",
+                    atom!(":-moz-vframeset-border"),
+                    true);
+    pseudo_element!(":-moz-line-frame",
+                    atom!(":-moz-line-frame"),
+                    true);
+    pseudo_element!(":-moz-button-content",
+                    atom!(":-moz-button-content"),
+                    true);
+    pseudo_element!(":-moz-buttonlabel",
+                    atom!(":-moz-buttonlabel"),
+                    true);
+    pseudo_element!(":-moz-cell-content",
+                    atom!(":-moz-cell-content"),
+                    true);
+    pseudo_element!(":-moz-dropdown-list",
+                    atom!(":-moz-dropdown-list"),
+                    true);
+    pseudo_element!(":-moz-fieldset-content",
+                    atom!(":-moz-fieldset-content"),
+                    true);
+    pseudo_element!(":-moz-frameset-blank",
+                    atom!(":-moz-frameset-blank"),
+                    true);
+    pseudo_element!(":-moz-display-comboboxcontrol-frame",
+                    atom!(":-moz-display-comboboxcontrol-frame"),
+                    true);
+    pseudo_element!(":-moz-html-canvas-content",
+                    atom!(":-moz-html-canvas-content"),
+                    true);
+    pseudo_element!(":-moz-inline-table",
+                    atom!(":-moz-inline-table"),
+                    true);
+    pseudo_element!(":-moz-table",
+                    atom!(":-moz-table"),
+                    true);
+    pseudo_element!(":-moz-table-cell",
+                    atom!(":-moz-table-cell"),
+                    true);
+    pseudo_element!(":-moz-table-column-group",
+                    atom!(":-moz-table-column-group"),
+                    true);
+    pseudo_element!(":-moz-table-column",
+                    atom!(":-moz-table-column"),
+                    true);
+    pseudo_element!(":-moz-table-wrapper",
+                    atom!(":-moz-table-wrapper"),
+                    true);
+    pseudo_element!(":-moz-table-row-group",
+                    atom!(":-moz-table-row-group"),
+                    true);
+    pseudo_element!(":-moz-table-row",
+                    atom!(":-moz-table-row"),
+                    true);
+    pseudo_element!(":-moz-canvas",
+                    atom!(":-moz-canvas"),
+                    true);
+    pseudo_element!(":-moz-pagebreak",
+                    atom!(":-moz-pagebreak"),
+                    true);
+    pseudo_element!(":-moz-page",
+                    atom!(":-moz-page"),
+                    true);
+    pseudo_element!(":-moz-pagecontent",
+                    atom!(":-moz-pagecontent"),
+                    true);
+    pseudo_element!(":-moz-page-sequence",
+                    atom!(":-moz-page-sequence"),
+                    true);
+    pseudo_element!(":-moz-scrolled-content",
+                    atom!(":-moz-scrolled-content"),
+                    true);
+    pseudo_element!(":-moz-scrolled-canvas",
+                    atom!(":-moz-scrolled-canvas"),
+                    true);
+    pseudo_element!(":-moz-scrolled-page-sequence",
+                    atom!(":-moz-scrolled-page-sequence"),
+                    true);
+    pseudo_element!(":-moz-column-content",
+                    atom!(":-moz-column-content"),
+                    true);
+    pseudo_element!(":-moz-viewport",
+                    atom!(":-moz-viewport"),
+                    true);
+    pseudo_element!(":-moz-viewport-scroll",
+                    atom!(":-moz-viewport-scroll"),
+                    true);
+    pseudo_element!(":-moz-anonymous-flex-item",
+                    atom!(":-moz-anonymous-flex-item"),
+                    true);
+    pseudo_element!(":-moz-anonymous-grid-item",
+                    atom!(":-moz-anonymous-grid-item"),
+                    true);
+    pseudo_element!(":-moz-ruby",
+                    atom!(":-moz-ruby"),
+                    true);
+    pseudo_element!(":-moz-ruby-base",
+                    atom!(":-moz-ruby-base"),
+                    true);
+    pseudo_element!(":-moz-ruby-base-container",
+                    atom!(":-moz-ruby-base-container"),
+                    true);
+    pseudo_element!(":-moz-ruby-text",
+                    atom!(":-moz-ruby-text"),
+                    true);
+    pseudo_element!(":-moz-ruby-text-container",
+                    atom!(":-moz-ruby-text-container"),
+                    true);
+    pseudo_element!(":-moz-tree-column",
+                    atom!(":-moz-tree-column"),
+                    true);
+    pseudo_element!(":-moz-tree-row",
+                    atom!(":-moz-tree-row"),
+                    true);
+    pseudo_element!(":-moz-tree-separator",
+                    atom!(":-moz-tree-separator"),
+                    true);
+    pseudo_element!(":-moz-tree-cell",
+                    atom!(":-moz-tree-cell"),
+                    true);
+    pseudo_element!(":-moz-tree-indentation",
+                    atom!(":-moz-tree-indentation"),
+                    true);
+    pseudo_element!(":-moz-tree-line",
+                    atom!(":-moz-tree-line"),
+                    true);
+    pseudo_element!(":-moz-tree-twisty",
+                    atom!(":-moz-tree-twisty"),
+                    true);
+    pseudo_element!(":-moz-tree-image",
+                    atom!(":-moz-tree-image"),
+                    true);
+    pseudo_element!(":-moz-tree-cell-text",
+                    atom!(":-moz-tree-cell-text"),
+                    true);
+    pseudo_element!(":-moz-tree-checkbox",
+                    atom!(":-moz-tree-checkbox"),
+                    true);
+    pseudo_element!(":-moz-tree-progressmeter",
+                    atom!(":-moz-tree-progressmeter"),
+                    true);
+    pseudo_element!(":-moz-tree-drop-feedback",
+                    atom!(":-moz-tree-drop-feedback"),
+                    true);
+    pseudo_element!(":-moz-svg-marker-anon-child",
+                    atom!(":-moz-svg-marker-anon-child"),
+                    true);
+    pseudo_element!(":-moz-svg-outer-svg-anon-child",
+                    atom!(":-moz-svg-outer-svg-anon-child"),
+                    true);
+    pseudo_element!(":-moz-svg-foreign-content",
+                    atom!(":-moz-svg-foreign-content"),
+                    true);
+    pseudo_element!(":-moz-svg-text",
+                    atom!(":-moz-svg-text"),
+                    true);
+}
diff --git a/components/style/properties/gecko.mako.rs b/components/style/properties/gecko.mako.rs
index f1014308e22..9fb7a1ac52d 100644
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@@ -425,7 +425,7 @@ impl ${style_struct.gecko_struct_name} {
     pub fn initial() -> Arc<Self> {
         let mut result = Arc::new(${style_struct.gecko_struct_name} { gecko: unsafe { zeroed() } });
         unsafe {
-            Gecko_Construct_${style_struct.gecko_ffi_name}(&mut Arc::make_mut(&mut result).gecko);
+            Gecko_Construct_${style_struct.gecko_ffi_name}(&mut Arc::get_mut(&mut result).unwrap().gecko);
         }
         result
     }
@@ -914,7 +914,6 @@ fn static_assert() {
             T::left   => true,
             T::right  => true
         };
-        // TODO(shinglyu): Rename Gecko's struct to mPageBreakBefore
         self.gecko.mBreakBefore = result;
     }
 
@@ -931,7 +930,6 @@ fn static_assert() {
             T::left   => true,
             T::right  => true
         };
-        // TODO(shinglyu): Rename Gecko's struct to mPageBreakBefore
         self.gecko.mBreakBefore = result;
     }
 
diff --git a/components/style/properties/longhand/ui.mako.rs b/components/style/properties/longhand/ui.mako.rs
index b78222ab560..f815c1d8518 100644
--- a/components/style/properties/longhand/ui.mako.rs
+++ b/components/style/properties/longhand/ui.mako.rs
@@ -15,5 +15,5 @@ ${helpers.single_keyword("ime-mode", "normal auto active disabled inactive",
 
 ${helpers.single_keyword("-moz-user-select", "auto text none all", products="gecko",
                          gecko_ffi_name="mUserSelect",
-                         gecko_constant_prefix="NS_STYLE_USER_SELECT",
+                         gecko_enum_prefix="StyleUserSelect",
                          animatable=False)}