servo: Merge #16878 - stylo: Rework pseudo-elements to support pseudo selectors with state (from emilio:pseudos); r=bholley,xidorn,hiro
authorEmilio Cobos Álvarez <emilio@crisal.io>
Mon, 15 May 2017 20:46:42 -0500
changeset 406625 1f595ec2b2a260460296adaf3999da88c69af866
parent 406624 0eb6bcebaf3d6f3d2b16c877f5a8828041445c16
child 406626 6028e667129f19ef7f77ad9bf1de55bff77d54f0
push id7391
push usermtabara@mozilla.com
push dateMon, 12 Jun 2017 13:08:53 +0000
treeherdermozilla-beta@2191d7f87e2e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbholley, xidorn, hiro
bugs16878
milestone55.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
servo: Merge #16878 - stylo: Rework pseudo-elements to support pseudo selectors with state (from emilio:pseudos); r=bholley,xidorn,hiro Source-Repo: https://github.com/servo/servo Source-Revision: 161dc666b017803c671a260f9d5298fc4c83f634
servo/components/script_layout_interface/wrapper_traits.rs
servo/components/selectors/parser.rs
servo/components/style/binding_tools/.gitignore
servo/components/style/binding_tools/README.md
servo/components/style/binding_tools/regen_atoms.py
servo/components/style/binding_tools/setup_bindgen.sh
servo/components/style/build_gecko.rs
servo/components/style/data.rs
servo/components/style/gecko/generated/bindings.rs
servo/components/style/gecko/generated/pseudo_element_definition.rs
servo/components/style/gecko/generated/pseudo_element_helper.rs
servo/components/style/gecko/generated/structs_debug.rs
servo/components/style/gecko/generated/structs_release.rs
servo/components/style/gecko/mod.rs
servo/components/style/gecko/pseudo_element.rs
servo/components/style/gecko/pseudo_element_definition.mako.rs
servo/components/style/gecko/regen_atoms.py
servo/components/style/gecko/selector_parser.rs
servo/components/style/gecko/wrapper.rs
servo/components/style/matching.rs
servo/components/style/restyle_hints.rs
servo/components/style/rule_tree/mod.rs
servo/components/style/servo/selector_parser.rs
servo/components/style/stylist.rs
servo/components/style/traversal.rs
servo/ports/geckolib/glue.rs
servo/tests/unit/style/restyle_hints.rs
servo/tests/unit/style/stylist.rs
servo/tests/unit/stylo/sanity_checks.rs
--- a/servo/components/script_layout_interface/wrapper_traits.rs
+++ b/servo/components/script_layout_interface/wrapper_traits.rs
@@ -15,16 +15,17 @@ use msg::constellation_msg::{FrameId, Pi
 use range::Range;
 use servo_url::ServoUrl;
 use std::fmt::Debug;
 use style::computed_values::display;
 use style::context::SharedStyleContext;
 use style::data::ElementData;
 use style::dom::{LayoutIterator, NodeInfo, PresentationalHintsSynthesizer, TNode};
 use style::dom::OpaqueNode;
+use style::element_state::ElementState;
 use style::font_metrics::ServoMetricsProvider;
 use style::properties::{CascadeFlags, ServoComputedValues};
 use style::selector_parser::{PseudoElement, PseudoElementCascadeType, SelectorImpl};
 use style::stylearc::Arc;
 use webrender_traits::ClipId;
 
 #[derive(Copy, PartialEq, Clone, Debug)]
 pub enum PseudoElementType<T> {
@@ -429,16 +430,17 @@ pub trait ThreadSafeLayoutElement: Clone
                     PseudoElementCascadeType::Lazy => {
                         if !data.styles().cached_pseudos.contains_key(&style_pseudo) {
                             let new_style =
                                 context.stylist
                                        .lazily_compute_pseudo_element_style(
                                            &context.guards,
                                            unsafe { &self.unsafe_get() },
                                            &style_pseudo,
+                                           ElementState::empty(),
                                            data.styles().primary.values(),
                                            &ServoMetricsProvider);
                             data.styles_mut().cached_pseudos
                                 .insert(style_pseudo.clone(), new_style.unwrap());
                         }
                         data.styles().cached_pseudos.get(&style_pseudo)
                             .unwrap().values().clone()
                     }
--- a/servo/components/selectors/parser.rs
+++ b/servo/components/selectors/parser.rs
@@ -56,17 +56,17 @@ macro_rules! with_all_bounds {
             type BorrowedNamespaceUrl: ?Sized + Eq;
             type BorrowedLocalName: ?Sized + Eq + Hash;
 
             /// non tree-structural pseudo-classes
             /// (see: https://drafts.csswg.org/selectors/#structural-pseudos)
             type NonTSPseudoClass: $($CommonBounds)* + Sized + ToCss + SelectorMethods<Impl = Self>;
 
             /// pseudo-elements
-            type PseudoElement: $($CommonBounds)* + Sized + ToCss;
+            type PseudoElementSelector: $($CommonBounds)* + Sized + ToCss;
         }
     }
 }
 
 macro_rules! with_bounds {
     ( [ $( $CommonBounds: tt )* ] [ $( $FromStr: tt )* ]) => {
         with_all_bounds! {
             [$($CommonBounds)* + $($FromStr)* + Display]
@@ -93,18 +93,18 @@ pub trait Parser {
 
     fn parse_non_ts_functional_pseudo_class
         (&self, _name: Cow<str>, _arguments: &mut CssParser)
         -> Result<<Self::Impl as SelectorImpl>::NonTSPseudoClass, ()>
     {
         Err(())
     }
 
-    fn parse_pseudo_element(&self, _name: Cow<str>)
-                            -> Result<<Self::Impl as SelectorImpl>::PseudoElement, ()> {
+    fn parse_pseudo_element(&self, _name: Cow<str>, _input: &mut CssParser)
+                            -> Result<<Self::Impl as SelectorImpl>::PseudoElementSelector, ()> {
         Err(())
     }
 
     fn default_namespace(&self) -> Option<<Self::Impl as SelectorImpl>::NamespaceUrl> {
         None
     }
 
     fn namespace_for_prefix(&self, _prefix: &<Self::Impl as SelectorImpl>::NamespacePrefix)
@@ -174,17 +174,17 @@ impl<Impl: SelectorImpl> SelectorInner<I
         let complex = ComplexSelector::from_vec(vec);
         Self::new(complex)
     }
 }
 
 #[derive(PartialEq, Eq, Hash, Clone)]
 pub struct Selector<Impl: SelectorImpl> {
     pub inner: SelectorInner<Impl>,
-    pub pseudo_element: Option<Impl::PseudoElement>,
+    pub pseudo_element: Option<Impl::PseudoElementSelector>,
     pub specificity: u32,
 }
 
 pub trait SelectorMethods {
     type Impl: SelectorImpl;
 
     fn visit<V>(&self, visitor: &mut V) -> bool
         where V: SelectorVisitor<Impl = Self::Impl>;
@@ -811,17 +811,17 @@ impl From<Specificity> for u32 {
     fn from(specificity: Specificity) -> u32 {
         cmp::min(specificity.id_selectors, MAX_10BIT) << 20
         | cmp::min(specificity.class_like_selectors, MAX_10BIT) << 10
         | cmp::min(specificity.element_selectors, MAX_10BIT)
     }
 }
 
 fn specificity<Impl>(complex_selector: &ComplexSelector<Impl>,
-                     pseudo_element: Option<&Impl::PseudoElement>)
+                     pseudo_element: Option<&Impl::PseudoElementSelector>)
                      -> u32
                      where Impl: SelectorImpl {
     let mut specificity = complex_selector_specificity(complex_selector);
     if pseudo_element.is_some() {
         specificity.element_selectors += 1;
     }
     specificity.into()
 }
@@ -911,17 +911,17 @@ fn parse_selector<P, Impl>(parser: &P, i
 /// If we parse N <= 4 entries, we save no reallocations.
 /// If we parse 4 < N <= 8 entries, we save one reallocation.
 /// If we parse N > 8 entries, we save two reallocations.
 type ParseVec<Impl> = SmallVec<[Component<Impl>; 8]>;
 
 fn parse_complex_selector_and_pseudo_element<P, Impl>(
         parser: &P,
         input: &mut CssParser)
-        -> Result<(ComplexSelector<Impl>, Option<Impl::PseudoElement>), ()>
+        -> Result<(ComplexSelector<Impl>, Option<Impl::PseudoElementSelector>), ()>
     where P: Parser<Impl=Impl>, Impl: SelectorImpl
 {
     let mut sequence = ParseVec::new();
     let mut pseudo_element;
     'outer_loop: loop {
         // Parse a sequence of simple selectors.
         pseudo_element = parse_compound_selector(parser, input, &mut sequence,
                                                  /* inside_negation = */ false)?;
@@ -1009,17 +1009,17 @@ fn parse_type_selector<P, Impl>(parser: 
             Ok(true)
         }
     }
 }
 
 #[derive(Debug)]
 enum SimpleSelectorParseResult<Impl: SelectorImpl> {
     SimpleSelector(Component<Impl>),
-    PseudoElement(Impl::PseudoElement),
+    PseudoElement(Impl::PseudoElementSelector),
 }
 
 /// * `Err(())`: Invalid selector, abort
 /// * `Ok(None)`: Not a simple selector, could be something else. `input` was not consumed.
 /// * `Ok(Some((namespace, local_name)))`: `None` for the local name means a `*` universal selector
 fn parse_qualified_name<'i, 't, P, Impl>
                        (parser: &P, input: &mut CssParser<'i, 't>,
                         in_attr_selector: bool)
@@ -1205,17 +1205,17 @@ fn parse_negation<P, Impl>(parser: &P,
 /// | [ HASH | class | attrib | pseudo | negation ]+
 ///
 /// `Err(())` means invalid selector
 fn parse_compound_selector<P, Impl>(
     parser: &P,
     input: &mut CssParser,
     mut sequence: &mut ParseVec<Impl>,
     inside_negation: bool)
-    -> Result<Option<Impl::PseudoElement>, ()>
+    -> Result<Option<Impl::PseudoElementSelector>, ()>
     where P: Parser<Impl=Impl>, Impl: SelectorImpl
 {
     // Consume any leading whitespace.
     loop {
         let position = input.position();
         if !matches!(input.next_including_whitespace(), Ok(Token::WhiteSpace(_))) {
             input.reset(position);
             break
@@ -1330,33 +1330,33 @@ fn parse_one_simple_selector<P, Impl>(pa
             match input.next_including_whitespace() {
                 Ok(Token::Ident(name)) => {
                     // Supported CSS 2.1 pseudo-elements only.
                     // ** Do not add to this list! **
                     if name.eq_ignore_ascii_case("before") ||
                        name.eq_ignore_ascii_case("after") ||
                        name.eq_ignore_ascii_case("first-line") ||
                        name.eq_ignore_ascii_case("first-letter") {
-                        let pseudo_element = P::parse_pseudo_element(parser, name)?;
+                        let pseudo_element = P::parse_pseudo_element(parser, name, input)?;
                         Ok(Some(SimpleSelectorParseResult::PseudoElement(pseudo_element)))
                     } else {
                         let pseudo_class = parse_simple_pseudo_class(parser, name)?;
                         Ok(Some(SimpleSelectorParseResult::SimpleSelector(pseudo_class)))
                     }
                 }
                 Ok(Token::Function(name)) => {
                     let pseudo = input.parse_nested_block(|input| {
                         parse_functional_pseudo_class(parser, input, name, inside_negation)
                     })?;
                     Ok(Some(SimpleSelectorParseResult::SimpleSelector(pseudo)))
                 }
                 Ok(Token::Colon) => {
                     match input.next_including_whitespace() {
                         Ok(Token::Ident(name)) => {
-                            let pseudo = P::parse_pseudo_element(parser, name)?;
+                            let pseudo = P::parse_pseudo_element(parser, name, input)?;
                             Ok(Some(SimpleSelectorParseResult::PseudoElement(pseudo)))
                         }
                         _ => Err(())
                     }
                 }
                 _ => Err(())
             }
         }
@@ -1450,17 +1450,17 @@ pub mod tests {
         type Identifier = DummyAtom;
         type ClassName = DummyAtom;
         type LocalName = DummyAtom;
         type NamespaceUrl = DummyAtom;
         type NamespacePrefix = DummyAtom;
         type BorrowedLocalName = DummyAtom;
         type BorrowedNamespaceUrl = DummyAtom;
         type NonTSPseudoClass = PseudoClass;
-        type PseudoElement = PseudoElement;
+        type PseudoElementSelector = PseudoElement;
     }
 
     #[derive(Default, Debug, Hash, Clone, PartialEq, Eq)]
     pub struct DummyAtom(String);
 
     impl fmt::Display for DummyAtom {
         fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
             <String as fmt::Display>::fmt(&self.0, fmt)
@@ -1500,17 +1500,17 @@ pub mod tests {
                                                 parser: &mut CssParser)
                                                 -> Result<PseudoClass, ()> {
             match_ignore_ascii_case! { &name,
                 "lang" => Ok(PseudoClass::Lang(try!(parser.expect_ident_or_string()).into_owned())),
                 _ => Err(())
             }
         }
 
-        fn parse_pseudo_element(&self, name: Cow<str>)
+        fn parse_pseudo_element(&self, name: Cow<str>, input: &mut CssParser)
                                 -> Result<PseudoElement, ()> {
             match_ignore_ascii_case! { &name,
                 "before" => Ok(PseudoElement::Before),
                 "after" => Ok(PseudoElement::After),
                 _ => Err(())
             }
         }
 
deleted file mode 100644
--- a/servo/components/style/binding_tools/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-llvm/
-rust-bindgen/
deleted file mode 100644
--- a/servo/components/style/binding_tools/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Geckolib tools
-
-This directory contains simple tools for generating the Rust bindings for [stylo](https://public.etherpad-mozilla.org/p/stylo).
-
-## `setup_bindgen.sh`
-
-This clones Servo's version of bindgen, and uses `llvm-3.8` library to build it. It will then be used to generate the Rust bindings.
deleted file mode 100755
--- a/servo/components/style/binding_tools/setup_bindgen.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-
-# 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/.
-
-set -o errexit
-set -o nounset
-set -o pipefail
-
-# Run in the tools directory.
-cd "$(dirname ${0})"
-
-# Setup and build bindgen.
-if [[ "$(uname)" == "Linux" ]]; then
-  export LIBCLANG_PATH=/usr/lib/llvm-3.8/lib
-else
-  export LIBCLANG_PATH="$(brew --prefix llvm38)/lib/llvm-3.8/lib"
-fi
-
-# Make sure we have llvm-3.8.
-if [[ ! -x "$(command -v clang-3.8)" ]]; then
-  echo "llvm-3.8 is required." \
-       "Mac users should |brew install llvm38|," \
-       "Linux users can find it in clang-3.8."
-  exit 1
-fi
-
-export LD_LIBRARY_PATH="${LIBCLANG_PATH}"
-export DYLD_LIBRARY_PATH="${LIBCLANG_PATH}"
--- a/servo/components/style/build_gecko.rs
+++ b/servo/components/style/build_gecko.rs
@@ -343,16 +343,18 @@ mod bindings {
             "ELEMENT_.*",
             "NS_FONT_.*",
             "NS_STYLE_.*",
             "NS_MATHML_.*",
             "NS_RADIUS_.*",
             "BORDER_COLOR_.*",
             "BORDER_STYLE_.*",
             "mozilla::SERVO_PREF_.*",
+            "CSS_PSEUDO_ELEMENT_.*",
+            "SERVO_CSS_PSEUDO_ELEMENT_FLAGS_.*",
             "kNameSpaceID_.*",
             "kGenericFont_.*",
             "kPresContext_.*",
         ];
         let whitelist = [
             "RawGecko.*",
             "mozilla::AnimationPropertySegment",
             "mozilla::ComputedTiming",
@@ -667,16 +669,17 @@ mod bindings {
             "RawServoStyleRule",
             "RawGeckoPresContext",
             "RawGeckoPresContextOwned",
             "RawGeckoStyleAnimationList",
             "RawGeckoServoStyleRuleList",
             "RawGeckoURLExtraData",
             "RefPtr",
             "CSSPseudoClassType",
+            "CSSPseudoElementType",
             "TraversalRestyleBehavior",
             "TraversalRootBehavior",
             "ComputedTimingFunction_BeforeFlag",
             "FontFamilyList",
             "FontFamilyType",
             "FontSizePrefs",
             "GeckoFontMetrics",
             "Keyframe",
@@ -837,17 +840,17 @@ mod bindings {
             // from the |structs| module. As such, we don't need to create an opaque
             // type with zero_size_type. If we ever introduce immutable borrow types
             // which _do_ need to be opaque, we'll need a separate mode.
         }
         write_binding_file(builder, BINDINGS_FILE, &Vec::new());
     }
 
     fn generate_atoms() {
-        let script = Path::new(file!()).parent().unwrap().join("binding_tools").join("regen_atoms.py");
+        let script = Path::new(file!()).parent().unwrap().join("gecko").join("regen_atoms.py");
         println!("cargo:rerun-if-changed={}", script.display());
         let status = Command::new(&*PYTHON)
             .arg(&script)
             .arg(DISTDIR_PATH.as_os_str())
             .arg(OUTDIR_PATH.as_os_str())
             .status()
             .unwrap();
         if !status.success() {
--- a/servo/components/style/data.rs
+++ b/servo/components/style/data.rs
@@ -379,16 +379,23 @@ impl ElementData {
                element,
                context.traversal_flags);
 
         let mut hint = match self.get_restyle() {
             Some(r) => r.hint.0,
             None => RestyleHint::empty(),
         };
 
+        debug!("compute_final_hint: {:?}, has_snapshot: {}, handled_snapshot: {}, \
+                pseudo: {:?}",
+                element,
+                element.has_snapshot(),
+                element.handled_snapshot(),
+                element.implemented_pseudo_element());
+
         if element.has_snapshot() && !element.handled_snapshot() {
             hint |= context.stylist.compute_restyle_hint(&element, context.snapshot_map);
             unsafe { element.set_handled_snapshot() }
             debug_assert!(element.handled_snapshot());
         }
 
         let empty_hint = hint.is_empty();
 
--- a/servo/components/style/gecko/generated/bindings.rs
+++ b/servo/components/style/gecko/generated/bindings.rs
@@ -21,16 +21,17 @@ use gecko_bindings::structs::RawServoDec
 use gecko_bindings::structs::RawServoStyleRule;
 use gecko_bindings::structs::RawGeckoPresContext;
 use gecko_bindings::structs::RawGeckoPresContextOwned;
 use gecko_bindings::structs::RawGeckoStyleAnimationList;
 use gecko_bindings::structs::RawGeckoServoStyleRuleList;
 use gecko_bindings::structs::RawGeckoURLExtraData;
 use gecko_bindings::structs::RefPtr;
 use gecko_bindings::structs::CSSPseudoClassType;
+use gecko_bindings::structs::CSSPseudoElementType;
 use gecko_bindings::structs::TraversalRestyleBehavior;
 use gecko_bindings::structs::TraversalRootBehavior;
 use gecko_bindings::structs::ComputedTimingFunction_BeforeFlag;
 use gecko_bindings::structs::FontFamilyList;
 use gecko_bindings::structs::FontFamilyType;
 use gecko_bindings::structs::FontSizePrefs;
 use gecko_bindings::structs::GeckoFontMetrics;
 use gecko_bindings::structs::Keyframe;
@@ -900,17 +901,17 @@ extern "C" {
 }
 extern "C" {
     pub fn Gecko_GetStyleContext(element: RawGeckoElementBorrowed,
                                  aPseudoTagOrNull: *mut nsIAtom)
      -> *mut nsStyleContext;
 }
 extern "C" {
     pub fn Gecko_GetImplementedPseudo(element: RawGeckoElementBorrowed)
-     -> *mut nsIAtom;
+     -> CSSPseudoElementType;
 }
 extern "C" {
     pub fn Gecko_CalcStyleDifference(oldstyle: *mut nsStyleContext,
                                      newstyle: ServoComputedValuesBorrowed)
      -> nsChangeHint;
 }
 extern "C" {
     pub fn Gecko_HintsHandledForDescendants(aHint: nsChangeHint)
@@ -1636,17 +1637,17 @@ extern "C" {
 extern "C" {
     pub fn Servo_StyleSheet_ClearAndUpdate(stylesheet:
                                                RawServoStyleSheetBorrowed,
                                            loader: *mut Loader,
                                            gecko_stylesheet:
                                                *mut ServoStyleSheet,
                                            data: *const nsACString,
                                            extra_data:
-                                                *mut RawGeckoURLExtraData,
+                                               *mut RawGeckoURLExtraData,
                                            line_number_offset: u32);
 }
 extern "C" {
     pub fn Servo_StyleSheet_HasRules(sheet: RawServoStyleSheetBorrowed)
      -> bool;
 }
 extern "C" {
     pub fn Servo_StyleSheet_GetRules(sheet: RawServoStyleSheetBorrowed)
@@ -2212,17 +2213,17 @@ extern "C" {
                               value: *const nsACString) -> bool;
 }
 extern "C" {
     pub fn Servo_CSSSupports(cond: *const nsACString) -> bool;
 }
 extern "C" {
     pub fn Servo_ComputedValues_GetForAnonymousBox(parent_style_or_null:
                                                        ServoComputedValuesBorrowedOrNull,
-                                                   pseudoTag: *mut nsIAtom,
+                                                   pseudo_tag: *mut nsIAtom,
                                                    skip_display_fixup: bool,
                                                    set:
                                                        RawServoStyleSetBorrowed)
      -> ServoComputedValuesStrong;
 }
 extern "C" {
     pub fn Servo_ComputedValues_Inherit(set: RawServoStyleSetBorrowed,
                                         parent_style:
@@ -2252,35 +2253,29 @@ extern "C" {
 }
 extern "C" {
     pub fn Servo_ResolveStyle(element: RawGeckoElementBorrowed,
                               set: RawServoStyleSetBorrowed,
                               allow_stale: bool) -> ServoComputedValuesStrong;
 }
 extern "C" {
     pub fn Servo_ResolvePseudoStyle(element: RawGeckoElementBorrowed,
-                                    pseudo_tag: *mut nsIAtom, is_probe: bool,
+                                    pseudo_type: CSSPseudoElementType,
+                                    is_probe: bool,
                                     set: RawServoStyleSetBorrowed)
      -> ServoComputedValuesStrong;
 }
 extern "C" {
-    pub fn Servo_ResolveRuleNode(element: RawGeckoElementBorrowed,
-                                 pseudo_tag: *mut nsIAtom,
-                                 set: RawServoStyleSetBorrowed)
-     -> RawServoRuleNodeStrong;
-}
-extern "C" {
-    pub fn Servo_HasAuthorSpecifiedRules(rule_node: RawServoRuleNodeBorrowed,
-                                         element: RawGeckoElementBorrowed,
+    pub fn Servo_HasAuthorSpecifiedRules(element: RawGeckoElementBorrowed,
                                          rule_type_mask: u32,
                                          author_colors_allowed: bool) -> bool;
 }
 extern "C" {
     pub fn Servo_ResolveStyleLazily(element: RawGeckoElementBorrowed,
-                                    pseudo_tag: *mut nsIAtom,
+                                    pseudo_type: CSSPseudoElementType,
                                     snapshots:
                                         *const ServoElementSnapshotTable,
                                     set: RawServoStyleSetBorrowed)
      -> ServoComputedValuesStrong;
 }
 extern "C" {
     pub fn Servo_TraverseSubtree(root: RawGeckoElementBorrowed,
                                  set: RawServoStyleSetBorrowed,
@@ -2294,18 +2289,18 @@ extern "C" {
 }
 extern "C" {
     pub fn Servo_StyleSet_GetBaseComputedValuesForElement(set:
                                                               RawServoStyleSetBorrowed,
                                                           element:
                                                               RawGeckoElementBorrowed,
                                                           snapshots:
                                                               *const ServoElementSnapshotTable,
-                                                          pseudo_tag:
-                                                              *mut nsIAtom)
+                                                          pseudo_type:
+                                                              CSSPseudoElementType)
      -> ServoComputedValuesStrong;
 }
 extern "C" {
     pub fn Servo_GetStyleFont(computed_values:
                                   ServoComputedValuesBorrowedOrNull)
      -> *const nsStyleFont;
 }
 extern "C" {
new file mode 100644
--- /dev/null
+++ b/servo/components/style/gecko/generated/pseudo_element_definition.rs
@@ -0,0 +1,1502 @@
+/* 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/. */
+
+/// Gecko's pseudo-element definition.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PseudoElement {
+        /// :after
+        After,
+        /// :before
+        Before,
+        /// :backdrop
+        Backdrop,
+        /// :cue
+        Cue,
+        /// :first-letter
+        FirstLetter,
+        /// :first-line
+        FirstLine,
+        /// :-moz-selection
+        MozSelection,
+        /// :-moz-focus-inner
+        MozFocusInner,
+        /// :-moz-focus-outer
+        MozFocusOuter,
+        /// :-moz-list-bullet
+        MozListBullet,
+        /// :-moz-list-number
+        MozListNumber,
+        /// :-moz-math-anonymous
+        MozMathAnonymous,
+        /// :-moz-number-wrapper
+        MozNumberWrapper,
+        /// :-moz-number-text
+        MozNumberText,
+        /// :-moz-number-spin-box
+        MozNumberSpinBox,
+        /// :-moz-number-spin-up
+        MozNumberSpinUp,
+        /// :-moz-number-spin-down
+        MozNumberSpinDown,
+        /// :-moz-progress-bar
+        MozProgressBar,
+        /// :-moz-range-track
+        MozRangeTrack,
+        /// :-moz-range-progress
+        MozRangeProgress,
+        /// :-moz-range-thumb
+        MozRangeThumb,
+        /// :-moz-meter-bar
+        MozMeterBar,
+        /// :-moz-placeholder
+        MozPlaceholder,
+        /// :placeholder
+        Placeholder,
+        /// :-moz-color-swatch
+        MozColorSwatch,
+        /// :-moz-text
+        MozText,
+        /// :-moz-oof-placeholder
+        OofPlaceholder,
+        /// :-moz-first-letter-continuation
+        FirstLetterContinuation,
+        /// :-moz-block-inside-inline-wrapper
+        MozBlockInsideInlineWrapper,
+        /// :-moz-mathml-anonymous-block
+        MozMathMLAnonymousBlock,
+        /// :-moz-xul-anonymous-block
+        MozXULAnonymousBlock,
+        /// :-moz-hframeset-border
+        HorizontalFramesetBorder,
+        /// :-moz-vframeset-border
+        VerticalFramesetBorder,
+        /// :-moz-line-frame
+        MozLineFrame,
+        /// :-moz-button-content
+        ButtonContent,
+        /// :-moz-cell-content
+        CellContent,
+        /// :-moz-dropdown-list
+        DropDownList,
+        /// :-moz-fieldset-content
+        FieldsetContent,
+        /// :-moz-frameset-blank
+        FramesetBlank,
+        /// :-moz-display-comboboxcontrol-frame
+        MozDisplayComboboxControlFrame,
+        /// :-moz-html-canvas-content
+        HtmlCanvasContent,
+        /// :-moz-inline-table
+        InlineTable,
+        /// :-moz-table
+        Table,
+        /// :-moz-table-cell
+        TableCell,
+        /// :-moz-table-column-group
+        TableColGroup,
+        /// :-moz-table-column
+        TableCol,
+        /// :-moz-table-wrapper
+        TableWrapper,
+        /// :-moz-table-row-group
+        TableRowGroup,
+        /// :-moz-table-row
+        TableRow,
+        /// :-moz-canvas
+        Canvas,
+        /// :-moz-pagebreak
+        PageBreak,
+        /// :-moz-page
+        Page,
+        /// :-moz-pagecontent
+        PageContent,
+        /// :-moz-page-sequence
+        PageSequence,
+        /// :-moz-scrolled-content
+        ScrolledContent,
+        /// :-moz-scrolled-canvas
+        ScrolledCanvas,
+        /// :-moz-scrolled-page-sequence
+        ScrolledPageSequence,
+        /// :-moz-column-content
+        ColumnContent,
+        /// :-moz-viewport
+        Viewport,
+        /// :-moz-viewport-scroll
+        ViewportScroll,
+        /// :-moz-anonymous-flex-item
+        AnonymousFlexItem,
+        /// :-moz-anonymous-grid-item
+        AnonymousGridItem,
+        /// :-moz-ruby
+        Ruby,
+        /// :-moz-ruby-base
+        RubyBase,
+        /// :-moz-ruby-base-container
+        RubyBaseContainer,
+        /// :-moz-ruby-text
+        RubyText,
+        /// :-moz-ruby-text-container
+        RubyTextContainer,
+        /// :-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,
+}
+
+
+
+/// The number of eager pseudo-elements.
+pub const EAGER_PSEUDO_COUNT: usize = 2;
+
+/// The list of eager pseudos.
+pub const EAGER_PSEUDOS: [PseudoElement; EAGER_PSEUDO_COUNT] = [
+    PseudoElement::Before,
+    PseudoElement::After,
+];
+
+impl PseudoElement {
+    /// Executes a closure with each pseudo-element as an argument.
+    pub fn each<F>(mut fun: F)
+        where F: FnMut(Self),
+    {
+            fun(PseudoElement::After);
+            fun(PseudoElement::Before);
+            fun(PseudoElement::Backdrop);
+            fun(PseudoElement::Cue);
+            fun(PseudoElement::FirstLetter);
+            fun(PseudoElement::FirstLine);
+            fun(PseudoElement::MozSelection);
+            fun(PseudoElement::MozFocusInner);
+            fun(PseudoElement::MozFocusOuter);
+            fun(PseudoElement::MozListBullet);
+            fun(PseudoElement::MozListNumber);
+            fun(PseudoElement::MozMathAnonymous);
+            fun(PseudoElement::MozNumberWrapper);
+            fun(PseudoElement::MozNumberText);
+            fun(PseudoElement::MozNumberSpinBox);
+            fun(PseudoElement::MozNumberSpinUp);
+            fun(PseudoElement::MozNumberSpinDown);
+            fun(PseudoElement::MozProgressBar);
+            fun(PseudoElement::MozRangeTrack);
+            fun(PseudoElement::MozRangeProgress);
+            fun(PseudoElement::MozRangeThumb);
+            fun(PseudoElement::MozMeterBar);
+            fun(PseudoElement::MozPlaceholder);
+            fun(PseudoElement::Placeholder);
+            fun(PseudoElement::MozColorSwatch);
+            fun(PseudoElement::MozText);
+            fun(PseudoElement::OofPlaceholder);
+            fun(PseudoElement::FirstLetterContinuation);
+            fun(PseudoElement::MozBlockInsideInlineWrapper);
+            fun(PseudoElement::MozMathMLAnonymousBlock);
+            fun(PseudoElement::MozXULAnonymousBlock);
+            fun(PseudoElement::HorizontalFramesetBorder);
+            fun(PseudoElement::VerticalFramesetBorder);
+            fun(PseudoElement::MozLineFrame);
+            fun(PseudoElement::ButtonContent);
+            fun(PseudoElement::CellContent);
+            fun(PseudoElement::DropDownList);
+            fun(PseudoElement::FieldsetContent);
+            fun(PseudoElement::FramesetBlank);
+            fun(PseudoElement::MozDisplayComboboxControlFrame);
+            fun(PseudoElement::HtmlCanvasContent);
+            fun(PseudoElement::InlineTable);
+            fun(PseudoElement::Table);
+            fun(PseudoElement::TableCell);
+            fun(PseudoElement::TableColGroup);
+            fun(PseudoElement::TableCol);
+            fun(PseudoElement::TableWrapper);
+            fun(PseudoElement::TableRowGroup);
+            fun(PseudoElement::TableRow);
+            fun(PseudoElement::Canvas);
+            fun(PseudoElement::PageBreak);
+            fun(PseudoElement::Page);
+            fun(PseudoElement::PageContent);
+            fun(PseudoElement::PageSequence);
+            fun(PseudoElement::ScrolledContent);
+            fun(PseudoElement::ScrolledCanvas);
+            fun(PseudoElement::ScrolledPageSequence);
+            fun(PseudoElement::ColumnContent);
+            fun(PseudoElement::Viewport);
+            fun(PseudoElement::ViewportScroll);
+            fun(PseudoElement::AnonymousFlexItem);
+            fun(PseudoElement::AnonymousGridItem);
+            fun(PseudoElement::Ruby);
+            fun(PseudoElement::RubyBase);
+            fun(PseudoElement::RubyBaseContainer);
+            fun(PseudoElement::RubyText);
+            fun(PseudoElement::RubyTextContainer);
+            fun(PseudoElement::Moztreecolumn);
+            fun(PseudoElement::Moztreerow);
+            fun(PseudoElement::Moztreeseparator);
+            fun(PseudoElement::Moztreecell);
+            fun(PseudoElement::Moztreeindentation);
+            fun(PseudoElement::Moztreeline);
+            fun(PseudoElement::Moztreetwisty);
+            fun(PseudoElement::Moztreeimage);
+            fun(PseudoElement::Moztreecelltext);
+            fun(PseudoElement::Moztreecheckbox);
+            fun(PseudoElement::Moztreeprogressmeter);
+            fun(PseudoElement::Moztreedropfeedback);
+            fun(PseudoElement::MozSVGMarkerAnonChild);
+            fun(PseudoElement::MozSVGOuterSVGAnonChild);
+            fun(PseudoElement::MozSVGForeignContent);
+            fun(PseudoElement::MozSVGText);
+    }
+
+    /// Get the pseudo-element as an atom.
+    #[inline]
+    pub fn atom(&self) -> Atom {
+        match *self {
+                PseudoElement::After => atom!(":after"),
+                PseudoElement::Before => atom!(":before"),
+                PseudoElement::Backdrop => atom!(":backdrop"),
+                PseudoElement::Cue => atom!(":cue"),
+                PseudoElement::FirstLetter => atom!(":first-letter"),
+                PseudoElement::FirstLine => atom!(":first-line"),
+                PseudoElement::MozSelection => atom!(":-moz-selection"),
+                PseudoElement::MozFocusInner => atom!(":-moz-focus-inner"),
+                PseudoElement::MozFocusOuter => atom!(":-moz-focus-outer"),
+                PseudoElement::MozListBullet => atom!(":-moz-list-bullet"),
+                PseudoElement::MozListNumber => atom!(":-moz-list-number"),
+                PseudoElement::MozMathAnonymous => atom!(":-moz-math-anonymous"),
+                PseudoElement::MozNumberWrapper => atom!(":-moz-number-wrapper"),
+                PseudoElement::MozNumberText => atom!(":-moz-number-text"),
+                PseudoElement::MozNumberSpinBox => atom!(":-moz-number-spin-box"),
+                PseudoElement::MozNumberSpinUp => atom!(":-moz-number-spin-up"),
+                PseudoElement::MozNumberSpinDown => atom!(":-moz-number-spin-down"),
+                PseudoElement::MozProgressBar => atom!(":-moz-progress-bar"),
+                PseudoElement::MozRangeTrack => atom!(":-moz-range-track"),
+                PseudoElement::MozRangeProgress => atom!(":-moz-range-progress"),
+                PseudoElement::MozRangeThumb => atom!(":-moz-range-thumb"),
+                PseudoElement::MozMeterBar => atom!(":-moz-meter-bar"),
+                PseudoElement::MozPlaceholder => atom!(":-moz-placeholder"),
+                PseudoElement::Placeholder => atom!(":placeholder"),
+                PseudoElement::MozColorSwatch => atom!(":-moz-color-swatch"),
+                PseudoElement::MozText => atom!(":-moz-text"),
+                PseudoElement::OofPlaceholder => atom!(":-moz-oof-placeholder"),
+                PseudoElement::FirstLetterContinuation => atom!(":-moz-first-letter-continuation"),
+                PseudoElement::MozBlockInsideInlineWrapper => atom!(":-moz-block-inside-inline-wrapper"),
+                PseudoElement::MozMathMLAnonymousBlock => atom!(":-moz-mathml-anonymous-block"),
+                PseudoElement::MozXULAnonymousBlock => atom!(":-moz-xul-anonymous-block"),
+                PseudoElement::HorizontalFramesetBorder => atom!(":-moz-hframeset-border"),
+                PseudoElement::VerticalFramesetBorder => atom!(":-moz-vframeset-border"),
+                PseudoElement::MozLineFrame => atom!(":-moz-line-frame"),
+                PseudoElement::ButtonContent => atom!(":-moz-button-content"),
+                PseudoElement::CellContent => atom!(":-moz-cell-content"),
+                PseudoElement::DropDownList => atom!(":-moz-dropdown-list"),
+                PseudoElement::FieldsetContent => atom!(":-moz-fieldset-content"),
+                PseudoElement::FramesetBlank => atom!(":-moz-frameset-blank"),
+                PseudoElement::MozDisplayComboboxControlFrame => atom!(":-moz-display-comboboxcontrol-frame"),
+                PseudoElement::HtmlCanvasContent => atom!(":-moz-html-canvas-content"),
+                PseudoElement::InlineTable => atom!(":-moz-inline-table"),
+                PseudoElement::Table => atom!(":-moz-table"),
+                PseudoElement::TableCell => atom!(":-moz-table-cell"),
+                PseudoElement::TableColGroup => atom!(":-moz-table-column-group"),
+                PseudoElement::TableCol => atom!(":-moz-table-column"),
+                PseudoElement::TableWrapper => atom!(":-moz-table-wrapper"),
+                PseudoElement::TableRowGroup => atom!(":-moz-table-row-group"),
+                PseudoElement::TableRow => atom!(":-moz-table-row"),
+                PseudoElement::Canvas => atom!(":-moz-canvas"),
+                PseudoElement::PageBreak => atom!(":-moz-pagebreak"),
+                PseudoElement::Page => atom!(":-moz-page"),
+                PseudoElement::PageContent => atom!(":-moz-pagecontent"),
+                PseudoElement::PageSequence => atom!(":-moz-page-sequence"),
+                PseudoElement::ScrolledContent => atom!(":-moz-scrolled-content"),
+                PseudoElement::ScrolledCanvas => atom!(":-moz-scrolled-canvas"),
+                PseudoElement::ScrolledPageSequence => atom!(":-moz-scrolled-page-sequence"),
+                PseudoElement::ColumnContent => atom!(":-moz-column-content"),
+                PseudoElement::Viewport => atom!(":-moz-viewport"),
+                PseudoElement::ViewportScroll => atom!(":-moz-viewport-scroll"),
+                PseudoElement::AnonymousFlexItem => atom!(":-moz-anonymous-flex-item"),
+                PseudoElement::AnonymousGridItem => atom!(":-moz-anonymous-grid-item"),
+                PseudoElement::Ruby => atom!(":-moz-ruby"),
+                PseudoElement::RubyBase => atom!(":-moz-ruby-base"),
+                PseudoElement::RubyBaseContainer => atom!(":-moz-ruby-base-container"),
+                PseudoElement::RubyText => atom!(":-moz-ruby-text"),
+                PseudoElement::RubyTextContainer => atom!(":-moz-ruby-text-container"),
+                PseudoElement::Moztreecolumn => atom!(":-moz-tree-column"),
+                PseudoElement::Moztreerow => atom!(":-moz-tree-row"),
+                PseudoElement::Moztreeseparator => atom!(":-moz-tree-separator"),
+                PseudoElement::Moztreecell => atom!(":-moz-tree-cell"),
+                PseudoElement::Moztreeindentation => atom!(":-moz-tree-indentation"),
+                PseudoElement::Moztreeline => atom!(":-moz-tree-line"),
+                PseudoElement::Moztreetwisty => atom!(":-moz-tree-twisty"),
+                PseudoElement::Moztreeimage => atom!(":-moz-tree-image"),
+                PseudoElement::Moztreecelltext => atom!(":-moz-tree-cell-text"),
+                PseudoElement::Moztreecheckbox => atom!(":-moz-tree-checkbox"),
+                PseudoElement::Moztreeprogressmeter => atom!(":-moz-tree-progressmeter"),
+                PseudoElement::Moztreedropfeedback => atom!(":-moz-tree-drop-feedback"),
+                PseudoElement::MozSVGMarkerAnonChild => atom!(":-moz-svg-marker-anon-child"),
+                PseudoElement::MozSVGOuterSVGAnonChild => atom!(":-moz-svg-outer-svg-anon-child"),
+                PseudoElement::MozSVGForeignContent => atom!(":-moz-svg-foreign-content"),
+                PseudoElement::MozSVGText => atom!(":-moz-svg-text"),
+        }
+    }
+
+    /// Whether this pseudo-element is an anonymous box.
+    #[inline]
+    fn is_anon_box(&self) -> bool {
+        match *self {
+                PseudoElement::After => false,
+                PseudoElement::Before => false,
+                PseudoElement::Backdrop => false,
+                PseudoElement::Cue => false,
+                PseudoElement::FirstLetter => false,
+                PseudoElement::FirstLine => false,
+                PseudoElement::MozSelection => false,
+                PseudoElement::MozFocusInner => false,
+                PseudoElement::MozFocusOuter => false,
+                PseudoElement::MozListBullet => false,
+                PseudoElement::MozListNumber => false,
+                PseudoElement::MozMathAnonymous => false,
+                PseudoElement::MozNumberWrapper => false,
+                PseudoElement::MozNumberText => false,
+                PseudoElement::MozNumberSpinBox => false,
+                PseudoElement::MozNumberSpinUp => false,
+                PseudoElement::MozNumberSpinDown => false,
+                PseudoElement::MozProgressBar => false,
+                PseudoElement::MozRangeTrack => false,
+                PseudoElement::MozRangeProgress => false,
+                PseudoElement::MozRangeThumb => false,
+                PseudoElement::MozMeterBar => false,
+                PseudoElement::MozPlaceholder => false,
+                PseudoElement::Placeholder => false,
+                PseudoElement::MozColorSwatch => false,
+                PseudoElement::MozText => true,
+                PseudoElement::OofPlaceholder => true,
+                PseudoElement::FirstLetterContinuation => true,
+                PseudoElement::MozBlockInsideInlineWrapper => true,
+                PseudoElement::MozMathMLAnonymousBlock => true,
+                PseudoElement::MozXULAnonymousBlock => true,
+                PseudoElement::HorizontalFramesetBorder => true,
+                PseudoElement::VerticalFramesetBorder => true,
+                PseudoElement::MozLineFrame => true,
+                PseudoElement::ButtonContent => true,
+                PseudoElement::CellContent => true,
+                PseudoElement::DropDownList => true,
+                PseudoElement::FieldsetContent => true,
+                PseudoElement::FramesetBlank => true,
+                PseudoElement::MozDisplayComboboxControlFrame => true,
+                PseudoElement::HtmlCanvasContent => true,
+                PseudoElement::InlineTable => true,
+                PseudoElement::Table => true,
+                PseudoElement::TableCell => true,
+                PseudoElement::TableColGroup => true,
+                PseudoElement::TableCol => true,
+                PseudoElement::TableWrapper => true,
+                PseudoElement::TableRowGroup => true,
+                PseudoElement::TableRow => true,
+                PseudoElement::Canvas => true,
+                PseudoElement::PageBreak => true,
+                PseudoElement::Page => true,
+                PseudoElement::PageContent => true,
+                PseudoElement::PageSequence => true,
+                PseudoElement::ScrolledContent => true,
+                PseudoElement::ScrolledCanvas => true,
+                PseudoElement::ScrolledPageSequence => true,
+                PseudoElement::ColumnContent => true,
+                PseudoElement::Viewport => true,
+                PseudoElement::ViewportScroll => true,
+                PseudoElement::AnonymousFlexItem => true,
+                PseudoElement::AnonymousGridItem => true,
+                PseudoElement::Ruby => true,
+                PseudoElement::RubyBase => true,
+                PseudoElement::RubyBaseContainer => true,
+                PseudoElement::RubyText => true,
+                PseudoElement::RubyTextContainer => true,
+                PseudoElement::Moztreecolumn => true,
+                PseudoElement::Moztreerow => true,
+                PseudoElement::Moztreeseparator => true,
+                PseudoElement::Moztreecell => true,
+                PseudoElement::Moztreeindentation => true,
+                PseudoElement::Moztreeline => true,
+                PseudoElement::Moztreetwisty => true,
+                PseudoElement::Moztreeimage => true,
+                PseudoElement::Moztreecelltext => true,
+                PseudoElement::Moztreecheckbox => true,
+                PseudoElement::Moztreeprogressmeter => true,
+                PseudoElement::Moztreedropfeedback => true,
+                PseudoElement::MozSVGMarkerAnonChild => true,
+                PseudoElement::MozSVGOuterSVGAnonChild => true,
+                PseudoElement::MozSVGForeignContent => true,
+                PseudoElement::MozSVGText => true,
+        }
+    }
+
+    /// Whether this pseudo-element is eagerly-cascaded.
+    #[inline]
+    pub fn is_eager(&self) -> bool {
+        matches!(*self,
+                 PseudoElement::Before | PseudoElement::After)
+    }
+
+    /// Gets the flags associated to this pseudo-element, or 0 if it's an
+    /// anonymous box.
+    pub fn flags(&self) -> u32 {
+        match *self {
+                PseudoElement::After => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after
+                }
+                PseudoElement::Before => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before
+                }
+                PseudoElement::Backdrop => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_backdrop
+                }
+                PseudoElement::Cue => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_cue
+                }
+                PseudoElement::FirstLetter => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLetter
+                }
+                PseudoElement::FirstLine => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLine
+                }
+                PseudoElement::MozSelection => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozSelection
+                }
+                PseudoElement::MozFocusInner => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozFocusInner
+                }
+                PseudoElement::MozFocusOuter => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozFocusOuter
+                }
+                PseudoElement::MozListBullet => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozListBullet
+                }
+                PseudoElement::MozListNumber => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozListNumber
+                }
+                PseudoElement::MozMathAnonymous => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozMathAnonymous
+                }
+                PseudoElement::MozNumberWrapper => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberWrapper
+                }
+                PseudoElement::MozNumberText => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberText
+                }
+                PseudoElement::MozNumberSpinBox => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinBox
+                }
+                PseudoElement::MozNumberSpinUp => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinUp
+                }
+                PseudoElement::MozNumberSpinDown => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinDown
+                }
+                PseudoElement::MozProgressBar => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozProgressBar
+                }
+                PseudoElement::MozRangeTrack => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeTrack
+                }
+                PseudoElement::MozRangeProgress => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeProgress
+                }
+                PseudoElement::MozRangeThumb => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeThumb
+                }
+                PseudoElement::MozMeterBar => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozMeterBar
+                }
+                PseudoElement::MozPlaceholder => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozPlaceholder
+                }
+                PseudoElement::Placeholder => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_placeholder
+                }
+                PseudoElement::MozColorSwatch => {
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozColorSwatch
+                }
+                PseudoElement::MozText => {
+                        0
+                }
+                PseudoElement::OofPlaceholder => {
+                        0
+                }
+                PseudoElement::FirstLetterContinuation => {
+                        0
+                }
+                PseudoElement::MozBlockInsideInlineWrapper => {
+                        0
+                }
+                PseudoElement::MozMathMLAnonymousBlock => {
+                        0
+                }
+                PseudoElement::MozXULAnonymousBlock => {
+                        0
+                }
+                PseudoElement::HorizontalFramesetBorder => {
+                        0
+                }
+                PseudoElement::VerticalFramesetBorder => {
+                        0
+                }
+                PseudoElement::MozLineFrame => {
+                        0
+                }
+                PseudoElement::ButtonContent => {
+                        0
+                }
+                PseudoElement::CellContent => {
+                        0
+                }
+                PseudoElement::DropDownList => {
+                        0
+                }
+                PseudoElement::FieldsetContent => {
+                        0
+                }
+                PseudoElement::FramesetBlank => {
+                        0
+                }
+                PseudoElement::MozDisplayComboboxControlFrame => {
+                        0
+                }
+                PseudoElement::HtmlCanvasContent => {
+                        0
+                }
+                PseudoElement::InlineTable => {
+                        0
+                }
+                PseudoElement::Table => {
+                        0
+                }
+                PseudoElement::TableCell => {
+                        0
+                }
+                PseudoElement::TableColGroup => {
+                        0
+                }
+                PseudoElement::TableCol => {
+                        0
+                }
+                PseudoElement::TableWrapper => {
+                        0
+                }
+                PseudoElement::TableRowGroup => {
+                        0
+                }
+                PseudoElement::TableRow => {
+                        0
+                }
+                PseudoElement::Canvas => {
+                        0
+                }
+                PseudoElement::PageBreak => {
+                        0
+                }
+                PseudoElement::Page => {
+                        0
+                }
+                PseudoElement::PageContent => {
+                        0
+                }
+                PseudoElement::PageSequence => {
+                        0
+                }
+                PseudoElement::ScrolledContent => {
+                        0
+                }
+                PseudoElement::ScrolledCanvas => {
+                        0
+                }
+                PseudoElement::ScrolledPageSequence => {
+                        0
+                }
+                PseudoElement::ColumnContent => {
+                        0
+                }
+                PseudoElement::Viewport => {
+                        0
+                }
+                PseudoElement::ViewportScroll => {
+                        0
+                }
+                PseudoElement::AnonymousFlexItem => {
+                        0
+                }
+                PseudoElement::AnonymousGridItem => {
+                        0
+                }
+                PseudoElement::Ruby => {
+                        0
+                }
+                PseudoElement::RubyBase => {
+                        0
+                }
+                PseudoElement::RubyBaseContainer => {
+                        0
+                }
+                PseudoElement::RubyText => {
+                        0
+                }
+                PseudoElement::RubyTextContainer => {
+                        0
+                }
+                PseudoElement::Moztreecolumn => {
+                        0
+                }
+                PseudoElement::Moztreerow => {
+                        0
+                }
+                PseudoElement::Moztreeseparator => {
+                        0
+                }
+                PseudoElement::Moztreecell => {
+                        0
+                }
+                PseudoElement::Moztreeindentation => {
+                        0
+                }
+                PseudoElement::Moztreeline => {
+                        0
+                }
+                PseudoElement::Moztreetwisty => {
+                        0
+                }
+                PseudoElement::Moztreeimage => {
+                        0
+                }
+                PseudoElement::Moztreecelltext => {
+                        0
+                }
+                PseudoElement::Moztreecheckbox => {
+                        0
+                }
+                PseudoElement::Moztreeprogressmeter => {
+                        0
+                }
+                PseudoElement::Moztreedropfeedback => {
+                        0
+                }
+                PseudoElement::MozSVGMarkerAnonChild => {
+                        0
+                }
+                PseudoElement::MozSVGOuterSVGAnonChild => {
+                        0
+                }
+                PseudoElement::MozSVGForeignContent => {
+                        0
+                }
+                PseudoElement::MozSVGText => {
+                        0
+                }
+        }
+    }
+
+    /// Construct a pseudo-element from a `CSSPseudoElementType`.
+    #[inline]
+    pub fn from_pseudo_type(type_: CSSPseudoElementType) -> Option<Self> {
+        match type_ {
+                    CSSPseudoElementType::after => {
+                        Some(PseudoElement::After)
+                    },
+                    CSSPseudoElementType::before => {
+                        Some(PseudoElement::Before)
+                    },
+                    CSSPseudoElementType::backdrop => {
+                        Some(PseudoElement::Backdrop)
+                    },
+                    CSSPseudoElementType::cue => {
+                        Some(PseudoElement::Cue)
+                    },
+                    CSSPseudoElementType::firstLetter => {
+                        Some(PseudoElement::FirstLetter)
+                    },
+                    CSSPseudoElementType::firstLine => {
+                        Some(PseudoElement::FirstLine)
+                    },
+                    CSSPseudoElementType::mozSelection => {
+                        Some(PseudoElement::MozSelection)
+                    },
+                    CSSPseudoElementType::mozFocusInner => {
+                        Some(PseudoElement::MozFocusInner)
+                    },
+                    CSSPseudoElementType::mozFocusOuter => {
+                        Some(PseudoElement::MozFocusOuter)
+                    },
+                    CSSPseudoElementType::mozListBullet => {
+                        Some(PseudoElement::MozListBullet)
+                    },
+                    CSSPseudoElementType::mozListNumber => {
+                        Some(PseudoElement::MozListNumber)
+                    },
+                    CSSPseudoElementType::mozMathAnonymous => {
+                        Some(PseudoElement::MozMathAnonymous)
+                    },
+                    CSSPseudoElementType::mozNumberWrapper => {
+                        Some(PseudoElement::MozNumberWrapper)
+                    },
+                    CSSPseudoElementType::mozNumberText => {
+                        Some(PseudoElement::MozNumberText)
+                    },
+                    CSSPseudoElementType::mozNumberSpinBox => {
+                        Some(PseudoElement::MozNumberSpinBox)
+                    },
+                    CSSPseudoElementType::mozNumberSpinUp => {
+                        Some(PseudoElement::MozNumberSpinUp)
+                    },
+                    CSSPseudoElementType::mozNumberSpinDown => {
+                        Some(PseudoElement::MozNumberSpinDown)
+                    },
+                    CSSPseudoElementType::mozProgressBar => {
+                        Some(PseudoElement::MozProgressBar)
+                    },
+                    CSSPseudoElementType::mozRangeTrack => {
+                        Some(PseudoElement::MozRangeTrack)
+                    },
+                    CSSPseudoElementType::mozRangeProgress => {
+                        Some(PseudoElement::MozRangeProgress)
+                    },
+                    CSSPseudoElementType::mozRangeThumb => {
+                        Some(PseudoElement::MozRangeThumb)
+                    },
+                    CSSPseudoElementType::mozMeterBar => {
+                        Some(PseudoElement::MozMeterBar)
+                    },
+                    CSSPseudoElementType::mozPlaceholder => {
+                        Some(PseudoElement::MozPlaceholder)
+                    },
+                    CSSPseudoElementType::placeholder => {
+                        Some(PseudoElement::Placeholder)
+                    },
+                    CSSPseudoElementType::mozColorSwatch => {
+                        Some(PseudoElement::MozColorSwatch)
+                    },
+            _ => None,
+        }
+    }
+
+    /// Construct a pseudo-element from an anonymous box `Atom`.
+    #[inline]
+    pub fn from_anon_box_atom(atom: &Atom) -> Option<Self> {
+                if atom == &atom!(":-moz-text") {
+                    return Some(PseudoElement::MozText);
+                }
+                if atom == &atom!(":-moz-oof-placeholder") {
+                    return Some(PseudoElement::OofPlaceholder);
+                }
+                if atom == &atom!(":-moz-first-letter-continuation") {
+                    return Some(PseudoElement::FirstLetterContinuation);
+                }
+                if atom == &atom!(":-moz-block-inside-inline-wrapper") {
+                    return Some(PseudoElement::MozBlockInsideInlineWrapper);
+                }
+                if atom == &atom!(":-moz-mathml-anonymous-block") {
+                    return Some(PseudoElement::MozMathMLAnonymousBlock);
+                }
+                if atom == &atom!(":-moz-xul-anonymous-block") {
+                    return Some(PseudoElement::MozXULAnonymousBlock);
+                }
+                if atom == &atom!(":-moz-hframeset-border") {
+                    return Some(PseudoElement::HorizontalFramesetBorder);
+                }
+                if atom == &atom!(":-moz-vframeset-border") {
+                    return Some(PseudoElement::VerticalFramesetBorder);
+                }
+                if atom == &atom!(":-moz-line-frame") {
+                    return Some(PseudoElement::MozLineFrame);
+                }
+                if atom == &atom!(":-moz-button-content") {
+                    return Some(PseudoElement::ButtonContent);
+                }
+                if atom == &atom!(":-moz-cell-content") {
+                    return Some(PseudoElement::CellContent);
+                }
+                if atom == &atom!(":-moz-dropdown-list") {
+                    return Some(PseudoElement::DropDownList);
+                }
+                if atom == &atom!(":-moz-fieldset-content") {
+                    return Some(PseudoElement::FieldsetContent);
+                }
+                if atom == &atom!(":-moz-frameset-blank") {
+                    return Some(PseudoElement::FramesetBlank);
+                }
+                if atom == &atom!(":-moz-display-comboboxcontrol-frame") {
+                    return Some(PseudoElement::MozDisplayComboboxControlFrame);
+                }
+                if atom == &atom!(":-moz-html-canvas-content") {
+                    return Some(PseudoElement::HtmlCanvasContent);
+                }
+                if atom == &atom!(":-moz-inline-table") {
+                    return Some(PseudoElement::InlineTable);
+                }
+                if atom == &atom!(":-moz-table") {
+                    return Some(PseudoElement::Table);
+                }
+                if atom == &atom!(":-moz-table-cell") {
+                    return Some(PseudoElement::TableCell);
+                }
+                if atom == &atom!(":-moz-table-column-group") {
+                    return Some(PseudoElement::TableColGroup);
+                }
+                if atom == &atom!(":-moz-table-column") {
+                    return Some(PseudoElement::TableCol);
+                }
+                if atom == &atom!(":-moz-table-wrapper") {
+                    return Some(PseudoElement::TableWrapper);
+                }
+                if atom == &atom!(":-moz-table-row-group") {
+                    return Some(PseudoElement::TableRowGroup);
+                }
+                if atom == &atom!(":-moz-table-row") {
+                    return Some(PseudoElement::TableRow);
+                }
+                if atom == &atom!(":-moz-canvas") {
+                    return Some(PseudoElement::Canvas);
+                }
+                if atom == &atom!(":-moz-pagebreak") {
+                    return Some(PseudoElement::PageBreak);
+                }
+                if atom == &atom!(":-moz-page") {
+                    return Some(PseudoElement::Page);
+                }
+                if atom == &atom!(":-moz-pagecontent") {
+                    return Some(PseudoElement::PageContent);
+                }
+                if atom == &atom!(":-moz-page-sequence") {
+                    return Some(PseudoElement::PageSequence);
+                }
+                if atom == &atom!(":-moz-scrolled-content") {
+                    return Some(PseudoElement::ScrolledContent);
+                }
+                if atom == &atom!(":-moz-scrolled-canvas") {
+                    return Some(PseudoElement::ScrolledCanvas);
+                }
+                if atom == &atom!(":-moz-scrolled-page-sequence") {
+                    return Some(PseudoElement::ScrolledPageSequence);
+                }
+                if atom == &atom!(":-moz-column-content") {
+                    return Some(PseudoElement::ColumnContent);
+                }
+                if atom == &atom!(":-moz-viewport") {
+                    return Some(PseudoElement::Viewport);
+                }
+                if atom == &atom!(":-moz-viewport-scroll") {
+                    return Some(PseudoElement::ViewportScroll);
+                }
+                if atom == &atom!(":-moz-anonymous-flex-item") {
+                    return Some(PseudoElement::AnonymousFlexItem);
+                }
+                if atom == &atom!(":-moz-anonymous-grid-item") {
+                    return Some(PseudoElement::AnonymousGridItem);
+                }
+                if atom == &atom!(":-moz-ruby") {
+                    return Some(PseudoElement::Ruby);
+                }
+                if atom == &atom!(":-moz-ruby-base") {
+                    return Some(PseudoElement::RubyBase);
+                }
+                if atom == &atom!(":-moz-ruby-base-container") {
+                    return Some(PseudoElement::RubyBaseContainer);
+                }
+                if atom == &atom!(":-moz-ruby-text") {
+                    return Some(PseudoElement::RubyText);
+                }
+                if atom == &atom!(":-moz-ruby-text-container") {
+                    return Some(PseudoElement::RubyTextContainer);
+                }
+                if atom == &atom!(":-moz-tree-column") {
+                    return Some(PseudoElement::Moztreecolumn);
+                }
+                if atom == &atom!(":-moz-tree-row") {
+                    return Some(PseudoElement::Moztreerow);
+                }
+                if atom == &atom!(":-moz-tree-separator") {
+                    return Some(PseudoElement::Moztreeseparator);
+                }
+                if atom == &atom!(":-moz-tree-cell") {
+                    return Some(PseudoElement::Moztreecell);
+                }
+                if atom == &atom!(":-moz-tree-indentation") {
+                    return Some(PseudoElement::Moztreeindentation);
+                }
+                if atom == &atom!(":-moz-tree-line") {
+                    return Some(PseudoElement::Moztreeline);
+                }
+                if atom == &atom!(":-moz-tree-twisty") {
+                    return Some(PseudoElement::Moztreetwisty);
+                }
+                if atom == &atom!(":-moz-tree-image") {
+                    return Some(PseudoElement::Moztreeimage);
+                }
+                if atom == &atom!(":-moz-tree-cell-text") {
+                    return Some(PseudoElement::Moztreecelltext);
+                }
+                if atom == &atom!(":-moz-tree-checkbox") {
+                    return Some(PseudoElement::Moztreecheckbox);
+                }
+                if atom == &atom!(":-moz-tree-progressmeter") {
+                    return Some(PseudoElement::Moztreeprogressmeter);
+                }
+                if atom == &atom!(":-moz-tree-drop-feedback") {
+                    return Some(PseudoElement::Moztreedropfeedback);
+                }
+                if atom == &atom!(":-moz-svg-marker-anon-child") {
+                    return Some(PseudoElement::MozSVGMarkerAnonChild);
+                }
+                if atom == &atom!(":-moz-svg-outer-svg-anon-child") {
+                    return Some(PseudoElement::MozSVGOuterSVGAnonChild);
+                }
+                if atom == &atom!(":-moz-svg-foreign-content") {
+                    return Some(PseudoElement::MozSVGForeignContent);
+                }
+                if atom == &atom!(":-moz-svg-text") {
+                    return Some(PseudoElement::MozSVGText);
+                }
+        None
+    }
+
+    /// Constructs an atom from a string of text, and whether we're in a
+    /// user-agent stylesheet.
+    ///
+    /// If we're not in a user-agent stylesheet, we will never parse anonymous
+    /// box pseudo-elements.
+    ///
+    /// Returns `None` if the pseudo-element is not recognised.
+    #[inline]
+    pub fn from_slice(s: &str, in_ua_stylesheet: bool) -> Option<Self> {
+        use std::ascii::AsciiExt;
+
+            if in_ua_stylesheet || PseudoElement::After.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("after") {
+                    return Some(PseudoElement::After)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Before.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("before") {
+                    return Some(PseudoElement::Before)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Backdrop.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("backdrop") {
+                    return Some(PseudoElement::Backdrop)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Cue.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("cue") {
+                    return Some(PseudoElement::Cue)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::FirstLetter.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("first-letter") {
+                    return Some(PseudoElement::FirstLetter)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::FirstLine.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("first-line") {
+                    return Some(PseudoElement::FirstLine)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozSelection.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-selection") {
+                    return Some(PseudoElement::MozSelection)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozFocusInner.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-focus-inner") {
+                    return Some(PseudoElement::MozFocusInner)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozFocusOuter.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-focus-outer") {
+                    return Some(PseudoElement::MozFocusOuter)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozListBullet.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-list-bullet") {
+                    return Some(PseudoElement::MozListBullet)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozListNumber.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-list-number") {
+                    return Some(PseudoElement::MozListNumber)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozMathAnonymous.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-math-anonymous") {
+                    return Some(PseudoElement::MozMathAnonymous)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozNumberWrapper.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-number-wrapper") {
+                    return Some(PseudoElement::MozNumberWrapper)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozNumberText.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-number-text") {
+                    return Some(PseudoElement::MozNumberText)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozNumberSpinBox.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-number-spin-box") {
+                    return Some(PseudoElement::MozNumberSpinBox)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozNumberSpinUp.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-number-spin-up") {
+                    return Some(PseudoElement::MozNumberSpinUp)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozNumberSpinDown.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-number-spin-down") {
+                    return Some(PseudoElement::MozNumberSpinDown)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozProgressBar.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-progress-bar") {
+                    return Some(PseudoElement::MozProgressBar)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozRangeTrack.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-range-track") {
+                    return Some(PseudoElement::MozRangeTrack)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozRangeProgress.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-range-progress") {
+                    return Some(PseudoElement::MozRangeProgress)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozRangeThumb.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-range-thumb") {
+                    return Some(PseudoElement::MozRangeThumb)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozMeterBar.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-meter-bar") {
+                    return Some(PseudoElement::MozMeterBar)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozPlaceholder.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-placeholder") {
+                    return Some(PseudoElement::MozPlaceholder)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Placeholder.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("placeholder") {
+                    return Some(PseudoElement::Placeholder)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozColorSwatch.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-color-swatch") {
+                    return Some(PseudoElement::MozColorSwatch)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozText.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-text") {
+                    return Some(PseudoElement::MozText)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::OofPlaceholder.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-oof-placeholder") {
+                    return Some(PseudoElement::OofPlaceholder)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::FirstLetterContinuation.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-first-letter-continuation") {
+                    return Some(PseudoElement::FirstLetterContinuation)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozBlockInsideInlineWrapper.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-block-inside-inline-wrapper") {
+                    return Some(PseudoElement::MozBlockInsideInlineWrapper)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozMathMLAnonymousBlock.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-mathml-anonymous-block") {
+                    return Some(PseudoElement::MozMathMLAnonymousBlock)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozXULAnonymousBlock.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-xul-anonymous-block") {
+                    return Some(PseudoElement::MozXULAnonymousBlock)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::HorizontalFramesetBorder.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-hframeset-border") {
+                    return Some(PseudoElement::HorizontalFramesetBorder)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::VerticalFramesetBorder.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-vframeset-border") {
+                    return Some(PseudoElement::VerticalFramesetBorder)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozLineFrame.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-line-frame") {
+                    return Some(PseudoElement::MozLineFrame)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::ButtonContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-button-content") {
+                    return Some(PseudoElement::ButtonContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::CellContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-cell-content") {
+                    return Some(PseudoElement::CellContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::DropDownList.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-dropdown-list") {
+                    return Some(PseudoElement::DropDownList)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::FieldsetContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-fieldset-content") {
+                    return Some(PseudoElement::FieldsetContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::FramesetBlank.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-frameset-blank") {
+                    return Some(PseudoElement::FramesetBlank)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozDisplayComboboxControlFrame.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-display-comboboxcontrol-frame") {
+                    return Some(PseudoElement::MozDisplayComboboxControlFrame)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::HtmlCanvasContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-html-canvas-content") {
+                    return Some(PseudoElement::HtmlCanvasContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::InlineTable.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-inline-table") {
+                    return Some(PseudoElement::InlineTable)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Table.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table") {
+                    return Some(PseudoElement::Table)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::TableCell.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table-cell") {
+                    return Some(PseudoElement::TableCell)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::TableColGroup.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table-column-group") {
+                    return Some(PseudoElement::TableColGroup)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::TableCol.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table-column") {
+                    return Some(PseudoElement::TableCol)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::TableWrapper.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table-wrapper") {
+                    return Some(PseudoElement::TableWrapper)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::TableRowGroup.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table-row-group") {
+                    return Some(PseudoElement::TableRowGroup)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::TableRow.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-table-row") {
+                    return Some(PseudoElement::TableRow)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Canvas.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-canvas") {
+                    return Some(PseudoElement::Canvas)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::PageBreak.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-pagebreak") {
+                    return Some(PseudoElement::PageBreak)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Page.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-page") {
+                    return Some(PseudoElement::Page)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::PageContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-pagecontent") {
+                    return Some(PseudoElement::PageContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::PageSequence.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-page-sequence") {
+                    return Some(PseudoElement::PageSequence)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::ScrolledContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-scrolled-content") {
+                    return Some(PseudoElement::ScrolledContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::ScrolledCanvas.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-scrolled-canvas") {
+                    return Some(PseudoElement::ScrolledCanvas)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::ScrolledPageSequence.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-scrolled-page-sequence") {
+                    return Some(PseudoElement::ScrolledPageSequence)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::ColumnContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-column-content") {
+                    return Some(PseudoElement::ColumnContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Viewport.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-viewport") {
+                    return Some(PseudoElement::Viewport)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::ViewportScroll.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-viewport-scroll") {
+                    return Some(PseudoElement::ViewportScroll)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::AnonymousFlexItem.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-anonymous-flex-item") {
+                    return Some(PseudoElement::AnonymousFlexItem)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::AnonymousGridItem.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-anonymous-grid-item") {
+                    return Some(PseudoElement::AnonymousGridItem)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Ruby.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-ruby") {
+                    return Some(PseudoElement::Ruby)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::RubyBase.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-ruby-base") {
+                    return Some(PseudoElement::RubyBase)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::RubyBaseContainer.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-ruby-base-container") {
+                    return Some(PseudoElement::RubyBaseContainer)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::RubyText.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-ruby-text") {
+                    return Some(PseudoElement::RubyText)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::RubyTextContainer.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-ruby-text-container") {
+                    return Some(PseudoElement::RubyTextContainer)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreecolumn.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-column") {
+                    return Some(PseudoElement::Moztreecolumn)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreerow.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-row") {
+                    return Some(PseudoElement::Moztreerow)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreeseparator.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-separator") {
+                    return Some(PseudoElement::Moztreeseparator)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreecell.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-cell") {
+                    return Some(PseudoElement::Moztreecell)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreeindentation.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-indentation") {
+                    return Some(PseudoElement::Moztreeindentation)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreeline.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-line") {
+                    return Some(PseudoElement::Moztreeline)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreetwisty.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-twisty") {
+                    return Some(PseudoElement::Moztreetwisty)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreeimage.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-image") {
+                    return Some(PseudoElement::Moztreeimage)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreecelltext.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-cell-text") {
+                    return Some(PseudoElement::Moztreecelltext)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreecheckbox.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-checkbox") {
+                    return Some(PseudoElement::Moztreecheckbox)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreeprogressmeter.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-progressmeter") {
+                    return Some(PseudoElement::Moztreeprogressmeter)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::Moztreedropfeedback.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-tree-drop-feedback") {
+                    return Some(PseudoElement::Moztreedropfeedback)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozSVGMarkerAnonChild.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-svg-marker-anon-child") {
+                    return Some(PseudoElement::MozSVGMarkerAnonChild)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozSVGOuterSVGAnonChild.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-svg-outer-svg-anon-child") {
+                    return Some(PseudoElement::MozSVGOuterSVGAnonChild)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozSVGForeignContent.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-svg-foreign-content") {
+                    return Some(PseudoElement::MozSVGForeignContent)
+                }
+            }
+            if in_ua_stylesheet || PseudoElement::MozSVGText.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("-moz-svg-text") {
+                    return Some(PseudoElement::MozSVGText)
+                }
+            }
+
+        None
+    }
+
+    /// Returns the pseudo-element's definition as a string, with only one colon
+    /// before it.
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            PseudoElement::After => ":after",
+            PseudoElement::Before => ":before",
+            PseudoElement::Backdrop => ":backdrop",
+            PseudoElement::Cue => ":cue",
+            PseudoElement::FirstLetter => ":first-letter",
+            PseudoElement::FirstLine => ":first-line",
+            PseudoElement::MozSelection => ":-moz-selection",
+            PseudoElement::MozFocusInner => ":-moz-focus-inner",
+            PseudoElement::MozFocusOuter => ":-moz-focus-outer",
+            PseudoElement::MozListBullet => ":-moz-list-bullet",
+            PseudoElement::MozListNumber => ":-moz-list-number",
+            PseudoElement::MozMathAnonymous => ":-moz-math-anonymous",
+            PseudoElement::MozNumberWrapper => ":-moz-number-wrapper",
+            PseudoElement::MozNumberText => ":-moz-number-text",
+            PseudoElement::MozNumberSpinBox => ":-moz-number-spin-box",
+            PseudoElement::MozNumberSpinUp => ":-moz-number-spin-up",
+            PseudoElement::MozNumberSpinDown => ":-moz-number-spin-down",
+            PseudoElement::MozProgressBar => ":-moz-progress-bar",
+            PseudoElement::MozRangeTrack => ":-moz-range-track",
+            PseudoElement::MozRangeProgress => ":-moz-range-progress",
+            PseudoElement::MozRangeThumb => ":-moz-range-thumb",
+            PseudoElement::MozMeterBar => ":-moz-meter-bar",
+            PseudoElement::MozPlaceholder => ":-moz-placeholder",
+            PseudoElement::Placeholder => ":placeholder",
+            PseudoElement::MozColorSwatch => ":-moz-color-swatch",
+            PseudoElement::MozText => ":-moz-text",
+            PseudoElement::OofPlaceholder => ":-moz-oof-placeholder",
+            PseudoElement::FirstLetterContinuation => ":-moz-first-letter-continuation",
+            PseudoElement::MozBlockInsideInlineWrapper => ":-moz-block-inside-inline-wrapper",
+            PseudoElement::MozMathMLAnonymousBlock => ":-moz-mathml-anonymous-block",
+            PseudoElement::MozXULAnonymousBlock => ":-moz-xul-anonymous-block",
+            PseudoElement::HorizontalFramesetBorder => ":-moz-hframeset-border",
+            PseudoElement::VerticalFramesetBorder => ":-moz-vframeset-border",
+            PseudoElement::MozLineFrame => ":-moz-line-frame",
+            PseudoElement::ButtonContent => ":-moz-button-content",
+            PseudoElement::CellContent => ":-moz-cell-content",
+            PseudoElement::DropDownList => ":-moz-dropdown-list",
+            PseudoElement::FieldsetContent => ":-moz-fieldset-content",
+            PseudoElement::FramesetBlank => ":-moz-frameset-blank",
+            PseudoElement::MozDisplayComboboxControlFrame => ":-moz-display-comboboxcontrol-frame",
+            PseudoElement::HtmlCanvasContent => ":-moz-html-canvas-content",
+            PseudoElement::InlineTable => ":-moz-inline-table",
+            PseudoElement::Table => ":-moz-table",
+            PseudoElement::TableCell => ":-moz-table-cell",
+            PseudoElement::TableColGroup => ":-moz-table-column-group",
+            PseudoElement::TableCol => ":-moz-table-column",
+            PseudoElement::TableWrapper => ":-moz-table-wrapper",
+            PseudoElement::TableRowGroup => ":-moz-table-row-group",
+            PseudoElement::TableRow => ":-moz-table-row",
+            PseudoElement::Canvas => ":-moz-canvas",
+            PseudoElement::PageBreak => ":-moz-pagebreak",
+            PseudoElement::Page => ":-moz-page",
+            PseudoElement::PageContent => ":-moz-pagecontent",
+            PseudoElement::PageSequence => ":-moz-page-sequence",
+            PseudoElement::ScrolledContent => ":-moz-scrolled-content",
+            PseudoElement::ScrolledCanvas => ":-moz-scrolled-canvas",
+            PseudoElement::ScrolledPageSequence => ":-moz-scrolled-page-sequence",
+            PseudoElement::ColumnContent => ":-moz-column-content",
+            PseudoElement::Viewport => ":-moz-viewport",
+            PseudoElement::ViewportScroll => ":-moz-viewport-scroll",
+            PseudoElement::AnonymousFlexItem => ":-moz-anonymous-flex-item",
+            PseudoElement::AnonymousGridItem => ":-moz-anonymous-grid-item",
+            PseudoElement::Ruby => ":-moz-ruby",
+            PseudoElement::RubyBase => ":-moz-ruby-base",
+            PseudoElement::RubyBaseContainer => ":-moz-ruby-base-container",
+            PseudoElement::RubyText => ":-moz-ruby-text",
+            PseudoElement::RubyTextContainer => ":-moz-ruby-text-container",
+            PseudoElement::Moztreecolumn => ":-moz-tree-column",
+            PseudoElement::Moztreerow => ":-moz-tree-row",
+            PseudoElement::Moztreeseparator => ":-moz-tree-separator",
+            PseudoElement::Moztreecell => ":-moz-tree-cell",
+            PseudoElement::Moztreeindentation => ":-moz-tree-indentation",
+            PseudoElement::Moztreeline => ":-moz-tree-line",
+            PseudoElement::Moztreetwisty => ":-moz-tree-twisty",
+            PseudoElement::Moztreeimage => ":-moz-tree-image",
+            PseudoElement::Moztreecelltext => ":-moz-tree-cell-text",
+            PseudoElement::Moztreecheckbox => ":-moz-tree-checkbox",
+            PseudoElement::Moztreeprogressmeter => ":-moz-tree-progressmeter",
+            PseudoElement::Moztreedropfeedback => ":-moz-tree-drop-feedback",
+            PseudoElement::MozSVGMarkerAnonChild => ":-moz-svg-marker-anon-child",
+            PseudoElement::MozSVGOuterSVGAnonChild => ":-moz-svg-outer-svg-anon-child",
+            PseudoElement::MozSVGForeignContent => ":-moz-svg-foreign-content",
+            PseudoElement::MozSVGText => ":-moz-svg-text",
+        }
+    }
+}
deleted file mode 100644
--- a/servo/components/style/gecko/generated/pseudo_element_helper.rs
+++ /dev/null
@@ -1,280 +0,0 @@
-/* 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 created by components/style/binding_tools/regen_atoms.py, 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!(":cue",
-                    atom!(":cue"),
-                    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!(":placeholder",
-                    atom!(":placeholder"),
-                    false);
-    pseudo_element!(":-moz-color-swatch",
-                    atom!(":-moz-color-swatch"),
-                    false);
-    pseudo_element!(":-moz-text",
-                    atom!(":-moz-text"),
-                    true);
-    pseudo_element!(":-moz-oof-placeholder",
-                    atom!(":-moz-oof-placeholder"),
-                    true);
-    pseudo_element!(":-moz-first-letter-continuation",
-                    atom!(":-moz-first-letter-continuation"),
-                    true);
-    pseudo_element!(":-moz-block-inside-inline-wrapper",
-                    atom!(":-moz-block-inside-inline-wrapper"),
-                    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-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);
-}
--- a/servo/components/style/gecko/generated/structs_debug.rs
+++ b/servo/components/style/gecko/generated/structs_debug.rs
@@ -969,16 +969,17 @@ pub mod root {
     pub const NS_STYLE_SCROLL_SNAP_TYPE_PROXIMITY: ::std::os::raw::c_uint = 2;
     pub const NS_STYLE_ORIENTATION_PORTRAIT: ::std::os::raw::c_uint = 0;
     pub const NS_STYLE_ORIENTATION_LANDSCAPE: ::std::os::raw::c_uint = 1;
     pub const NS_STYLE_SCAN_PROGRESSIVE: ::std::os::raw::c_uint = 0;
     pub const NS_STYLE_SCAN_INTERLACE: ::std::os::raw::c_uint = 1;
     pub const NS_STYLE_DISPLAY_MODE_BROWSER: ::std::os::raw::c_uint = 0;
     pub const NS_STYLE_DISPLAY_MODE_MINIMAL_UI: ::std::os::raw::c_uint = 1;
     pub const NS_STYLE_DISPLAY_MODE_STANDALONE: ::std::os::raw::c_uint = 2;
+    pub const NS_STYLE_DISPLAY_MODE_FULLSCREEN: ::std::os::raw::c_uint = 3;
     pub const NS_THEME_NONE: ::std::os::raw::c_uint = 0;
     pub const NS_THEME_BUTTON: ::std::os::raw::c_uint = 1;
     pub const NS_THEME_RADIO: ::std::os::raw::c_uint = 2;
     pub const NS_THEME_CHECKBOX: ::std::os::raw::c_uint = 3;
     pub const NS_THEME_AUTO: ::std::os::raw::c_uint = 4;
     pub const NS_THEME_BUTTON_BEVEL: ::std::os::raw::c_uint = 7;
     pub const NS_THEME_FOCUS_OUTLINE: ::std::os::raw::c_uint = 8;
     pub const NS_THEME_TOOLBOX: ::std::os::raw::c_uint = 11;
@@ -1105,16 +1106,28 @@ pub mod root {
         246;
     pub const NS_THEME_GTK_INFO_BAR: ::std::os::raw::c_uint = 247;
     pub const NS_THEME_MAC_SOURCE_LIST: ::std::os::raw::c_uint = 248;
     pub const NS_THEME_MAC_SOURCE_LIST_SELECTION: ::std::os::raw::c_uint =
         249;
     pub const NS_THEME_MAC_ACTIVE_SOURCE_LIST_SELECTION:
               ::std::os::raw::c_uint =
         250;
+    pub const CSS_PSEUDO_ELEMENT_IS_CSS2: ::std::os::raw::c_uint = 1;
+    pub const CSS_PSEUDO_ELEMENT_CONTAINS_ELEMENTS: ::std::os::raw::c_uint =
+        2;
+    pub const CSS_PSEUDO_ELEMENT_SUPPORTS_STYLE_ATTRIBUTE:
+              ::std::os::raw::c_uint =
+        4;
+    pub const CSS_PSEUDO_ELEMENT_SUPPORTS_USER_ACTION_STATE:
+              ::std::os::raw::c_uint =
+        8;
+    pub const CSS_PSEUDO_ELEMENT_UA_SHEET_ONLY: ::std::os::raw::c_uint = 16;
+    pub const CSS_PSEUDO_ELEMENT_IS_JS_CREATED_NAC: ::std::os::raw::c_uint =
+        32;
     pub const kNameSpaceID_Unknown: ::std::os::raw::c_int = -1;
     pub const kNameSpaceID_XMLNS: ::std::os::raw::c_uint = 1;
     pub const kNameSpaceID_XML: ::std::os::raw::c_uint = 2;
     pub const kNameSpaceID_XHTML: ::std::os::raw::c_uint = 3;
     pub const kNameSpaceID_XLink: ::std::os::raw::c_uint = 4;
     pub const kNameSpaceID_XSLT: ::std::os::raw::c_uint = 5;
     pub const kNameSpaceID_XBL: ::std::os::raw::c_uint = 6;
     pub const kNameSpaceID_MathML: ::std::os::raw::c_uint = 7;
@@ -1163,16 +1176,18 @@ pub mod root {
         pub struct pair<_T1, _T2> {
             pub first: _T1,
             pub second: _T2,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T1>>,
             pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T2>>,
         }
         pub type pair_first_type<_T1> = _T1;
         pub type pair_second_type<_T2> = _T2;
+        pub type pair__PCCP = u8;
+        pub type pair__PCCFP = u8;
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct input_iterator_tag {
             pub _address: u8,
         }
         #[test]
         fn bindgen_test_layout_input_iterator_tag() {
             assert_eq!(::std::mem::size_of::<input_iterator_tag>() , 1usize ,
@@ -1192,20 +1207,27 @@ pub mod root {
             pub _address: u8,
         }
         pub type iterator_iterator_category<_Category> = _Category;
         pub type iterator_value_type<_Tp> = _Tp;
         pub type iterator_difference_type<_Distance> = _Distance;
         pub type iterator_pointer<_Pointer> = _Pointer;
         pub type iterator_reference<_Reference> = _Reference;
         #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct __iterator_traits {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
         pub struct iterator_traits {
             pub _address: u8,
         }
         #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
         pub struct reverse_iterator<_Iterator> {
             pub current: _Iterator,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iterator>>,
         }
         pub type reverse_iterator___traits_type = root::std::iterator_traits;
         pub type reverse_iterator_iterator_type<_Iterator> = _Iterator;
         pub type reverse_iterator_difference_type =
             root::std::reverse_iterator___traits_type;
@@ -1213,26 +1235,26 @@ pub mod root {
             root::std::reverse_iterator___traits_type;
         pub type reverse_iterator_reference =
             root::std::reverse_iterator___traits_type;
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct atomic {
         }
         #[test]
-        fn __bindgen_test_layout_atomic_instantiation_89651() {
+        fn __bindgen_test_layout_atomic_instantiation_61524() {
             assert_eq!(::std::mem::size_of::<u32>() , 4usize , concat ! (
                        "Size of template specialization: " , stringify ! ( u32
                        ) ));
             assert_eq!(::std::mem::align_of::<u32>() , 4usize , concat ! (
                        "Alignment of template specialization: " , stringify !
                        ( u32 ) ));
         }
         #[test]
-        fn __bindgen_test_layout_atomic_instantiation_89659() {
+        fn __bindgen_test_layout_atomic_instantiation_61532() {
             assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                        "Size of template specialization: " , stringify ! ( u64
                        ) ));
             assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                        "Alignment of template specialization: " , stringify !
                        ( u64 ) ));
         }
         pub mod chrono {
@@ -1283,18 +1305,19 @@ pub mod root {
                 root::mozilla::detail::nsStringRepr;
             pub type nsStringRepr_base_string_type =
                 root::mozilla::detail::nsStringRepr_self_type;
             pub type nsStringRepr_substring_type = root::nsAString;
             pub type nsStringRepr_substring_tuple_type =
                 root::nsSubstringTuple;
             pub type nsStringRepr_string_type = ::nsstring::nsStringRepr;
             pub type nsStringRepr_const_iterator =
-                root::nsReadingIterator<u16>;
-            pub type nsStringRepr_iterator = root::nsWritingIterator<u16>;
+                root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>;
+            pub type nsStringRepr_iterator =
+                root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>;
             pub type nsStringRepr_comparator_type = root::nsStringComparator;
             pub type nsStringRepr_char_iterator =
                 *mut root::mozilla::detail::nsStringRepr_char_type;
             pub type nsStringRepr_const_char_iterator =
                 *const root::mozilla::detail::nsStringRepr_char_type;
             pub type nsStringRepr_index_type = u32;
             pub type nsStringRepr_size_type = u32;
             pub const nsStringRepr_F_NONE:
@@ -1374,19 +1397,19 @@ pub mod root {
                 root::mozilla::detail::nsCStringRepr;
             pub type nsCStringRepr_base_string_type =
                 root::mozilla::detail::nsCStringRepr_self_type;
             pub type nsCStringRepr_substring_type = root::nsACString;
             pub type nsCStringRepr_substring_tuple_type =
                 root::nsCSubstringTuple;
             pub type nsCStringRepr_string_type = root::nsCString;
             pub type nsCStringRepr_const_iterator =
-                root::nsReadingIterator<::std::os::raw::c_char>;
+                root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>;
             pub type nsCStringRepr_iterator =
-                root::nsWritingIterator<::std::os::raw::c_char>;
+                root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>;
             pub type nsCStringRepr_comparator_type =
                 root::nsCStringComparator;
             pub type nsCStringRepr_char_iterator =
                 *mut root::mozilla::detail::nsCStringRepr_char_type;
             pub type nsCStringRepr_const_char_iterator =
                 *const root::mozilla::detail::nsCStringRepr_char_type;
             pub type nsCStringRepr_index_type = u32;
             pub type nsCStringRepr_size_type = u32;
@@ -1451,21 +1474,16 @@ pub mod root {
                             * const _ as usize } , 12usize , concat ! (
                             "Alignment of field: " , stringify ! (
                             nsCStringRepr ) , "::" , stringify ! ( mFlags )
                             ));
             }
             impl Clone for nsCStringRepr {
                 fn clone(&self) -> Self { *self }
             }
-            #[repr(C)]
-            #[derive(Debug, Copy, Clone)]
-            pub struct AllocPolicyBasedFreePolicy {
-                pub _address: u8,
-            }
             /**
  * LinkedList supports refcounted elements using this adapter class. Clients
  * using LinkedList<RefPtr<T>> will get a data structure that holds a strong
  * reference to T as long as T is in the list.
  */
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct LinkedListElementTraits {
@@ -1891,36 +1909,36 @@ pub mod root {
                             concat ! (
                             "Alignment of " , stringify ! ( URLValue ) ));
             }
             #[repr(C)]
             #[derive(Debug)]
             pub struct ImageValue {
                 pub _base: root::mozilla::css::URLValueData,
                 pub mRequests: [u64; 6usize],
-                pub mInitialized: bool,
+                pub mLoadedImage: bool,
             }
             #[test]
             fn bindgen_test_layout_ImageValue() {
                 assert_eq!(::std::mem::size_of::<ImageValue>() , 112usize ,
                            concat ! ( "Size of: " , stringify ! ( ImageValue )
                            ));
                 assert_eq! (::std::mem::align_of::<ImageValue>() , 8usize ,
                             concat ! (
                             "Alignment of " , stringify ! ( ImageValue ) ));
                 assert_eq! (unsafe {
                             & ( * ( 0 as * const ImageValue ) ) . mRequests as
                             * const _ as usize } , 56usize , concat ! (
                             "Alignment of field: " , stringify ! ( ImageValue
                             ) , "::" , stringify ! ( mRequests ) ));
                 assert_eq! (unsafe {
-                            & ( * ( 0 as * const ImageValue ) ) . mInitialized
+                            & ( * ( 0 as * const ImageValue ) ) . mLoadedImage
                             as * const _ as usize } , 104usize , concat ! (
                             "Alignment of field: " , stringify ! ( ImageValue
-                            ) , "::" , stringify ! ( mInitialized ) ));
+                            ) , "::" , stringify ! ( mLoadedImage ) ));
             }
             #[repr(C)]
             #[derive(Debug)]
             pub struct GridNamedArea {
                 pub mName: ::nsstring::nsStringRepr,
                 pub mColumnStart: u32,
                 pub mColumnEnd: u32,
                 pub mRowStart: u32,
@@ -6878,17 +6896,17 @@ pub mod root {
             _unused: [u8; 0],
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct EventListenerManager {
             _unused: [u8; 0],
         }
         #[test]
-        fn __bindgen_test_layout_StaticRefPtr_instantiation_141274() {
+        fn __bindgen_test_layout_StaticRefPtr_instantiation_118207() {
             assert_eq!(::std::mem::size_of::<root::mozilla::StaticRefPtr<root::mozilla::URLExtraData>>()
                        , 8usize , concat ! (
                        "Size of template specialization: " , stringify ! (
                        root::mozilla::StaticRefPtr<root::mozilla::URLExtraData>
                        ) ));
             assert_eq!(::std::mem::align_of::<root::mozilla::StaticRefPtr<root::mozilla::URLExtraData>>()
                        , 8usize , concat ! (
                        "Alignment of template specialization: " , stringify !
@@ -7801,23 +7819,24 @@ pub mod root {
             _unused: [u8; 0],
         }
         #[repr(C)]
         #[derive(Debug)]
         pub struct CounterStyleManager {
             pub mRefCnt: root::nsAutoRefCnt,
             pub _mOwningThread: root::nsAutoOwningThread,
             pub mPresContext: *mut root::nsPresContext,
-            pub mCacheTable: [u64; 6usize],
+            pub mStyles: [u64; 6usize],
+            pub mRetiredStyles: root::nsTArray<*mut root::mozilla::CounterStyle>,
         }
         pub type CounterStyleManager_HasThreadSafeRefCnt =
             root::mozilla::FalseType;
         #[test]
         fn bindgen_test_layout_CounterStyleManager() {
-            assert_eq!(::std::mem::size_of::<CounterStyleManager>() , 72usize
+            assert_eq!(::std::mem::size_of::<CounterStyleManager>() , 80usize
                        , concat ! (
                        "Size of: " , stringify ! ( CounterStyleManager ) ));
             assert_eq! (::std::mem::align_of::<CounterStyleManager>() , 8usize
                         , concat ! (
                         "Alignment of " , stringify ! ( CounterStyleManager )
                         ));
             assert_eq! (unsafe {
                         & ( * ( 0 as * const CounterStyleManager ) ) . mRefCnt
@@ -7835,22 +7854,28 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const CounterStyleManager ) ) .
                         mPresContext as * const _ as usize } , 16usize ,
                         concat ! (
                         "Alignment of field: " , stringify ! (
                         CounterStyleManager ) , "::" , stringify ! (
                         mPresContext ) ));
             assert_eq! (unsafe {
+                        & ( * ( 0 as * const CounterStyleManager ) ) . mStyles
+                        as * const _ as usize } , 24usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        CounterStyleManager ) , "::" , stringify ! ( mStyles )
+                        ));
+            assert_eq! (unsafe {
                         & ( * ( 0 as * const CounterStyleManager ) ) .
-                        mCacheTable as * const _ as usize } , 24usize , concat
-                        ! (
+                        mRetiredStyles as * const _ as usize } , 72usize ,
+                        concat ! (
                         "Alignment of field: " , stringify ! (
                         CounterStyleManager ) , "::" , stringify ! (
-                        mCacheTable ) ));
+                        mRetiredStyles ) ));
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct RestyleManager {
             _unused: [u8; 0],
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
@@ -8017,17 +8042,17 @@ pub mod root {
  * We key the cache on the initial URI (before any redirects), with some
  * canonicalization applied. See ComputeHash() for the details.
  * Controlled documents do not share their cache entries with
  * non-controlled documents, or other controlled documents.
  */
             #[repr(C)]
             #[derive(Debug)]
             pub struct ImageCacheKey {
-                pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
+                pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
                 pub mBlobSerial: [u64; 2usize],
                 pub mOriginAttributes: root::mozilla::OriginAttributes,
                 pub mControlledDocument: *mut ::std::os::raw::c_void,
                 pub mHash: u32,
                 pub mIsChrome: bool,
             }
             #[test]
             fn bindgen_test_layout_ImageCacheKey() {
@@ -8149,16 +8174,36 @@ pub mod root {
                         const _ as usize } , 8usize , concat ! (
                         "Alignment of field: " , stringify ! ( CounterStyle )
                         , "::" , stringify ! ( mStyle ) ));
         }
         impl Clone for CounterStyle {
             fn clone(&self) -> Self { *self }
         }
         #[repr(C)]
+        #[derive(Debug)]
+        pub struct CounterStylePtr {
+            pub mRaw: usize,
+        }
+        pub const CounterStylePtr_kAnonymousFlag: usize = 1;
+        #[test]
+        fn bindgen_test_layout_CounterStylePtr() {
+            assert_eq!(::std::mem::size_of::<CounterStylePtr>() , 8usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( CounterStylePtr ) ));
+            assert_eq! (::std::mem::align_of::<CounterStylePtr>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( CounterStylePtr ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const CounterStylePtr ) ) . mRaw as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( CounterStylePtr
+                        ) , "::" , stringify ! ( mRaw ) ));
+        }
+        #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct Position {
             pub mXPosition: root::mozilla::Position_Coord,
             pub mYPosition: root::mozilla::Position_Coord,
         }
         pub type Position_Coord = root::nsStyleCoord_CalcValue;
         #[test]
         fn bindgen_test_layout_Position() {
@@ -9091,18 +9136,20 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const PropertyStyleAnimationValuePair )
                         ) . mValue as * const _ as usize } , 8usize , concat !
                         (
                         "Alignment of field: " , stringify ! (
                         PropertyStyleAnimationValuePair ) , "::" , stringify !
                         ( mValue ) ));
         }
-        #[test]
-        fn __bindgen_test_layout_DefaultDelete_instantiation_178529() {
+        pub type ComputedKeyframeValues =
+            root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>;
+        #[test]
+        fn __bindgen_test_layout_DefaultDelete_instantiation_155943() {
             assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
                        1usize , concat ! (
                        "Size of template specialization: " , stringify ! (
                        root::mozilla::DefaultDelete ) ));
             assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>()
                        , 1usize , concat ! (
                        "Alignment of template specialization: " , stringify !
                        ( root::mozilla::DefaultDelete ) ));
@@ -11407,32 +11454,16 @@ pub mod root {
     #[test]
     fn bindgen_test_layout_nsCString() {
         assert_eq!(::std::mem::size_of::<nsCString>() , 16usize , concat ! (
                    "Size of: " , stringify ! ( nsCString ) ));
         assert_eq! (::std::mem::align_of::<nsCString>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsCString ) ));
     }
     #[repr(C)]
-    #[derive(Debug)]
-    pub struct nsDependentCSubstring {
-        pub _base: root::nsACString,
-    }
-    pub type nsDependentCSubstring_self_type = root::nsDependentCSubstring;
-    #[test]
-    fn bindgen_test_layout_nsDependentCSubstring() {
-        assert_eq!(::std::mem::size_of::<nsDependentCSubstring>() , 16usize ,
-                   concat ! (
-                   "Size of: " , stringify ! ( nsDependentCSubstring ) ));
-        assert_eq! (::std::mem::align_of::<nsDependentCSubstring>() , 8usize ,
-                    concat ! (
-                    "Alignment of " , stringify ! ( nsDependentCSubstring )
-                    ));
-    }
-    #[repr(C)]
     pub struct nsCStringComparator__bindgen_vtable(::std::os::raw::c_void);
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsCStringComparator {
         pub vtable_: *const nsCStringComparator__bindgen_vtable,
     }
     pub type nsCStringComparator_char_type = ::std::os::raw::c_char;
     #[test]
@@ -11547,28 +11578,28 @@ pub mod root {
         fn clone(&self) -> Self { *self }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsCharTraits {
         pub _address: u8,
     }
     #[test]
-    fn __bindgen_test_layout_nsCharTraits_instantiation_55035() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_51368() {
         assert_eq!(::std::mem::size_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
         assert_eq!(::std::mem::align_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCharTraits_instantiation_55039() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_51372() {
         assert_eq!(::std::mem::size_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
         assert_eq!(::std::mem::align_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
@@ -12478,36 +12509,16 @@ pub mod root {
         pub struct Rooted {
         }
         pub type Rooted_ElementType<T> = T;
         pub type HandleObject = root::JS::Handle<*mut root::JSObject>;
         pub type HandleValue = root::JS::Handle<root::JS::Value>;
         pub type MutableHandleValue =
             root::JS::MutableHandle<root::JS::Value>;
         pub type RootedObject = [u64; 3usize];
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
-        pub struct DeletePolicy {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct FreePolicy {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_FreePolicy() {
-            assert_eq!(::std::mem::size_of::<FreePolicy>() , 1usize , concat !
-                       ( "Size of: " , stringify ! ( FreePolicy ) ));
-            assert_eq! (::std::mem::align_of::<FreePolicy>() , 1usize , concat
-                        ! ( "Alignment of " , stringify ! ( FreePolicy ) ));
-        }
-        impl Clone for FreePolicy {
-            fn clone(&self) -> Self { *self }
-        }
         /**
  * A GC pointer, tagged with the trace kind.
  *
  * In general, a GC pointer should be stored with an exact type. This class
  * is for use when that is not possible because a single pointer must point
  * to several kinds of GC thing.
  */
         #[repr(C)]
@@ -12805,16 +12816,21 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const AutoSetAsyncStackForNewCalls ) )
                         . oldAsyncCallIsExplicit as * const _ as usize } ,
                         40usize , concat ! (
                         "Alignment of field: " , stringify ! (
                         AutoSetAsyncStackForNewCalls ) , "::" , stringify ! (
                         oldAsyncCallIsExplicit ) ));
         }
+        pub type WarningReporter =
+            ::std::option::Option<unsafe extern "C" fn(cx:
+                                                           *mut root::JSContext,
+                                                       report:
+                                                           *mut root::JSErrorReport)>;
         #[repr(C)]
         #[derive(Debug)]
         pub struct AutoHideScriptedCaller {
             pub mContext: *mut root::JSContext,
             pub _mCheckNotUsedAsTemporary: root::mozilla::detail::GuardObjectNotificationReceiver,
         }
         #[test]
         fn bindgen_test_layout_AutoHideScriptedCaller() {
@@ -12966,16 +12982,106 @@ pub mod root {
                         ! ( "Alignment of " , stringify ! ( SourceHook ) ));
         }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct JSCompartment {
         _unused: [u8; 0],
     }
+    /**
+ * Describes a single error or warning that occurs in the execution of script.
+ */
+    #[repr(C)]
+    pub struct JSErrorReport {
+        pub _base: root::JSErrorBase,
+        pub linebuf_: *const u16,
+        pub linebufLength_: usize,
+        pub tokenOffset_: usize,
+        pub notes: root::mozilla::UniquePtr<root::JSErrorNotes>,
+        pub flags: ::std::os::raw::c_uint,
+        pub exnType: i16,
+        pub _bitfield_1: u8,
+        pub __bindgen_padding_0: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_JSErrorReport() {
+        assert_eq!(::std::mem::size_of::<JSErrorReport>() , 72usize , concat !
+                   ( "Size of: " , stringify ! ( JSErrorReport ) ));
+        assert_eq! (::std::mem::align_of::<JSErrorReport>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( JSErrorReport ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . linebuf_ as *
+                    const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( linebuf_ ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . linebufLength_ as
+                    * const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( linebufLength_ ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . tokenOffset_ as *
+                    const _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( tokenOffset_ ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . notes as * const
+                    _ as usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( notes ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . flags as * const
+                    _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( flags ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . exnType as *
+                    const _ as usize } , 68usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( exnType ) ));
+    }
+    impl JSErrorReport {
+        #[inline]
+        pub fn isMuted(&self) -> bool {
+            let mask = 1usize as u8;
+            let field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            let val = (field_val & mask) >> 0usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_isMuted(&mut self, val: bool) {
+            let mask = 1usize as u8;
+            let val = val as u8 as u8;
+            let mut field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            field_val &= !mask;
+            field_val |= (val << 0usize) & mask;
+            self._bitfield_1 = unsafe { ::std::mem::transmute(field_val) };
+        }
+        #[inline]
+        pub fn ownsLinebuf_(&self) -> bool {
+            let mask = 2usize as u8;
+            let field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            let val = (field_val & mask) >> 1usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_ownsLinebuf_(&mut self, val: bool) {
+            let mask = 2usize as u8;
+            let val = val as u8 as u8;
+            let mut field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            field_val &= !mask;
+            field_val |= (val << 1usize) & mask;
+            self._bitfield_1 = unsafe { ::std::mem::transmute(field_val) };
+        }
+    }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct JSRuntime {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct JSTracer {
@@ -13031,17 +13137,17 @@ pub mod root {
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsCOMPtr<T> {
         pub mRawPtr: *mut T,
         pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
     }
     pub type nsCOMPtr_element_type<T> = T;
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_92866() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_64813() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsISupports> ) ));
@@ -13779,17 +13885,17 @@ pub mod root {
         pub mFontFeatureValues: [u64; 6usize],
     }
     pub type gfxFontFeatureValueSet_HasThreadSafeRefCnt =
         root::mozilla::FalseType;
     #[repr(C)]
     #[derive(Debug)]
     pub struct gfxFontFeatureValueSet_ValueList {
         pub name: ::nsstring::nsStringRepr,
-        pub featureSelectors: root::nsTArray<::std::os::raw::c_uint>,
+        pub featureSelectors: root::nsTArray<u32>,
     }
     #[test]
     fn bindgen_test_layout_gfxFontFeatureValueSet_ValueList() {
         assert_eq!(::std::mem::size_of::<gfxFontFeatureValueSet_ValueList>() ,
                    24usize , concat ! (
                    "Size of: " , stringify ! (
                    gfxFontFeatureValueSet_ValueList ) ));
         assert_eq! (::std::mem::align_of::<gfxFontFeatureValueSet_ValueList>()
@@ -13884,17 +13990,17 @@ pub mod root {
                     gfxFontFeatureValueSet_FeatureValueHashKey ) , "::" ,
                     stringify ! ( mName ) ));
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct gfxFontFeatureValueSet_FeatureValueHashEntry {
         pub _base: root::PLDHashEntryHdr,
         pub mKey: root::gfxFontFeatureValueSet_FeatureValueHashKey,
-        pub mValues: root::nsTArray<::std::os::raw::c_uint>,
+        pub mValues: root::nsTArray<u32>,
     }
     pub type gfxFontFeatureValueSet_FeatureValueHashEntry_KeyType =
         *const root::gfxFontFeatureValueSet_FeatureValueHashKey;
     pub type gfxFontFeatureValueSet_FeatureValueHashEntry_KeyTypePointer =
         *const root::gfxFontFeatureValueSet_FeatureValueHashKey;
     pub const gfxFontFeatureValueSet_FeatureValueHashEntry_ALLOW_MEMMOVE:
               root::gfxFontFeatureValueSet_FeatureValueHashEntry__bindgen_ty_1
               =
@@ -13994,17 +14100,17 @@ pub mod root {
         pub stretch: i16,
         pub kerning: u8,
         pub synthesis: u8,
         pub size: root::nscoord,
         pub sizeAdjust: f32,
         pub alternateValues: root::nsTArray<root::gfxAlternateValue>,
         pub featureValueLookup: root::RefPtr<root::gfxFontFeatureValueSet>,
         pub fontFeatureSettings: root::nsTArray<root::gfxFontFeature>,
-        pub fontVariationSettings: root::nsTArray<root::mozilla::gfx::FontVariation>,
+        pub fontVariationSettings: root::nsTArray<root::gfxFontVariation>,
         pub languageOverride: u32,
     }
     #[test]
     fn bindgen_test_layout_nsFont() {
         assert_eq!(::std::mem::size_of::<nsFont>() , 88usize , concat ! (
                    "Size of: " , stringify ! ( nsFont ) ));
         assert_eq! (::std::mem::align_of::<nsFont>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsFont ) ));
@@ -16394,17 +16500,17 @@ pub mod root {
    * have this document as their owner and that are being evaluated right now.
    */
         pub mExternalScriptsBeingEvaluated: u32,
         /**
    * The current frame request callback handle
    */
         pub mFrameRequestCallbackCounter: i32,
         pub mStaticCloneCount: u32,
-        pub mBlockedTrackingNodes: root::nsTArray<root::nsCOMPtr<root::nsIWeakReference>>,
+        pub mBlockedTrackingNodes: root::nsTArray<root::nsWeakPtr>,
         pub mWindow: *mut root::nsPIDOMWindowInner,
         pub mCachedEncoder: root::nsCOMPtr<root::nsIDocumentEncoder>,
         pub mFrameRequestCallbacks: root::nsTArray<root::nsIDocument_FrameRequest>,
         pub mBFCacheEntry: *mut root::nsIBFCacheEntry,
         pub mBaseTarget: ::nsstring::nsStringRepr,
         pub mStateObjectContainer: root::nsCOMPtr<root::nsIStructuredCloneContainer>,
         pub mStateObjectCached: root::nsCOMPtr<root::nsIVariant>,
         pub mInSyncOperationCount: u32,
@@ -19681,17 +19787,17 @@ pub mod root {
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsDOMAttributeMap {
         pub _base: root::nsIDOMMozNamedAttrMap,
         pub _base_1: root::nsWrapperCache,
         pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
-        pub mContent: root::nsCOMPtr<root::mozilla::dom::Element>,
+        pub mContent: root::nsCOMPtr<root::nsDOMAttributeMap_Element>,
         /**
    * Cache of Attrs.
    */
         pub mAttributeCache: root::nsDOMAttributeMap_AttrCache,
     }
     pub type nsDOMAttributeMap_Attr = root::mozilla::dom::Attr;
     pub type nsDOMAttributeMap_Element = root::mozilla::dom::Element;
     pub type nsDOMAttributeMap_ErrorResult = root::mozilla::ErrorResult;
@@ -20714,67 +20820,67 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( nsNodeWeakReference
                     ) , "::" , stringify ! ( mNode ) ));
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsDOMMutationObserver {
         _unused: [u8; 0],
     }
-    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_LISTENERMANAGER;
-    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_PROPERTIES;
-    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_ANONYMOUS_ROOT;
-    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
-    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_NATIVE_ANONYMOUS_ROOT;
-    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_FORCE_XBL_BINDINGS;
-    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_MAY_BE_IN_BINDING_MNGR;
-    pub const NODE_IS_EDITABLE: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_EDITABLE;
-    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_NATIVE_ANONYMOUS;
-    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_IN_SHADOW_TREE;
-    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_EMPTY_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_SLOW_SELECTOR;
-    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_EDGE_CHILD_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
-    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_ALL_SELECTOR_FLAGS;
-    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_NEEDS_FRAME;
-    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_DESCENDANTS_NEED_FRAMES;
-    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_ACCESSKEY;
-    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_DIRECTION_RTL;
-    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_HAS_DIRECTION_LTR;
-    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_ALL_DIRECTION_FLAGS;
-    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_CHROME_ONLY_ACCESS;
-    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
-    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_84 =
-        _bindgen_ty_84::NODE_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_84 {
+    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_LISTENERMANAGER;
+    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_PROPERTIES;
+    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_ANONYMOUS_ROOT;
+    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
+    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_NATIVE_ANONYMOUS_ROOT;
+    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_FORCE_XBL_BINDINGS;
+    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_MAY_BE_IN_BINDING_MNGR;
+    pub const NODE_IS_EDITABLE: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_EDITABLE;
+    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_NATIVE_ANONYMOUS;
+    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_IN_SHADOW_TREE;
+    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_EMPTY_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_SLOW_SELECTOR;
+    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_EDGE_CHILD_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
+    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_ALL_SELECTOR_FLAGS;
+    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_NEEDS_FRAME;
+    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_DESCENDANTS_NEED_FRAMES;
+    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_ACCESSKEY;
+    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_DIRECTION_RTL;
+    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_HAS_DIRECTION_LTR;
+    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_ALL_DIRECTION_FLAGS;
+    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_CHROME_ONLY_ACCESS;
+    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
+    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_77 =
+        _bindgen_ty_77::NODE_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_77 {
         NODE_HAS_LISTENERMANAGER = 4,
         NODE_HAS_PROPERTIES = 8,
         NODE_IS_ANONYMOUS_ROOT = 16,
         NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = 32,
         NODE_IS_NATIVE_ANONYMOUS_ROOT = 64,
         NODE_FORCE_XBL_BINDINGS = 128,
         NODE_MAY_BE_IN_BINDING_MNGR = 256,
         NODE_IS_EDITABLE = 512,
@@ -25917,17 +26023,17 @@ pub mod root {
         pub _base: root::imgIRequest,
         pub _base_1: root::mozilla::image::IProgressObserver,
         pub _base_2: root::nsISupportsPriority,
         pub _base_3: root::nsISecurityInfoProvider,
         pub _base_4: root::nsITimedChannel,
         pub mRefCnt: root::nsAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mBehaviour: root::mozilla::UniquePtr<root::ProxyBehaviour>,
-        pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
+        pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
         pub mListener: *mut root::imgINotificationObserver,
         pub mLoadGroup: root::nsCOMPtr<root::nsILoadGroup>,
         pub mLoadFlags: root::nsLoadFlags,
         pub mLockCount: u32,
         pub mAnimationConsumers: u32,
         pub mCanceled: bool,
         pub mIsInLoadGroup: bool,
         pub mListenerIsStrongRef: bool,
@@ -27149,17 +27255,17 @@ pub mod root {
         pub _base_1: root::nsIThreadRetargetableStreamListener,
         pub _base_2: root::nsIChannelEventSink,
         pub _base_3: root::nsIInterfaceRequestor,
         pub _base_4: root::nsIAsyncVerifyRedirectCallback,
         pub mRefCnt: root::mozilla::ThreadSafeAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mLoader: *mut root::imgLoader,
         pub mRequest: root::nsCOMPtr<root::nsIRequest>,
-        pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
+        pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
         pub mCurrentURI: root::nsCOMPtr<root::nsIURI>,
         pub mLoadingPrincipal: root::nsCOMPtr<root::nsIPrincipal>,
         pub mPrincipal: root::nsCOMPtr<root::nsIPrincipal>,
         pub mProperties: root::nsCOMPtr<root::nsIProperties>,
         pub mSecurityInfo: root::nsCOMPtr<root::nsISupports>,
         pub mChannel: root::nsCOMPtr<root::nsIChannel>,
         pub mPrevChannelSink: root::nsCOMPtr<root::nsIInterfaceRequestor>,
         pub mApplicationCache: root::nsCOMPtr<root::nsIApplicationCache>,
@@ -27176,18 +27282,18 @@ pub mod root {
         pub mRedirectCallback: root::nsCOMPtr<root::nsIAsyncVerifyRedirectCallback>,
         pub mNewRedirectChannel: root::nsCOMPtr<root::nsIChannel>,
         pub mInnerWindowId: u64,
         pub mCORSMode: i32,
         pub mReferrerPolicy: root::imgRequest_ReferrerPolicy,
         pub mImageErrorCode: root::nsresult,
         pub mBoostCategoriesRequested: u32,
         pub mMutex: root::mozilla::Mutex,
-        pub mProgressTracker: root::RefPtr<root::mozilla::image::ProgressTracker>,
-        pub mImage: root::RefPtr<root::mozilla::image::Image>,
+        pub mProgressTracker: root::RefPtr<root::imgRequest_ProgressTracker>,
+        pub mImage: root::RefPtr<root::imgRequest_Image>,
         pub _bitfield_1: u8,
         pub __bindgen_padding_0: [u8; 7usize],
     }
     pub type imgRequest_Image = root::mozilla::image::Image;
     pub type imgRequest_ImageCacheKey = root::mozilla::image::ImageCacheKey;
     pub type imgRequest_ImageURL = root::mozilla::image::ImageURL;
     pub type imgRequest_ProgressTracker =
         root::mozilla::image::ProgressTracker;
@@ -28607,32 +28713,32 @@ pub mod root {
                     ) , "::" , stringify ! ( mRefCnt ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStyleQuoteValues ) ) . mQuotePairs
                     as * const _ as usize } , 8usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStyleQuoteValues
                     ) , "::" , stringify ! ( mQuotePairs ) ));
     }
     #[test]
-    fn __bindgen_test_layout_StaticRefPtr_instantiation_174521() {
+    fn __bindgen_test_layout_StaticRefPtr_instantiation_151935() {
         assert_eq!(::std::mem::size_of::<root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::StaticRefPtr<root::nsStyleQuoteValues> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::StaticRefPtr<root::nsStyleQuoteValues> ) ));
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsStyleList {
         pub mListStylePosition: u8,
         pub mListStyleImage: root::RefPtr<root::nsStyleImageRequest>,
-        pub mCounterStyle: root::RefPtr<root::mozilla::CounterStyle>,
+        pub mCounterStyle: root::mozilla::CounterStylePtr,
         pub mQuotes: root::RefPtr<root::nsStyleQuoteValues>,
         pub mImageRegion: root::nsRect,
     }
     extern "C" {
         #[link_name = "_ZN11nsStyleList14sInitialQuotesE"]
         pub static mut nsStyleList_sInitialQuotes:
                    root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>;
     }
@@ -30706,17 +30812,17 @@ pub mod root {
     }
     pub type RawGeckoNode = root::nsINode;
     pub type RawGeckoElement = root::mozilla::dom::Element;
     pub type RawGeckoDocument = root::nsIDocument;
     pub type RawGeckoPresContext = root::nsPresContext;
     pub type RawGeckoURLExtraData = root::mozilla::URLExtraData;
     pub type RawGeckoKeyframeList = root::nsTArray<root::mozilla::Keyframe>;
     pub type RawGeckoComputedKeyframeValuesList =
-        root::nsTArray<root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>>;
+        root::nsTArray<root::mozilla::ComputedKeyframeValues>;
     pub type RawGeckoAnimationValueList =
         root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>;
     pub type RawGeckoStyleAnimationList =
         root::nsStyleAutoArray<root::mozilla::StyleAnimation>;
     pub type RawGeckoFontFaceRuleList =
         root::nsTArray<root::nsFontFaceRuleContainer>;
     pub type RawGeckoAnimationPropertySegment =
         root::mozilla::AnimationPropertySegment;
@@ -31069,58 +31175,58 @@ pub mod root {
     pub struct mozAutoDocUpdate {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsAttrValueOrString {
         _unused: [u8; 0],
     }
-    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_1;
     pub const ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO:
-              root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_86
-              =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
+              root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_79
+              =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_3;
     pub const ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT:
-              root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
-    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_PENDING_RESTYLE_FLAGS;
-    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
-    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_ALL_RESTYLE_FLAGS;
-    pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_HAS_SCROLLGRAB;
-    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_86 =
-        _bindgen_ty_86::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_86 {
+              root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
+    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_PENDING_RESTYLE_FLAGS;
+    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
+    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_ALL_RESTYLE_FLAGS;
+    pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_HAS_SCROLLGRAB;
+    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_79 =
+        _bindgen_ty_79::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_79 {
         ELEMENT_SHARED_RESTYLE_BIT_1 = 8388608,
         ELEMENT_SHARED_RESTYLE_BIT_2 = 16777216,
         ELEMENT_SHARED_RESTYLE_BIT_3 = 33554432,
         ELEMENT_SHARED_RESTYLE_BIT_4 = 67108864,
         ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR = 134217728,
         ELEMENT_PENDING_RESTYLE_FLAGS = 41943040,
         ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS = 83886080,
         ELEMENT_ALL_RESTYLE_FLAGS = 260046848,
@@ -31496,16 +31602,41 @@ pub mod root {
                     & ( * ( 0 as * const GeckoFontMetrics ) ) . mXSize as *
                     const _ as usize } , 4usize , concat ! (
                     "Alignment of field: " , stringify ! ( GeckoFontMetrics )
                     , "::" , stringify ! ( mXSize ) ));
     }
     impl Clone for GeckoFontMetrics {
         fn clone(&self) -> Self { *self }
     }
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after: u32 = 1;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before: u32 = 1;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_backdrop: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_cue: u32 = 36;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLetter: u32 = 3;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLine: u32 = 3;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozSelection: u32 = 2;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozFocusInner: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozFocusOuter: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozListBullet: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozListNumber: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozMathAnonymous: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberWrapper: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberText: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinBox: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinUp: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinDown: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozProgressBar: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeTrack: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeProgress: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeThumb: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozMeterBar: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozPlaceholder: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_placeholder: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozColorSwatch: u32 = 12;
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsROCSSPrimitiveValue {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsIDOMCSSFontFaceRule {
@@ -31831,1297 +31962,1177 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( __va_list_tag ) ,
                     "::" , stringify ! ( reg_save_area ) ));
     }
     impl Clone for __va_list_tag {
         fn clone(&self) -> Self { *self }
     }
     pub type __builtin_va_list = [root::__va_list_tag; 1usize];
     #[test]
-    fn __bindgen_test_layout_IntegralConstant_instantiation_202097() {
+    fn __bindgen_test_layout_IntegralConstant_instantiation_179789() {
         assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u8 )
                    ));
         assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
                    "Alignment of template specialization: " , stringify ! ( u8
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntegralConstant_instantiation_202101() {
+    fn __bindgen_test_layout_IntegralConstant_instantiation_179793() {
         assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u8 )
                    ));
         assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
                    "Alignment of template specialization: " , stringify ! ( u8
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsReadingIterator_instantiation_202928() {
-        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<u16>>() ,
-                   24usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsReadingIterator<u16> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<u16>>() ,
-                   8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsReadingIterator<u16> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsWritingIterator_instantiation_202932() {
-        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<u16>>() ,
-                   24usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsWritingIterator<u16> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<u16>>() ,
-                   8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsWritingIterator<u16> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsReadingIterator_instantiation_203005() {
-        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<::std::os::raw::c_char>>()
+    fn __bindgen_test_layout_nsReadingIterator_instantiation_180625() {
+        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
+                   , 24usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsWritingIterator_instantiation_180628() {
+        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
                    , 24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
-                   root::nsReadingIterator<::std::os::raw::c_char> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<::std::os::raw::c_char>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsReadingIterator<::std::os::raw::c_char> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsWritingIterator_instantiation_203009() {
-        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<::std::os::raw::c_char>>()
+                   root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsReadingIterator_instantiation_180700() {
+        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
                    , 24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
-                   root::nsWritingIterator<::std::os::raw::c_char> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<::std::os::raw::c_char>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsWritingIterator<::std::os::raw::c_char> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout__bindgen_ty_id_208835_instantiation_208832() {
-        assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
-                   "Size of template specialization: " , stringify ! ( u8 )
-                   ));
-        assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! ( u8
+                   root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>
+                   ) ));
+        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout__bindgen_ty_id_208868_instantiation_208865() {
-        assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
-                   "Size of template specialization: " , stringify ! ( u8 )
-                   ));
-        assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! ( u8
+    fn __bindgen_test_layout_nsWritingIterator_instantiation_180703() {
+        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
+                   , 24usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>
                    ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_209136() {
+        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>
+                   ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsTArray_instantiation_185110() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCString>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCString> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCString>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCString> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Handle_instantiation_210095() {
+    fn __bindgen_test_layout_Handle_instantiation_185961() {
         assert_eq!(::std::mem::size_of::<root::JS::Handle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Handle<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Handle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Handle<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Handle_instantiation_210111() {
+    fn __bindgen_test_layout_Handle_instantiation_185977() {
         assert_eq!(::std::mem::size_of::<root::JS::Handle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Handle<root::JS::Value> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Handle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Handle<root::JS::Value> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_MutableHandle_instantiation_210121() {
+    fn __bindgen_test_layout_MutableHandle_instantiation_185987() {
         assert_eq!(::std::mem::size_of::<root::JS::MutableHandle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::MutableHandle<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::MutableHandle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::MutableHandle<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_MutableHandle_instantiation_210137() {
+    fn __bindgen_test_layout_MutableHandle_instantiation_186003() {
         assert_eq!(::std::mem::size_of::<root::JS::MutableHandle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::MutableHandle<root::JS::Value> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::MutableHandle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::MutableHandle<root::JS::Value> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Rooted_instantiation_210140() {
+    fn __bindgen_test_layout_Rooted_instantiation_186006() {
         assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 3usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 3usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DeletePolicy_instantiation_210477() {
-        assert_eq!(::std::mem::size_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-        assert_eq!(::std::mem::align_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_212527() {
+    fn __bindgen_test_layout_nsTArray_instantiation_188553() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<::nsstring::nsStringRepr>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<::nsstring::nsStringRepr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_212531() {
+    fn __bindgen_test_layout_nsTArray_instantiation_188557() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::mozilla::FontFamilyName>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FontFamilyName> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::FontFamilyName>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FontFamilyName> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_212544() {
-        assert_eq!(::std::mem::size_of::<root::nsTArray<::std::os::raw::c_uint>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsTArray<::std::os::raw::c_uint> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsTArray<::std::os::raw::c_uint>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsTArray<::std::os::raw::c_uint> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_TenuredHeap_instantiation_213669() {
+    fn __bindgen_test_layout_nsTArray_instantiation_188570() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<u32>>() , 8usize ,
+                   concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<u32> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<u32>>() , 8usize ,
+                   concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<u32> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_TenuredHeap_instantiation_189732() {
         assert_eq!(::std::mem::size_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
         assert_eq!(::std::mem::align_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_instantiation_213759() {
+    fn __bindgen_test_layout_Heap_instantiation_189822() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_instantiation_213874() {
+    fn __bindgen_test_layout_Heap_instantiation_189937() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<root::JS::Value>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<root::JS::Value> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<root::JS::Value>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<root::JS::Value> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_TErrorResult_instantiation_213881() {
+    fn __bindgen_test_layout_TErrorResult_instantiation_189944() {
         assert_eq!(::std::mem::size_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 32usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
     }
     #[test]
-    fn __bindgen_test_layout_TErrorResult_instantiation_213897() {
+    fn __bindgen_test_layout_TErrorResult_instantiation_189960() {
         assert_eq!(::std::mem::size_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 32usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_213902() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_189965() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsStringBuffer>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStringBuffer> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsStringBuffer>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStringBuffer> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_213954() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_190017() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIAtom> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIAtom> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_214437() {
+    fn __bindgen_test_layout_RefPtr_instantiation_190500() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_214783() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_190846() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::mozilla::dom::NodeInfo>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::NodeInfo> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::mozilla::dom::NodeInfo>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::NodeInfo> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_215028() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_191091() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIURI>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIURI> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIURI>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIURI> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_215175() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_191238() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsINode>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsINode> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsINode>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsINode> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DeletePolicy_instantiation_219294() {
-        assert_eq!(::std::mem::size_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-        assert_eq!(::std::mem::align_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_219292() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_195342() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::JSErrorNotes_Note>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::JSErrorNotes_Note> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::JSErrorNotes_Note>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::JSErrorNotes_Note> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_iterator_instantiation_219327() {
+    fn __bindgen_test_layout_iterator_instantiation_195374() {
         assert_eq!(::std::mem::size_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::std::iterator ) ));
         assert_eq!(::std::mem::align_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::std::iterator ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_219895() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_195943() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIPrincipal>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIPrincipal> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIPrincipal>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIPrincipal> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_221493() {
+    fn __bindgen_test_layout_nsTArray_instantiation_197531() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_LinkedList_instantiation_221769() {
+    fn __bindgen_test_layout_LinkedList_instantiation_197804() {
         assert_eq!(::std::mem::size_of::<root::mozilla::LinkedList>() ,
                    24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::LinkedList ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::LinkedList>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::LinkedList ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_221785() {
+    fn __bindgen_test_layout_RefPtr_instantiation_197820() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_221784() {
+    fn __bindgen_test_layout_nsTArray_instantiation_197819() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::Element>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::Element>> )
                    ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::Element>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::Element>> )
                    ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_221814() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_197849() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIObserver>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIObserver> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIObserver>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIObserver> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_221813() {
+    fn __bindgen_test_layout_nsTArray_instantiation_197848() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr<root::nsIObserver>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIObserver>> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr<root::nsIObserver>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIObserver>> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_221859() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_197894() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIDocument> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIDocument> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_222024() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_198059() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsContentList>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsContentList> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsContentList>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsContentList> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_222351() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_198386() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIRunnable> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIRunnable> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_222444() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_198479() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::mozilla::dom::Link>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::mozilla::dom::Link> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::mozilla::dom::Link>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::mozilla::dom::Link> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_222481() {
-        assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIWeakReference>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsCOMPtr<root::nsIWeakReference> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIWeakReference>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsCOMPtr<root::nsIWeakReference> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_222739() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_222737() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_198770() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsISMILAttr>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsISMILAttr> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsISMILAttr>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsISMILAttr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_223287() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_199317() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsDataHashtable_instantiation_223286() {
+    fn __bindgen_test_layout_nsDataHashtable_instantiation_199316() {
         assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_223403() {
+    fn __bindgen_test_layout_nsTArray_instantiation_199432() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_223454() {
+    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_199483() {
         assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u64 )
                    ));
         assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u64 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_223634() {
+    fn __bindgen_test_layout_nsTArray_instantiation_199663() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsRect>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsRect> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsRect>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsRect> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_223750() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_223915() {
+    fn __bindgen_test_layout_nsTArray_instantiation_199941() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr<root::nsIAtom>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIAtom>> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr<root::nsIAtom>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIAtom>> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_224702() {
+    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_200728() {
         assert_eq!(::std::mem::size_of::<[u64; 29usize]>() , 232usize , concat
                    ! (
                    "Size of template specialization: " , stringify ! (
                    [u64; 29usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 29usize]>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 29usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_224794() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_200820() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_224975() {
+    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_201001() {
         assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_225498() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_201524() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<::std::os::raw::c_void>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<::std::os::raw::c_void> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<::std::os::raw::c_void>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<::std::os::raw::c_void> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_225506() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_201532() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::WeakFrame>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::WeakFrame> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::WeakFrame>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::WeakFrame> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_OwningNonNull_instantiation_225621() {
+    fn __bindgen_test_layout_OwningNonNull_instantiation_201647() {
         assert_eq!(::std::mem::size_of::<root::mozilla::OwningNonNull<root::nsINode>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::nsINode> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::OwningNonNull<root::nsINode>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::nsINode> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_PointTyped_instantiation_226700() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_201774() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIWeakReference>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIWeakReference> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIWeakReference>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIWeakReference> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_PointTyped_instantiation_202726() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntPointTyped_instantiation_226705() {
+    fn __bindgen_test_layout_IntPointTyped_instantiation_202729() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_SizeTyped_instantiation_226708() {
+    fn __bindgen_test_layout_SizeTyped_instantiation_202732() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RectTyped_instantiation_226716() {
+    fn __bindgen_test_layout_RectTyped_instantiation_202738() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntPointTyped_instantiation_226748() {
+    fn __bindgen_test_layout_IntPointTyped_instantiation_202762() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntSizeTyped_instantiation_226756() {
+    fn __bindgen_test_layout_IntSizeTyped_instantiation_202768() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntRectTyped_instantiation_226764() {
+    fn __bindgen_test_layout_IntRectTyped_instantiation_202774() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_MarginTyped_instantiation_226931() {
+    fn __bindgen_test_layout_MarginTyped_instantiation_202903() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RectTyped_instantiation_226966() {
+    fn __bindgen_test_layout_RectTyped_instantiation_202930() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntRectTyped_instantiation_226971() {
+    fn __bindgen_test_layout_IntRectTyped_instantiation_202933() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactor_instantiation_227017() {
+    fn __bindgen_test_layout_ScaleFactor_instantiation_202969() {
         assert_eq!(::std::mem::size_of::<u32>() , 4usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u32 )
                    ));
         assert_eq!(::std::mem::align_of::<u32>() , 4usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u32 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactors2D_instantiation_227117() {
+    fn __bindgen_test_layout_ScaleFactors2D_instantiation_203069() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactors2D_instantiation_227125() {
+    fn __bindgen_test_layout_ScaleFactors2D_instantiation_203077() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactors2D_instantiation_227169() {
+    fn __bindgen_test_layout_ScaleFactors2D_instantiation_203121() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_227799() {
+    fn __bindgen_test_layout_nsTArray_instantiation_203751() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_227815() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_203767() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::nsIFrame>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIFrame> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::nsIFrame>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIFrame> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_231089() {
+    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_207030() {
         assert_eq!(::std::mem::size_of::<[u64; 29usize]>() , 232usize , concat
                    ! (
                    "Size of template specialization: " , stringify ! (
                    [u64; 29usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 29usize]>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 29usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_231725() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_207663() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::mozilla::dom::CSSValue>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::CSSValue> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::mozilla::dom::CSSValue>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::CSSValue> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_231816() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_231820() {
+    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_207755() {
         assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_233009() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_208944() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsISupports> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_233295() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_209290() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_234885() {
+    fn __bindgen_test_layout_nsTArray_instantiation_210870() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<f64>>() , 8usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<f64>>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_234897() {
+    fn __bindgen_test_layout_RefPtr_instantiation_210882() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_234896() {
+    fn __bindgen_test_layout_nsTArray_instantiation_210881() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_234930() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_210915() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::mozilla::dom::Element>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_235027() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_211012() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::ProfilerBacktrace>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::ProfilerBacktrace> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::ProfilerBacktrace>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::ProfilerBacktrace> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsDataHashtable_instantiation_236809() {
+    fn __bindgen_test_layout_nsDataHashtable_instantiation_212783() {
         assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_OwningNonNull_instantiation_236848() {
+    fn __bindgen_test_layout_OwningNonNull_instantiation_212822() {
         assert_eq!(::std::mem::size_of::<root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_236869() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_212845() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::nsIAtom>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_236900() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_212881() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::nsIContent>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_237445() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_237459() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_213437() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::mozilla::URLExtraData>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::URLExtraData> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::mozilla::URLExtraData>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::URLExtraData> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_237463() {
+    fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_213441() {
         assert_eq!(::std::mem::size_of::<root::nsMainThreadPtrHolder<root::nsIURI>>()
                    , 24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsMainThreadPtrHolder<root::nsIURI> ) ));
         assert_eq!(::std::mem::align_of::<root::nsMainThreadPtrHolder<root::nsIURI>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsMainThreadPtrHolder<root::nsIURI> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_237537() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_213515() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::nsIDocument>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIDocument> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIDocument> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_237824() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_237822() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_213800() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsCSSValueList>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValueList> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsCSSValueList>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValueList> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_237830() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_237828() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_213803() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsCSSValuePairList>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValuePairList> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsCSSValuePairList>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValuePairList> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Maybe_instantiation_238173() {
+    fn __bindgen_test_layout_Maybe_instantiation_214145() {
         assert_eq!(::std::mem::size_of::<[u64; 2usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 2usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_238340() {
+    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_214311() {
         assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u64 )
                    ));
         assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u64 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Maybe_instantiation_238491() {
+    fn __bindgen_test_layout_Maybe_instantiation_214472() {
         assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 3usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 3usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_238506() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_214487() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsStyleImageRequest>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStyleImageRequest> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsStyleImageRequest>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStyleImageRequest> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_238514() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_238512() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_214493() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsStyleSides>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsStyleSides> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsStyleSides>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsStyleSides> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_238553() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_pair_instantiation_238704() {
+    fn __bindgen_test_layout_pair_instantiation_214679() {
         assert_eq!(::std::mem::size_of::<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>()
                    , 32usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr> ) ));
         assert_eq!(::std::mem::align_of::<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_238703() {
+    fn __bindgen_test_layout_nsTArray_instantiation_214678() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::std::pair<::nsstring::nsStringRepr,
                                                      ::nsstring::nsStringRepr>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::std::pair<::nsstring::nsStringRepr,
                                                       ::nsstring::nsStringRepr>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_239705() {
+    fn __bindgen_test_layout_RefPtr_instantiation_215667() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::RawServoAnimationValue>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::RawServoAnimationValue> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::RawServoAnimationValue>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::RawServoAnimationValue> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_BaseTimeDuration_instantiation_243697() {
+    fn __bindgen_test_layout_BaseTimeDuration_instantiation_219655() {
         assert_eq!(::std::mem::size_of::<root::mozilla::BaseTimeDuration>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::BaseTimeDuration ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::BaseTimeDuration>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::BaseTimeDuration ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_244289() {
+    fn __bindgen_test_layout_nsTArray_instantiation_220247() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Maybe_instantiation_244471() {
+    fn __bindgen_test_layout_Maybe_instantiation_220427() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_244646() {
+    fn __bindgen_test_layout_RefPtr_instantiation_220602() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::DOMRect>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMRect> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::DOMRect>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMRect> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Sequence_instantiation_244890() {
+    fn __bindgen_test_layout_Sequence_instantiation_220846() {
         assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u64 )
                    ));
         assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u64 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_245189() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_221145() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::mozilla::dom::Element>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsClassHashtable_instantiation_245188() {
+    fn __bindgen_test_layout_nsClassHashtable_instantiation_221144() {
         assert_eq!(::std::mem::size_of::<[u64; 6usize]>() , 48usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 6usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 6usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_246324() {
+    fn __bindgen_test_layout_nsTArray_instantiation_222311() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsAutoPtr_instantiation_246362() {
+    fn __bindgen_test_layout_nsAutoPtr_instantiation_222349() {
         assert_eq!(::std::mem::size_of::<root::nsAutoPtr<root::nsMediaQuery>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsAutoPtr<root::nsMediaQuery> ) ));
         assert_eq!(::std::mem::align_of::<root::nsAutoPtr<root::nsMediaQuery>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsAutoPtr<root::nsMediaQuery> ) ));
--- a/servo/components/style/gecko/generated/structs_release.rs
+++ b/servo/components/style/gecko/generated/structs_release.rs
@@ -969,16 +969,17 @@ pub mod root {
     pub const NS_STYLE_SCROLL_SNAP_TYPE_PROXIMITY: ::std::os::raw::c_uint = 2;
     pub const NS_STYLE_ORIENTATION_PORTRAIT: ::std::os::raw::c_uint = 0;
     pub const NS_STYLE_ORIENTATION_LANDSCAPE: ::std::os::raw::c_uint = 1;
     pub const NS_STYLE_SCAN_PROGRESSIVE: ::std::os::raw::c_uint = 0;
     pub const NS_STYLE_SCAN_INTERLACE: ::std::os::raw::c_uint = 1;
     pub const NS_STYLE_DISPLAY_MODE_BROWSER: ::std::os::raw::c_uint = 0;
     pub const NS_STYLE_DISPLAY_MODE_MINIMAL_UI: ::std::os::raw::c_uint = 1;
     pub const NS_STYLE_DISPLAY_MODE_STANDALONE: ::std::os::raw::c_uint = 2;
+    pub const NS_STYLE_DISPLAY_MODE_FULLSCREEN: ::std::os::raw::c_uint = 3;
     pub const NS_THEME_NONE: ::std::os::raw::c_uint = 0;
     pub const NS_THEME_BUTTON: ::std::os::raw::c_uint = 1;
     pub const NS_THEME_RADIO: ::std::os::raw::c_uint = 2;
     pub const NS_THEME_CHECKBOX: ::std::os::raw::c_uint = 3;
     pub const NS_THEME_AUTO: ::std::os::raw::c_uint = 4;
     pub const NS_THEME_BUTTON_BEVEL: ::std::os::raw::c_uint = 7;
     pub const NS_THEME_FOCUS_OUTLINE: ::std::os::raw::c_uint = 8;
     pub const NS_THEME_TOOLBOX: ::std::os::raw::c_uint = 11;
@@ -1105,16 +1106,28 @@ pub mod root {
         246;
     pub const NS_THEME_GTK_INFO_BAR: ::std::os::raw::c_uint = 247;
     pub const NS_THEME_MAC_SOURCE_LIST: ::std::os::raw::c_uint = 248;
     pub const NS_THEME_MAC_SOURCE_LIST_SELECTION: ::std::os::raw::c_uint =
         249;
     pub const NS_THEME_MAC_ACTIVE_SOURCE_LIST_SELECTION:
               ::std::os::raw::c_uint =
         250;
+    pub const CSS_PSEUDO_ELEMENT_IS_CSS2: ::std::os::raw::c_uint = 1;
+    pub const CSS_PSEUDO_ELEMENT_CONTAINS_ELEMENTS: ::std::os::raw::c_uint =
+        2;
+    pub const CSS_PSEUDO_ELEMENT_SUPPORTS_STYLE_ATTRIBUTE:
+              ::std::os::raw::c_uint =
+        4;
+    pub const CSS_PSEUDO_ELEMENT_SUPPORTS_USER_ACTION_STATE:
+              ::std::os::raw::c_uint =
+        8;
+    pub const CSS_PSEUDO_ELEMENT_UA_SHEET_ONLY: ::std::os::raw::c_uint = 16;
+    pub const CSS_PSEUDO_ELEMENT_IS_JS_CREATED_NAC: ::std::os::raw::c_uint =
+        32;
     pub const kNameSpaceID_Unknown: ::std::os::raw::c_int = -1;
     pub const kNameSpaceID_XMLNS: ::std::os::raw::c_uint = 1;
     pub const kNameSpaceID_XML: ::std::os::raw::c_uint = 2;
     pub const kNameSpaceID_XHTML: ::std::os::raw::c_uint = 3;
     pub const kNameSpaceID_XLink: ::std::os::raw::c_uint = 4;
     pub const kNameSpaceID_XSLT: ::std::os::raw::c_uint = 5;
     pub const kNameSpaceID_XBL: ::std::os::raw::c_uint = 6;
     pub const kNameSpaceID_MathML: ::std::os::raw::c_uint = 7;
@@ -1163,16 +1176,18 @@ pub mod root {
         pub struct pair<_T1, _T2> {
             pub first: _T1,
             pub second: _T2,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T1>>,
             pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T2>>,
         }
         pub type pair_first_type<_T1> = _T1;
         pub type pair_second_type<_T2> = _T2;
+        pub type pair__PCCP = u8;
+        pub type pair__PCCFP = u8;
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct input_iterator_tag {
             pub _address: u8,
         }
         #[test]
         fn bindgen_test_layout_input_iterator_tag() {
             assert_eq!(::std::mem::size_of::<input_iterator_tag>() , 1usize ,
@@ -1192,20 +1207,27 @@ pub mod root {
             pub _address: u8,
         }
         pub type iterator_iterator_category<_Category> = _Category;
         pub type iterator_value_type<_Tp> = _Tp;
         pub type iterator_difference_type<_Distance> = _Distance;
         pub type iterator_pointer<_Pointer> = _Pointer;
         pub type iterator_reference<_Reference> = _Reference;
         #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct __iterator_traits {
+            pub _address: u8,
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
         pub struct iterator_traits {
             pub _address: u8,
         }
         #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
         pub struct reverse_iterator<_Iterator> {
             pub current: _Iterator,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iterator>>,
         }
         pub type reverse_iterator___traits_type = root::std::iterator_traits;
         pub type reverse_iterator_iterator_type<_Iterator> = _Iterator;
         pub type reverse_iterator_difference_type =
             root::std::reverse_iterator___traits_type;
@@ -1213,26 +1235,26 @@ pub mod root {
             root::std::reverse_iterator___traits_type;
         pub type reverse_iterator_reference =
             root::std::reverse_iterator___traits_type;
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct atomic {
         }
         #[test]
-        fn __bindgen_test_layout_atomic_instantiation_88535() {
+        fn __bindgen_test_layout_atomic_instantiation_60373() {
             assert_eq!(::std::mem::size_of::<u32>() , 4usize , concat ! (
                        "Size of template specialization: " , stringify ! ( u32
                        ) ));
             assert_eq!(::std::mem::align_of::<u32>() , 4usize , concat ! (
                        "Alignment of template specialization: " , stringify !
                        ( u32 ) ));
         }
         #[test]
-        fn __bindgen_test_layout_atomic_instantiation_88543() {
+        fn __bindgen_test_layout_atomic_instantiation_60381() {
             assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                        "Size of template specialization: " , stringify ! ( u64
                        ) ));
             assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                        "Alignment of template specialization: " , stringify !
                        ( u64 ) ));
         }
     }
@@ -1277,18 +1299,19 @@ pub mod root {
                 root::mozilla::detail::nsStringRepr;
             pub type nsStringRepr_base_string_type =
                 root::mozilla::detail::nsStringRepr_self_type;
             pub type nsStringRepr_substring_type = root::nsAString;
             pub type nsStringRepr_substring_tuple_type =
                 root::nsSubstringTuple;
             pub type nsStringRepr_string_type = ::nsstring::nsStringRepr;
             pub type nsStringRepr_const_iterator =
-                root::nsReadingIterator<u16>;
-            pub type nsStringRepr_iterator = root::nsWritingIterator<u16>;
+                root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>;
+            pub type nsStringRepr_iterator =
+                root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>;
             pub type nsStringRepr_comparator_type = root::nsStringComparator;
             pub type nsStringRepr_char_iterator =
                 *mut root::mozilla::detail::nsStringRepr_char_type;
             pub type nsStringRepr_const_char_iterator =
                 *const root::mozilla::detail::nsStringRepr_char_type;
             pub type nsStringRepr_index_type = u32;
             pub type nsStringRepr_size_type = u32;
             pub const nsStringRepr_F_NONE:
@@ -1368,19 +1391,19 @@ pub mod root {
                 root::mozilla::detail::nsCStringRepr;
             pub type nsCStringRepr_base_string_type =
                 root::mozilla::detail::nsCStringRepr_self_type;
             pub type nsCStringRepr_substring_type = root::nsACString;
             pub type nsCStringRepr_substring_tuple_type =
                 root::nsCSubstringTuple;
             pub type nsCStringRepr_string_type = root::nsCString;
             pub type nsCStringRepr_const_iterator =
-                root::nsReadingIterator<::std::os::raw::c_char>;
+                root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>;
             pub type nsCStringRepr_iterator =
-                root::nsWritingIterator<::std::os::raw::c_char>;
+                root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>;
             pub type nsCStringRepr_comparator_type =
                 root::nsCStringComparator;
             pub type nsCStringRepr_char_iterator =
                 *mut root::mozilla::detail::nsCStringRepr_char_type;
             pub type nsCStringRepr_const_char_iterator =
                 *const root::mozilla::detail::nsCStringRepr_char_type;
             pub type nsCStringRepr_index_type = u32;
             pub type nsCStringRepr_size_type = u32;
@@ -1814,30 +1837,36 @@ pub mod root {
                             concat ! (
                             "Alignment of " , stringify ! ( URLValue ) ));
             }
             #[repr(C)]
             #[derive(Debug)]
             pub struct ImageValue {
                 pub _base: root::mozilla::css::URLValueData,
                 pub mRequests: [u64; 5usize],
+                pub mLoadedImage: bool,
             }
             #[test]
             fn bindgen_test_layout_ImageValue() {
-                assert_eq!(::std::mem::size_of::<ImageValue>() , 96usize ,
+                assert_eq!(::std::mem::size_of::<ImageValue>() , 104usize ,
                            concat ! ( "Size of: " , stringify ! ( ImageValue )
                            ));
                 assert_eq! (::std::mem::align_of::<ImageValue>() , 8usize ,
                             concat ! (
                             "Alignment of " , stringify ! ( ImageValue ) ));
                 assert_eq! (unsafe {
                             & ( * ( 0 as * const ImageValue ) ) . mRequests as
                             * const _ as usize } , 56usize , concat ! (
                             "Alignment of field: " , stringify ! ( ImageValue
                             ) , "::" , stringify ! ( mRequests ) ));
+                assert_eq! (unsafe {
+                            & ( * ( 0 as * const ImageValue ) ) . mLoadedImage
+                            as * const _ as usize } , 96usize , concat ! (
+                            "Alignment of field: " , stringify ! ( ImageValue
+                            ) , "::" , stringify ! ( mLoadedImage ) ));
             }
             #[repr(C)]
             #[derive(Debug)]
             pub struct GridNamedArea {
                 pub mName: ::nsstring::nsStringRepr,
                 pub mColumnStart: u32,
                 pub mColumnEnd: u32,
                 pub mRowStart: u32,
@@ -6332,34 +6361,16 @@ pub mod root {
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct BaseTimeDuration__SomethingVeryRandomHere {
             pub _address: u8,
         }
         #[repr(C)]
         #[derive(Debug, Copy)]
-        pub struct MallocAllocPolicy {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_MallocAllocPolicy() {
-            assert_eq!(::std::mem::size_of::<MallocAllocPolicy>() , 1usize ,
-                       concat ! (
-                       "Size of: " , stringify ! ( MallocAllocPolicy ) ));
-            assert_eq! (::std::mem::align_of::<MallocAllocPolicy>() , 1usize ,
-                        concat ! (
-                        "Alignment of " , stringify ! ( MallocAllocPolicy )
-                        ));
-        }
-        impl Clone for MallocAllocPolicy {
-            fn clone(&self) -> Self { *self }
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
         pub struct ErrorResult {
             pub _bindgen_opaque_blob: [u64; 2usize],
         }
         pub type ErrorResult_BaseErrorResult =
             root::mozilla::binding_danger::TErrorResult;
         #[test]
         fn bindgen_test_layout_ErrorResult() {
             assert_eq!(::std::mem::size_of::<ErrorResult>() , 16usize , concat
@@ -6743,17 +6754,17 @@ pub mod root {
             _unused: [u8; 0],
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct EventListenerManager {
             _unused: [u8; 0],
         }
         #[test]
-        fn __bindgen_test_layout_StaticRefPtr_instantiation_138166() {
+        fn __bindgen_test_layout_StaticRefPtr_instantiation_114870() {
             assert_eq!(::std::mem::size_of::<root::mozilla::StaticRefPtr<root::mozilla::URLExtraData>>()
                        , 8usize , concat ! (
                        "Size of template specialization: " , stringify ! (
                        root::mozilla::StaticRefPtr<root::mozilla::URLExtraData>
                        ) ));
             assert_eq!(::std::mem::align_of::<root::mozilla::StaticRefPtr<root::mozilla::URLExtraData>>()
                        , 8usize , concat ! (
                        "Alignment of template specialization: " , stringify !
@@ -7645,23 +7656,24 @@ pub mod root {
         pub struct EventStateManager {
             _unused: [u8; 0],
         }
         #[repr(C)]
         #[derive(Debug)]
         pub struct CounterStyleManager {
             pub mRefCnt: root::nsAutoRefCnt,
             pub mPresContext: *mut root::nsPresContext,
-            pub mCacheTable: [u64; 5usize],
+            pub mStyles: [u64; 5usize],
+            pub mRetiredStyles: root::nsTArray<*mut root::mozilla::CounterStyle>,
         }
         pub type CounterStyleManager_HasThreadSafeRefCnt =
             root::mozilla::FalseType;
         #[test]
         fn bindgen_test_layout_CounterStyleManager() {
-            assert_eq!(::std::mem::size_of::<CounterStyleManager>() , 56usize
+            assert_eq!(::std::mem::size_of::<CounterStyleManager>() , 64usize
                        , concat ! (
                        "Size of: " , stringify ! ( CounterStyleManager ) ));
             assert_eq! (::std::mem::align_of::<CounterStyleManager>() , 8usize
                         , concat ! (
                         "Alignment of " , stringify ! ( CounterStyleManager )
                         ));
             assert_eq! (unsafe {
                         & ( * ( 0 as * const CounterStyleManager ) ) . mRefCnt
@@ -7672,22 +7684,28 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const CounterStyleManager ) ) .
                         mPresContext as * const _ as usize } , 8usize , concat
                         ! (
                         "Alignment of field: " , stringify ! (
                         CounterStyleManager ) , "::" , stringify ! (
                         mPresContext ) ));
             assert_eq! (unsafe {
+                        & ( * ( 0 as * const CounterStyleManager ) ) . mStyles
+                        as * const _ as usize } , 16usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        CounterStyleManager ) , "::" , stringify ! ( mStyles )
+                        ));
+            assert_eq! (unsafe {
                         & ( * ( 0 as * const CounterStyleManager ) ) .
-                        mCacheTable as * const _ as usize } , 16usize , concat
-                        ! (
+                        mRetiredStyles as * const _ as usize } , 56usize ,
+                        concat ! (
                         "Alignment of field: " , stringify ! (
                         CounterStyleManager ) , "::" , stringify ! (
-                        mCacheTable ) ));
+                        mRetiredStyles ) ));
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct RestyleManager {
             _unused: [u8; 0],
         }
         /**
  * BlockingResourceBase
@@ -7772,17 +7790,17 @@ pub mod root {
  * We key the cache on the initial URI (before any redirects), with some
  * canonicalization applied. See ComputeHash() for the details.
  * Controlled documents do not share their cache entries with
  * non-controlled documents, or other controlled documents.
  */
             #[repr(C)]
             #[derive(Debug)]
             pub struct ImageCacheKey {
-                pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
+                pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
                 pub mBlobSerial: [u64; 2usize],
                 pub mOriginAttributes: root::mozilla::OriginAttributes,
                 pub mControlledDocument: *mut ::std::os::raw::c_void,
                 pub mHash: u32,
                 pub mIsChrome: bool,
             }
             #[test]
             fn bindgen_test_layout_ImageCacheKey() {
@@ -7904,16 +7922,36 @@ pub mod root {
                         const _ as usize } , 8usize , concat ! (
                         "Alignment of field: " , stringify ! ( CounterStyle )
                         , "::" , stringify ! ( mStyle ) ));
         }
         impl Clone for CounterStyle {
             fn clone(&self) -> Self { *self }
         }
         #[repr(C)]
+        #[derive(Debug)]
+        pub struct CounterStylePtr {
+            pub mRaw: usize,
+        }
+        pub const CounterStylePtr_kAnonymousFlag: usize = 1;
+        #[test]
+        fn bindgen_test_layout_CounterStylePtr() {
+            assert_eq!(::std::mem::size_of::<CounterStylePtr>() , 8usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( CounterStylePtr ) ));
+            assert_eq! (::std::mem::align_of::<CounterStylePtr>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( CounterStylePtr ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const CounterStylePtr ) ) . mRaw as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( CounterStylePtr
+                        ) , "::" , stringify ! ( mRaw ) ));
+        }
+        #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct Position {
             pub mXPosition: root::mozilla::Position_Coord,
             pub mYPosition: root::mozilla::Position_Coord,
         }
         pub type Position_Coord = root::nsStyleCoord_CalcValue;
         #[test]
         fn bindgen_test_layout_Position() {
@@ -8846,18 +8884,20 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const PropertyStyleAnimationValuePair )
                         ) . mValue as * const _ as usize } , 8usize , concat !
                         (
                         "Alignment of field: " , stringify ! (
                         PropertyStyleAnimationValuePair ) , "::" , stringify !
                         ( mValue ) ));
         }
-        #[test]
-        fn __bindgen_test_layout_DefaultDelete_instantiation_175037() {
+        pub type ComputedKeyframeValues =
+            root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>;
+        #[test]
+        fn __bindgen_test_layout_DefaultDelete_instantiation_152265() {
             assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
                        1usize , concat ! (
                        "Size of template specialization: " , stringify ! (
                        root::mozilla::DefaultDelete ) ));
             assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>()
                        , 1usize , concat ! (
                        "Alignment of template specialization: " , stringify !
                        ( root::mozilla::DefaultDelete ) ));
@@ -10940,32 +10980,16 @@ pub mod root {
     #[test]
     fn bindgen_test_layout_nsCString() {
         assert_eq!(::std::mem::size_of::<nsCString>() , 16usize , concat ! (
                    "Size of: " , stringify ! ( nsCString ) ));
         assert_eq! (::std::mem::align_of::<nsCString>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsCString ) ));
     }
     #[repr(C)]
-    #[derive(Debug)]
-    pub struct nsDependentCSubstring {
-        pub _base: root::nsACString,
-    }
-    pub type nsDependentCSubstring_self_type = root::nsDependentCSubstring;
-    #[test]
-    fn bindgen_test_layout_nsDependentCSubstring() {
-        assert_eq!(::std::mem::size_of::<nsDependentCSubstring>() , 16usize ,
-                   concat ! (
-                   "Size of: " , stringify ! ( nsDependentCSubstring ) ));
-        assert_eq! (::std::mem::align_of::<nsDependentCSubstring>() , 8usize ,
-                    concat ! (
-                    "Alignment of " , stringify ! ( nsDependentCSubstring )
-                    ));
-    }
-    #[repr(C)]
     pub struct nsCStringComparator__bindgen_vtable(::std::os::raw::c_void);
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsCStringComparator {
         pub vtable_: *const nsCStringComparator__bindgen_vtable,
     }
     pub type nsCStringComparator_char_type = ::std::os::raw::c_char;
     #[test]
@@ -11080,28 +11104,28 @@ pub mod root {
         fn clone(&self) -> Self { *self }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsCharTraits {
         pub _address: u8,
     }
     #[test]
-    fn __bindgen_test_layout_nsCharTraits_instantiation_53827() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_50107() {
         assert_eq!(::std::mem::size_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
         assert_eq!(::std::mem::align_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCharTraits_instantiation_53831() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_50111() {
         assert_eq!(::std::mem::size_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
         assert_eq!(::std::mem::align_of::<root::nsCharTraits>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCharTraits ) ));
@@ -11999,36 +12023,16 @@ pub mod root {
         pub struct Rooted {
         }
         pub type Rooted_ElementType<T> = T;
         pub type HandleObject = root::JS::Handle<*mut root::JSObject>;
         pub type HandleValue = root::JS::Handle<root::JS::Value>;
         pub type MutableHandleValue =
             root::JS::MutableHandle<root::JS::Value>;
         pub type RootedObject = [u64; 3usize];
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
-        pub struct DeletePolicy {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct FreePolicy {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_FreePolicy() {
-            assert_eq!(::std::mem::size_of::<FreePolicy>() , 1usize , concat !
-                       ( "Size of: " , stringify ! ( FreePolicy ) ));
-            assert_eq! (::std::mem::align_of::<FreePolicy>() , 1usize , concat
-                        ! ( "Alignment of " , stringify ! ( FreePolicy ) ));
-        }
-        impl Clone for FreePolicy {
-            fn clone(&self) -> Self { *self }
-        }
         /**
  * A GC pointer, tagged with the trace kind.
  *
  * In general, a GC pointer should be stored with an exact type. This class
  * is for use when that is not possible because a single pointer must point
  * to several kinds of GC thing.
  */
         #[repr(C)]
@@ -12326,16 +12330,21 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const AutoSetAsyncStackForNewCalls ) )
                         . oldAsyncCallIsExplicit as * const _ as usize } ,
                         40usize , concat ! (
                         "Alignment of field: " , stringify ! (
                         AutoSetAsyncStackForNewCalls ) , "::" , stringify ! (
                         oldAsyncCallIsExplicit ) ));
         }
+        pub type WarningReporter =
+            ::std::option::Option<unsafe extern "C" fn(cx:
+                                                           *mut root::JSContext,
+                                                       report:
+                                                           *mut root::JSErrorReport)>;
         #[repr(C)]
         #[derive(Debug)]
         pub struct AutoHideScriptedCaller {
             pub mContext: *mut root::JSContext,
         }
         #[test]
         fn bindgen_test_layout_AutoHideScriptedCaller() {
             assert_eq!(::std::mem::size_of::<AutoHideScriptedCaller>() ,
@@ -12479,16 +12488,106 @@ pub mod root {
                         ! ( "Alignment of " , stringify ! ( SourceHook ) ));
         }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct JSCompartment {
         _unused: [u8; 0],
     }
+    /**
+ * Describes a single error or warning that occurs in the execution of script.
+ */
+    #[repr(C)]
+    pub struct JSErrorReport {
+        pub _base: root::JSErrorBase,
+        pub linebuf_: *const u16,
+        pub linebufLength_: usize,
+        pub tokenOffset_: usize,
+        pub notes: root::mozilla::UniquePtr<root::JSErrorNotes>,
+        pub flags: ::std::os::raw::c_uint,
+        pub exnType: i16,
+        pub _bitfield_1: u8,
+        pub __bindgen_padding_0: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_JSErrorReport() {
+        assert_eq!(::std::mem::size_of::<JSErrorReport>() , 72usize , concat !
+                   ( "Size of: " , stringify ! ( JSErrorReport ) ));
+        assert_eq! (::std::mem::align_of::<JSErrorReport>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( JSErrorReport ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . linebuf_ as *
+                    const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( linebuf_ ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . linebufLength_ as
+                    * const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( linebufLength_ ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . tokenOffset_ as *
+                    const _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( tokenOffset_ ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . notes as * const
+                    _ as usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( notes ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . flags as * const
+                    _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( flags ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const JSErrorReport ) ) . exnType as *
+                    const _ as usize } , 68usize , concat ! (
+                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
+                    "::" , stringify ! ( exnType ) ));
+    }
+    impl JSErrorReport {
+        #[inline]
+        pub fn isMuted(&self) -> bool {
+            let mask = 1usize as u8;
+            let field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            let val = (field_val & mask) >> 0usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_isMuted(&mut self, val: bool) {
+            let mask = 1usize as u8;
+            let val = val as u8 as u8;
+            let mut field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            field_val &= !mask;
+            field_val |= (val << 0usize) & mask;
+            self._bitfield_1 = unsafe { ::std::mem::transmute(field_val) };
+        }
+        #[inline]
+        pub fn ownsLinebuf_(&self) -> bool {
+            let mask = 2usize as u8;
+            let field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            let val = (field_val & mask) >> 1usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_ownsLinebuf_(&mut self, val: bool) {
+            let mask = 2usize as u8;
+            let val = val as u8 as u8;
+            let mut field_val: u8 =
+                unsafe { ::std::mem::transmute(self._bitfield_1) };
+            field_val &= !mask;
+            field_val |= (val << 1usize) & mask;
+            self._bitfield_1 = unsafe { ::std::mem::transmute(field_val) };
+        }
+    }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct JSRuntime {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct JSTracer {
@@ -12728,17 +12827,17 @@ pub mod root {
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsCOMPtr {
         pub _base: root::nsCOMPtr_base,
     }
     pub type nsCOMPtr_element_type<T> = T;
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_91623() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_63537() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
@@ -13444,17 +13543,17 @@ pub mod root {
         pub mFontFeatureValues: [u64; 5usize],
     }
     pub type gfxFontFeatureValueSet_HasThreadSafeRefCnt =
         root::mozilla::FalseType;
     #[repr(C)]
     #[derive(Debug)]
     pub struct gfxFontFeatureValueSet_ValueList {
         pub name: ::nsstring::nsStringRepr,
-        pub featureSelectors: root::nsTArray<::std::os::raw::c_uint>,
+        pub featureSelectors: root::nsTArray<u32>,
     }
     #[test]
     fn bindgen_test_layout_gfxFontFeatureValueSet_ValueList() {
         assert_eq!(::std::mem::size_of::<gfxFontFeatureValueSet_ValueList>() ,
                    24usize , concat ! (
                    "Size of: " , stringify ! (
                    gfxFontFeatureValueSet_ValueList ) ));
         assert_eq! (::std::mem::align_of::<gfxFontFeatureValueSet_ValueList>()
@@ -13549,17 +13648,17 @@ pub mod root {
                     gfxFontFeatureValueSet_FeatureValueHashKey ) , "::" ,
                     stringify ! ( mName ) ));
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct gfxFontFeatureValueSet_FeatureValueHashEntry {
         pub _base: root::PLDHashEntryHdr,
         pub mKey: root::gfxFontFeatureValueSet_FeatureValueHashKey,
-        pub mValues: root::nsTArray<::std::os::raw::c_uint>,
+        pub mValues: root::nsTArray<u32>,
     }
     pub type gfxFontFeatureValueSet_FeatureValueHashEntry_KeyType =
         *const root::gfxFontFeatureValueSet_FeatureValueHashKey;
     pub type gfxFontFeatureValueSet_FeatureValueHashEntry_KeyTypePointer =
         *const root::gfxFontFeatureValueSet_FeatureValueHashKey;
     pub const gfxFontFeatureValueSet_FeatureValueHashEntry_ALLOW_MEMMOVE:
               root::gfxFontFeatureValueSet_FeatureValueHashEntry__bindgen_ty_1
               =
@@ -13652,17 +13751,17 @@ pub mod root {
         pub stretch: i16,
         pub kerning: u8,
         pub synthesis: u8,
         pub size: root::nscoord,
         pub sizeAdjust: f32,
         pub alternateValues: root::nsTArray<root::gfxAlternateValue>,
         pub featureValueLookup: root::RefPtr<root::gfxFontFeatureValueSet>,
         pub fontFeatureSettings: root::nsTArray<root::gfxFontFeature>,
-        pub fontVariationSettings: root::nsTArray<root::mozilla::gfx::FontVariation>,
+        pub fontVariationSettings: root::nsTArray<root::gfxFontVariation>,
         pub languageOverride: u32,
     }
     #[test]
     fn bindgen_test_layout_nsFont() {
         assert_eq!(::std::mem::size_of::<nsFont>() , 88usize , concat ! (
                    "Size of: " , stringify ! ( nsFont ) ));
         assert_eq! (::std::mem::align_of::<nsFont>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsFont ) ));
@@ -16025,17 +16124,17 @@ pub mod root {
    * have this document as their owner and that are being evaluated right now.
    */
         pub mExternalScriptsBeingEvaluated: u32,
         /**
    * The current frame request callback handle
    */
         pub mFrameRequestCallbackCounter: i32,
         pub mStaticCloneCount: u32,
-        pub mBlockedTrackingNodes: root::nsTArray<root::nsCOMPtr>,
+        pub mBlockedTrackingNodes: root::nsTArray<root::nsWeakPtr>,
         pub mWindow: *mut root::nsPIDOMWindowInner,
         pub mCachedEncoder: root::nsCOMPtr,
         pub mFrameRequestCallbacks: root::nsTArray<root::nsIDocument_FrameRequest>,
         pub mBFCacheEntry: *mut root::nsIBFCacheEntry,
         pub mBaseTarget: ::nsstring::nsStringRepr,
         pub mStateObjectContainer: root::nsCOMPtr,
         pub mStateObjectCached: root::nsCOMPtr,
         pub mInSyncOperationCount: u32,
@@ -20292,67 +20391,67 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( nsNodeWeakReference
                     ) , "::" , stringify ! ( mNode ) ));
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsDOMMutationObserver {
         _unused: [u8; 0],
     }
-    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_LISTENERMANAGER;
-    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_PROPERTIES;
-    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_ANONYMOUS_ROOT;
-    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
-    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_NATIVE_ANONYMOUS_ROOT;
-    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_FORCE_XBL_BINDINGS;
-    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_MAY_BE_IN_BINDING_MNGR;
-    pub const NODE_IS_EDITABLE: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_EDITABLE;
-    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_NATIVE_ANONYMOUS;
-    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_IN_SHADOW_TREE;
-    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_EMPTY_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_SLOW_SELECTOR;
-    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_EDGE_CHILD_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
-    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_ALL_SELECTOR_FLAGS;
-    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_NEEDS_FRAME;
-    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_DESCENDANTS_NEED_FRAMES;
-    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_ACCESSKEY;
-    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_DIRECTION_RTL;
-    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_HAS_DIRECTION_LTR;
-    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_ALL_DIRECTION_FLAGS;
-    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_CHROME_ONLY_ACCESS;
-    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
-    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_82 =
-        _bindgen_ty_82::NODE_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_82 {
+    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_LISTENERMANAGER;
+    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_PROPERTIES;
+    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_ANONYMOUS_ROOT;
+    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
+    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_NATIVE_ANONYMOUS_ROOT;
+    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_FORCE_XBL_BINDINGS;
+    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_MAY_BE_IN_BINDING_MNGR;
+    pub const NODE_IS_EDITABLE: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_EDITABLE;
+    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_NATIVE_ANONYMOUS;
+    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_IN_SHADOW_TREE;
+    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_EMPTY_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_SLOW_SELECTOR;
+    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_EDGE_CHILD_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
+    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_ALL_SELECTOR_FLAGS;
+    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_NEEDS_FRAME;
+    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_DESCENDANTS_NEED_FRAMES;
+    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_ACCESSKEY;
+    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_DIRECTION_RTL;
+    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_HAS_DIRECTION_LTR;
+    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_ALL_DIRECTION_FLAGS;
+    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_CHROME_ONLY_ACCESS;
+    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
+    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_72 =
+        _bindgen_ty_72::NODE_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_72 {
         NODE_HAS_LISTENERMANAGER = 4,
         NODE_HAS_PROPERTIES = 8,
         NODE_IS_ANONYMOUS_ROOT = 16,
         NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = 32,
         NODE_IS_NATIVE_ANONYMOUS_ROOT = 64,
         NODE_FORCE_XBL_BINDINGS = 128,
         NODE_MAY_BE_IN_BINDING_MNGR = 256,
         NODE_IS_EDITABLE = 512,
@@ -25493,17 +25592,17 @@ pub mod root {
     pub struct imgRequestProxy {
         pub _base: root::imgIRequest,
         pub _base_1: root::mozilla::image::IProgressObserver,
         pub _base_2: root::nsISupportsPriority,
         pub _base_3: root::nsISecurityInfoProvider,
         pub _base_4: root::nsITimedChannel,
         pub mRefCnt: root::nsAutoRefCnt,
         pub mBehaviour: root::mozilla::UniquePtr<root::ProxyBehaviour>,
-        pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
+        pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
         pub mListener: *mut root::imgINotificationObserver,
         pub mLoadGroup: root::nsCOMPtr,
         pub mLoadFlags: root::nsLoadFlags,
         pub mLockCount: u32,
         pub mAnimationConsumers: u32,
         pub mCanceled: bool,
         pub mIsInLoadGroup: bool,
         pub mListenerIsStrongRef: bool,
@@ -26633,17 +26732,17 @@ pub mod root {
         pub _base: root::nsIStreamListener,
         pub _base_1: root::nsIThreadRetargetableStreamListener,
         pub _base_2: root::nsIChannelEventSink,
         pub _base_3: root::nsIInterfaceRequestor,
         pub _base_4: root::nsIAsyncVerifyRedirectCallback,
         pub mRefCnt: root::mozilla::ThreadSafeAutoRefCnt,
         pub mLoader: *mut root::imgLoader,
         pub mRequest: root::nsCOMPtr,
-        pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
+        pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
         pub mCurrentURI: root::nsCOMPtr,
         pub mLoadingPrincipal: root::nsCOMPtr,
         pub mPrincipal: root::nsCOMPtr,
         pub mProperties: root::nsCOMPtr,
         pub mSecurityInfo: root::nsCOMPtr,
         pub mChannel: root::nsCOMPtr,
         pub mPrevChannelSink: root::nsCOMPtr,
         pub mApplicationCache: root::nsCOMPtr,
@@ -26660,18 +26759,18 @@ pub mod root {
         pub mRedirectCallback: root::nsCOMPtr,
         pub mNewRedirectChannel: root::nsCOMPtr,
         pub mInnerWindowId: u64,
         pub mCORSMode: i32,
         pub mReferrerPolicy: root::imgRequest_ReferrerPolicy,
         pub mImageErrorCode: root::nsresult,
         pub mBoostCategoriesRequested: u32,
         pub mMutex: root::mozilla::Mutex,
-        pub mProgressTracker: root::RefPtr<root::mozilla::image::ProgressTracker>,
-        pub mImage: root::RefPtr<root::mozilla::image::Image>,
+        pub mProgressTracker: root::RefPtr<root::imgRequest_ProgressTracker>,
+        pub mImage: root::RefPtr<root::imgRequest_Image>,
         pub _bitfield_1: u8,
         pub __bindgen_padding_0: [u8; 7usize],
     }
     pub type imgRequest_Image = root::mozilla::image::Image;
     pub type imgRequest_ImageCacheKey = root::mozilla::image::ImageCacheKey;
     pub type imgRequest_ImageURL = root::mozilla::image::ImageURL;
     pub type imgRequest_ProgressTracker =
         root::mozilla::image::ProgressTracker;
@@ -28091,32 +28190,32 @@ pub mod root {
                     ) , "::" , stringify ! ( mRefCnt ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStyleQuoteValues ) ) . mQuotePairs
                     as * const _ as usize } , 8usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStyleQuoteValues
                     ) , "::" , stringify ! ( mQuotePairs ) ));
     }
     #[test]
-    fn __bindgen_test_layout_StaticRefPtr_instantiation_171029() {
+    fn __bindgen_test_layout_StaticRefPtr_instantiation_148257() {
         assert_eq!(::std::mem::size_of::<root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::StaticRefPtr<root::nsStyleQuoteValues> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::StaticRefPtr<root::nsStyleQuoteValues> ) ));
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsStyleList {
         pub mListStylePosition: u8,
         pub mListStyleImage: root::RefPtr<root::nsStyleImageRequest>,
-        pub mCounterStyle: root::RefPtr<root::mozilla::CounterStyle>,
+        pub mCounterStyle: root::mozilla::CounterStylePtr,
         pub mQuotes: root::RefPtr<root::nsStyleQuoteValues>,
         pub mImageRegion: root::nsRect,
     }
     extern "C" {
         #[link_name = "_ZN11nsStyleList14sInitialQuotesE"]
         pub static mut nsStyleList_sInitialQuotes:
                    root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>;
     }
@@ -30190,17 +30289,17 @@ pub mod root {
     }
     pub type RawGeckoNode = root::nsINode;
     pub type RawGeckoElement = root::mozilla::dom::Element;
     pub type RawGeckoDocument = root::nsIDocument;
     pub type RawGeckoPresContext = root::nsPresContext;
     pub type RawGeckoURLExtraData = root::mozilla::URLExtraData;
     pub type RawGeckoKeyframeList = root::nsTArray<root::mozilla::Keyframe>;
     pub type RawGeckoComputedKeyframeValuesList =
-        root::nsTArray<root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>>;
+        root::nsTArray<root::mozilla::ComputedKeyframeValues>;
     pub type RawGeckoAnimationValueList =
         root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>;
     pub type RawGeckoStyleAnimationList =
         root::nsStyleAutoArray<root::mozilla::StyleAnimation>;
     pub type RawGeckoFontFaceRuleList =
         root::nsTArray<root::nsFontFaceRuleContainer>;
     pub type RawGeckoAnimationPropertySegment =
         root::mozilla::AnimationPropertySegment;
@@ -30553,58 +30652,58 @@ pub mod root {
     pub struct mozAutoDocUpdate {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsAttrValueOrString {
         _unused: [u8; 0],
     }
-    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
     pub const ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO:
-              root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_84
-              =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_3;
+              root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_74
+              =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
     pub const ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT:
-              root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
-    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_PENDING_RESTYLE_FLAGS;
-    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
-    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_ALL_RESTYLE_FLAGS;
-    pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_HAS_SCROLLGRAB;
-    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_84 =
-        _bindgen_ty_84::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_84 {
+              root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
+    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_PENDING_RESTYLE_FLAGS;
+    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
+    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_ALL_RESTYLE_FLAGS;
+    pub const ELEMENT_HAS_SCROLLGRAB: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_HAS_SCROLLGRAB;
+    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_74 =
+        _bindgen_ty_74::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_74 {
         ELEMENT_SHARED_RESTYLE_BIT_1 = 8388608,
         ELEMENT_SHARED_RESTYLE_BIT_2 = 16777216,
         ELEMENT_SHARED_RESTYLE_BIT_3 = 33554432,
         ELEMENT_SHARED_RESTYLE_BIT_4 = 67108864,
         ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR = 134217728,
         ELEMENT_PENDING_RESTYLE_FLAGS = 41943040,
         ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS = 83886080,
         ELEMENT_ALL_RESTYLE_FLAGS = 260046848,
@@ -30980,16 +31079,41 @@ pub mod root {
                     & ( * ( 0 as * const GeckoFontMetrics ) ) . mXSize as *
                     const _ as usize } , 4usize , concat ! (
                     "Alignment of field: " , stringify ! ( GeckoFontMetrics )
                     , "::" , stringify ! ( mXSize ) ));
     }
     impl Clone for GeckoFontMetrics {
         fn clone(&self) -> Self { *self }
     }
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_after: u32 = 1;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_before: u32 = 1;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_backdrop: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_cue: u32 = 36;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLetter: u32 = 3;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_firstLine: u32 = 3;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozSelection: u32 = 2;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozFocusInner: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozFocusOuter: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozListBullet: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozListNumber: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozMathAnonymous: u32 = 0;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberWrapper: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberText: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinBox: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinUp: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozNumberSpinDown: u32 = 24;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozProgressBar: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeTrack: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeProgress: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozRangeThumb: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozMeterBar: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozPlaceholder: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_placeholder: u32 = 8;
+    pub const SERVO_CSS_PSEUDO_ELEMENT_FLAGS_mozColorSwatch: u32 = 12;
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsROCSSPrimitiveValue {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsIDOMCSSFontFaceRule {
@@ -31315,1297 +31439,1177 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( __va_list_tag ) ,
                     "::" , stringify ! ( reg_save_area ) ));
     }
     impl Clone for __va_list_tag {
         fn clone(&self) -> Self { *self }
     }
     pub type __builtin_va_list = [root::__va_list_tag; 1usize];
     #[test]
-    fn __bindgen_test_layout_IntegralConstant_instantiation_198488() {
+    fn __bindgen_test_layout_IntegralConstant_instantiation_175992() {
         assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u8 )
                    ));
         assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
                    "Alignment of template specialization: " , stringify ! ( u8
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntegralConstant_instantiation_198492() {
+    fn __bindgen_test_layout_IntegralConstant_instantiation_175996() {
         assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u8 )
                    ));
         assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
                    "Alignment of template specialization: " , stringify ! ( u8
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsReadingIterator_instantiation_199316() {
-        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<u16>>() ,
-                   24usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsReadingIterator<u16> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<u16>>() ,
-                   8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsReadingIterator<u16> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsWritingIterator_instantiation_199320() {
-        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<u16>>() ,
-                   24usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsWritingIterator<u16> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<u16>>() ,
-                   8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsWritingIterator<u16> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsReadingIterator_instantiation_199393() {
-        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<::std::os::raw::c_char>>()
+    fn __bindgen_test_layout_nsReadingIterator_instantiation_176825() {
+        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
+                   , 24usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsWritingIterator_instantiation_176828() {
+        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
                    , 24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
-                   root::nsReadingIterator<::std::os::raw::c_char> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<::std::os::raw::c_char>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsReadingIterator<::std::os::raw::c_char> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsWritingIterator_instantiation_199397() {
-        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<::std::os::raw::c_char>>()
+                   root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>
+                   ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsReadingIterator_instantiation_176900() {
+        assert_eq!(::std::mem::size_of::<root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
                    , 24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
-                   root::nsWritingIterator<::std::os::raw::c_char> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<::std::os::raw::c_char>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsWritingIterator<::std::os::raw::c_char> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout__bindgen_ty_id_205166_instantiation_205163() {
-        assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
-                   "Size of template specialization: " , stringify ! ( u8 )
-                   ));
-        assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! ( u8
+                   root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>
+                   ) ));
+        assert_eq!(::std::mem::align_of::<root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout__bindgen_ty_id_205199_instantiation_205196() {
-        assert_eq!(::std::mem::size_of::<u8>() , 1usize , concat ! (
-                   "Size of template specialization: " , stringify ! ( u8 )
-                   ));
-        assert_eq!(::std::mem::align_of::<u8>() , 1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! ( u8
+    fn __bindgen_test_layout_nsWritingIterator_instantiation_176903() {
+        assert_eq!(::std::mem::size_of::<root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
+                   , 24usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>
                    ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_205467() {
+        assert_eq!(::std::mem::align_of::<root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>
+                   ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsTArray_instantiation_181257() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCString>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCString> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCString>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCString> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Handle_instantiation_206419() {
+    fn __bindgen_test_layout_Handle_instantiation_182101() {
         assert_eq!(::std::mem::size_of::<root::JS::Handle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Handle<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Handle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Handle<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Handle_instantiation_206435() {
+    fn __bindgen_test_layout_Handle_instantiation_182117() {
         assert_eq!(::std::mem::size_of::<root::JS::Handle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Handle<root::JS::Value> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Handle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Handle<root::JS::Value> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_MutableHandle_instantiation_206445() {
+    fn __bindgen_test_layout_MutableHandle_instantiation_182127() {
         assert_eq!(::std::mem::size_of::<root::JS::MutableHandle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::MutableHandle<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::MutableHandle<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::MutableHandle<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_MutableHandle_instantiation_206461() {
+    fn __bindgen_test_layout_MutableHandle_instantiation_182143() {
         assert_eq!(::std::mem::size_of::<root::JS::MutableHandle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::MutableHandle<root::JS::Value> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::MutableHandle<root::JS::Value>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::MutableHandle<root::JS::Value> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Rooted_instantiation_206464() {
+    fn __bindgen_test_layout_Rooted_instantiation_182146() {
         assert_eq!(::std::mem::size_of::<[u64; 3usize]>() , 24usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 3usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 3usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 3usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DeletePolicy_instantiation_206801() {
-        assert_eq!(::std::mem::size_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-        assert_eq!(::std::mem::align_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_208804() {
+    fn __bindgen_test_layout_nsTArray_instantiation_184649() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<::nsstring::nsStringRepr>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<::nsstring::nsStringRepr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_208808() {
+    fn __bindgen_test_layout_nsTArray_instantiation_184653() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::mozilla::FontFamilyName>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FontFamilyName> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::FontFamilyName>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FontFamilyName> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_208821() {
-        assert_eq!(::std::mem::size_of::<root::nsTArray<::std::os::raw::c_uint>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsTArray<::std::os::raw::c_uint> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsTArray<::std::os::raw::c_uint>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsTArray<::std::os::raw::c_uint> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_TenuredHeap_instantiation_209688() {
+    fn __bindgen_test_layout_nsTArray_instantiation_184666() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<u32>>() , 8usize ,
+                   concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<u32> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<u32>>() , 8usize ,
+                   concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<u32> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_TenuredHeap_instantiation_185519() {
         assert_eq!(::std::mem::size_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
         assert_eq!(::std::mem::align_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_instantiation_209778() {
+    fn __bindgen_test_layout_Heap_instantiation_185609() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_TErrorResult_instantiation_209888() {
+    fn __bindgen_test_layout_TErrorResult_instantiation_185719() {
         assert_eq!(::std::mem::size_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
     }
     #[test]
-    fn __bindgen_test_layout_TErrorResult_instantiation_209904() {
+    fn __bindgen_test_layout_TErrorResult_instantiation_185735() {
         assert_eq!(::std::mem::size_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_209909() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_185740() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsStringBuffer>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStringBuffer> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsStringBuffer>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStringBuffer> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_209961() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_185792() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIAtom> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIAtom> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_210435() {
+    fn __bindgen_test_layout_RefPtr_instantiation_186266() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_210781() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_186612() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::mozilla::dom::NodeInfo>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::NodeInfo> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::mozilla::dom::NodeInfo>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::NodeInfo> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_211024() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_186855() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIURI>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIURI> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIURI>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIURI> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_211171() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_187002() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsINode>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsINode> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsINode>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsINode> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DeletePolicy_instantiation_215266() {
-        assert_eq!(::std::mem::size_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-        assert_eq!(::std::mem::align_of::<root::JS::DeletePolicy>() , 1usize ,
-                   concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::JS::DeletePolicy ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_215264() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_191082() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::JSErrorNotes_Note>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::JSErrorNotes_Note> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::JSErrorNotes_Note>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::JSErrorNotes_Note> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_iterator_instantiation_215299() {
+    fn __bindgen_test_layout_iterator_instantiation_191114() {
         assert_eq!(::std::mem::size_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::std::iterator ) ));
         assert_eq!(::std::mem::align_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::std::iterator ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_215865() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_191681() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_instantiation_217123() {
+    fn __bindgen_test_layout_Heap_instantiation_192929() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<root::JS::Value>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<root::JS::Value> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<root::JS::Value>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<root::JS::Value> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_217465() {
+    fn __bindgen_test_layout_nsTArray_instantiation_193271() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_LinkedList_instantiation_217741() {
+    fn __bindgen_test_layout_LinkedList_instantiation_193544() {
         assert_eq!(::std::mem::size_of::<root::mozilla::LinkedList>() ,
                    24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::LinkedList ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::LinkedList>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::LinkedList ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_217757() {
+    fn __bindgen_test_layout_RefPtr_instantiation_193560() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_217756() {
+    fn __bindgen_test_layout_nsTArray_instantiation_193559() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::Element>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::Element>> )
                    ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::Element>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::Element>> )
                    ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_217786() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_193589() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_217785() {
+    fn __bindgen_test_layout_nsTArray_instantiation_193588() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_217831() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_193634() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIDocument> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIDocument> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_217996() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_193799() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsContentList>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsContentList> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsContentList>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsContentList> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_218323() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_194126() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIRunnable> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIRunnable> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_218416() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_194219() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_218453() {
-        assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
-                   (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsCOMPtr ) ));
-        assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
-                   ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsCOMPtr ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_218709() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_218707() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_194508() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsISMILAttr>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsISMILAttr> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsISMILAttr>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsISMILAttr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_219247() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_195045() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::DOMIntersectionObserver>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsDataHashtable_instantiation_219246() {
+    fn __bindgen_test_layout_nsDataHashtable_instantiation_195044() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_219363() {
+    fn __bindgen_test_layout_nsTArray_instantiation_195160() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_219410() {
+    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_195207() {
         assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u64 )
                    ));
         assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u64 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_219587() {
+    fn __bindgen_test_layout_nsTArray_instantiation_195384() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsRect>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsRect> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsRect>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsRect> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_219703() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_219865() {
+    fn __bindgen_test_layout_nsTArray_instantiation_195659() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_220652() {
+    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_196446() {
         assert_eq!(::std::mem::size_of::<[u64; 28usize]>() , 224usize , concat
                    ! (
                    "Size of template specialization: " , stringify ! (
                    [u64; 28usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 28usize]>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 28usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_220744() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_196538() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_220925() {
+    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_196719() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_221442() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_197236() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::WeakFrame>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::WeakFrame> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::WeakFrame>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::WeakFrame> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_OwningNonNull_instantiation_221557() {
+    fn __bindgen_test_layout_OwningNonNull_instantiation_197351() {
         assert_eq!(::std::mem::size_of::<root::mozilla::OwningNonNull<root::nsINode>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::nsINode> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::OwningNonNull<root::nsINode>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::nsINode> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_221842() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_197478() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
+                   (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
+                   ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_197638() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<::std::os::raw::c_void>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<::std::os::raw::c_void> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<::std::os::raw::c_void>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<::std::os::raw::c_void> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_PointTyped_instantiation_222633() {
+    fn __bindgen_test_layout_PointTyped_instantiation_198427() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntPointTyped_instantiation_222638() {
+    fn __bindgen_test_layout_IntPointTyped_instantiation_198430() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_SizeTyped_instantiation_222641() {
+    fn __bindgen_test_layout_SizeTyped_instantiation_198433() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RectTyped_instantiation_222649() {
+    fn __bindgen_test_layout_RectTyped_instantiation_198439() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntPointTyped_instantiation_222681() {
+    fn __bindgen_test_layout_IntPointTyped_instantiation_198463() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntSizeTyped_instantiation_222689() {
+    fn __bindgen_test_layout_IntSizeTyped_instantiation_198469() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntRectTyped_instantiation_222697() {
+    fn __bindgen_test_layout_IntRectTyped_instantiation_198475() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_MarginTyped_instantiation_222864() {
+    fn __bindgen_test_layout_MarginTyped_instantiation_198604() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RectTyped_instantiation_222899() {
+    fn __bindgen_test_layout_RectTyped_instantiation_198631() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_IntRectTyped_instantiation_222904() {
+    fn __bindgen_test_layout_IntRectTyped_instantiation_198634() {
         assert_eq!(::std::mem::size_of::<[u32; 4usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 4usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 4usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactor_instantiation_222950() {
+    fn __bindgen_test_layout_ScaleFactor_instantiation_198670() {
         assert_eq!(::std::mem::size_of::<u32>() , 4usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u32 )
                    ));
         assert_eq!(::std::mem::align_of::<u32>() , 4usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u32 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactors2D_instantiation_223050() {
+    fn __bindgen_test_layout_ScaleFactors2D_instantiation_198770() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactors2D_instantiation_223058() {
+    fn __bindgen_test_layout_ScaleFactors2D_instantiation_198778() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_ScaleFactors2D_instantiation_223102() {
+    fn __bindgen_test_layout_ScaleFactors2D_instantiation_198822() {
         assert_eq!(::std::mem::size_of::<[u32; 2usize]>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 2usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_223732() {
+    fn __bindgen_test_layout_nsTArray_instantiation_199452() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::FramePropertyTable_PropertyValue>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_223748() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_199468() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::nsIFrame>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIFrame> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::nsIFrame>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIFrame> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_227020() {
+    fn __bindgen_test_layout_nsPIDOMWindow_instantiation_202726() {
         assert_eq!(::std::mem::size_of::<[u64; 28usize]>() , 224usize , concat
                    ! (
                    "Size of template specialization: " , stringify ! (
                    [u64; 28usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 28usize]>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 28usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_227650() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_203353() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::mozilla::dom::CSSValue>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::CSSValue> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::mozilla::dom::CSSValue>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::dom::CSSValue> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_227741() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_227745() {
+    fn __bindgen_test_layout_nsRefPtrHashtable_instantiation_203445() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_228934() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_204634() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsISupports> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_instantiation_229220() {
+    fn __bindgen_test_layout_nsCOMPtr_instantiation_204980() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_230810() {
+    fn __bindgen_test_layout_nsTArray_instantiation_206560() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<f64>>() , 8usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<f64>>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_230822() {
+    fn __bindgen_test_layout_RefPtr_instantiation_206572() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_230821() {
+    fn __bindgen_test_layout_nsTArray_instantiation_206571() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::DOMIntersectionObserverEntry>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_230855() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_206605() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::mozilla::dom::Element>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_230952() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_206702() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::ProfilerBacktrace>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::ProfilerBacktrace> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::ProfilerBacktrace>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::ProfilerBacktrace> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsDataHashtable_instantiation_232714() {
+    fn __bindgen_test_layout_nsDataHashtable_instantiation_208453() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_OwningNonNull_instantiation_232753() {
+    fn __bindgen_test_layout_OwningNonNull_instantiation_208492() {
         assert_eq!(::std::mem::size_of::<root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::OwningNonNull<root::mozilla::EffectCompositor_AnimationStyleRuleProcessor>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_232774() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_208515() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::nsIAtom>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_232805() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_208551() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::nsIContent>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_233350() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_233364() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_209107() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::mozilla::URLExtraData>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::URLExtraData> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::mozilla::URLExtraData>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::mozilla::URLExtraData> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_233368() {
+    fn __bindgen_test_layout_nsMainThreadPtrHolder_instantiation_209111() {
         assert_eq!(::std::mem::size_of::<root::nsMainThreadPtrHolder<root::nsIURI>>()
                    , 24usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsMainThreadPtrHolder<root::nsIURI> ) ));
         assert_eq!(::std::mem::align_of::<root::nsMainThreadPtrHolder<root::nsIURI>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsMainThreadPtrHolder<root::nsIURI> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsPtrHashKey_instantiation_233442() {
+    fn __bindgen_test_layout_nsPtrHashKey_instantiation_209185() {
         assert_eq!(::std::mem::size_of::<root::nsPtrHashKey<root::nsIDocument>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIDocument> ) ));
         assert_eq!(::std::mem::align_of::<root::nsPtrHashKey<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsPtrHashKey<root::nsIDocument> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_233729() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_233727() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_209470() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsCSSValueList>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValueList> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsCSSValueList>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValueList> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_233735() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_233733() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_209473() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsCSSValuePairList>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValuePairList> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsCSSValuePairList>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsCSSValuePairList> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Maybe_instantiation_234005() {
+    fn __bindgen_test_layout_Maybe_instantiation_209742() {
         assert_eq!(::std::mem::size_of::<[u64; 2usize]>() , 16usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 2usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 2usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 2usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_234172() {
+    fn __bindgen_test_layout_SupportsWeakPtr_instantiation_209908() {
         assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u64 )
                    ));
         assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u64 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Maybe_instantiation_234320() {
+    fn __bindgen_test_layout_Maybe_instantiation_210066() {
         assert_eq!(::std::mem::size_of::<[u32; 3usize]>() , 12usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u32; 3usize] ) ));
         assert_eq!(::std::mem::align_of::<[u32; 3usize]>() , 4usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u32; 3usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_already_AddRefed_instantiation_234335() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_210081() {
         assert_eq!(::std::mem::size_of::<root::already_AddRefed<root::nsStyleImageRequest>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStyleImageRequest> ) ));
         assert_eq!(::std::mem::align_of::<root::already_AddRefed<root::nsStyleImageRequest>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::already_AddRefed<root::nsStyleImageRequest> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_234343() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_UniquePtr_instantiation_234341() {
+    fn __bindgen_test_layout_UniquePtr_instantiation_210087() {
         assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::nsStyleSides>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsStyleSides> ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::nsStyleSides>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::UniquePtr<root::nsStyleSides> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_DefaultDelete_instantiation_234382() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
-                   1usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::DefaultDelete ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_pair_instantiation_234533() {
+    fn __bindgen_test_layout_pair_instantiation_210273() {
         assert_eq!(::std::mem::size_of::<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>()
                    , 32usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr> ) ));
         assert_eq!(::std::mem::align_of::<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_234532() {
+    fn __bindgen_test_layout_nsTArray_instantiation_210272() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::std::pair<::nsstring::nsStringRepr,
                                                      ::nsstring::nsStringRepr>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::std::pair<::nsstring::nsStringRepr,
                                                       ::nsstring::nsStringRepr>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::std::pair<::nsstring::nsStringRepr, ::nsstring::nsStringRepr>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_235534() {
+    fn __bindgen_test_layout_RefPtr_instantiation_211261() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::RawServoAnimationValue>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::RawServoAnimationValue> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::RawServoAnimationValue>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::RawServoAnimationValue> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_BaseTimeDuration_instantiation_239526() {
+    fn __bindgen_test_layout_BaseTimeDuration_instantiation_215249() {
         assert_eq!(::std::mem::size_of::<root::mozilla::BaseTimeDuration>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::BaseTimeDuration ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::BaseTimeDuration>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::BaseTimeDuration ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_240118() {
+    fn __bindgen_test_layout_nsTArray_instantiation_215841() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::DisplayItemClip_RoundedRect>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Maybe_instantiation_240294() {
+    fn __bindgen_test_layout_Maybe_instantiation_216015() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_240469() {
+    fn __bindgen_test_layout_RefPtr_instantiation_216190() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::DOMRect>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMRect> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::DOMRect>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DOMRect> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Sequence_instantiation_240713() {
+    fn __bindgen_test_layout_Sequence_instantiation_216434() {
         assert_eq!(::std::mem::size_of::<u64>() , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! ( u64 )
                    ));
         assert_eq!(::std::mem::align_of::<u64>() , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    u64 ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_241012() {
+    fn __bindgen_test_layout_nsRefPtrHashKey_instantiation_216733() {
         assert_eq!(::std::mem::size_of::<root::nsRefPtrHashKey<root::mozilla::dom::Element>>()
                    , 16usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsClassHashtable_instantiation_241011() {
+    fn __bindgen_test_layout_nsClassHashtable_instantiation_216732() {
         assert_eq!(::std::mem::size_of::<[u64; 5usize]>() , 40usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
         assert_eq!(::std::mem::align_of::<[u64; 5usize]>() , 8usize , concat !
                    (
                    "Alignment of template specialization: " , stringify ! (
                    [u64; 5usize] ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_242145() {
+    fn __bindgen_test_layout_nsTArray_instantiation_217897() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsAutoPtr_instantiation_242181() {
+    fn __bindgen_test_layout_nsAutoPtr_instantiation_217933() {
         assert_eq!(::std::mem::size_of::<root::nsAutoPtr<root::nsMediaQuery>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsAutoPtr<root::nsMediaQuery> ) ));
         assert_eq!(::std::mem::align_of::<root::nsAutoPtr<root::nsMediaQuery>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsAutoPtr<root::nsMediaQuery> ) ));
--- a/servo/components/style/gecko/mod.rs
+++ b/servo/components/style/gecko/mod.rs
@@ -7,16 +7,17 @@
 #[macro_use]
 mod non_ts_pseudo_class_list;
 
 pub mod arc_types;
 pub mod conversions;
 pub mod data;
 pub mod global_style_data;
 pub mod media_queries;
+pub mod pseudo_element;
 pub mod restyle_damage;
 pub mod rules;
 pub mod selector_parser;
 pub mod snapshot;
 pub mod snapshot_helpers;
 pub mod traversal;
 pub mod url;
 pub mod values;
new file mode 100644
--- /dev/null
+++ b/servo/components/style/gecko/pseudo_element.rs
@@ -0,0 +1,91 @@
+/* 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/. */
+
+//! Gecko's definition of a pseudo-element.
+//!
+//! Note that a few autogenerated bits of this live in
+//! `pseudo_element_definition.mako.rs`. If you touch that file, you probably
+//! need to update the checked-in files for Servo.
+
+use cssparser::ToCss;
+use gecko_bindings::structs::{self, CSSPseudoElementType};
+use selector_parser::PseudoElementCascadeType;
+use std::fmt;
+use string_cache::Atom;
+
+include!(concat!(env!("OUT_DIR"), "/gecko/pseudo_element_definition.rs"));
+
+impl PseudoElement {
+    /// Returns the kind of cascade type that a given pseudo is going to use.
+    ///
+    /// In Gecko we only compute ::before and ::after eagerly. We save the rules
+    /// for anonymous boxes separately, so we resolve them as precomputed
+    /// pseudos.
+    ///
+    /// We resolve the others lazily, see `Servo_ResolvePseudoStyle`.
+    pub fn cascade_type(&self) -> PseudoElementCascadeType {
+        if self.is_eager() {
+            debug_assert!(!self.is_anon_box());
+            return PseudoElementCascadeType::Eager
+        }
+
+        if self.is_anon_box() {
+            return PseudoElementCascadeType::Precomputed
+        }
+
+        PseudoElementCascadeType::Lazy
+    }
+
+    /// Gets the canonical index of this eagerly-cascaded pseudo-element.
+    #[inline]
+    pub fn eager_index(&self) -> usize {
+        EAGER_PSEUDOS.iter().position(|p| p == self)
+            .expect("Not an eager pseudo")
+    }
+
+    /// Creates a pseudo-element from an eager index.
+    #[inline]
+    pub fn from_eager_index(i: usize) -> Self {
+        EAGER_PSEUDOS[i].clone()
+    }
+
+    /// Whether this pseudo-element is ::before or ::after.
+    #[inline]
+    pub fn is_before_or_after(&self) -> bool {
+        matches!(*self, PseudoElement::Before | PseudoElement::After)
+    }
+
+    /// Whether this pseudo-element is lazily-cascaded.
+    #[inline]
+    pub fn is_lazy(&self) -> bool {
+        !self.is_eager() && !self.is_precomputed()
+    }
+
+    /// Whether this pseudo-element is web-exposed.
+    pub fn exposed_in_non_ua_sheets(&self) -> bool {
+        if self.is_anon_box() {
+            return false;
+        }
+
+        (self.flags() & structs::CSS_PSEUDO_ELEMENT_UA_SHEET_ONLY) == 0
+    }
+
+    /// Whether this pseudo-element supports user action selectors.
+    pub fn supports_user_action_state(&self) -> bool {
+        (self.flags() & structs::CSS_PSEUDO_ELEMENT_SUPPORTS_USER_ACTION_STATE) != 0
+    }
+
+    /// Whether this pseudo-element is precomputed.
+    #[inline]
+    pub fn is_precomputed(&self) -> bool {
+        self.is_anon_box()
+    }
+}
+
+impl ToCss for PseudoElement {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
+        dest.write_char(':')?;
+        dest.write_str(self.as_str())
+    }
+}
new file mode 100644
--- /dev/null
+++ b/servo/components/style/gecko/pseudo_element_definition.mako.rs
@@ -0,0 +1,138 @@
+/* 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/. */
+
+/// Gecko's pseudo-element definition.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum PseudoElement {
+    % for pseudo in PSEUDOS:
+        /// ${pseudo.value}
+        ${pseudo.capitalized()},
+    % endfor
+}
+
+<% EAGER_PSEUDOS = ["Before", "After"] %>
+
+/// The number of eager pseudo-elements.
+pub const EAGER_PSEUDO_COUNT: usize = ${len(EAGER_PSEUDOS)};
+
+/// The list of eager pseudos.
+pub const EAGER_PSEUDOS: [PseudoElement; EAGER_PSEUDO_COUNT] = [
+    % for eager_pseudo_name in EAGER_PSEUDOS:
+    PseudoElement::${eager_pseudo_name},
+    % endfor
+];
+
+impl PseudoElement {
+    /// Executes a closure with each pseudo-element as an argument.
+    pub fn each<F>(mut fun: F)
+        where F: FnMut(Self),
+    {
+        % for pseudo in PSEUDOS:
+            fun(PseudoElement::${pseudo.capitalized()});
+        % endfor
+    }
+
+    /// Get the pseudo-element as an atom.
+    #[inline]
+    pub fn atom(&self) -> Atom {
+        match *self {
+            % for pseudo in PSEUDOS:
+                PseudoElement::${pseudo.capitalized()} => atom!("${pseudo.value}"),
+            % endfor
+        }
+    }
+
+    /// Whether this pseudo-element is an anonymous box.
+    #[inline]
+    fn is_anon_box(&self) -> bool {
+        match *self {
+            % for pseudo in PSEUDOS:
+                PseudoElement::${pseudo.capitalized()} => ${str(pseudo.is_anon_box()).lower()},
+            % endfor
+        }
+    }
+
+    /// Whether this pseudo-element is eagerly-cascaded.
+    #[inline]
+    pub fn is_eager(&self) -> bool {
+        matches!(*self,
+                 ${" | ".join(map(lambda name: "PseudoElement::{}".format(name), EAGER_PSEUDOS))})
+    }
+
+    /// Gets the flags associated to this pseudo-element, or 0 if it's an
+    /// anonymous box.
+    pub fn flags(&self) -> u32 {
+        match *self {
+            % for pseudo in PSEUDOS:
+                PseudoElement::${pseudo.capitalized()} => {
+                    % if pseudo.is_anon_box():
+                        0
+                    % else:
+                        structs::SERVO_CSS_PSEUDO_ELEMENT_FLAGS_${pseudo.original_ident}
+                    % endif
+                }
+            % endfor
+        }
+    }
+
+    /// Construct a pseudo-element from a `CSSPseudoElementType`.
+    #[inline]
+    pub fn from_pseudo_type(type_: CSSPseudoElementType) -> Option<Self> {
+        match type_ {
+            % for pseudo in PSEUDOS:
+                % if not pseudo.is_anon_box():
+                    CSSPseudoElementType::${pseudo.original_ident} => {
+                        Some(PseudoElement::${pseudo.capitalized()})
+                    },
+                % endif
+            % endfor
+            _ => None,
+        }
+    }
+
+    /// Construct a pseudo-element from an anonymous box `Atom`.
+    #[inline]
+    pub fn from_anon_box_atom(atom: &Atom) -> Option<Self> {
+        % for pseudo in PSEUDOS:
+            % if pseudo.is_anon_box():
+                if atom == &atom!("${pseudo.value}") {
+                    return Some(PseudoElement::${pseudo.capitalized()});
+                }
+            % endif
+        % endfor
+        None
+    }
+
+    /// Constructs an atom from a string of text, and whether we're in a
+    /// user-agent stylesheet.
+    ///
+    /// If we're not in a user-agent stylesheet, we will never parse anonymous
+    /// box pseudo-elements.
+    ///
+    /// Returns `None` if the pseudo-element is not recognised.
+    #[inline]
+    pub fn from_slice(s: &str, in_ua_stylesheet: bool) -> Option<Self> {
+        use std::ascii::AsciiExt;
+
+        % for pseudo in PSEUDOS:
+            if in_ua_stylesheet || PseudoElement::${pseudo.capitalized()}.exposed_in_non_ua_sheets() {
+                if s.eq_ignore_ascii_case("${pseudo.value[1:]}") {
+                    return Some(PseudoElement::${pseudo.capitalized()})
+                }
+            }
+        % endfor
+
+        None
+    }
+
+    /// Returns the pseudo-element's definition as a string, with only one colon
+    /// before it.
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+        % for pseudo in PSEUDOS:
+            PseudoElement::${pseudo.capitalized()} => "${pseudo.value}",
+        % endfor
+        }
+    }
+}
rename from servo/components/style/binding_tools/regen_atoms.py
rename to servo/components/style/gecko/regen_atoms.py
--- a/servo/components/style/binding_tools/regen_atoms.py
+++ b/servo/components/style/gecko/regen_atoms.py
@@ -5,16 +5,20 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 import re
 import os
 import sys
 
 from io import BytesIO
 
+GECKO_DIR = os.path.dirname(__file__.replace('\\', '/'))
+sys.path.insert(0, os.path.join(os.path.dirname(GECKO_DIR), "properties"))
+
+import build
 
 PRELUDE = """
 /* 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 created by components/style/binding_tools/regen_atoms.py, DO NOT EDIT DIRECTLY */
 """[1:]
@@ -69,35 +73,41 @@ def map_atom(ident):
                  "self", "type", "use", "where", "in"}:
         return ident + "_"
     return ident
 
 
 class Atom:
     def __init__(self, source, ident, value):
         self.ident = "{}_{}".format(source.CLASS, ident)
-        self._original_ident = ident
+        self.original_ident = ident
         self.value = value
         self.source = source
 
     def cpp_class(self):
         return self.source.CLASS
 
     def gnu_symbol(self):
-        return gnu_symbolify(self.source, self._original_ident)
+        return gnu_symbolify(self.source, self.original_ident)
 
     def msvc32_symbol(self):
-        return msvc32_symbolify(self.source, self._original_ident)
+        return msvc32_symbolify(self.source, self.original_ident)
 
     def msvc64_symbol(self):
-        return msvc64_symbolify(self.source, self._original_ident)
+        return msvc64_symbolify(self.source, self.original_ident)
 
     def type(self):
         return self.source.TYPE
 
+    def capitalized(self):
+        return self.original_ident[0].upper() + self.original_ident[1:]
+
+    def is_anon_box(self):
+        return self.type() == "nsICSSAnonBoxPseudo"
+
 
 def collect_atoms(objdir):
     atoms = []
     for source in SOURCES:
         path = os.path.abspath(os.path.join(objdir, source.FILE))
         print("cargo:rerun-if-changed={}".format(path))
         with open(path) as f:
             for line in f.readlines():
@@ -206,65 +216,33 @@ def write_atom_macro(atoms, file_name):
         msvc32_symbols = get_symbols(Atom.msvc32_symbol)
         msvc64_symbols = get_symbols(Atom.msvc64_symbol)
         f.write(CFG_IF.format(gnu=gnu_symbols, msvc32=msvc32_symbols, msvc64=msvc64_symbols))
 
         macro_rules = [RULE_TEMPLATE.format(atom=atom.value, name=atom.ident) for atom in atoms]
         f.write(MACRO.format('\n'.join(macro_rules)))
 
 
-PSEUDO_ELEMENT_HEADER = """
-/*
- * 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")
- * }
- * ```
- *
- */
-"""
+def write_pseudo_elements(atoms, target_filename):
+    pseudos = []
+    for atom in atoms:
+        if atom.type() == "nsICSSPseudoElement" or atom.type() == "nsICSSAnonBoxPseudo":
+            pseudos.append(atom)
 
-PSEUDO_ELEMENT_MACRO_INVOCATION = """
-    pseudo_element!(\"{}\",
-                    atom!(\"{}\"),
-                    {});
-"""[1:]
+    pseudo_definition_template = os.path.join(GECKO_DIR, "pseudo_element_definition.mako.rs")
+    print("cargo:rerun-if-changed={}".format(pseudo_definition_template))
+    contents = build.render(pseudo_definition_template, PSEUDOS=pseudos)
 
-
-def write_pseudo_element_helper(atoms, target_filename):
     with FileAvoidWrite(target_filename) as f:
-        f.write(PRELUDE)
-        f.write(PSEUDO_ELEMENT_HEADER)
-        f.write("{\n")
-        for atom in atoms:
-            if atom.type() == "nsICSSPseudoElement":
-                f.write(PSEUDO_ELEMENT_MACRO_INVOCATION.format(atom.value, atom.value, "false"))
-            elif atom.type() == "nsICSSAnonBoxPseudo":
-                f.write(PSEUDO_ELEMENT_MACRO_INVOCATION.format(atom.value, atom.value, "true"))
-        f.write("}\n")
+        f.write(contents)
 
 
 def generate_atoms(dist, out):
     atoms = collect_atoms(dist)
     write_atom_macro(atoms, os.path.join(out, "atom_macro.rs"))
-    write_pseudo_element_helper(atoms, os.path.join(out, "pseudo_element_helper.rs"))
+    write_pseudo_elements(atoms, os.path.join(out, "pseudo_element_definition.rs"))
 
 
 if __name__ == "__main__":
     if len(sys.argv) != 3:
         print("Usage: {} dist out".format(sys.argv[0]))
         exit(2)
     generate_atoms(sys.argv[1], sys.argv[2])
--- a/servo/components/style/gecko/selector_parser.rs
+++ b/servo/components/style/gecko/selector_parser.rs
@@ -1,224 +1,28 @@
 /* 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/. */
 
 //! Gecko-specific bits for selector-parsing.
 
 use cssparser::{Parser, ToCss};
+use element_state::{IN_ACTIVE_STATE, IN_FOCUS_STATE, IN_HOVER_STATE};
 use element_state::ElementState;
 use gecko_bindings::structs::CSSPseudoClassType;
-use gecko_bindings::structs::nsIAtom;
 use selector_parser::{SelectorParser, PseudoElementCascadeType};
 use selectors::parser::{ComplexSelector, SelectorMethods};
 use selectors::visitor::SelectorVisitor;
 use std::borrow::Cow;
 use std::fmt;
-use std::ptr;
 use string_cache::{Atom, Namespace, WeakAtom, WeakNamespace};
 
+pub use gecko::pseudo_element::{PseudoElement, EAGER_PSEUDOS, EAGER_PSEUDO_COUNT};
 pub use gecko::snapshot::SnapshotMap;
 
-/// A representation of a CSS pseudo-element.
-///
-/// In Gecko, we represent pseudo-elements as plain `Atom`s.
-///
-/// The boolean field represents whether this element is an anonymous box. This
-/// is just for convenience, instead of recomputing it.
-///
-/// Also, note that the `Atom` member 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 struct PseudoElement(Atom, bool);
-
-/// List of eager pseudos. Keep this in sync with the count below.
-macro_rules! each_eager_pseudo {
-    ($macro_name:ident, $atom_macro:ident) => {
-        $macro_name!($atom_macro!(":after"), 0);
-        $macro_name!($atom_macro!(":before"), 1);
-    }
-}
-
-/// The number of eager pseudo-elements (just ::before and ::after).
-pub const EAGER_PSEUDO_COUNT: usize = 2;
-
-
-impl PseudoElement {
-    /// Returns the kind of cascade type that a given pseudo is going to use.
-    ///
-    /// In Gecko we only compute ::before and ::after eagerly. We save the rules
-    /// for anonymous boxes separately, so we resolve them as precomputed
-    /// pseudos.
-    ///
-    /// We resolve the others lazily, see `Servo_ResolvePseudoStyle`.
-    pub fn cascade_type(&self) -> PseudoElementCascadeType {
-        if self.is_eager() {
-            debug_assert!(!self.is_anon_box());
-            return PseudoElementCascadeType::Eager
-        }
-
-        if self.is_anon_box() {
-            return PseudoElementCascadeType::Precomputed
-        }
-
-        PseudoElementCascadeType::Lazy
-    }
-
-    /// Gets the canonical index of this eagerly-cascaded pseudo-element.
-    #[inline]
-    pub fn eager_index(&self) -> usize {
-        macro_rules! case {
-            ($atom:expr, $idx:expr) => { if *self.as_atom() == $atom { return $idx; } }
-        }
-        each_eager_pseudo!(case, atom);
-        panic!("Not eager")
-    }
-
-    /// Creates a pseudo-element from an eager index.
-    #[inline]
-    pub fn from_eager_index(i: usize) -> Self {
-        macro_rules! case {
-            ($atom:expr, $idx:expr) => { if i == $idx { return PseudoElement($atom, false); } }
-        }
-        each_eager_pseudo!(case, atom);
-        panic!("Not eager")
-    }
-
-    /// Get the pseudo-element as an atom.
-    #[inline]
-    pub fn as_atom(&self) -> &Atom {
-        &self.0
-    }
-
-    /// Whether this pseudo-element is an anonymous box.
-    #[inline]
-    fn is_anon_box(&self) -> bool {
-        self.1
-    }
-
-    /// Whether this pseudo-element is ::before or ::after.
-    #[inline]
-    pub fn is_before_or_after(&self) -> bool {
-        *self.as_atom() == atom!(":before") ||
-        *self.as_atom() == atom!(":after")
-    }
-
-    /// Whether this pseudo-element is eagerly-cascaded.
-    #[inline]
-    pub fn is_eager(&self) -> bool {
-        macro_rules! case {
-            ($atom:expr, $idx:expr) => { if *self.as_atom() == $atom { return true; } }
-        }
-        each_eager_pseudo!(case, atom);
-        return false;
-    }
-
-    /// Whether this pseudo-element is lazily-cascaded.
-    #[inline]
-    pub fn is_lazy(&self) -> bool {
-        !self.is_eager() && !self.is_precomputed()
-    }
-
-    /// Whether this pseudo-element is precomputed.
-    #[inline]
-    pub fn is_precomputed(&self) -> bool {
-        self.is_anon_box()
-    }
-
-    /// Construct a pseudo-element from an `Atom`, receiving whether it is also
-    /// an anonymous box, and don't check it on release builds.
-    ///
-    /// On debug builds we assert it's the result we expect.
-    #[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!(concat!(env!("OUT_DIR"), "/gecko/pseudo_element_helper.rs"));
-
-        None
-    }
-
-    /// Constructs an atom from a string of text, and whether we're in a
-    /// user-agent stylesheet.
-    ///
-    /// If we're not in a user-agent stylesheet, we will never parse anonymous
-    /// box pseudo-elements.
-    ///
-    /// Returns `None` if the pseudo-element is not recognised.
-    #[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!(concat!(env!("OUT_DIR"), "/gecko/pseudo_element_helper.rs"));
-
-        None
-    }
-
-    /// Returns null or nsIAtom pointer corresponding to a given PseudoElement.
-    #[inline]
-    pub fn ns_atom_or_null_from_opt(pseudo: Option<&PseudoElement>) -> *mut nsIAtom {
-        pseudo.map(|p| p.as_atom().as_ptr()).unwrap_or(ptr::null_mut())
-    }
-}
-
-impl ToCss for PseudoElement {
-    fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-        // FIXME: why does the atom contain one colon? Pseudo-element has two
-        debug_assert!(self.0.as_slice().starts_with(&[b':' as u16]) &&
-                      !self.0.as_slice().starts_with(&[b':' as u16, b':' as u16]));
-        try!(dest.write_char(':'));
-        write!(dest, "{}", self.0)
-    }
-}
-
 bitflags! {
     flags NonTSPseudoClassFlag: u8 {
         // See NonTSPseudoClass::is_internal()
         const PSEUDO_CLASS_INTERNAL = 0x01,
     }
 }
 
 macro_rules! pseudo_class_name {
@@ -320,16 +124,25 @@ impl NonTSPseudoClass {
                     $(NonTSPseudoClass::$s_name(..) => check_flag!($s_flags),)*
                     NonTSPseudoClass::MozAny(_) => false,
                 }
             }
         }
         apply_non_ts_list!(pseudo_class_check_internal)
     }
 
+    /// https://drafts.csswg.org/selectors-4/#useraction-pseudos
+    ///
+    /// We intentionally skip the link-related ones.
+    fn is_safe_user_action_state(&self) -> bool {
+        matches!(*self, NonTSPseudoClass::Hover |
+                        NonTSPseudoClass::Active |
+                        NonTSPseudoClass::Focus)
+    }
+
     /// Get the state flag associated with a pseudo-class, if any.
     pub fn state_flag(&self) -> ElementState {
         macro_rules! flag {
             (_) => (ElementState::empty());
             ($state:ident) => (::element_state::$state);
         }
         macro_rules! pseudo_class_state {
             (bare: [$(($css:expr, $name:ident, $gecko_type:tt, $state:tt, $flags:tt),)*],
@@ -370,27 +183,79 @@ impl NonTSPseudoClass {
         apply_non_ts_list!(pseudo_class_geckotype)
     }
 }
 
 /// The dummy struct we use to implement our selector parsing.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct SelectorImpl;
 
+/// Some subset of pseudo-elements in Gecko are sensitive to some state
+/// selectors.
+///
+/// We store the sensitive states in this struct in order to properly handle
+/// these.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct PseudoElementSelector {
+    pseudo: PseudoElement,
+    state: ElementState,
+}
+
+impl PseudoElementSelector {
+    /// Returns the pseudo-element this selector represents.
+    pub fn pseudo_element(&self) -> &PseudoElement {
+        &self.pseudo
+    }
+
+    /// Returns the pseudo-element selector state.
+    pub fn state(&self) -> ElementState {
+        self.state
+    }
+}
+
+impl ToCss for PseudoElementSelector {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+        where W: fmt::Write,
+    {
+        if cfg!(debug_assertions) {
+            let mut state = self.state;
+            state.remove(IN_HOVER_STATE | IN_ACTIVE_STATE | IN_FOCUS_STATE);
+            assert_eq!(state, ElementState::empty(),
+                       "Unhandled pseudo-element state selector?");
+        }
+
+        self.pseudo.to_css(dest)?;
+
+        if self.state.contains(IN_HOVER_STATE) {
+            dest.write_str(":hover")?
+        }
+
+        if self.state.contains(IN_ACTIVE_STATE) {
+            dest.write_str(":active")?
+        }
+
+        if self.state.contains(IN_FOCUS_STATE) {
+            dest.write_str(":focus")?
+        }
+
+        Ok(())
+    }
+}
+
 impl ::selectors::SelectorImpl for SelectorImpl {
     type AttrValue = Atom;
     type Identifier = Atom;
     type ClassName = Atom;
     type LocalName = Atom;
     type NamespacePrefix = Atom;
     type NamespaceUrl = Namespace;
     type BorrowedNamespaceUrl = WeakNamespace;
     type BorrowedLocalName = WeakAtom;
 
-    type PseudoElement = PseudoElement;
+    type PseudoElementSelector = PseudoElementSelector;
     type NonTSPseudoClass = NonTSPseudoClass;
 }
 
 impl<'a> ::selectors::Parser for SelectorParser<'a> {
     type Impl = SelectorImpl;
 
     fn parse_non_ts_pseudo_class(&self, name: Cow<str>) -> Result<NonTSPseudoClass, ()> {
         macro_rules! pseudo_class_parse {
@@ -442,21 +307,48 @@ impl<'a> ::selectors::Parser for Selecto
         let pseudo_class = apply_non_ts_list!(pseudo_class_string_parse);
         if !pseudo_class.is_internal() || self.in_user_agent_stylesheet() {
             Ok(pseudo_class)
         } else {
             Err(())
         }
     }
 
-    fn parse_pseudo_element(&self, name: Cow<str>) -> Result<PseudoElement, ()> {
-        match PseudoElement::from_slice(&name, self.in_user_agent_stylesheet()) {
-            Some(pseudo) => Ok(pseudo),
-            None => Err(()),
-        }
+    fn parse_pseudo_element(&self, name: Cow<str>, input: &mut Parser) -> Result<PseudoElementSelector, ()> {
+        let pseudo =
+            match PseudoElement::from_slice(&name, self.in_user_agent_stylesheet()) {
+                Some(pseudo) => pseudo,
+                None => return Err(()),
+            };
+
+        let state = if pseudo.supports_user_action_state() {
+            input.try(|input| {
+                let mut state = ElementState::empty();
+
+                while !input.is_exhausted() {
+                    input.expect_colon()?;
+                    let ident = input.expect_ident()?;
+                    let pseudo_class = self.parse_non_ts_pseudo_class(ident)?;
+
+                    if !pseudo_class.is_safe_user_action_state() {
+                        return Err(())
+                    }
+                    state.insert(pseudo_class.state_flag());
+                }
+
+                Ok(state)
+            }).ok()
+        } else {
+            None
+        };
+
+        Ok(PseudoElementSelector {
+            pseudo: pseudo,
+            state: state.unwrap_or(ElementState::empty()),
+        })
     }
 
     fn default_namespace(&self) -> Option<Namespace> {
         self.namespaces.default.clone()
     }
 
     fn namespace_for_prefix(&self, prefix: &Atom) -> Option<Namespace> {
         self.namespaces.prefixes.get(prefix).cloned()
@@ -471,35 +363,28 @@ impl SelectorImpl {
     }
 
     /// A helper to traverse each eagerly cascaded pseudo-element, executing
     /// `fun` on it.
     #[inline]
     pub fn each_eagerly_cascaded_pseudo_element<F>(mut fun: F)
         where F: FnMut(PseudoElement),
     {
-        macro_rules! case {
-            ($atom:expr, $idx:expr) => { fun(PseudoElement($atom, false)); }
+        for pseudo in &EAGER_PSEUDOS {
+            fun(pseudo.clone())
         }
-        each_eager_pseudo!(case, atom);
     }
 
 
     #[inline]
     /// Executes a function for each pseudo-element.
-    pub fn each_pseudo_element<F>(mut fun: F)
+    pub fn each_pseudo_element<F>(fun: F)
         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!(concat!(env!("OUT_DIR"), "/gecko/pseudo_element_helper.rs"));
+        PseudoElement::each(fun)
     }
 
     #[inline]
     /// Returns the relevant state flag for a given non-tree-structural
     /// pseudo-class.
     pub fn pseudo_class_state_flag(pc: &NonTSPseudoClass) -> ElementState {
         pc.state_flag()
     }
--- a/servo/components/style/gecko/wrapper.rs
+++ b/servo/components/style/gecko/wrapper.rs
@@ -622,17 +622,18 @@ impl<'le> TElement for GeckoElement<'le>
                                        /* ignoreCase = */ false)
         }
     }
 
     fn existing_style_for_restyle_damage<'a>(&'a self,
                                              _existing_values: &'a Arc<ComputedValues>,
                                              pseudo: Option<&PseudoElement>)
                                              -> Option<&'a nsStyleContext> {
-        let atom_ptr = PseudoElement::ns_atom_or_null_from_opt(pseudo);
+        // TODO(emilio): Migrate this to CSSPseudoElementType.
+        let atom_ptr = pseudo.map_or(ptr::null_mut(), |p| p.atom().as_ptr());
         unsafe {
             let context_ptr = Gecko_GetStyleContext(self.0, atom_ptr);
             context_ptr.as_ref()
         }
     }
 
     fn has_snapshot(&self) -> bool {
         self.flags() & (ELEMENT_HAS_SNAPSHOT as u32) != 0
@@ -694,25 +695,19 @@ impl<'le> TElement for GeckoElement<'le>
         self.flags() & (NODE_IS_NATIVE_ANONYMOUS as u32) != 0
     }
 
     fn implemented_pseudo_element(&self) -> Option<PseudoElement> {
         if !self.is_native_anonymous() {
             return None;
         }
 
-        let maybe_atom =
+        let pseudo_type =
             unsafe { bindings::Gecko_GetImplementedPseudo(self.0) };
-
-        if maybe_atom.is_null() {
-            return None;
-        }
-
-        let atom = Atom::from(maybe_atom);
-        Some(PseudoElement::from_atom_unchecked(atom, /* anon_box = */ false))
+        PseudoElement::from_pseudo_type(pseudo_type)
     }
 
     fn store_children_to_process(&self, _: isize) {
         // This is only used for bottom-up traversal, and is thus a no-op for Gecko.
     }
 
     fn did_process_child(&self) -> isize {
         panic!("Atomic child count not implemented in Gecko");
--- a/servo/components/style/matching.rs
+++ b/servo/components/style/matching.rs
@@ -10,16 +10,17 @@
 use Atom;
 use atomic_refcell::AtomicRefMut;
 use bit_vec::BitVec;
 use cache::{LRUCache, LRUCacheMutIterator};
 use cascade_info::CascadeInfo;
 use context::{CurrentElementInfo, SelectorFlagsMap, SharedStyleContext, StyleContext};
 use data::{ComputedStyle, ElementData, ElementStyles, RestyleData};
 use dom::{AnimationRules, SendElement, TElement, TNode};
+use element_state::ElementState;
 use font_metrics::FontMetricsProvider;
 use properties::{CascadeFlags, ComputedValues, SKIP_ROOT_AND_ITEM_BASED_DISPLAY_FIXUP, cascade};
 use properties::longhands::display::computed_value as display;
 use restyle_hints::{RESTYLE_CSS_ANIMATIONS, RESTYLE_CSS_TRANSITIONS, RestyleHint};
 use restyle_hints::{RESTYLE_STYLE_ATTRIBUTE, RESTYLE_SMIL};
 use rule_tree::{CascadeLevel, RuleTree, StrongRuleNode};
 use selector_parser::{PseudoElement, RestyleDamage, SelectorImpl};
 use selectors::bloom::BloomFilter;
@@ -1010,23 +1011,28 @@ pub trait MatchMethods : TElement {
         let selector_matching_target = match implemented_pseudo {
             Some(..) => {
                 self.closest_non_native_anonymous_ancestor()
                     .expect("Pseudo-element without non-NAC parent?")
             },
             None => *self,
         };
 
+        let pseudo_and_state = match implemented_pseudo {
+            Some(ref pseudo) => Some((pseudo, self.get_state())),
+            None => None,
+        };
+
         // Compute the primary rule node.
         *relations = stylist.push_applicable_declarations(&selector_matching_target,
                                                           Some(bloom),
                                                           style_attribute,
                                                           smil_override,
                                                           animation_rules,
-                                                          implemented_pseudo.as_ref(),
+                                                          pseudo_and_state,
                                                           &mut applicable_declarations,
                                                           &mut set_selector_flags);
 
         let primary_rule_node =
             compute_rule_node::<Self>(&stylist.rule_tree,
                                       &mut applicable_declarations,
                                       &context.shared.guards);
 
@@ -1071,17 +1077,17 @@ pub trait MatchMethods : TElement {
             debug_assert!(applicable_declarations.is_empty());
             // NB: We handle animation rules for ::before and ::after when
             // traversing them.
             stylist.push_applicable_declarations(self,
                                                  Some(bloom_filter),
                                                  None,
                                                  None,
                                                  AnimationRules(None, None),
-                                                 Some(&pseudo),
+                                                 Some((&pseudo, ElementState::empty())),
                                                  &mut applicable_declarations,
                                                  &mut set_selector_flags);
 
             if !applicable_declarations.is_empty() {
                 let new_rules =
                     compute_rule_node::<Self>(rule_tree,
                                               &mut applicable_declarations,
                                               &guards);
--- a/servo/components/style/restyle_hints.rs
+++ b/servo/components/style/restyle_hints.rs
@@ -4,21 +4,22 @@
 
 //! Restyle hints: an optimization to avoid unnecessarily matching selectors.
 
 #![deny(missing_docs)]
 
 use Atom;
 use dom::TElement;
 use element_state::*;
+use fnv::FnvHashMap;
 #[cfg(feature = "gecko")]
 use gecko_bindings::structs::nsRestyleHint;
 #[cfg(feature = "servo")]
 use heapsize::HeapSizeOf;
-use selector_parser::{AttrValue, NonTSPseudoClass, SelectorImpl, Snapshot, SnapshotMap};
+use selector_parser::{AttrValue, NonTSPseudoClass, PseudoElement, SelectorImpl, Snapshot, SnapshotMap};
 use selectors::{Element, MatchAttr};
 use selectors::matching::{ElementSelectorFlags, StyleRelations};
 use selectors::matching::matches_selector;
 use selectors::parser::{AttrSelector, Combinator, Component, Selector};
 use selectors::parser::{SelectorInner, SelectorMethods};
 use selectors::visitor::SelectorVisitor;
 use smallvec::SmallVec;
 use std::borrow::Borrow;
@@ -223,16 +224,28 @@ impl<'a, E> ElementWrapper<'a, E>
 
         let snapshot = self.snapshot_map.get(&self.element);
         debug_assert!(snapshot.is_some(), "has_snapshot lied!");
 
         self.cached_snapshot.set(snapshot);
 
         snapshot
     }
+
+    fn state_changes(&self) -> ElementState {
+        let snapshot = match self.snapshot() {
+            Some(s) => s,
+            None => return ElementState::empty(),
+        };
+
+        match snapshot.state() {
+            Some(state) => state ^ self.element.get_state(),
+            None => ElementState::empty(),
+        }
+    }
 }
 
 impl<'a, E> MatchAttr for ElementWrapper<'a, E>
     where E: TElement,
 {
     type Impl = SelectorImpl;
 
     fn match_attr_has(&self, attr: &AttrSelector<SelectorImpl>) -> bool {
@@ -559,16 +572,48 @@ pub struct Dependency {
 }
 
 impl Borrow<SelectorInner<SelectorImpl>> for Dependency {
     fn borrow(&self) -> &SelectorInner<SelectorImpl> {
         &self.selector
     }
 }
 
+/// A similar version of the above, but for pseudo-elements, which only care
+/// about the full selector, and need it in order to properly track
+/// pseudo-element selector state.
+///
+/// NOTE(emilio): We could add a `hint` and `sensitivities` field to the
+/// `PseudoElementDependency` and stop posting `RESTYLE_DESCENDANTS`s hints if
+/// we visited all the pseudo-elements of an element unconditionally as part of
+/// the traversal.
+///
+/// That would allow us to stop posting `RESTYLE_DESCENDANTS` hints for dumb
+/// selectors, and storing pseudo dependencies in the element dependency map.
+///
+/// That would allow us to avoid restyling the element itself when a selector
+/// has only changed a pseudo-element's style, too.
+///
+/// There's no good way to do that right now though, and I think for the
+/// foreseeable future we may just want to optimize that `RESTYLE_DESCENDANTS`
+/// to become a `RESTYLE_PSEUDO_ELEMENTS` or something like that, in order to at
+/// least not restyle the whole subtree.
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+struct PseudoElementDependency {
+    #[cfg_attr(feature = "servo", ignore_heap_size_of = "defined in selectors")]
+    selector: Selector<SelectorImpl>,
+}
+
+impl Borrow<SelectorInner<SelectorImpl>> for PseudoElementDependency {
+    fn borrow(&self) -> &SelectorInner<SelectorImpl> {
+        &self.selector.inner
+    }
+}
+
 /// The following visitor visits all the simple selectors for a given complex
 /// selector, taking care of :not and :any combinators, collecting whether any
 /// of them is sensitive to attribute or state changes.
 struct SensitivitiesVisitor {
     sensitivities: Sensitivities,
 }
 
 impl SelectorVisitor for SensitivitiesVisitor {
@@ -583,23 +628,29 @@ impl SelectorVisitor for SensitivitiesVi
 /// A set of dependencies for a given stylist.
 ///
 /// Note that we can have many dependencies, often more than the total number
 /// of selectors given that we can get multiple partial selectors for a given
 /// selector. As such, we want all the usual optimizations, including the
 /// SelectorMap and the bloom filter.
 #[derive(Debug)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-pub struct DependencySet(pub SelectorMap<Dependency>);
+pub struct DependencySet {
+    /// A map used for pseudo-element's dependencies.
+    ///
+    /// Note that pseudo-elements are somewhat special, because some of them in
+    /// Gecko track state, and also because they don't do selector-matching as
+    /// normal, but against their parent element.
+    pseudo_dependencies: FnvHashMap<PseudoElement, SelectorMap<PseudoElementDependency>>,
+
+    /// This is for all other normal element's selectors/selector parts.
+    dependencies: SelectorMap<Dependency>,
+}
 
 impl DependencySet {
-    fn add_dependency(&mut self, dep: Dependency) {
-        self.0.insert(dep);
-    }
-
     /// Adds a selector to this `DependencySet`.
     pub fn note_selector(&mut self, selector: &Selector<SelectorImpl>) {
         let mut combinator = None;
         let mut iter = selector.inner.complex.iter();
         let mut index = 0;
 
         loop {
             let sequence_start = index;
@@ -612,41 +663,53 @@ impl DependencySet {
             // Note that this works because we can't have combinators nested
             // inside simple selectors (i.e. in :not() or :-moz-any()). If we
             // ever support that we'll need to visit complex selectors as well.
             for ss in &mut iter {
                 ss.visit(&mut visitor);
                 index += 1; // Account for the simple selector.
             }
 
+
+            let pseudo_selector_is_state_dependent =
+                sequence_start == 0 &&
+                selector.pseudo_element.as_ref().map_or(false, |pseudo_selector| {
+                    !pseudo_selector.state().is_empty()
+                });
+
+            if pseudo_selector_is_state_dependent {
+                let pseudo_selector = selector.pseudo_element.as_ref().unwrap();
+                self.pseudo_dependencies
+                    .entry(pseudo_selector.pseudo_element().clone())
+                    .or_insert_with(SelectorMap::new)
+                    .insert(PseudoElementDependency {
+                        selector: selector.clone(),
+                    });
+            }
+
             // If we found a sensitivity, add an entry in the dependency set.
             if !visitor.sensitivities.is_empty() {
                 let mut hint = combinator_to_restyle_hint(combinator);
-                let dep_selector;
-                if sequence_start == 0 {
-                    if selector.pseudo_element.is_some() {
-                        // TODO(emilio): use more fancy restyle hints to avoid
-                        // restyling the whole subtree when pseudos change.
-                        //
-                        // We currently need is_pseudo_element to handle eager
-                        // pseudos (so the style the parent stores doesn't
-                        // become stale), and restyle_descendants to handle all
-                        // of them (::before and ::after, because we find them
-                        // in the subtree, and other lazy pseudos for the same
-                        // reason).
-                        hint |= RESTYLE_SELF | RESTYLE_DESCENDANTS;
-                    }
 
-                    // Reuse the bloom hashes if this is the base selector.
-                    dep_selector = selector.inner.clone();
-                } else {
-                    dep_selector = SelectorInner::new(selector.inner.complex.slice_from(sequence_start));
+                if sequence_start == 0 && selector.pseudo_element.is_some() {
+                    // FIXME(emilio): Be more granular about this. See the
+                    // comment in `PseudoElementDependency` about how could this
+                    // be modified in order to be more efficient and restyle
+                    // less.
+                    hint |= RESTYLE_DESCENDANTS;
                 }
 
-                self.add_dependency(Dependency {
+                let dep_selector = if sequence_start == 0 {
+                    // Reuse the bloom hashes if this is the base selector.
+                    selector.inner.clone()
+                } else {
+                    SelectorInner::new(selector.inner.complex.slice_from(sequence_start))
+                };
+
+                self.dependencies.insert(Dependency {
                     sensitivities: visitor.sensitivities,
                     hint: hint,
                     selector: dep_selector,
                 });
             }
 
             combinator = iter.next_sequence();
             if combinator.is_none() {
@@ -654,73 +717,143 @@ impl DependencySet {
             }
 
             index += 1; // Account for the combinator.
         }
     }
 
     /// Create an empty `DependencySet`.
     pub fn new() -> Self {
-        DependencySet(SelectorMap::new())
+        DependencySet {
+            dependencies: SelectorMap::new(),
+            pseudo_dependencies: FnvHashMap::default(),
+        }
     }
 
     /// Return the total number of dependencies that this set contains.
     pub fn len(&self) -> usize {
-        self.0.len()
+        self.dependencies.len() +
+            self.pseudo_dependencies.values().fold(0, |acc, val| acc + val.len())
     }
 
     /// Clear this dependency set.
     pub fn clear(&mut self) {
-        self.0 = SelectorMap::new();
+        self.dependencies = SelectorMap::new();
+        self.pseudo_dependencies.clear()
     }
 
-    /// Compute a restyle hint given an element and a snapshot, per the rules
-    /// explained in the rest of the documentation.
-    pub fn compute_hint<E>(&self,
-                           el: &E,
-                           snapshots: &SnapshotMap)
-                           -> RestyleHint
-        where E: TElement + Clone,
+    fn compute_pseudo_hint<E>(
+        &self,
+        pseudo: &E,
+        pseudo_element: PseudoElement,
+        snapshots: &SnapshotMap)
+        -> RestyleHint
+        where E: TElement,
+    {
+        debug!("compute_pseudo_hint: {:?}, {:?}", pseudo, pseudo_element);
+        debug_assert!(pseudo.has_snapshot());
+
+        let map = match self.pseudo_dependencies.get(&pseudo_element) {
+            Some(map) => map,
+            None => return RestyleHint::empty(),
+        };
+
+        // Only pseudo-element's state is relevant.
+        let pseudo_state_changes =
+            ElementWrapper::new(*pseudo, snapshots).state_changes();
+
+        debug!("pseudo_state_changes: {:?}", pseudo_state_changes);
+        if pseudo_state_changes.is_empty() {
+            return RestyleHint::empty();
+        }
+
+        let selector_matching_target =
+            pseudo.closest_non_native_anonymous_ancestor().unwrap();
+
+        // Note that we rely on that, if the originating element changes, it'll
+        // post a restyle hint that would make us redo selector matching, so we
+        // don't need to care about that.
+        //
+        // If that ever changes, we'd need to share more code with
+        // `compute_element_hint`.
+        let mut hint = RestyleHint::empty();
+        map.lookup(selector_matching_target, &mut |dep| {
+            // If the selector didn't match before, it either doesn't match now
+            // either (or it doesn't matter because our parent posted a restyle
+            // for us above).
+            if !matches_selector(&dep.selector.inner, &selector_matching_target,
+                                 None, &mut StyleRelations::empty(),
+                                 &mut |_, _| {}) {
+                return true;
+            }
+
+            let pseudo_selector = dep.selector.pseudo_element.as_ref().unwrap();
+            debug_assert!(!pseudo_selector.state().is_empty());
+
+            if pseudo_selector.state().intersects(pseudo_state_changes) {
+                hint = RESTYLE_SELF;
+                return false;
+            }
+
+            true
+        });
+
+        hint
+    }
+
+    fn compute_element_hint<E>(
+        &self,
+        el: &E,
+        snapshots: &SnapshotMap)
+        -> RestyleHint
+        where E: TElement,
     {
         debug_assert!(el.has_snapshot(), "Shouldn't be here!");
+
         let snapshot_el = ElementWrapper::new(el.clone(), snapshots);
-
         let snapshot =
             snapshot_el.snapshot().expect("has_snapshot lied so badly");
 
-        let current_state = el.get_state();
-        let state_changes =
-            snapshot.state()
-                .map_or_else(ElementState::empty,
-                             |old_state| current_state ^ old_state);
+        let state_changes = snapshot_el.state_changes();
         let attrs_changed = snapshot.has_attrs();
-
         if state_changes.is_empty() && !attrs_changed {
             return RestyleHint::empty();
         }
 
         let mut hint = RestyleHint::empty();
 
         // Compute whether the snapshot has any different id or class attributes
         // from the element. If it does, we need to pass those to the lookup, so
         // that we get all the possible applicable selectors from the rulehash.
         let mut additional_id = None;
         let mut additional_classes = SmallVec::<[Atom; 8]>::new();
-        if snapshot.has_attrs() {
+        if attrs_changed {
             let id = snapshot.id_attr();
             if id.is_some() && id != el.get_id() {
                 additional_id = id;
             }
 
-            snapshot.each_class(|c| if !el.has_class(c) { additional_classes.push(c.clone()) });
+            snapshot.each_class(|c| {
+                if !el.has_class(c) {
+                    additional_classes.push(c.clone())
+                }
+            });
         }
 
-        self.0.lookup_with_additional(*el, additional_id, &additional_classes, &mut |dep| {
-            if !dep.sensitivities.sensitive_to(attrs_changed, state_changes) ||
-               hint.contains(dep.hint) {
+        self.dependencies
+            .lookup_with_additional(*el, additional_id, &additional_classes, &mut |dep| {
+            trace!("scanning dependency: {:?}", dep);
+            if !dep.sensitivities.sensitive_to(attrs_changed,
+                                               state_changes) {
+                trace!(" > non-sensitive");
+                return true;
+            }
+
+            if hint.contains(dep.hint) {
+                trace!(" > hint was already there");
                 return true;
             }
 
             // We can ignore the selector flags, since they would have already
             // been set during original matching for any element that might
             // change its matching behavior here.
             let matched_then =
                 matches_selector(&dep.selector, &snapshot_el, None,
@@ -733,14 +866,30 @@ impl DependencySet {
             if matched_then != matches_now {
                 hint.insert(dep.hint);
             }
 
             !hint.is_all()
         });
 
         debug!("Calculated restyle hint: {:?} for {:?}. (State={:?}, {} Deps)",
-               hint, el, current_state, self.len());
-        trace!("Deps: {:?}", self);
+               hint, el, el.get_state(), self.len());
 
         hint
     }
+
+
+    /// Compute a restyle hint given an element and a snapshot, per the rules
+    /// explained in the rest of the documentation.
+    pub fn compute_hint<E>(&self,
+                           el: &E,
+                           snapshots: &SnapshotMap)
+                           -> RestyleHint
+        where E: TElement + Clone,
+    {
+        debug!("DependencySet::compute_hint({:?})", el);
+        if let Some(pseudo) = el.implemented_pseudo_element() {
+            return self.compute_pseudo_hint(el, pseudo, snapshots);
+        }
+
+        self.compute_element_hint(el, snapshots)
+    }
 }
--- a/servo/components/style/rule_tree/mod.rs
+++ b/servo/components/style/rule_tree/mod.rs
@@ -1066,20 +1066,21 @@ impl StrongRuleNode {
                         }
                     }
                 }
             }
 
             if !have_explicit_ua_inherit { break }
 
             // Continue to the parent element and search for the inherited properties.
-            element = match element.parent_element() {
+            element = match element.inheritance_parent() {
                 Some(parent) => parent,
                 None => break
             };
+
             let parent_data = element.mutate_data().unwrap();
             let parent_rule_node = parent_data.styles().primary.rules.clone();
             element_rule_node = Cow::Owned(parent_rule_node);
 
             properties = inherited_properties;
         }
 
         false
--- a/servo/components/style/servo/selector_parser.rs
+++ b/servo/components/style/servo/selector_parser.rs
@@ -73,16 +73,28 @@ impl ToCss for PseudoElement {
         })
     }
 }
 
 /// The number of eager pseudo-elements. Keep this in sync with cascade_type.
 pub const EAGER_PSEUDO_COUNT: usize = 3;
 
 impl PseudoElement {
+    /// The pseudo-element, used for compatibility with Gecko's
+    /// `PseudoElementSelector`.
+    pub fn pseudo_element(&self) -> &Self {
+        self
+    }
+
+    /// The pseudo-element selector's state, used for compatibility with Gecko's
+    /// `PseudoElementSelector`.
+    pub fn state(&self) -> ElementState {
+        ElementState::empty()
+    }
+
     /// Gets the canonical index of this eagerly-cascaded pseudo-element.
     #[inline]
     pub fn eager_index(&self) -> usize {
         debug_assert!(self.is_eager());
         self.clone() as usize
     }
 
     /// Creates a pseudo-element from an eager index.
@@ -247,17 +259,17 @@ impl NonTSPseudoClass {
 
 /// The abstract struct we implement the selector parser implementation on top
 /// of.
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 pub struct SelectorImpl;
 
 impl ::selectors::SelectorImpl for SelectorImpl {
-    type PseudoElement = PseudoElement;
+    type PseudoElementSelector = PseudoElement;
     type NonTSPseudoClass = NonTSPseudoClass;
 
     type AttrValue = String;
     type Identifier = Atom;
     type ClassName = Atom;
     type LocalName = LocalName;
     type NamespacePrefix = Prefix;
     type NamespaceUrl = Namespace;
@@ -306,17 +318,20 @@ impl<'a> ::selectors::Parser for Selecto
         let pseudo_class = match_ignore_ascii_case!{ &name,
             "lang" => Lang(String::from(try!(parser.expect_ident_or_string())).into_boxed_str()),
             _ => return Err(())
         };
 
         Ok(pseudo_class)
     }
 
-    fn parse_pseudo_element(&self, name: Cow<str>) -> Result<PseudoElement, ()> {
+    fn parse_pseudo_element(&self,
+                            name: Cow<str>,
+                            _input: &mut CssParser)
+                            -> Result<PseudoElement, ()> {
         use self::PseudoElement::*;
         let pseudo_element = match_ignore_ascii_case! { &name,
             "before" => Before,
             "after" => After,
             "selection" => Selection,
             "-servo-details-summary" => {
                 if !self.in_user_agent_stylesheet() {
                     return Err(())
--- a/servo/components/style/stylist.rs
+++ b/servo/components/style/stylist.rs
@@ -444,29 +444,28 @@ impl Stylist {
     }
 
     #[inline]
     fn add_rule_to_map(&mut self,
                        selector: &Selector<SelectorImpl>,
                        rule: &Arc<Locked<StyleRule>>,
                        stylesheet: &Stylesheet)
     {
-        let map = if let Some(ref pseudo) = selector.pseudo_element {
+        let map = if let Some(ref pseudo_selector) = selector.pseudo_element {
             self.pseudos_map
-                .entry(pseudo.clone())
+                .entry(pseudo_selector.pseudo_element().clone())
                 .or_insert_with(PerPseudoElementSelectorMap::new)
                 .borrow_for_origin(&stylesheet.origin)
         } else {
             self.element_map.borrow_for_origin(&stylesheet.origin)
         };
 
-        map.insert(Rule::new(selector.inner.clone(),
+        map.insert(Rule::new(selector.clone(),
                              rule.clone(),
-                             self.rules_source_order,
-                             selector.specificity));
+                             self.rules_source_order));
     }
 
     #[inline]
     fn note_for_revalidation(&mut self, selector: &Selector<SelectorImpl>) {
         if needs_revalidation(selector) {
             self.selectors_for_cache_revalidation.insert(selector.inner.clone());
         }
     }
@@ -491,16 +490,19 @@ impl Stylist {
     /// Returns whether the given ElementState bit is relied upon by a selector
     /// of some rule in the stylist.
     pub fn has_state_dependency(&self, state: ElementState) -> bool {
         self.state_dependencies.intersects(state)
     }
 
     #[inline]
     fn note_attribute_and_state_dependencies(&mut self, selector: &Selector<SelectorImpl>) {
+        if let Some(ref pseudo_selector) = selector.pseudo_element {
+            self.state_dependencies.insert(pseudo_selector.state());
+        }
         selector.visit(&mut AttributeAndStateDependencyVisitor(self));
     }
 
     /// Computes the style for a given "precomputed" pseudo-element, taking the
     /// universal rules and applying them.
     ///
     /// If `inherit_all` is true, then all properties are inherited from the
     /// parent; otherwise, non-inherited properties are reset to their initial
@@ -598,25 +600,27 @@ impl Stylist {
     /// :selection.
     ///
     /// Check the documentation on lazy pseudo-elements in
     /// docs/components/style.md
     pub fn lazily_compute_pseudo_element_style<E>(&self,
                                                   guards: &StylesheetGuards,
                                                   element: &E,
                                                   pseudo: &PseudoElement,
+                                                  pseudo_state: ElementState,
                                                   parent: &Arc<ComputedValues>,
                                                   font_metrics: &FontMetricsProvider)
                                                   -> Option<ComputedStyle>
         where E: TElement,
     {
-        let rule_node = match self.lazy_pseudo_rules(guards, element, pseudo) {
-            Some(rule_node) => rule_node,
-            None => return None
-        };
+        let rule_node =
+            match self.lazy_pseudo_rules(guards, element, pseudo, pseudo_state) {
+                Some(rule_node) => rule_node,
+                None => return None
+            };
 
         // Read the comment on `precomputed_values_for_pseudo` to see why it's
         // difficult to assert that display: contents nodes never arrive here
         // (tl;dr: It doesn't apply for replaced elements and such, but the
         // computed value is still "contents").
         let computed =
             properties::cascade(&self.device,
                                 &rule_node,
@@ -634,17 +638,18 @@ impl Stylist {
 
     /// Computes the rule node for a lazily-cascaded pseudo-element.
     ///
     /// See the documentation on lazy pseudo-elements in
     /// docs/components/style.md
     pub fn lazy_pseudo_rules<E>(&self,
                                 guards: &StylesheetGuards,
                                 element: &E,
-                                pseudo: &PseudoElement)
+                                pseudo: &PseudoElement,
+                                pseudo_state: ElementState)
                                 -> Option<StrongRuleNode>
         where E: TElement
     {
         debug_assert!(pseudo.is_lazy());
         if self.pseudos_map.get(pseudo).is_none() {
             return None
         }
 
@@ -674,17 +679,17 @@ impl Stylist {
 
 
         let mut declarations = vec![];
         self.push_applicable_declarations(element,
                                           None,
                                           None,
                                           None,
                                           AnimationRules(None, None),
-                                          Some(pseudo),
+                                          Some((pseudo, pseudo_state)),
                                           &mut declarations,
                                           &mut set_selector_flags);
         if declarations.is_empty() {
             return None
         }
 
         let rule_node =
             self.rule_tree.insert_ordered_rules_with_important(
@@ -803,42 +808,45 @@ impl Stylist {
     /// have matched.
     pub fn push_applicable_declarations<E, V, F>(
                                         &self,
                                         element: &E,
                                         parent_bf: Option<&BloomFilter>,
                                         style_attribute: Option<&Arc<Locked<PropertyDeclarationBlock>>>,
                                         smil_override: Option<&Arc<Locked<PropertyDeclarationBlock>>>,
                                         animation_rules: AnimationRules,
-                                        pseudo_element: Option<&PseudoElement>,
+                                        pseudo_element: Option<(&PseudoElement, ElementState)>,
                                         applicable_declarations: &mut V,
                                         flags_setter: &mut F)
                                         -> StyleRelations
         where E: TElement,
               V: Push<ApplicableDeclarationBlock> + VecLike<ApplicableDeclarationBlock>,
               F: FnMut(&E, ElementSelectorFlags),
     {
         debug_assert!(!self.is_device_dirty);
         // Gecko definitely has pseudo-elements with style attributes, like
         // ::-moz-color-swatch.
         debug_assert!(cfg!(feature = "gecko") ||
                       style_attribute.is_none() || pseudo_element.is_none(),
                       "Style attributes do not apply to pseudo-elements");
-        debug_assert!(pseudo_element.as_ref().map_or(true, |p| !p.is_precomputed()));
+        debug_assert!(pseudo_element.as_ref().map_or(true, |p| !p.0.is_precomputed()));
 
         let map = match pseudo_element {
-            Some(ref pseudo) => self.pseudos_map.get(pseudo).unwrap(),
+            Some((ref pseudo, _)) => self.pseudos_map.get(pseudo).unwrap(),
             None => &self.element_map,
         };
 
         let mut relations = StyleRelations::empty();
 
-        debug!("Determining if style is shareable: pseudo: {}", pseudo_element.is_some());
+        debug!("Determining if style is shareable: pseudo: {}",
+               pseudo_element.is_some());
+
         // Step 1: Normal user-agent rules.
         map.user_agent.get_all_matching_rules(element,
+                                              pseudo_element,
                                               parent_bf,
                                               applicable_declarations,
                                               &mut relations,
                                               flags_setter,
                                               CascadeLevel::UANormal);
         debug!("UA normal: {:?}", relations);
 
         if pseudo_element.is_none() {
@@ -855,23 +863,25 @@ impl Stylist {
                 relations |= AFFECTED_BY_PRESENTATIONAL_HINTS;