servo: Merge #17895 - Clean up traversal modes (from bholley:clean_up_traversal); r=emilio
authorBobby Holley <bobbyholley@gmail.com>
Thu, 27 Jul 2017 18:29:29 -0500
changeset 420228 c510f3e6e17f76d274f3b59d2620150703f05e56
parent 420227 084696d19f1af89b7d3d83ffa709227661c4e245
child 420229 81049c04c4ad1731f36e63666dc1f5ffaf98149b
push id7566
push usermtabara@mozilla.com
push dateWed, 02 Aug 2017 08:25:16 +0000
treeherdermozilla-beta@86913f512c3c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersemilio
bugs17895, 1384769
milestone56.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 #17895 - Clean up traversal modes (from bholley:clean_up_traversal); r=emilio https://bugzilla.mozilla.org/show_bug.cgi?id=1384769 Source-Repo: https://github.com/servo/servo Source-Revision: 255c9d00da8d6837a5625ad19d9b1cd623286c3b
servo/components/layout_thread/lib.rs
servo/components/style/context.rs
servo/components/style/dom.rs
servo/components/style/gecko/generated/bindings.rs
servo/components/style/gecko/generated/structs_debug.rs
servo/components/style/gecko/generated/structs_release.rs
servo/components/style/invalidation/element/restyle_hints.rs
servo/components/style/lib.rs
servo/components/style/matching.rs
servo/components/style/traversal.rs
servo/components/style/traversal_flags.rs
servo/ports/geckolib/glue.rs
--- a/servo/components/layout_thread/lib.rs
+++ b/servo/components/layout_thread/lib.rs
@@ -130,17 +130,18 @@ use style::media_queries::{Device, Media
 use style::properties::PropertyId;
 use style::selector_parser::SnapshotMap;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW, REPAINT, REPOSITION, STORE_OVERFLOW};
 use style::shared_lock::{SharedRwLock, SharedRwLockReadGuard, StylesheetGuards};
 use style::stylesheets::{Origin, Stylesheet, StylesheetInDocument, UserAgentStylesheets};
 use style::stylist::{ExtraStyleData, Stylist};
 use style::thread_state;
 use style::timer::Timer;
-use style::traversal::{DomTraversal, TraversalDriver, TraversalFlags};
+use style::traversal::{DomTraversal, TraversalDriver};
+use style::traversal_flags::TraversalFlags;
 
 /// Information needed by the layout thread.
 pub struct LayoutThread {
     /// The ID of the pipeline that we belong to.
     id: PipelineId,
 
     /// The ID of the top-level browsing context that we belong to.
     top_level_browsing_context_id: TopLevelBrowsingContextId,
--- a/servo/components/style/context.rs
+++ b/servo/components/style/context.rs
@@ -29,17 +29,18 @@ use std::ops;
 #[cfg(feature = "servo")] use std::sync::Mutex;
 #[cfg(feature = "servo")] use std::sync::mpsc::Sender;
 use style_traits::CSSPixel;
 use style_traits::DevicePixel;
 use stylist::Stylist;
 use thread_state;
 use time;
 use timer::Timer;
-use traversal::{DomTraversal, TraversalFlags};
+use traversal::DomTraversal;
+use traversal_flags::TraversalFlags;
 
 pub use selectors::matching::QuirksMode;
 
 /// This structure is used to create a local style context from a shared one.
 #[cfg(feature = "servo")]
 pub struct ThreadLocalStyleContextCreationInfo {
     new_animations_sender: Sender<Animation>,
 }
--- a/servo/components/style/dom.rs
+++ b/servo/components/style/dom.rs
@@ -28,17 +28,17 @@ use shared_lock::Locked;
 use smallvec::VecLike;
 use std::fmt;
 #[cfg(feature = "gecko")] use std::collections::HashMap;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::ops::Deref;
 use stylist::Stylist;
 use thread_state;
-use traversal::TraversalFlags;
+use traversal_flags::TraversalFlags;
 
 pub use style_traits::UnsafeNode;
 
 /// An opaque handle to a node, which, unlike UnsafeNode, cannot be transformed
 /// back into a non-opaque representation. The only safe operation that can be
 /// performed on this node is to compare it to another opaque handle or to another
 /// OpaqueNode.
 ///
--- a/servo/components/style/gecko/generated/bindings.rs
+++ b/servo/components/style/gecko/generated/bindings.rs
@@ -39,18 +39,17 @@ use gecko_bindings::structs::RawGeckoPre
 use gecko_bindings::structs::RawGeckoStyleAnimationList;
 use gecko_bindings::structs::RawGeckoStyleChildrenIteratorBorrowedMut;
 use gecko_bindings::structs::RawGeckoServoStyleRuleList;
 use gecko_bindings::structs::RawGeckoURLExtraData;
 use gecko_bindings::structs::RawGeckoXBLBinding;
 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::ServoTraversalFlags;
 use gecko_bindings::structs::ComputedTimingFunction_BeforeFlag;
 use gecko_bindings::structs::CounterStylePtr;
 use gecko_bindings::structs::FontFamilyList;
 use gecko_bindings::structs::FontFamilyType;
 use gecko_bindings::structs::FontSizePrefs;
 use gecko_bindings::structs::GeckoFontMetrics;
 use gecko_bindings::structs::IterationCompositeOperation;
 use gecko_bindings::structs::Keyframe;
@@ -2776,23 +2775,27 @@ extern "C" {
 }
 extern "C" {
     pub fn Servo_NoteExplicitHints(element: RawGeckoElementBorrowed,
                                    restyle_hint: nsRestyleHint,
                                    change_hint: nsChangeHint);
 }
 extern "C" {
     pub fn Servo_TakeChangeHint(element: RawGeckoElementBorrowed,
-                                restyle_behavior: TraversalRestyleBehavior,
+                                flags: ServoTraversalFlags,
                                 was_restyled: *mut bool) -> nsChangeHint;
 }
 extern "C" {
     pub fn Servo_ResolveStyle(element: RawGeckoElementBorrowed,
                               set: RawServoStyleSetBorrowed,
-                              restyle_behavior: TraversalRestyleBehavior)
+                              flags: ServoTraversalFlags)
+     -> ServoStyleContextStrong;
+}
+extern "C" {
+    pub fn Servo_ResolveStyleAllowStale(element: RawGeckoElementBorrowed)
      -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_ResolvePseudoStyle(element: RawGeckoElementBorrowed,
                                     pseudo_type: CSSPseudoElementType,
                                     is_probe: bool,
                                     inherited_style:
                                         ServoStyleContextBorrowedOrNull,
@@ -2816,19 +2819,17 @@ extern "C" {
                                         *const ServoElementSnapshotTable,
                                     set: RawServoStyleSetBorrowed)
      -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_TraverseSubtree(root: RawGeckoElementBorrowed,
                                  set: RawServoStyleSetBorrowed,
                                  snapshots: *const ServoElementSnapshotTable,
-                                 root_behavior: TraversalRootBehavior,
-                                 restyle_behavior: TraversalRestyleBehavior)
-     -> bool;
+                                 flags: ServoTraversalFlags) -> bool;
 }
 extern "C" {
     pub fn Servo_AssertTreeIsClean(root: RawGeckoElementBorrowed);
 }
 extern "C" {
     pub fn Servo_MaybeGCRuleTree(set: RawServoStyleSetBorrowed);
 }
 extern "C" {
@@ -2882,10 +2883,11 @@ extern "C" {
                                               *const ::std::os::raw::c_char,
                                           param:
                                               *const ::std::os::raw::c_char,
                                           paramLen: u32,
                                           source:
                                               *const ::std::os::raw::c_char,
                                           sourceLen: u32, lineNumber: u32,
                                           colNumber: u32, aURI: *mut nsIURI,
-                                          followup: *const ::std::os::raw::c_char);
-}
+                                          followup:
+                                              *const ::std::os::raw::c_char);
+}
--- a/servo/components/style/gecko/generated/structs_debug.rs
+++ b/servo/components/style/gecko/generated/structs_debug.rs
@@ -1047,16 +1047,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 ,
@@ -1076,20 +1078,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;
@@ -1288,17 +1297,17 @@ pub mod root {
                 VOIDED = 2,
                 SHARED = 4,
                 OWNED = 8,
                 FIXED = 16,
                 LITERAL = 32,
             }
             #[repr(u16)]
             #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-            pub enum StringClassFlags { FIXED = 1, }
+            pub enum StringClassFlags { FIXED = 1, NULL_TERMINATED = 2, }
             /**
  * 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 {
@@ -1383,19 +1392,19 @@ pub mod root {
                             "Alignment of field: " , stringify ! ( MutexImpl )
                             , "::" , stringify ! ( platformData_ ) ));
             }
         }
         #[repr(u32)]
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum ArenaObjectID {
             eArenaObjectID_DummyBeforeFirstObjectID = 173,
-            eArenaObjectID_nsLineBox = 174,
-            eArenaObjectID_nsRuleNode = 175,
-            eArenaObjectID_GeckoStyleContext = 176,
+            eArenaObjectID_GeckoStyleContext = 174,
+            eArenaObjectID_nsLineBox = 175,
+            eArenaObjectID_nsRuleNode = 176,
             eArenaObjectID_DisplayItemData = 177,
             eArenaObjectID_nsInheritedStyleData = 178,
             eArenaObjectID_nsResetStyleData = 179,
             eArenaObjectID_nsConditionalResetStyleData = 180,
             eArenaObjectID_nsConditionalResetStyleDataEntry = 181,
             eArenaObjectID_nsFrameList = 182,
             eArenaObjectID_CustomCounterStyle = 183,
             eArenaObjectID_DependentBuiltinCounterStyle = 184,
@@ -2503,16 +2512,26 @@ pub mod root {
             #[derive(Debug, Copy, Clone)]
             pub struct Path {
                 _unused: [u8; 0],
             }
         }
         pub mod layers {
             #[allow(unused_imports)]
             use self::super::super::super::root;
+            #[repr(C)]
+            #[derive(Debug, Copy, Clone)]
+            pub struct LayerManager {
+                _unused: [u8; 0],
+            }
+            #[repr(C)]
+            #[derive(Debug, Copy, Clone)]
+            pub struct ContainerLayer {
+                _unused: [u8; 0],
+            }
             /**
  * The viewport and displayport metrics for the painted frame at the
  * time of a layer-tree transaction.  These metrics are especially
  * useful for shadow layers, because the metrics values are updated
  * atomically with new pixels.
  */
             #[repr(C)]
             #[derive(Debug, Copy)]
@@ -3336,158 +3355,16 @@ pub mod root {
                           } |
                               ((mUsesContainerScrolling as u8 as u8) <<
                                    3usize) & (8u64 as u8))
                      } |
                          ((mForceDisableApz as u8 as u8) << 4usize) &
                              (16u64 as u8))
                 }
             }
-            /**
- * This class is used for communicating information about the currently focused
- * element of a document and the scrollable frames to use when keyboard scrolling
- * it. It is created on the main thread at paint-time, but is then passed over
- * IPC to the compositor/APZ code.
- */
-            #[repr(C)]
-            #[derive(Debug, Copy)]
-            pub struct FocusTarget {
-                pub mSequenceNumber: u64,
-                pub mFocusHasKeyEventListeners: bool,
-                pub mType: root::mozilla::layers::FocusTarget_FocusTargetType,
-                pub mData: root::mozilla::layers::FocusTarget_FocusTargetData,
-            }
-            #[repr(C)]
-            #[derive(Debug, Copy)]
-            pub struct FocusTarget_ScrollTargets {
-                pub mHorizontal: root::mozilla::layers::FrameMetrics_ViewID,
-                pub mVertical: root::mozilla::layers::FrameMetrics_ViewID,
-            }
-            #[test]
-            fn bindgen_test_layout_FocusTarget_ScrollTargets() {
-                assert_eq!(::std::mem::size_of::<FocusTarget_ScrollTargets>()
-                           , 16usize , concat ! (
-                           "Size of: " , stringify ! (
-                           FocusTarget_ScrollTargets ) ));
-                assert_eq! (::std::mem::align_of::<FocusTarget_ScrollTargets>()
-                            , 8usize , concat ! (
-                            "Alignment of " , stringify ! (
-                            FocusTarget_ScrollTargets ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget_ScrollTargets ) )
-                            . mHorizontal as * const _ as usize } , 0usize ,
-                            concat ! (
-                            "Alignment of field: " , stringify ! (
-                            FocusTarget_ScrollTargets ) , "::" , stringify ! (
-                            mHorizontal ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget_ScrollTargets ) )
-                            . mVertical as * const _ as usize } , 8usize ,
-                            concat ! (
-                            "Alignment of field: " , stringify ! (
-                            FocusTarget_ScrollTargets ) , "::" , stringify ! (
-                            mVertical ) ));
-            }
-            impl Clone for FocusTarget_ScrollTargets {
-                fn clone(&self) -> Self { *self }
-            }
-            #[repr(u32)]
-            #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-            pub enum FocusTarget_FocusTargetType {
-                eNone = 0,
-                eRefLayer = 1,
-                eScrollLayer = 2,
-            }
-            #[repr(C)]
-            #[derive(Debug, Copy)]
-            pub struct FocusTarget_FocusTargetData {
-                pub mRefLayerId: root::__BindgenUnionField<u64>,
-                pub mScrollTargets: root::__BindgenUnionField<root::mozilla::layers::FocusTarget_ScrollTargets>,
-                pub bindgen_union_field: [u64; 2usize],
-            }
-            #[test]
-            fn bindgen_test_layout_FocusTarget_FocusTargetData() {
-                assert_eq!(::std::mem::size_of::<FocusTarget_FocusTargetData>()
-                           , 16usize , concat ! (
-                           "Size of: " , stringify ! (
-                           FocusTarget_FocusTargetData ) ));
-                assert_eq! (::std::mem::align_of::<FocusTarget_FocusTargetData>()
-                            , 8usize , concat ! (
-                            "Alignment of " , stringify ! (
-                            FocusTarget_FocusTargetData ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget_FocusTargetData )
-                            ) . mRefLayerId as * const _ as usize } , 0usize ,
-                            concat ! (
-                            "Alignment of field: " , stringify ! (
-                            FocusTarget_FocusTargetData ) , "::" , stringify !
-                            ( mRefLayerId ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget_FocusTargetData )
-                            ) . mScrollTargets as * const _ as usize } ,
-                            0usize , concat ! (
-                            "Alignment of field: " , stringify ! (
-                            FocusTarget_FocusTargetData ) , "::" , stringify !
-                            ( mScrollTargets ) ));
-            }
-            impl Clone for FocusTarget_FocusTargetData {
-                fn clone(&self) -> Self { *self }
-            }
-            pub const FocusTarget_sFocusTargetTypeCount: usize = 3;
-            extern "C" {
-                #[link_name =
-                      "_ZN7mozilla6layers11FocusTarget23sHighestFocusTargetTypeE"]
-                pub static FocusTarget_sHighestFocusTargetType:
-                           root::mozilla::layers::FocusTarget_FocusTargetType;
-            }
-            #[test]
-            fn bindgen_test_layout_FocusTarget() {
-                assert_eq!(::std::mem::size_of::<FocusTarget>() , 32usize ,
-                           concat ! (
-                           "Size of: " , stringify ! ( FocusTarget ) ));
-                assert_eq! (::std::mem::align_of::<FocusTarget>() , 8usize ,
-                            concat ! (
-                            "Alignment of " , stringify ! ( FocusTarget ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget ) ) .
-                            mSequenceNumber as * const _ as usize } , 0usize ,
-                            concat ! (
-                            "Alignment of field: " , stringify ! ( FocusTarget
-                            ) , "::" , stringify ! ( mSequenceNumber ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget ) ) .
-                            mFocusHasKeyEventListeners as * const _ as usize }
-                            , 8usize , concat ! (
-                            "Alignment of field: " , stringify ! ( FocusTarget
-                            ) , "::" , stringify ! (
-                            mFocusHasKeyEventListeners ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget ) ) . mType as *
-                            const _ as usize } , 12usize , concat ! (
-                            "Alignment of field: " , stringify ! ( FocusTarget
-                            ) , "::" , stringify ! ( mType ) ));
-                assert_eq! (unsafe {
-                            & ( * ( 0 as * const FocusTarget ) ) . mData as *
-                            const _ as usize } , 16usize , concat ! (
-                            "Alignment of field: " , stringify ! ( FocusTarget
-                            ) , "::" , stringify ! ( mData ) ));
-            }
-            impl Clone for FocusTarget {
-                fn clone(&self) -> Self { *self }
-            }
-            #[repr(C)]
-            #[derive(Debug, Copy, Clone)]
-            pub struct LayerManager {
-                _unused: [u8; 0],
-            }
-            #[repr(C)]
-            #[derive(Debug, Copy, Clone)]
-            pub struct ContainerLayer {
-                _unused: [u8; 0],
-            }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct Layer {
                 _unused: [u8; 0],
             }
         }
         pub mod dom {
             #[allow(unused_imports)]
@@ -4573,16 +4450,21 @@ pub mod root {
                 _unused: [u8; 0],
             }
             #[repr(C)]
             #[derive(Debug)]
             pub struct UnionMember {
                 pub mStorage: root::mozilla::AlignedStorage2,
             }
             #[repr(C)]
+            #[derive(Debug, Copy, Clone)]
+            pub struct TabGroup {
+                _unused: [u8; 0],
+            }
+            #[repr(C)]
             pub struct DispatcherTrait__bindgen_vtable(::std::os::raw::c_void);
             #[repr(C)]
             #[derive(Debug, Copy)]
             pub struct DispatcherTrait {
                 pub vtable_: *const DispatcherTrait__bindgen_vtable,
             }
             #[test]
             fn bindgen_test_layout_DispatcherTrait() {
@@ -5976,67 +5858,67 @@ pub mod root {
      * An object implementing the .classList property for this element.
      */
                 pub mClassList: root::RefPtr<root::nsDOMTokenList>,
                 pub mExtendedSlots: root::mozilla::UniquePtr<root::mozilla::dom::FragmentOrElement_nsExtendedDOMSlots>,
             }
             #[test]
             fn bindgen_test_layout_FragmentOrElement_nsDOMSlots() {
                 assert_eq!(::std::mem::size_of::<FragmentOrElement_nsDOMSlots>()
-                           , 96usize , concat ! (
+                           , 104usize , concat ! (
                            "Size of: " , stringify ! (
                            FragmentOrElement_nsDOMSlots ) ));
                 assert_eq! (::std::mem::align_of::<FragmentOrElement_nsDOMSlots>()
                             , 8usize , concat ! (
                             "Alignment of " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) ));
                 assert_eq! (unsafe {
                             & (
                             * ( 0 as * const FragmentOrElement_nsDOMSlots ) )
-                            . mStyle as * const _ as usize } , 48usize ,
+                            . mStyle as * const _ as usize } , 56usize ,
                             concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) , "::" , stringify
                             ! ( mStyle ) ));
                 assert_eq! (unsafe {
                             & (
                             * ( 0 as * const FragmentOrElement_nsDOMSlots ) )
-                            . mDataset as * const _ as usize } , 56usize ,
+                            . mDataset as * const _ as usize } , 64usize ,
                             concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) , "::" , stringify
                             ! ( mDataset ) ));
                 assert_eq! (unsafe {
                             & (
                             * ( 0 as * const FragmentOrElement_nsDOMSlots ) )
-                            . mAttributeMap as * const _ as usize } , 64usize
+                            . mAttributeMap as * const _ as usize } , 72usize
                             , concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) , "::" , stringify
                             ! ( mAttributeMap ) ));
                 assert_eq! (unsafe {
                             & (
                             * ( 0 as * const FragmentOrElement_nsDOMSlots ) )
-                            . mChildrenList as * const _ as usize } , 72usize
+                            . mChildrenList as * const _ as usize } , 80usize
                             , concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) , "::" , stringify
                             ! ( mChildrenList ) ));
                 assert_eq! (unsafe {
                             & (
                             * ( 0 as * const FragmentOrElement_nsDOMSlots ) )
-                            . mClassList as * const _ as usize } , 80usize ,
+                            . mClassList as * const _ as usize } , 88usize ,
                             concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) , "::" , stringify
                             ! ( mClassList ) ));
                 assert_eq! (unsafe {
                             & (
                             * ( 0 as * const FragmentOrElement_nsDOMSlots ) )
-                            . mExtendedSlots as * const _ as usize } , 88usize
+                            . mExtendedSlots as * const _ as usize } , 96usize
                             , concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsDOMSlots ) , "::" , stringify
                             ! ( mExtendedSlots ) ));
             }
             extern "C" {
                 #[link_name =
                       "_ZN7mozilla3dom17FragmentOrElement21_cycleCollectorGlobalE"]
@@ -7292,231 +7174,16 @@ pub mod root {
                         mFlushAnimations as * const _ as usize } , 1usize ,
                         concat ! (
                         "Alignment of field: " , stringify ! ( ChangesToFlush
                         ) , "::" , stringify ! ( mFlushAnimations ) ));
         }
         impl Clone for ChangesToFlush {
             fn clone(&self) -> Self { *self }
         }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct CSSPixel {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_CSSPixel() {
-            assert_eq!(::std::mem::size_of::<CSSPixel>() , 1usize , concat ! (
-                       "Size of: " , stringify ! ( CSSPixel ) ));
-            assert_eq! (::std::mem::align_of::<CSSPixel>() , 1usize , concat !
-                        ( "Alignment of " , stringify ! ( CSSPixel ) ));
-        }
-        impl Clone for CSSPixel {
-            fn clone(&self) -> Self { *self }
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct LayoutDevicePixel {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_LayoutDevicePixel() {
-            assert_eq!(::std::mem::size_of::<LayoutDevicePixel>() , 1usize ,
-                       concat ! (
-                       "Size of: " , stringify ! ( LayoutDevicePixel ) ));
-            assert_eq! (::std::mem::align_of::<LayoutDevicePixel>() , 1usize ,
-                        concat ! (
-                        "Alignment of " , stringify ! ( LayoutDevicePixel )
-                        ));
-        }
-        impl Clone for LayoutDevicePixel {
-            fn clone(&self) -> Self { *self }
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct LayerPixel {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_LayerPixel() {
-            assert_eq!(::std::mem::size_of::<LayerPixel>() , 1usize , concat !
-                       ( "Size of: " , stringify ! ( LayerPixel ) ));
-            assert_eq! (::std::mem::align_of::<LayerPixel>() , 1usize , concat
-                        ! ( "Alignment of " , stringify ! ( LayerPixel ) ));
-        }
-        impl Clone for LayerPixel {
-            fn clone(&self) -> Self { *self }
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct ScreenPixel {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_ScreenPixel() {
-            assert_eq!(::std::mem::size_of::<ScreenPixel>() , 1usize , concat
-                       ! ( "Size of: " , stringify ! ( ScreenPixel ) ));
-            assert_eq! (::std::mem::align_of::<ScreenPixel>() , 1usize ,
-                        concat ! (
-                        "Alignment of " , stringify ! ( ScreenPixel ) ));
-        }
-        impl Clone for ScreenPixel {
-            fn clone(&self) -> Self { *self }
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct ParentLayerPixel {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_ParentLayerPixel() {
-            assert_eq!(::std::mem::size_of::<ParentLayerPixel>() , 1usize ,
-                       concat ! (
-                       "Size of: " , stringify ! ( ParentLayerPixel ) ));
-            assert_eq! (::std::mem::align_of::<ParentLayerPixel>() , 1usize ,
-                        concat ! (
-                        "Alignment of " , stringify ! ( ParentLayerPixel ) ));
-        }
-        impl Clone for ParentLayerPixel {
-            fn clone(&self) -> Self { *self }
-        }
-        pub type CSSPoint = [u32; 2usize];
-        pub type CSSIntPoint = [u32; 2usize];
-        pub type CSSSize = [u32; 2usize];
-        pub type CSSRect = [u32; 4usize];
-        pub type LayoutDeviceIntPoint = [u32; 2usize];
-        pub type LayoutDeviceIntSize = [u32; 2usize];
-        pub type LayoutDeviceIntRect = [u32; 4usize];
-        pub type ScreenIntSize = u8;
-        pub type ScreenMargin = [u32; 4usize];
-        pub type ParentLayerRect = [u32; 4usize];
-        pub type ParentLayerIntRect = [u32; 4usize];
-        pub type CSSToLayoutDeviceScale = u32;
-        pub type CSSToParentLayerScale2D = [u32; 2usize];
-        pub type LayoutDeviceToLayerScale2D = [u32; 2usize];
-        pub type ScreenToLayerScale2D = [u32; 2usize];
-        pub type TimeStampValue = u64;
-        /**
- * Instances of this class represent moments in time, or a special
- * "null" moment. We do not use the non-monotonic system clock or
- * local time, since they can be reset, causing apparent backward
- * travel in time, which can confuse algorithms. Instead we measure
- * elapsed time according to the system.  This time can never go
- * backwards (i.e. it never wraps around, at least not in less than
- * five million years of system elapsed time). It might not advance
- * while the system is sleeping. If TimeStamp::SetNow() is not called
- * at all for hours or days, we might not notice the passage of some
- * of that time.
- *
- * We deliberately do not expose a way to convert TimeStamps to some
- * particular unit. All you can do is compute a difference between two
- * TimeStamps to get a TimeDuration. You can also add a TimeDuration
- * to a TimeStamp to get a new TimeStamp. You can't do something
- * meaningless like add two TimeStamps.
- *
- * Internally this is implemented as either a wrapper around
- *   - high-resolution, monotonic, system clocks if they exist on this
- *     platform
- *   - PRIntervalTime otherwise.  We detect wraparounds of
- *     PRIntervalTime and work around them.
- *
- * This class is similar to C++11's time_point, however it is
- * explicitly nullable and provides an IsNull() method. time_point
- * is initialized to the clock's epoch and provides a
- * time_since_epoch() method that functions similiarly. i.e.
- * t.IsNull() is equivalent to t.time_since_epoch() == decltype(t)::duration::zero();
- */
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct TimeStamp {
-            /**
-   * When built with PRIntervalTime, a value of 0 means this instance
-   * is "null". Otherwise, the low 32 bits represent a PRIntervalTime,
-   * and the high 32 bits represent a counter of the number of
-   * rollovers of PRIntervalTime that we've seen. This counter starts
-   * at 1 to avoid a real time colliding with the "null" value.
-   *
-   * PR_INTERVAL_MAX is set at 100,000 ticks per second. So the minimum
-   * time to wrap around is about 2^64/100000 seconds, i.e. about
-   * 5,849,424 years.
-   *
-   * When using a system clock, a value is system dependent.
-   */
-            pub mValue: root::mozilla::TimeStampValue,
-        }
-        #[test]
-        fn bindgen_test_layout_TimeStamp() {
-            assert_eq!(::std::mem::size_of::<TimeStamp>() , 8usize , concat !
-                       ( "Size of: " , stringify ! ( TimeStamp ) ));
-            assert_eq! (::std::mem::align_of::<TimeStamp>() , 8usize , concat
-                        ! ( "Alignment of " , stringify ! ( TimeStamp ) ));
-            assert_eq! (unsafe {
-                        & ( * ( 0 as * const TimeStamp ) ) . mValue as * const
-                        _ as usize } , 0usize , concat ! (
-                        "Alignment of field: " , stringify ! ( TimeStamp ) ,
-                        "::" , stringify ! ( mValue ) ));
-        }
-        impl Clone for TimeStamp {
-            fn clone(&self) -> Self { *self }
-        }
-        /**
- * Instances of this class represent the length of an interval of time.
- * Negative durations are allowed, meaning the end is before the start.
- *
- * Internally the duration is stored as a int64_t in units of
- * PR_TicksPerSecond() when building with NSPR interval timers, or a
- * system-dependent unit when building with system clocks.  The
- * system-dependent unit must be constant, otherwise the semantics of
- * this class would be broken.
- *
- * The ValueCalculator template parameter determines how arithmetic
- * operations are performed on the integer count of ticks (mValue).
- */
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
-        pub struct BaseTimeDuration {
-            pub mValue: i64,
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
-        pub struct BaseTimeDuration__SomethingVeryRandomHere {
-            pub _address: u8,
-        }
-        /**
- * Perform arithmetic operations on the value of a BaseTimeDuration without
- * doing strict checks on the range of values.
- */
-        #[repr(C)]
-        #[derive(Debug, Copy)]
-        pub struct TimeDurationValueCalculator {
-            pub _address: u8,
-        }
-        #[test]
-        fn bindgen_test_layout_TimeDurationValueCalculator() {
-            assert_eq!(::std::mem::size_of::<TimeDurationValueCalculator>() ,
-                       1usize , concat ! (
-                       "Size of: " , stringify ! ( TimeDurationValueCalculator
-                       ) ));
-            assert_eq! (::std::mem::align_of::<TimeDurationValueCalculator>()
-                        , 1usize , concat ! (
-                        "Alignment of " , stringify ! (
-                        TimeDurationValueCalculator ) ));
-        }
-        impl Clone for TimeDurationValueCalculator {
-            fn clone(&self) -> Self { *self }
-        }
-        /**
- * Specialization of BaseTimeDuration that uses TimeDurationValueCalculator for
- * arithmetic on the mValue member.
- *
- * Use this class for time durations that are *not* expected to hold values of
- * Forever (or the negative equivalent) or when such time duration are *not*
- * expected to be used in arithmetic operations.
- */
-        pub type TimeDuration = root::mozilla::BaseTimeDuration;
         /**
  * EventStates is the class used to represent the event states of nsIContent
  * instances. These states are calculated by IntrinsicState() and
  * ContentStatesChanged() has to be called when one of them changes thus
  * informing the layout/style engine of the change.
  * Event states are associated with pseudo-classes.
  */
         #[repr(C)]
@@ -7540,31 +7207,41 @@ pub mod root {
                         "::" , stringify ! ( mStates ) ));
         }
         impl Clone for EventStates {
             fn clone(&self) -> Self { *self }
         }
         #[repr(i32)]
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum LazyComputeBehavior { Allow = 0, Assert = 1, }
-        #[repr(i32)]
-        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-        pub enum TraversalRootBehavior {
-            Normal = 0,
-            UnstyledChildrenOnly = 1,
-        }
-        #[repr(i32)]
-        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-        pub enum TraversalRestyleBehavior {
-            Normal = 0,
-            ForNewlyBoundElement = 1,
-            ForReconstruct = 2,
-            ForThrottledAnimationFlush = 3,
-            ForCSSRuleChanges = 4,
-        }
+        pub const ServoTraversalFlags_Empty:
+                  root::mozilla::ServoTraversalFlags =
+            0;
+        pub const ServoTraversalFlags_AnimationOnly:
+                  root::mozilla::ServoTraversalFlags =
+            1;
+        pub const ServoTraversalFlags_ForCSSRuleChanges:
+                  root::mozilla::ServoTraversalFlags =
+            2;
+        pub const ServoTraversalFlags_UnstyledChildrenOnly:
+                  root::mozilla::ServoTraversalFlags =
+            4;
+        pub const ServoTraversalFlags_Forgetful:
+                  root::mozilla::ServoTraversalFlags =
+            8;
+        pub const ServoTraversalFlags_AggressivelyForgetful:
+                  root::mozilla::ServoTraversalFlags =
+            16;
+        pub const ServoTraversalFlags_ClearDirtyDescendants:
+                  root::mozilla::ServoTraversalFlags =
+            32;
+        pub const ServoTraversalFlags_ClearAnimationOnlyDirtyDescendants:
+                  root::mozilla::ServoTraversalFlags =
+            64;
+        pub type ServoTraversalFlags = u32;
         #[repr(i32)]
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum StyleRuleInclusion { All = 0, DefaultOnly = 1, }
         pub const UpdateAnimationsTasks_CSSAnimations:
                   root::mozilla::UpdateAnimationsTasks =
             1;
         pub const UpdateAnimationsTasks_CSSTransitions:
                   root::mozilla::UpdateAnimationsTasks =
@@ -8058,16 +7735,135 @@ pub mod root {
                         , "::" , stringify ! ( gecko ) ));
         }
         #[repr(u8)]
         /**
  * Enumeration that represents one of the two supported style system backends.
  */
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum StyleBackendType { None = 0, Gecko = 1, Servo = 2, }
+        pub type TimeStampValue = u64;
+        /**
+ * Instances of this class represent moments in time, or a special
+ * "null" moment. We do not use the non-monotonic system clock or
+ * local time, since they can be reset, causing apparent backward
+ * travel in time, which can confuse algorithms. Instead we measure
+ * elapsed time according to the system.  This time can never go
+ * backwards (i.e. it never wraps around, at least not in less than
+ * five million years of system elapsed time). It might not advance
+ * while the system is sleeping. If TimeStamp::SetNow() is not called
+ * at all for hours or days, we might not notice the passage of some
+ * of that time.
+ *
+ * We deliberately do not expose a way to convert TimeStamps to some
+ * particular unit. All you can do is compute a difference between two
+ * TimeStamps to get a TimeDuration. You can also add a TimeDuration
+ * to a TimeStamp to get a new TimeStamp. You can't do something
+ * meaningless like add two TimeStamps.
+ *
+ * Internally this is implemented as either a wrapper around
+ *   - high-resolution, monotonic, system clocks if they exist on this
+ *     platform
+ *   - PRIntervalTime otherwise.  We detect wraparounds of
+ *     PRIntervalTime and work around them.
+ *
+ * This class is similar to C++11's time_point, however it is
+ * explicitly nullable and provides an IsNull() method. time_point
+ * is initialized to the clock's epoch and provides a
+ * time_since_epoch() method that functions similiarly. i.e.
+ * t.IsNull() is equivalent to t.time_since_epoch() == decltype(t)::duration::zero();
+ */
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct TimeStamp {
+            /**
+   * When built with PRIntervalTime, a value of 0 means this instance
+   * is "null". Otherwise, the low 32 bits represent a PRIntervalTime,
+   * and the high 32 bits represent a counter of the number of
+   * rollovers of PRIntervalTime that we've seen. This counter starts
+   * at 1 to avoid a real time colliding with the "null" value.
+   *
+   * PR_INTERVAL_MAX is set at 100,000 ticks per second. So the minimum
+   * time to wrap around is about 2^64/100000 seconds, i.e. about
+   * 5,849,424 years.
+   *
+   * When using a system clock, a value is system dependent.
+   */
+            pub mValue: root::mozilla::TimeStampValue,
+        }
+        #[test]
+        fn bindgen_test_layout_TimeStamp() {
+            assert_eq!(::std::mem::size_of::<TimeStamp>() , 8usize , concat !
+                       ( "Size of: " , stringify ! ( TimeStamp ) ));
+            assert_eq! (::std::mem::align_of::<TimeStamp>() , 8usize , concat
+                        ! ( "Alignment of " , stringify ! ( TimeStamp ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const TimeStamp ) ) . mValue as * const
+                        _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( TimeStamp ) ,
+                        "::" , stringify ! ( mValue ) ));
+        }
+        impl Clone for TimeStamp {
+            fn clone(&self) -> Self { *self }
+        }
+        /**
+ * Instances of this class represent the length of an interval of time.
+ * Negative durations are allowed, meaning the end is before the start.
+ *
+ * Internally the duration is stored as a int64_t in units of
+ * PR_TicksPerSecond() when building with NSPR interval timers, or a
+ * system-dependent unit when building with system clocks.  The
+ * system-dependent unit must be constant, otherwise the semantics of
+ * this class would be broken.
+ *
+ * The ValueCalculator template parameter determines how arithmetic
+ * operations are performed on the integer count of ticks (mValue).
+ */
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct BaseTimeDuration {
+            pub mValue: i64,
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct BaseTimeDuration__SomethingVeryRandomHere {
+            pub _address: u8,
+        }
+        /**
+ * Perform arithmetic operations on the value of a BaseTimeDuration without
+ * doing strict checks on the range of values.
+ */
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct TimeDurationValueCalculator {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_TimeDurationValueCalculator() {
+            assert_eq!(::std::mem::size_of::<TimeDurationValueCalculator>() ,
+                       1usize , concat ! (
+                       "Size of: " , stringify ! ( TimeDurationValueCalculator
+                       ) ));
+            assert_eq! (::std::mem::align_of::<TimeDurationValueCalculator>()
+                        , 1usize , concat ! (
+                        "Alignment of " , stringify ! (
+                        TimeDurationValueCalculator ) ));
+        }
+        impl Clone for TimeDurationValueCalculator {
+            fn clone(&self) -> Self { *self }
+        }
+        /**
+ * Specialization of BaseTimeDuration that uses TimeDurationValueCalculator for
+ * arithmetic on the mValue member.
+ *
+ * Use this class for time durations that are *not* expected to hold values of
+ * Forever (or the negative equivalent) or when such time duration are *not*
+ * expected to be used in arithmetic operations.
+ */
+        pub type TimeDuration = root::mozilla::BaseTimeDuration;
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct ErrorResult {
             pub _bindgen_opaque_blob: [u64; 4usize],
         }
         pub type ErrorResult_BaseErrorResult =
             root::mozilla::binding_danger::TErrorResult;
         #[test]
@@ -8914,16 +8710,112 @@ pub mod root {
             eIMEConvertedClause = 16,
             eIMESelectedClause = 32,
             eAccessibility = 64,
             eFind = 128,
             eURLSecondary = 256,
             eURLStrikeout = 512,
         }
         #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct CSSPixel {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_CSSPixel() {
+            assert_eq!(::std::mem::size_of::<CSSPixel>() , 1usize , concat ! (
+                       "Size of: " , stringify ! ( CSSPixel ) ));
+            assert_eq! (::std::mem::align_of::<CSSPixel>() , 1usize , concat !
+                        ( "Alignment of " , stringify ! ( CSSPixel ) ));
+        }
+        impl Clone for CSSPixel {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct LayoutDevicePixel {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_LayoutDevicePixel() {
+            assert_eq!(::std::mem::size_of::<LayoutDevicePixel>() , 1usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( LayoutDevicePixel ) ));
+            assert_eq! (::std::mem::align_of::<LayoutDevicePixel>() , 1usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( LayoutDevicePixel )
+                        ));
+        }
+        impl Clone for LayoutDevicePixel {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct LayerPixel {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_LayerPixel() {
+            assert_eq!(::std::mem::size_of::<LayerPixel>() , 1usize , concat !
+                       ( "Size of: " , stringify ! ( LayerPixel ) ));
+            assert_eq! (::std::mem::align_of::<LayerPixel>() , 1usize , concat
+                        ! ( "Alignment of " , stringify ! ( LayerPixel ) ));
+        }
+        impl Clone for LayerPixel {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct ScreenPixel {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_ScreenPixel() {
+            assert_eq!(::std::mem::size_of::<ScreenPixel>() , 1usize , concat
+                       ! ( "Size of: " , stringify ! ( ScreenPixel ) ));
+            assert_eq! (::std::mem::align_of::<ScreenPixel>() , 1usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( ScreenPixel ) ));
+        }
+        impl Clone for ScreenPixel {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct ParentLayerPixel {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_ParentLayerPixel() {
+            assert_eq!(::std::mem::size_of::<ParentLayerPixel>() , 1usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( ParentLayerPixel ) ));
+            assert_eq! (::std::mem::align_of::<ParentLayerPixel>() , 1usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( ParentLayerPixel ) ));
+        }
+        impl Clone for ParentLayerPixel {
+            fn clone(&self) -> Self { *self }
+        }
+        pub type CSSPoint = [u32; 2usize];
+        pub type CSSIntPoint = [u32; 2usize];
+        pub type CSSSize = [u32; 2usize];
+        pub type CSSRect = [u32; 4usize];
+        pub type LayoutDeviceIntPoint = [u32; 2usize];
+        pub type LayoutDeviceIntSize = [u32; 2usize];
+        pub type LayoutDeviceIntRect = [u32; 4usize];
+        pub type ScreenIntSize = u8;
+        pub type ScreenMargin = [u32; 4usize];
+        pub type ParentLayerRect = [u32; 4usize];
+        pub type ParentLayerIntRect = [u32; 4usize];
+        pub type CSSToLayoutDeviceScale = u32;
+        pub type CSSToParentLayerScale2D = [u32; 2usize];
+        pub type LayoutDeviceToLayerScale2D = [u32; 2usize];
+        pub type ScreenToLayerScale2D = [u32; 2usize];
+        #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct AccessibleCaretEventHub {
             _unused: [u8; 0],
         }
         pub mod a11y {
             #[allow(unused_imports)]
             use self::super::super::super::root;
             #[repr(C)]
@@ -9045,17 +8937,17 @@ pub mod root {
             eUseCounter_MozGetAsFile = 66,
             eUseCounter_UseOfCaptureEvents = 67,
             eUseCounter_UseOfReleaseEvents = 68,
             eUseCounter_UseOfDOM3LoadMethod = 69,
             eUseCounter_ChromeUseOfDOM3LoadMethod = 70,
             eUseCounter_ShowModalDialog = 71,
             eUseCounter_Window_Content = 72,
             eUseCounter_SyncXMLHttpRequest = 73,
-            eUseCounter_Window_Controllers = 74,
+            eUseCounter_Window_Cc_ontrollers = 74,
             eUseCounter_ImportXULIntoContent = 75,
             eUseCounter_PannerNodeDoppler = 76,
             eUseCounter_NavigatorGetUserMedia = 77,
             eUseCounter_WebrtcDeprecatedPrefix = 78,
             eUseCounter_RTCPeerConnectionGetStreams = 79,
             eUseCounter_AppCache = 80,
             eUseCounter_PrefixedImageSmoothingEnabled = 81,
             eUseCounter_PrefixedFullscreenAPI = 82,
@@ -9549,16 +9441,17 @@ pub mod root {
             pub mAcquired: root::mozilla::BlockingResourceBase_AcquisitionState,
         }
         #[repr(u32)]
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum BlockingResourceBase_BlockingResourceType {
             eMutex = 0,
             eReentrantMonitor = 1,
             eCondVar = 2,
+            eRecursiveMutex = 3,
         }
         pub type BlockingResourceBase_DDT = root::mozilla::DeadlockDetector;
         pub type BlockingResourceBase_AcquisitionState = bool;
         extern "C" {
             #[link_name =
                   "_ZN7mozilla20BlockingResourceBase17kResourceTypeNameE"]
             pub static mut BlockingResourceBase_kResourceTypeName:
                        [*const ::std::os::raw::c_char; 0usize];
@@ -17483,1387 +17376,16 @@ pub mod root {
  */
     #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
     pub enum nsEventStatus {
         nsEventStatus_eIgnore = 0,
         nsEventStatus_eConsumeNoDefault = 1,
         nsEventStatus_eConsumeDoDefault = 2,
         nsEventStatus_eSentinel = 3,
     }
-    pub type gfxSize = [u64; 2usize];
-    pub type nsIntRect = root::mozilla::gfx::IntRect;
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct pixman_region32_data {
-        pub size: ::std::os::raw::c_long,
-        pub numRects: ::std::os::raw::c_long,
-    }
-    #[test]
-    fn bindgen_test_layout_pixman_region32_data() {
-        assert_eq!(::std::mem::size_of::<pixman_region32_data>() , 16usize ,
-                   concat ! (
-                   "Size of: " , stringify ! ( pixman_region32_data ) ));
-        assert_eq! (::std::mem::align_of::<pixman_region32_data>() , 8usize ,
-                    concat ! (
-                    "Alignment of " , stringify ! ( pixman_region32_data ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_region32_data ) ) . size as *
-                    const _ as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! (
-                    pixman_region32_data ) , "::" , stringify ! ( size ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_region32_data ) ) . numRects
-                    as * const _ as usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! (
-                    pixman_region32_data ) , "::" , stringify ! ( numRects )
-                    ));
-    }
-    impl Clone for pixman_region32_data {
-        fn clone(&self) -> Self { *self }
-    }
-    pub type pixman_region32_data_t = root::pixman_region32_data;
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct pixman_box32 {
-        pub x1: i32,
-        pub y1: i32,
-        pub x2: i32,
-        pub y2: i32,
-    }
-    #[test]
-    fn bindgen_test_layout_pixman_box32() {
-        assert_eq!(::std::mem::size_of::<pixman_box32>() , 16usize , concat !
-                   ( "Size of: " , stringify ! ( pixman_box32 ) ));
-        assert_eq! (::std::mem::align_of::<pixman_box32>() , 4usize , concat !
-                    ( "Alignment of " , stringify ! ( pixman_box32 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_box32 ) ) . x1 as * const _ as
-                    usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
-                    "::" , stringify ! ( x1 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_box32 ) ) . y1 as * const _ as
-                    usize } , 4usize , concat ! (
-                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
-                    "::" , stringify ! ( y1 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_box32 ) ) . x2 as * const _ as
-                    usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
-                    "::" , stringify ! ( x2 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_box32 ) ) . y2 as * const _ as
-                    usize } , 12usize , concat ! (
-                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
-                    "::" , stringify ! ( y2 ) ));
-    }
-    impl Clone for pixman_box32 {
-        fn clone(&self) -> Self { *self }
-    }
-    pub type pixman_box32_t = root::pixman_box32;
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct pixman_region32 {
-        pub extents: root::pixman_box32_t,
-        pub data: *mut root::pixman_region32_data_t,
-    }
-    #[test]
-    fn bindgen_test_layout_pixman_region32() {
-        assert_eq!(::std::mem::size_of::<pixman_region32>() , 24usize , concat
-                   ! ( "Size of: " , stringify ! ( pixman_region32 ) ));
-        assert_eq! (::std::mem::align_of::<pixman_region32>() , 8usize ,
-                    concat ! (
-                    "Alignment of " , stringify ! ( pixman_region32 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_region32 ) ) . extents as *
-                    const _ as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! ( pixman_region32 ) ,
-                    "::" , stringify ! ( extents ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const pixman_region32 ) ) . data as * const
-                    _ as usize } , 16usize , concat ! (
-                    "Alignment of field: " , stringify ! ( pixman_region32 ) ,
-                    "::" , stringify ! ( data ) ));
-    }
-    impl Clone for pixman_region32 {
-        fn clone(&self) -> Self { *self }
-    }
-    pub type pixman_region32_t = root::pixman_region32;
-    #[repr(i32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum VisitSide { TOP = 0, BOTTOM = 1, LEFT = 2, RIGHT = 3, }
-    /**
- * Presentation shell interface. Presentation shells are the
- * controlling point for managing the presentation of a document. The
- * presentation shell holds a live reference to the document, the
- * presentation context, the style manager, the style set and the root
- * frame. <p>
- *
- * When this object is Release'd, it will release the document, the
- * presentation context, the style manager, the style set and the root
- * frame.
- */
-    #[repr(C)]
-    pub struct nsIPresShell {
-        pub _base: root::nsISupports,
-        pub mDocument: root::nsCOMPtr<root::nsIDocument>,
-        pub mPresContext: root::RefPtr<root::nsPresContext>,
-        pub mStyleSet: root::mozilla::StyleSetHandle,
-        pub mFrameConstructor: *mut root::nsCSSFrameConstructor,
-        pub mViewManager: *mut root::nsViewManager,
-        pub mFrameArena: root::nsPresArena,
-        pub mSelection: root::RefPtr<root::nsFrameSelection>,
-        pub mFrameManager: *mut root::nsFrameManagerBase,
-        pub mForwardingContainer: u64,
-        pub mDocAccessible: *mut root::mozilla::a11y::DocAccessible,
-        pub mReflowContinueTimer: root::nsCOMPtr<root::nsITimer>,
-        pub mDrawEventTargetFrame: *mut root::nsIFrame,
-        pub mAllocatedPointers: [u64; 6usize],
-        pub mPaintCount: u64,
-        pub mScrollPositionClampingScrollPortSize: root::nsSize,
-        pub mAutoWeakFrames: *mut root::AutoWeakFrame,
-        pub mWeakFrames: [u64; 6usize],
-        pub mCanvasBackgroundColor: root::nscolor,
-        pub mResolution: [u32; 2usize],
-        pub mSelectionFlags: i16,
-        pub mRenderFlags: root::nsIPresShell_RenderFlags,
-        pub _bitfield_1: [u8; 2usize],
-        pub mPresShellId: u32,
-        pub mFontSizeInflationEmPerLine: u32,
-        pub mFontSizeInflationMinTwips: u32,
-        pub mFontSizeInflationLineThreshold: u32,
-        pub mFontSizeInflationForceEnabled: bool,
-        pub mFontSizeInflationDisabledInMasterProcess: bool,
-        pub mFontSizeInflationEnabled: bool,
-        pub mFontSizeInflationEnabledIsDirty: bool,
-        pub mPaintingIsFrozen: bool,
-        pub mIsNeverPainting: bool,
-        pub mInFlush: bool,
-    }
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
-    pub struct nsIPresShell_COMTypeInfo {
-        pub _address: u8,
-    }
-    pub type nsIPresShell_FocusTarget = root::mozilla::layers::FocusTarget;
-    pub type nsIPresShell_LayerManager = root::mozilla::layers::LayerManager;
-    pub type nsIPresShell_SourceSurface = root::mozilla::gfx::SourceSurface;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_eRenderFlag {
-        STATE_IGNORING_VIEWPORT_SCROLLING = 1,
-        STATE_DRAWWINDOW_NOT_FLUSHING = 2,
-    }
-    pub type nsIPresShell_RenderFlags = u8;
-    #[repr(u32)]
-    /**
-   * Gets nearest scrollable frame from the specified content node. The frame
-   * is scrollable with overflow:scroll or overflow:auto in some direction when
-   * aDirection is eEither.  Otherwise, this returns a nearest frame that is
-   * scrollable in the specified direction.
-   */
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_ScrollDirection {
-        eHorizontal = 0,
-        eVertical = 1,
-        eEither = 2,
-    }
-    #[repr(u32)]
-    /**
-   * Tell the pres shell that a frame needs to be marked dirty and needs
-   * Reflow.  It's OK if this is an ancestor of the frame needing reflow as
-   * long as the ancestor chain between them doesn't cross a reflow root.
-   *
-   * The bit to add should be NS_FRAME_IS_DIRTY, NS_FRAME_HAS_DIRTY_CHILDREN
-   * or nsFrameState(0); passing 0 means that dirty bits won't be set on the
-   * frame or its ancestors/descendants, but that intrinsic widths will still
-   * be marked dirty.  Passing aIntrinsicDirty = eResize and aBitToAdd = 0
-   * would result in no work being done, so don't do that.
-   */
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_IntrinsicDirty {
-        eResize = 0,
-        eTreeChange = 1,
-        eStyleChange = 2,
-    }
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_ReflowRootHandling {
-        ePositionOrSizeChange = 0,
-        eNoPositionOrSizeChange = 1,
-        eInferFromBitToAdd = 2,
-    }
-    pub const nsIPresShell_SCROLL_TOP: root::nsIPresShell__bindgen_ty_1 =
-        nsIPresShell__bindgen_ty_1::SCROLL_TOP;
-    pub const nsIPresShell_SCROLL_BOTTOM: root::nsIPresShell__bindgen_ty_1 =
-        nsIPresShell__bindgen_ty_1::SCROLL_BOTTOM;
-    pub const nsIPresShell_SCROLL_LEFT: root::nsIPresShell__bindgen_ty_1 =
-        nsIPresShell__bindgen_ty_1::SCROLL_TOP;
-    pub const nsIPresShell_SCROLL_RIGHT: root::nsIPresShell__bindgen_ty_1 =
-        nsIPresShell__bindgen_ty_1::SCROLL_BOTTOM;
-    pub const nsIPresShell_SCROLL_CENTER: root::nsIPresShell__bindgen_ty_1 =
-        nsIPresShell__bindgen_ty_1::SCROLL_CENTER;
-    pub const nsIPresShell_SCROLL_MINIMUM: root::nsIPresShell__bindgen_ty_1 =
-        nsIPresShell__bindgen_ty_1::SCROLL_MINIMUM;
-    #[repr(i32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell__bindgen_ty_1 {
-        SCROLL_TOP = 0,
-        SCROLL_BOTTOM = 100,
-        SCROLL_CENTER = 50,
-        SCROLL_MINIMUM = -1,
-    }
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_WhenToScroll {
-        SCROLL_ALWAYS = 0,
-        SCROLL_IF_NOT_VISIBLE = 1,
-        SCROLL_IF_NOT_FULLY_VISIBLE = 2,
-    }
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct nsIPresShell_ScrollAxis {
-        pub _bindgen_opaque_blob: u32,
-    }
-    #[test]
-    fn bindgen_test_layout_nsIPresShell_ScrollAxis() {
-        assert_eq!(::std::mem::size_of::<nsIPresShell_ScrollAxis>() , 4usize ,
-                   concat ! (
-                   "Size of: " , stringify ! ( nsIPresShell_ScrollAxis ) ));
-        assert_eq! (::std::mem::align_of::<nsIPresShell_ScrollAxis>() , 4usize
-                    , concat ! (
-                    "Alignment of " , stringify ! ( nsIPresShell_ScrollAxis )
-                    ));
-    }
-    impl Clone for nsIPresShell_ScrollAxis {
-        fn clone(&self) -> Self { *self }
-    }
-    pub const nsIPresShell_SCROLL_FIRST_ANCESTOR_ONLY:
-              root::nsIPresShell__bindgen_ty_2 =
-        nsIPresShell__bindgen_ty_2::SCROLL_FIRST_ANCESTOR_ONLY;
-    pub const nsIPresShell_SCROLL_OVERFLOW_HIDDEN:
-              root::nsIPresShell__bindgen_ty_2 =
-        nsIPresShell__bindgen_ty_2::SCROLL_OVERFLOW_HIDDEN;
-    pub const nsIPresShell_SCROLL_NO_PARENT_FRAMES:
-              root::nsIPresShell__bindgen_ty_2 =
-        nsIPresShell__bindgen_ty_2::SCROLL_NO_PARENT_FRAMES;
-    pub const nsIPresShell_SCROLL_SMOOTH: root::nsIPresShell__bindgen_ty_2 =
-        nsIPresShell__bindgen_ty_2::SCROLL_SMOOTH;
-    pub const nsIPresShell_SCROLL_SMOOTH_AUTO:
-              root::nsIPresShell__bindgen_ty_2 =
-        nsIPresShell__bindgen_ty_2::SCROLL_SMOOTH_AUTO;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell__bindgen_ty_2 {
-        SCROLL_FIRST_ANCESTOR_ONLY = 1,
-        SCROLL_OVERFLOW_HIDDEN = 2,
-        SCROLL_NO_PARENT_FRAMES = 4,
-        SCROLL_SMOOTH = 8,
-        SCROLL_SMOOTH_AUTO = 16,
-    }
-    pub const nsIPresShell_RENDER_IS_UNTRUSTED:
-              root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_IS_UNTRUSTED;
-    pub const nsIPresShell_RENDER_IGNORE_VIEWPORT_SCROLLING:
-              root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_IGNORE_VIEWPORT_SCROLLING;
-    pub const nsIPresShell_RENDER_CARET: root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_CARET;
-    pub const nsIPresShell_RENDER_USE_WIDGET_LAYERS:
-              root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_USE_WIDGET_LAYERS;
-    pub const nsIPresShell_RENDER_ASYNC_DECODE_IMAGES:
-              root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_ASYNC_DECODE_IMAGES;
-    pub const nsIPresShell_RENDER_DOCUMENT_RELATIVE:
-              root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_DOCUMENT_RELATIVE;
-    pub const nsIPresShell_RENDER_DRAWWINDOW_NOT_FLUSHING:
-              root::nsIPresShell__bindgen_ty_3 =
-        nsIPresShell__bindgen_ty_3::RENDER_DRAWWINDOW_NOT_FLUSHING;
-    #[repr(u32)]
-    /**
-   * Render the document into an arbitrary gfxContext
-   * Designed for getting a picture of a document or a piece of a document
-   * Note that callers will generally want to call FlushPendingNotifications
-   * to get an up-to-date view of the document
-   * @param aRect is the region to capture into the offscreen buffer, in the
-   * root frame's coordinate system (if aIgnoreViewportScrolling is false)
-   * or in the root scrolled frame's coordinate system
-   * (if aIgnoreViewportScrolling is true). The coordinates are in appunits.
-   * @param aFlags see below;
-   *   set RENDER_IS_UNTRUSTED if the contents may be passed to malicious
-   * agents. E.g. we might choose not to paint the contents of sensitive widgets
-   * such as the file name in a file upload widget, and we might choose not
-   * to paint themes.
-   *   set RENDER_IGNORE_VIEWPORT_SCROLLING to ignore
-   * clipping and scrollbar painting due to scrolling in the viewport
-   *   set RENDER_CARET to draw the caret if one would be visible
-   * (by default the caret is never drawn)
-   *   set RENDER_USE_LAYER_MANAGER to force rendering to go through
-   * the layer manager for the window. This may be unexpectedly slow
-   * (if the layer manager must read back data from the GPU) or low-quality
-   * (if the layer manager reads back pixel data and scales it
-   * instead of rendering using the appropriate scaling). It may also
-   * slow everything down if the area rendered does not correspond to the
-   * normal visible area of the window.
-   *   set RENDER_ASYNC_DECODE_IMAGES to avoid having images synchronously
-   * decoded during rendering.
-   * (by default images decode synchronously with RenderDocument)
-   *   set RENDER_DOCUMENT_RELATIVE to render the document as if there has been
-   * no scrolling and interpret |aRect| relative to the document instead of the
-   * CSS viewport. Only considered if RENDER_IGNORE_VIEWPORT_SCROLLING is set
-   * or the document is in ignore viewport scrolling mode
-   * (nsIPresShell::SetIgnoreViewportScrolling/IgnoringViewportScrolling).
-   * @param aBackgroundColor a background color to render onto
-   * @param aRenderedContext the gfxContext to render to. We render so that
-   * one CSS pixel in the source document is rendered to one unit in the current
-   * transform.
-   */
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell__bindgen_ty_3 {
-        RENDER_IS_UNTRUSTED = 1,
-        RENDER_IGNORE_VIEWPORT_SCROLLING = 2,
-        RENDER_CARET = 4,
-        RENDER_USE_WIDGET_LAYERS = 8,
-        RENDER_ASYNC_DECODE_IMAGES = 16,
-        RENDER_DOCUMENT_RELATIVE = 32,
-        RENDER_DRAWWINDOW_NOT_FLUSHING = 64,
-    }
-    pub const nsIPresShell_RENDER_IS_IMAGE: root::nsIPresShell__bindgen_ty_4 =
-        nsIPresShell__bindgen_ty_4::RENDER_IS_IMAGE;
-    pub const nsIPresShell_RENDER_AUTO_SCALE: root::nsIPresShell__bindgen_ty_4
-              =
-        nsIPresShell__bindgen_ty_4::RENDER_AUTO_SCALE;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell__bindgen_ty_4 {
-        RENDER_IS_IMAGE = 256,
-        RENDER_AUTO_SCALE = 128,
-    }
-    pub const nsIPresShell_FORCE_DRAW: root::nsIPresShell__bindgen_ty_5 =
-        nsIPresShell__bindgen_ty_5::FORCE_DRAW;
-    pub const nsIPresShell_ADD_FOR_SUBDOC: root::nsIPresShell__bindgen_ty_5 =
-        nsIPresShell__bindgen_ty_5::ADD_FOR_SUBDOC;
-    pub const nsIPresShell_APPEND_UNSCROLLED_ONLY:
-              root::nsIPresShell__bindgen_ty_5 =
-        nsIPresShell__bindgen_ty_5::APPEND_UNSCROLLED_ONLY;
-    #[repr(u32)]
-    /**
-   * Add a solid color item to the bottom of aList with frame aFrame and bounds
-   * aBounds. Checks first if this needs to be done by checking if aFrame is a
-   * canvas frame (if the FORCE_DRAW flag is passed then this check is skipped).
-   * aBackstopColor is composed behind the background color of the canvas, it is
-   * transparent by default.
-   * We attempt to make the background color part of the scrolled canvas (to reduce
-   * transparent layers), and if async scrolling is enabled (and the background
-   * is opaque) then we add a second, unscrolled item to handle the checkerboarding
-   * case.
-   * ADD_FOR_SUBDOC shoud be specified when calling this for a subdocument, and
-   * LayoutUseContainersForRootFrame might cause the whole list to be scrolled. In
-   * that case the second unscrolled item will be elided.
-   * APPEND_UNSCROLLED_ONLY only attempts to add the unscrolled item, so that we
-   * can add it manually after LayoutUseContainersForRootFrame has built the
-   * scrolling ContainerLayer.
-   */
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell__bindgen_ty_5 {
-        FORCE_DRAW = 1,
-        ADD_FOR_SUBDOC = 2,
-        APPEND_UNSCROLLED_ONLY = 4,
-    }
-    #[repr(C)]
-    pub struct nsIPresShell_PointerCaptureInfo {
-        pub mPendingContent: root::nsCOMPtr<root::nsIContent>,
-        pub mOverrideContent: root::nsCOMPtr<root::nsIContent>,
-    }
-    #[test]
-    fn bindgen_test_layout_nsIPresShell_PointerCaptureInfo() {
-        assert_eq!(::std::mem::size_of::<nsIPresShell_PointerCaptureInfo>() ,
-                   16usize , concat ! (
-                   "Size of: " , stringify ! ( nsIPresShell_PointerCaptureInfo
-                   ) ));
-        assert_eq! (::std::mem::align_of::<nsIPresShell_PointerCaptureInfo>()
-                    , 8usize , concat ! (
-                    "Alignment of " , stringify ! (
-                    nsIPresShell_PointerCaptureInfo ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell_PointerCaptureInfo ) ) .
-                    mPendingContent as * const _ as usize } , 0usize , concat
-                    ! (
-                    "Alignment of field: " , stringify ! (
-                    nsIPresShell_PointerCaptureInfo ) , "::" , stringify ! (
-                    mPendingContent ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell_PointerCaptureInfo ) ) .
-                    mOverrideContent as * const _ as usize } , 8usize , concat
-                    ! (
-                    "Alignment of field: " , stringify ! (
-                    nsIPresShell_PointerCaptureInfo ) , "::" , stringify ! (
-                    mOverrideContent ) ));
-    }
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct nsIPresShell_PointerInfo {
-        pub mPointerType: u16,
-        pub mActiveState: bool,
-        pub mPrimaryState: bool,
-        pub mPreventMouseEventByContent: bool,
-    }
-    #[test]
-    fn bindgen_test_layout_nsIPresShell_PointerInfo() {
-        assert_eq!(::std::mem::size_of::<nsIPresShell_PointerInfo>() , 6usize
-                   , concat ! (
-                   "Size of: " , stringify ! ( nsIPresShell_PointerInfo ) ));
-        assert_eq! (::std::mem::align_of::<nsIPresShell_PointerInfo>() ,
-                    2usize , concat ! (
-                    "Alignment of " , stringify ! ( nsIPresShell_PointerInfo )
-                    ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
-                    mPointerType as * const _ as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! (
-                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
-                    mPointerType ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
-                    mActiveState as * const _ as usize } , 2usize , concat ! (
-                    "Alignment of field: " , stringify ! (
-                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
-                    mActiveState ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
-                    mPrimaryState as * const _ as usize } , 3usize , concat !
-                    (
-                    "Alignment of field: " , stringify ! (
-                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
-                    mPrimaryState ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
-                    mPreventMouseEventByContent as * const _ as usize } ,
-                    4usize , concat ! (
-                    "Alignment of field: " , stringify ! (
-                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
-                    mPreventMouseEventByContent ) ));
-    }
-    impl Clone for nsIPresShell_PointerInfo {
-        fn clone(&self) -> Self { *self }
-    }
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_PaintFlags {
-        PAINT_LAYERS = 1,
-        PAINT_COMPOSITE = 2,
-        PAINT_SYNC_DECODE_IMAGES = 4,
-    }
-    #[repr(u32)]
-    /**
-   * Ensures that the refresh driver is running, and schedules a view
-   * manager flush on the next tick.
-   *
-   * @param aType PAINT_DELAYED_COMPRESS : Schedule a paint to be executed after a delay, and
-   * put FrameLayerBuilder in 'compressed' mode that avoids short cut optimizations.
-   */
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum nsIPresShell_PaintType {
-        PAINT_DEFAULT = 0,
-        PAINT_DELAYED_COMPRESS = 1,
-    }
-    extern "C" {
-        #[link_name = "_ZN12nsIPresShell12gCaptureInfoE"]
-        pub static mut nsIPresShell_gCaptureInfo: root::CapturingContentInfo;
-    }
-    extern "C" {
-        #[link_name = "_ZN12nsIPresShell14gKeyDownTargetE"]
-        pub static mut nsIPresShell_gKeyDownTarget: *mut root::nsIContent;
-    }
-    #[test]
-    fn bindgen_test_layout_nsIPresShell() {
-        assert_eq!(::std::mem::size_of::<nsIPresShell>() , 5456usize , concat
-                   ! ( "Size of: " , stringify ! ( nsIPresShell ) ));
-        assert_eq! (::std::mem::align_of::<nsIPresShell>() , 8usize , concat !
-                    ( "Alignment of " , stringify ! ( nsIPresShell ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mDocument as *
-                    const _ as usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mDocument ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mPresContext as *
-                    const _ as usize } , 16usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mPresContext ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mStyleSet as *
-                    const _ as usize } , 24usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mStyleSet ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mFrameConstructor
-                    as * const _ as usize } , 32usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFrameConstructor ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mViewManager as *
-                    const _ as usize } , 40usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mViewManager ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mFrameArena as *
-                    const _ as usize } , 48usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFrameArena ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mSelection as *
-                    const _ as usize } , 5240usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mSelection ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mFrameManager as *
-                    const _ as usize } , 5248usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFrameManager ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mForwardingContainer as * const _ as usize } , 5256usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mForwardingContainer ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mDocAccessible as
-                    * const _ as usize } , 5264usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mDocAccessible ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mReflowContinueTimer as * const _ as usize } , 5272usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mReflowContinueTimer ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mDrawEventTargetFrame as * const _ as usize } , 5280usize
-                    , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mDrawEventTargetFrame ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mAllocatedPointers
-                    as * const _ as usize } , 5288usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mAllocatedPointers ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mPaintCount as *
-                    const _ as usize } , 5336usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mPaintCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mScrollPositionClampingScrollPortSize as * const _ as
-                    usize } , 5344usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mScrollPositionClampingScrollPortSize
-                    ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mAutoWeakFrames as
-                    * const _ as usize } , 5352usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mAutoWeakFrames ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mWeakFrames as *
-                    const _ as usize } , 5360usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mWeakFrames ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mCanvasBackgroundColor as * const _ as usize } , 5408usize
-                    , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mCanvasBackgroundColor ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mResolution as *
-                    const _ as usize } , 5412usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mResolution ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mSelectionFlags as
-                    * const _ as usize } , 5420usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mSelectionFlags ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mRenderFlags as *
-                    const _ as usize } , 5422usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mRenderFlags ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mPresShellId as *
-                    const _ as usize } , 5428usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mPresShellId ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationEmPerLine as * const _ as usize } ,
-                    5432usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFontSizeInflationEmPerLine ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationMinTwips as * const _ as usize } ,
-                    5436usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFontSizeInflationMinTwips ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationLineThreshold as * const _ as usize } ,
-                    5440usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFontSizeInflationLineThreshold ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationForceEnabled as * const _ as usize } ,
-                    5444usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFontSizeInflationForceEnabled ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationDisabledInMasterProcess as * const _ as
-                    usize } , 5445usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! (
-                    mFontSizeInflationDisabledInMasterProcess ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationEnabled as * const _ as usize } ,
-                    5446usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFontSizeInflationEnabled ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) .
-                    mFontSizeInflationEnabledIsDirty as * const _ as usize } ,
-                    5447usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mFontSizeInflationEnabledIsDirty )
-                    ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mPaintingIsFrozen
-                    as * const _ as usize } , 5448usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mPaintingIsFrozen ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mIsNeverPainting
-                    as * const _ as usize } , 5449usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mIsNeverPainting ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsIPresShell ) ) . mInFlush as *
-                    const _ as usize } , 5450usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
-                    "::" , stringify ! ( mInFlush ) ));
-    }
-    impl nsIPresShell {
-        #[inline]
-        pub fn mDidInitialize(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 1u64 as u16;
-            let val = (unit_field_val & mask) >> 0usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mDidInitialize(&mut self, val: bool) {
-            let mask = 1u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 0usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mIsDestroying(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 2u64 as u16;
-            let val = (unit_field_val & mask) >> 1usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mIsDestroying(&mut self, val: bool) {
-            let mask = 2u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 1usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mIsReflowing(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 4u64 as u16;
-            let val = (unit_field_val & mask) >> 2usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mIsReflowing(&mut self, val: bool) {
-            let mask = 4u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 2usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mPaintingSuppressed(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 8u64 as u16;
-            let val = (unit_field_val & mask) >> 3usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mPaintingSuppressed(&mut self, val: bool) {
-            let mask = 8u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 3usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mIsActive(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 16u64 as u16;
-            let val = (unit_field_val & mask) >> 4usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mIsActive(&mut self, val: bool) {
-            let mask = 16u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 4usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mFrozen(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 32u64 as u16;
-            let val = (unit_field_val & mask) >> 5usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mFrozen(&mut self, val: bool) {
-            let mask = 32u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 5usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mIsFirstPaint(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 64u64 as u16;
-            let val = (unit_field_val & mask) >> 6usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mIsFirstPaint(&mut self, val: bool) {
-            let mask = 64u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 6usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mObservesMutationsForPrint(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 128u64 as u16;
-            let val = (unit_field_val & mask) >> 7usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mObservesMutationsForPrint(&mut self, val: bool) {
-            let mask = 128u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 7usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mSuppressInterruptibleReflows(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 256u64 as u16;
-            let val = (unit_field_val & mask) >> 8usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mSuppressInterruptibleReflows(&mut self, val: bool) {
-            let mask = 256u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 8usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mScrollPositionClampingScrollPortSizeSet(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 512u64 as u16;
-            let val = (unit_field_val & mask) >> 9usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mScrollPositionClampingScrollPortSizeSet(&mut self,
-                                                            val: bool) {
-            let mask = 512u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 9usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mNeedLayoutFlush(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 1024u64 as u16;
-            let val = (unit_field_val & mask) >> 10usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mNeedLayoutFlush(&mut self, val: bool) {
-            let mask = 1024u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 10usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mNeedStyleFlush(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 2048u64 as u16;
-            let val = (unit_field_val & mask) >> 11usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mNeedStyleFlush(&mut self, val: bool) {
-            let mask = 2048u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 11usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mObservingStyleFlushes(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 4096u64 as u16;
-            let val = (unit_field_val & mask) >> 12usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mObservingStyleFlushes(&mut self, val: bool) {
-            let mask = 4096u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 12usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mObservingLayoutFlushes(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 8192u64 as u16;
-            let val = (unit_field_val & mask) >> 13usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mObservingLayoutFlushes(&mut self, val: bool) {
-            let mask = 8192u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 13usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn mNeedThrottledAnimationFlush(&self) -> bool {
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            let mask = 16384u64 as u16;
-            let val = (unit_field_val & mask) >> 14usize;
-            unsafe { ::std::mem::transmute(val as u8) }
-        }
-        #[inline]
-        pub fn set_mNeedThrottledAnimationFlush(&mut self, val: bool) {
-            let mask = 16384u64 as u16;
-            let val = val as u8 as u16;
-            let mut unit_field_val: u16 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u16 as *mut u8,
-                                                ::std::mem::size_of::<u16>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 14usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u16>());
-            }
-        }
-        #[inline]
-        pub fn new_bitfield_1(mDidInitialize: bool, mIsDestroying: bool,
-                              mIsReflowing: bool, mPaintingSuppressed: bool,
-                              mIsActive: bool, mFrozen: bool,
-                              mIsFirstPaint: bool,
-                              mObservesMutationsForPrint: bool,
-                              mSuppressInterruptibleReflows: bool,
-                              mScrollPositionClampingScrollPortSizeSet: bool,
-                              mNeedLayoutFlush: bool, mNeedStyleFlush: bool,
-                              mObservingStyleFlushes: bool,
-                              mObservingLayoutFlushes: bool,
-                              mNeedThrottledAnimationFlush: bool) -> u16 {
-            ({
-                 ({
-                      ({
-                           ({
-                                ({
-                                     ({
-                                          ({
-                                               ({
-                                                    ({
-                                                         ({
-                                                              ({
-                                                                   ({
-                                                                        ({
-                                                                             ({
-                                                                                  ({
-                                                                                       0
-                                                                                   }
-                                                                                       |
-                                                                                       ((mDidInitialize
-                                                                                             as
-                                                                                             u8
-                                                                                             as
-                                                                                             u16)
-                                                                                            <<
-                                                                                            0usize)
-                                                                                           &
-                                                                                           (1u64
-                                                                                                as
-                                                                                                u16))
-                                                                              }
-                                                                                  |
-                                                                                  ((mIsDestroying
-                                                                                        as
-                                                                                        u8
-                                                                                        as
-                                                                                        u16)
-                                                                                       <<
-                                                                                       1usize)
-                                                                                      &
-                                                                                      (2u64
-                                                                                           as
-                                                                                           u16))
-                                                                         } |
-                                                                             ((mIsReflowing
-                                                                                   as
-                                                                                   u8
-                                                                                   as
-                                                                                   u16)
-                                                                                  <<
-                                                                                  2usize)
-                                                                                 &
-                                                                                 (4u64
-                                                                                      as
-                                                                                      u16))
-                                                                    } |
-                                                                        ((mPaintingSuppressed
-                                                                              as
-                                                                              u8
-                                                                              as
-                                                                              u16)
-                                                                             <<
-                                                                             3usize)
-                                                                            &
-                                                                            (8u64
-                                                                                 as
-                                                                                 u16))
-                                                               } |
-                                                                   ((mIsActive
-                                                                         as u8
-                                                                         as
-                                                                         u16)
-                                                                        <<
-                                                                        4usize)
-                                                                       &
-                                                                       (16u64
-                                                                            as
-                                                                            u16))
-                                                          } |
-                                                              ((mFrozen as u8
-                                                                    as u16) <<
-                                                                   5usize) &
-                                                                  (32u64 as
-                                                                       u16))
-                                                     } |
-                                                         ((mIsFirstPaint as u8
-                                                               as u16) <<
-                                                              6usize) &
-                                                             (64u64 as u16))
-                                                } |
-                                                    ((mObservesMutationsForPrint
-                                                          as u8 as u16) <<
-                                                         7usize) &
-                                                        (128u64 as u16))
-                                           } |
-                                               ((mSuppressInterruptibleReflows
-                                                     as u8 as u16) << 8usize)
-                                                   & (256u64 as u16))
-                                      } |
-                                          ((mScrollPositionClampingScrollPortSizeSet
-                                                as u8 as u16) << 9usize) &
-                                              (512u64 as u16))
-                                 } |
-                                     ((mNeedLayoutFlush as u8 as u16) <<
-                                          10usize) & (1024u64 as u16))
-                            } |
-                                ((mNeedStyleFlush as u8 as u16) << 11usize) &
-                                    (2048u64 as u16))
-                       } |
-                           ((mObservingStyleFlushes as u8 as u16) << 12usize)
-                               & (4096u64 as u16))
-                  } |
-                      ((mObservingLayoutFlushes as u8 as u16) << 13usize) &
-                          (8192u64 as u16))
-             } |
-                 ((mNeedThrottledAnimationFlush as u8 as u16) << 14usize) &
-                     (16384u64 as u16))
-        }
-    }
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsStyleFont {
         pub mFont: root::nsFont,
         pub mSize: root::nscoord,
         pub mGenericID: u8,
         pub mScriptLevel: i8,
         pub mMathVariant: u8,
@@ -18965,28 +17487,28 @@ pub mod root {
                     ( "Alignment of " , stringify ! ( nsStyleColor ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStyleColor ) ) . mColor as * const
                     _ as usize } , 0usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStyleColor ) ,
                     "::" , stringify ! ( mColor ) ));
     }
     #[test]
-    fn __bindgen_test_layout_StaticRefPtr_instantiation_88() {
+    fn __bindgen_test_layout_StaticRefPtr_instantiation_80() {
         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> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_StaticRefPtr_instantiation_89() {
+    fn __bindgen_test_layout_StaticRefPtr_instantiation_81() {
         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> ) ));
@@ -21000,20 +19522,19 @@ pub mod root {
                     "::" , stringify ! ( mClipFlags ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStyleEffects ) ) . mMixBlendMode as
                     * const _ as usize } , 37usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStyleEffects ) ,
                     "::" , stringify ! ( mMixBlendMode ) ));
     }
     /**
- * We want C++ to be abe to read the style struct fields of ComputedValues
+ * We want C++ to be able to read the style struct fields of ComputedValues
  * so we define this type on the C++ side and use the bindgenned version
  * on the Rust side.
- *
  */
     #[repr(C)]
     #[derive(Debug)]
     pub struct ServoComputedData {
         pub Font: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoFont>,
         pub Color: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoColor>,
         pub List: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoList>,
         pub Text: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoText>,
@@ -21047,193 +19568,190 @@ pub mod root {
   /// relevant link for this element. A element's "relevant link" is the
   /// element being matched if it is a link or the nearest ancestor link.
         pub visited_style: ::gecko_bindings::structs::ServoVisitedStyle,
         pub font_computation_data: ::gecko_bindings::structs::ServoFontComputationData,
     }
     #[test]
     fn bindgen_test_layout_ServoComputedData() {
         assert_eq!(::std::mem::size_of::<ServoComputedData>() , 224usize ,
-                   concat ! (
-                   "Size of: " , stringify ! ( ServoComputedData ) ));
+                   concat ! ( "Size of: " , stringify ! ( ServoComputedData )
+                   ));
         assert_eq! (::std::mem::align_of::<ServoComputedData>() , 8usize ,
                     concat ! (
                     "Alignment of " , stringify ! ( ServoComputedData ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Font as *
                     const _ as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Font ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Font ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Color as *
                     const _ as usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Color ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Color ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . List as *
                     const _ as usize } , 16usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( List ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( List ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Text as *
                     const _ as usize } , 24usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Text ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Visibility
-                    as * const _ as usize } , 32usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Visibility ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) .
-                    UserInterface as * const _ as usize } , 40usize , concat !
-                    (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( UserInterface ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Text ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Visibility as
+                    * const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Visibility ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . UserInterface
+                    as * const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( UserInterface ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . TableBorder
                     as * const _ as usize } , 48usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( TableBorder ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( TableBorder ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . SVG as *
                     const _ as usize } , 56usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( SVG ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Background
-                    as * const _ as usize } , 64usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Background ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Position as
-                    * const _ as usize } , 72usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Position ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . TextReset
-                    as * const _ as usize } , 80usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( TextReset ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Display as
-                    * const _ as usize } , 88usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Display ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Content as
-                    * const _ as usize } , 96usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Content ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . UIReset as
-                    * const _ as usize } , 104usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( UIReset ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( SVG ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Background as
+                    * const _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Background ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Position as *
+                    const _ as usize } , 72usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Position ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . TextReset as
+                    * const _ as usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( TextReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Display as *
+                    const _ as usize } , 88usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Display ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Content as *
+                    const _ as usize } , 96usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Content ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . UIReset as *
+                    const _ as usize } , 104usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( UIReset ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Table as *
                     const _ as usize } , 112usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Table ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Table ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Margin as *
                     const _ as usize } , 120usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Margin ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Padding as
-                    * const _ as usize } , 128usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Padding ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Margin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Padding as *
+                    const _ as usize } , 128usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Padding ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Border as *
                     const _ as usize } , 136usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Border ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Outline as
-                    * const _ as usize } , 144usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Outline ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Border ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Outline as *
+                    const _ as usize } , 144usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Outline ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . XUL as *
                     const _ as usize } , 152usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( XUL ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . SVGReset as
-                    * const _ as usize } , 160usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( SVGReset ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( XUL ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . SVGReset as *
+                    const _ as usize } , 160usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( SVGReset ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . Column as *
                     const _ as usize } , 168usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Column ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) . Effects as
-                    * const _ as usize } , 176usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( Effects ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Column ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . Effects as *
+                    const _ as usize } , 176usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( Effects ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) .
                     custom_properties as * const _ as usize } , 184usize ,
                     concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( custom_properties ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) .
-                    writing_mode as * const _ as usize } , 192usize , concat !
-                    (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( writing_mode ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( custom_properties ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . writing_mode
+                    as * const _ as usize } , 192usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( writing_mode ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . flags as *
                     const _ as usize } , 193usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( flags ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( flags ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) . rules as *
                     const _ as usize } , 200usize , concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( rules ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedData ) ) .
-                    visited_style as * const _ as usize } , 208usize , concat
-                    ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( visited_style ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( rules ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedData ) ) . visited_style
+                    as * const _ as usize } , 208usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( visited_style ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const ServoComputedData ) ) .
                     font_computation_data as * const _ as usize } , 216usize ,
                     concat ! (
-                    "Alignment of field: " , stringify ! ( ServoComputedData
-                    ) , "::" , stringify ! ( font_computation_data ) ));
+                    "Alignment of field: " , stringify ! ( ServoComputedData )
+                    , "::" , stringify ! ( font_computation_data ) ));
     }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct ServoComputedDataForgotten {
         pub mPtr: *const root::ServoComputedData,
     }
     #[test]
     fn bindgen_test_layout_ServoComputedDataForgotten() {
         assert_eq!(::std::mem::size_of::<ServoComputedDataForgotten>() ,
                    8usize , concat ! (
                    "Size of: " , stringify ! ( ServoComputedDataForgotten )
                    ));
         assert_eq! (::std::mem::align_of::<ServoComputedDataForgotten>() ,
                     8usize , concat ! (
-                    "Alignment of " , stringify ! (
-                    ServoComputedDataForgotten ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const ServoComputedDataForgotten ) ) .
-                    mPtr as * const _ as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! (
-                    ServoComputedDataForgotten ) , "::" , stringify ! ( mPtr
+                    "Alignment of " , stringify ! ( ServoComputedDataForgotten
                     ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedDataForgotten ) ) . mPtr
+                    as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    ServoComputedDataForgotten ) , "::" , stringify ! ( mPtr )
+                    ));
     }
     impl Clone for ServoComputedDataForgotten {
         fn clone(&self) -> Self { *self }
     }
     #[repr(u32)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
     pub enum WeakMapTraceKind {
         DoNotTraceWeakMaps = 0,
@@ -21862,24 +20380,29 @@ pub mod root {
      */
         pub mChildNodes: root::RefPtr<root::nsChildContentList>,
         /**
      * Weak reference to this node.  This is cleared by the destructor of
      * nsNodeWeakReference.
      */
         pub mWeakReference: *mut root::nsNodeWeakReference,
         /**
+     * A set of ranges in the common ancestor for the selection to which
+     * this node belongs to.
+     */
+        pub mCommonAncestorRanges: u64,
+        /**
      * Number of descendant nodes in the uncomposed document that have been
      * explicitly set as editable.
      */
         pub mEditableDescendantCount: u32,
     }
     #[test]
     fn bindgen_test_layout_nsINode_nsSlots() {
-        assert_eq!(::std::mem::size_of::<nsINode_nsSlots>() , 48usize , concat
+        assert_eq!(::std::mem::size_of::<nsINode_nsSlots>() , 56usize , concat
                    ! ( "Size of: " , stringify ! ( nsINode_nsSlots ) ));
         assert_eq! (::std::mem::align_of::<nsINode_nsSlots>() , 8usize ,
                     concat ! (
                     "Alignment of " , stringify ! ( nsINode_nsSlots ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsINode_nsSlots ) ) .
                     mMutationObservers as * const _ as usize } , 8usize ,
                     concat ! (
@@ -21892,17 +20415,23 @@ pub mod root {
                     "::" , stringify ! ( mChildNodes ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsINode_nsSlots ) ) . mWeakReference
                     as * const _ as usize } , 32usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsINode_nsSlots ) ,
                     "::" , stringify ! ( mWeakReference ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsINode_nsSlots ) ) .
-                    mEditableDescendantCount as * const _ as usize } , 40usize
+                    mCommonAncestorRanges as * const _ as usize } , 40usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsINode_nsSlots ) ,
+                    "::" , stringify ! ( mCommonAncestorRanges ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsINode_nsSlots ) ) .
+                    mEditableDescendantCount as * const _ as usize } , 48usize
                     , concat ! (
                     "Alignment of field: " , stringify ! ( nsINode_nsSlots ) ,
                     "::" , stringify ! ( mEditableDescendantCount ) ));
     }
     #[repr(u32)]
     /**
    * Boolean flags
    */
@@ -23374,17 +21903,17 @@ pub mod root {
         eMozGetAsFile = 19,
         eUseOfCaptureEvents = 20,
         eUseOfReleaseEvents = 21,
         eUseOfDOM3LoadMethod = 22,
         eChromeUseOfDOM3LoadMethod = 23,
         eShowModalDialog = 24,
         eWindow_Content = 25,
         eSyncXMLHttpRequest = 26,
-        eWindow_Controllers = 27,
+        eWindow_Cc_ontrollers = 27,
         eImportXULIntoContent = 28,
         ePannerNodeDoppler = 29,
         eNavigatorGetUserMedia = 30,
         eWebrtcDeprecatedPrefix = 31,
         eRTCPeerConnectionGetStreams = 32,
         eAppCache = 33,
         ePrefixedImageSmoothingEnabled = 34,
         ePrefixedFullscreenAPI = 35,
@@ -26214,19 +24743,26 @@ pub mod root {
  *     expectation, but it makes sense in this case)
  */
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsStyleContext {
         pub mParent: root::RefPtr<root::nsStyleContext>,
         pub mPseudoTag: root::nsCOMPtr<root::nsIAtom>,
         pub mBits: u64,
-        pub mRefCnt: u32,
         pub mFrameRefCnt: u32,
     }
+    pub const nsStyleContext_kAllResolvedStructs:
+              root::nsStyleContext__bindgen_ty_1 =
+        nsStyleContext__bindgen_ty_1::kAllResolvedStructs;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsStyleContext__bindgen_ty_1 {
+        kAllResolvedStructs = 4294967295,
+    }
     extern "C" {
         #[link_name = "_ZN14nsStyleContext16sDependencyTableE"]
         pub static mut nsStyleContext_sDependencyTable: [u32; 0usize];
     }
     #[test]
     fn bindgen_test_layout_nsStyleContext() {
         assert_eq!(::std::mem::size_of::<nsStyleContext>() , 32usize , concat
                    ! ( "Size of: " , stringify ! ( nsStyleContext ) ));
@@ -26243,23 +24779,18 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( nsStyleContext ) ,
                     "::" , stringify ! ( mPseudoTag ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStyleContext ) ) . mBits as * const
                     _ as usize } , 16usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStyleContext ) ,
                     "::" , stringify ! ( mBits ) ));
         assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleContext ) ) . mRefCnt as *
-                    const _ as usize } , 24usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleContext ) ,
-                    "::" , stringify ! ( mRefCnt ) ));
-        assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStyleContext ) ) . mFrameRefCnt as
-                    * const _ as usize } , 28usize , concat ! (
+                    * const _ as usize } , 24usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStyleContext ) ,
                     "::" , stringify ! ( mFrameRefCnt ) ));
     }
     #[repr(C)]
     pub struct nsPresContext {
         pub _base: root::nsIObserver,
         pub _base_1: u64,
         pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
@@ -27983,33 +26514,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mUsesViewportUnits(&self) -> ::std::os::raw::c_uint {
+        pub fn mPendingViewportChange(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 1073741824u64 as u64;
             let val = (unit_field_val & mask) >> 30usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mUsesViewportUnits(&mut self,
-                                      val: ::std::os::raw::c_uint) {
+        pub fn set_mPendingViewportChange(&mut self,
+                                          val: ::std::os::raw::c_uint) {
             let mask = 1073741824u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28022,33 +26553,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mPendingViewportChange(&self) -> ::std::os::raw::c_uint {
+        pub fn mCounterStylesDirty(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 2147483648u64 as u64;
             let val = (unit_field_val & mask) >> 31usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mPendingViewportChange(&mut self,
-                                          val: ::std::os::raw::c_uint) {
+        pub fn set_mCounterStylesDirty(&mut self,
+                                       val: ::std::os::raw::c_uint) {
             let mask = 2147483648u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28061,33 +26592,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mCounterStylesDirty(&self) -> ::std::os::raw::c_uint {
+        pub fn mPostedFlushCounterStyles(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 4294967296u64 as u64;
             let val = (unit_field_val & mask) >> 32usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mCounterStylesDirty(&mut self,
-                                       val: ::std::os::raw::c_uint) {
+        pub fn set_mPostedFlushCounterStyles(&mut self,
+                                             val: ::std::os::raw::c_uint) {
             let mask = 4294967296u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28100,33 +26631,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mPostedFlushCounterStyles(&self) -> ::std::os::raw::c_uint {
+        pub fn mSuppressResizeReflow(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 8589934592u64 as u64;
             let val = (unit_field_val & mask) >> 33usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mPostedFlushCounterStyles(&mut self,
-                                             val: ::std::os::raw::c_uint) {
+        pub fn set_mSuppressResizeReflow(&mut self,
+                                         val: ::std::os::raw::c_uint) {
             let mask = 8589934592u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28139,33 +26670,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mSuppressResizeReflow(&self) -> ::std::os::raw::c_uint {
+        pub fn mIsVisual(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 17179869184u64 as u64;
             let val = (unit_field_val & mask) >> 34usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mSuppressResizeReflow(&mut self,
-                                         val: ::std::os::raw::c_uint) {
+        pub fn set_mIsVisual(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 17179869184u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28178,32 +26708,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mIsVisual(&self) -> ::std::os::raw::c_uint {
+        pub fn mFireAfterPaintEvents(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 34359738368u64 as u64;
             let val = (unit_field_val & mask) >> 35usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mIsVisual(&mut self, val: ::std::os::raw::c_uint) {
+        pub fn set_mFireAfterPaintEvents(&mut self,
+                                         val: ::std::os::raw::c_uint) {
             let mask = 34359738368u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28216,33 +26747,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mFireAfterPaintEvents(&self) -> ::std::os::raw::c_uint {
+        pub fn mIsChrome(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 68719476736u64 as u64;
             let val = (unit_field_val & mask) >> 36usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mFireAfterPaintEvents(&mut self,
-                                         val: ::std::os::raw::c_uint) {
+        pub fn set_mIsChrome(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 68719476736u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28255,32 +26785,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mIsChrome(&self) -> ::std::os::raw::c_uint {
+        pub fn mIsChromeOriginImage(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 137438953472u64 as u64;
             let val = (unit_field_val & mask) >> 37usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mIsChrome(&mut self, val: ::std::os::raw::c_uint) {
+        pub fn set_mIsChromeOriginImage(&mut self,
+                                        val: ::std::os::raw::c_uint) {
             let mask = 137438953472u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28293,33 +26824,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mIsChromeOriginImage(&self) -> ::std::os::raw::c_uint {
+        pub fn mPaintFlashing(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 274877906944u64 as u64;
             let val = (unit_field_val & mask) >> 38usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mIsChromeOriginImage(&mut self,
-                                        val: ::std::os::raw::c_uint) {
+        pub fn set_mPaintFlashing(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 274877906944u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28332,32 +26862,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mPaintFlashing(&self) -> ::std::os::raw::c_uint {
+        pub fn mPaintFlashingInitialized(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 549755813888u64 as u64;
             let val = (unit_field_val & mask) >> 39usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mPaintFlashing(&mut self, val: ::std::os::raw::c_uint) {
+        pub fn set_mPaintFlashingInitialized(&mut self,
+                                             val: ::std::os::raw::c_uint) {
             let mask = 549755813888u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28370,33 +26901,35 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mPaintFlashingInitialized(&self) -> ::std::os::raw::c_uint {
+        pub fn mHasWarnedAboutPositionedTableParts(&self)
+         -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 1099511627776u64 as u64;
             let val = (unit_field_val & mask) >> 40usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mPaintFlashingInitialized(&mut self,
-                                             val: ::std::os::raw::c_uint) {
+        pub fn set_mHasWarnedAboutPositionedTableParts(&mut self,
+                                                       val:
+                                                           ::std::os::raw::c_uint) {
             let mask = 1099511627776u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28409,35 +26942,35 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mHasWarnedAboutPositionedTableParts(&self)
+        pub fn mHasWarnedAboutTooLargeDashedOrDottedRadius(&self)
          -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 2199023255552u64 as u64;
             let val = (unit_field_val & mask) >> 41usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mHasWarnedAboutPositionedTableParts(&mut self,
-                                                       val:
-                                                           ::std::os::raw::c_uint) {
+        pub fn set_mHasWarnedAboutTooLargeDashedOrDottedRadius(&mut self,
+                                                               val:
+                                                                   ::std::os::raw::c_uint) {
             let mask = 2199023255552u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28450,35 +26983,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mHasWarnedAboutTooLargeDashedOrDottedRadius(&self)
-         -> ::std::os::raw::c_uint {
+        pub fn mQuirkSheetAdded(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 4398046511104u64 as u64;
             let val = (unit_field_val & mask) >> 42usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mHasWarnedAboutTooLargeDashedOrDottedRadius(&mut self,
-                                                               val:
-                                                                   ::std::os::raw::c_uint) {
+        pub fn set_mQuirkSheetAdded(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 4398046511104u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28491,32 +27021,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mQuirkSheetAdded(&self) -> ::std::os::raw::c_uint {
+        pub fn mNeedsPrefUpdate(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 8796093022208u64 as u64;
             let val = (unit_field_val & mask) >> 43usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mQuirkSheetAdded(&mut self, val: ::std::os::raw::c_uint) {
+        pub fn set_mNeedsPrefUpdate(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 8796093022208u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28529,32 +27059,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mNeedsPrefUpdate(&self) -> ::std::os::raw::c_uint {
+        pub fn mHadNonBlankPaint(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 17592186044416u64 as u64;
             let val = (unit_field_val & mask) >> 44usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mNeedsPrefUpdate(&mut self, val: ::std::os::raw::c_uint) {
+        pub fn set_mHadNonBlankPaint(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 17592186044416u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28567,32 +27097,33 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mHadNonBlankPaint(&self) -> ::std::os::raw::c_uint {
+        pub fn mRestyleLoggingEnabled(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 35184372088832u64 as u64;
             let val = (unit_field_val & mask) >> 45usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mHadNonBlankPaint(&mut self, val: ::std::os::raw::c_uint) {
+        pub fn set_mRestyleLoggingEnabled(&mut self,
+                                          val: ::std::os::raw::c_uint) {
             let mask = 35184372088832u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28605,33 +27136,32 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mRestyleLoggingEnabled(&self) -> ::std::os::raw::c_uint {
+        pub fn mInitialized(&self) -> ::std::os::raw::c_uint {
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
             };
             let mask = 70368744177664u64 as u64;
             let val = (unit_field_val & mask) >> 46usize;
             unsafe { ::std::mem::transmute(val as u32) }
         }
         #[inline]
-        pub fn set_mRestyleLoggingEnabled(&mut self,
-                                          val: ::std::os::raw::c_uint) {
+        pub fn set_mInitialized(&mut self, val: ::std::os::raw::c_uint) {
             let mask = 70368744177664u64 as u64;
             let val = val as u32 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
@@ -28644,54 +27174,16 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mInitialized(&self) -> ::std::os::raw::c_uint {
-            let mut unit_field_val: u64 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u64 as *mut u8,
-                                                ::std::mem::size_of::<u64>())
-            };
-            let mask = 140737488355328u64 as u64;
-            let val = (unit_field_val & mask) >> 47usize;
-            unsafe { ::std::mem::transmute(val as u32) }
-        }
-        #[inline]
-        pub fn set_mInitialized(&mut self, val: ::std::os::raw::c_uint) {
-            let mask = 140737488355328u64 as u64;
-            let val = val as u32 as u64;
-            let mut unit_field_val: u64 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u64 as *mut u8,
-                                                ::std::mem::size_of::<u64>())
-            };
-            unit_field_val &= !mask;
-            unit_field_val |= (val << 47usize) & mask;
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
-                                                    *const u8,
-                                                &mut self._bitfield_1 as
-                                                    *mut _ as *mut u8,
-                                                ::std::mem::size_of::<u64>());
-            }
-        }
-        #[inline]
         pub fn new_bitfield_1(mHasPendingInterrupt: ::std::os::raw::c_uint,
                               mPendingInterruptFromTest:
                                   ::std::os::raw::c_uint,
                               mInterruptsEnabled: ::std::os::raw::c_uint,
                               mUseDocumentFonts: ::std::os::raw::c_uint,
                               mUseDocumentColors: ::std::os::raw::c_uint,
                               mUnderlineLinks: ::std::os::raw::c_uint,
                               mSendAfterPaintToContent:
@@ -28718,17 +27210,16 @@ pub mod root {
                               mPendingMediaFeatureValuesChanged:
                                   ::std::os::raw::c_uint,
                               mPrefChangePendingNeedsReflow:
                                   ::std::os::raw::c_uint,
                               mIsEmulatingMedia: ::std::os::raw::c_uint,
                               mIsGlyph: ::std::os::raw::c_uint,
                               mUsesRootEMUnits: ::std::os::raw::c_uint,
                               mUsesExChUnits: ::std::os::raw::c_uint,
-                              mUsesViewportUnits: ::std::os::raw::c_uint,
                               mPendingViewportChange: ::std::os::raw::c_uint,
                               mCounterStylesDirty: ::std::os::raw::c_uint,
                               mPostedFlushCounterStyles:
                                   ::std::os::raw::c_uint,
                               mSuppressResizeReflow: ::std::os::raw::c_uint,
                               mIsVisual: ::std::os::raw::c_uint,
                               mFireAfterPaintEvents: ::std::os::raw::c_uint,
                               mIsChrome: ::std::os::raw::c_uint,
@@ -28786,543 +27277,530 @@ pub mod root {
                                                                                                                                                                                                           ({
                                                                                                                                                                                                                ({
                                                                                                                                                                                                                     ({
                                                                                                                                                                                                                          ({
                                                                                                                                                                                                                               ({
                                                                                                                                                                                                                                    ({
                                                                                                                                                                                                                                         ({
                                                                                                                                                                                                                                              ({
-                                                                                                                                                                                                                                                  ({
-                                                                                                                                                                                                                                                       0
-                                                                                                                                                                                                                                                   }
-                                                                                                                                                                                                                                                       |
-                                                                                                                                                                                                                                                       ((mHasPendingInterrupt
-                                                                                                                                                                                                                                                             as
-                                                                                                                                                                                                                                                             u32
-                                                                                                                                                                                                                                                             as
-                                                                                                                                                                                                                                                             u64)
-                                                                                                                                                                                                                                                            <<
-                                                                                                                                                                                                                                                            0usize)
-                                                                                                                                                                                                                                                           &
-                                                                                                                                                                                                                                                           (1u64
-                                                                                                                                                                                                                                                                as
-                                                                                                                                                                                                                                                                u64))
+                                                                                                                                                                                                                                                  0
                                                                                                                                                                                                                                               }
                                                                                                                                                                                                                                                   |
-                                                                                                                                                                                                                                                  ((mPendingInterruptFromTest
+                                                                                                                                                                                                                                                  ((mHasPendingInterrupt
                                                                                                                                                                                                                                                         as
                                                                                                                                                                                                                                                         u32
                                                                                                                                                                                                                                                         as
                                                                                                                                                                                                                                                         u64)
                                                                                                                                                                                                                                                        <<
-                                                                                                                                                                                                                                                       1usize)
+                                                                                                                                                                                                                                                       0usize)
                                                                                                                                                                                                                                                       &
-                                                                                                                                                                                                                                                      (2u64
+                                                                                                                                                                                                                                                      (1u64
                                                                                                                                                                                                                                                            as
                                                                                                                                                                                                                                                            u64))
                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                              |
-                                                                                                                                                                                                                                             ((mInterruptsEnabled
+                                                                                                                                                                                                                                             ((mPendingInterruptFromTest
                                                                                                                                                                                                                                                    as
                                                                                                                                                                                                                                                    u32
                                                                                                                                                                                                                                                    as
                                                                                                                                                                                                                                                    u64)
                                                                                                                                                                                                                                                   <<
-                                                                                                                                                                                                                                                  2usize)
+                                                                                                                                                                                                                                                  1usize)
                                                                                                                                                                                                                                                  &
-                                                                                                                                                                                                                                                 (4u64
+                                                                                                                                                                                                                                                 (2u64
                                                                                                                                                                                                                                                       as
                                                                                                                                                                                                                                                       u64))
                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                         |
-                                                                                                                                                                                                                                        ((mUseDocumentFonts
+                                                                                                                                                                                                                                        ((mInterruptsEnabled
                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                               u32
                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                               u64)
                                                                                                                                                                                                                                              <<
-                                                                                                                                                                                                                                             3usize)
+                                                                                                                                                                                                                                             2usize)
                                                                                                                                                                                                                                             &
-                                                                                                                                                                                                                                            (8u64
+                                                                                                                                                                                                                                            (4u64
                                                                                                                                                                                                                                                  as
                                                                                                                                                                                                                                                  u64))
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                    |
-                                                                                                                                                                                                                                   ((mUseDocumentColors
+                                                                                                                                                                                                                                   ((mUseDocumentFonts
                                                                                                                                                                                                                                          as
                                                                                                                                                                                                                                          u32
                                                                                                                                                                                                                                          as
                                                                                                                                                                                                                                          u64)
                                                                                                                                                                                                                                         <<
-                                                                                                                                                                                                                                        4usize)
+                                                                                                                                                                                                                                        3usize)
                                                                                                                                                                                                                                        &
-                                                                                                                                                                                                                                       (16u64
+                                                                                                                                                                                                                                       (8u64
                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                             u64))
                                                                                                                                                                                                                           }
                                                                                                                                                                                                                               |
-                                                                                                                                                                                                                              ((mUnderlineLinks
+                                                                                                                                                                                                                              ((mUseDocumentColors
                                                                                                                                                                                                                                     as
                                                                                                                                                                                                                                     u32
                                                                                                                                                                                                                                     as
                                                                                                                                                                                                                                     u64)
                                                                                                                                                                                                                                    <<
-                                                                                                                                                                                                                                   5usize)
+                                                                                                                                                                                                                                   4usize)
                                                                                                                                                                                                                                   &
-                                                                                                                                                                                                                                  (32u64
+                                                                                                                                                                                                                                  (16u64
                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                        u64))
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                          |
-                                                                                                                                                                                                                         ((mSendAfterPaintToContent
+                                                                                                                                                                                                                         ((mUnderlineLinks
                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                u32
                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                u64)
                                                                                                                                                                                                                               <<
-                                                                                                                                                                                                                              6usize)
+                                                                                                                                                                                                                              5usize)
                                                                                                                                                                                                                              &
-                                                                                                                                                                                                                             (64u64
+                                                                                                                                                                                                                             (32u64
                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                   u64))
                                                                                                                                                                                                                 }
                                                                                                                                                                                                                     |
-                                                                                                                                                                                                                    ((mUseFocusColors
+                                                                                                                                                                                                                    ((mSendAfterPaintToContent
                                                                                                                                                                                                                           as
                                                                                                                                                                                                                           u32
                                                                                                                                                                                                                           as
                                                                                                                                                                                                                           u64)
                                                                                                                                                                                                                          <<
-                                                                                                                                                                                                                         7usize)
+                                                                                                                                                                                                                         6usize)
                                                                                                                                                                                                                         &
-                                                                                                                                                                                                                        (128u64
+                                                                                                                                                                                                                        (64u64
                                                                                                                                                                                                                              as
                                                                                                                                                                                                                              u64))
                                                                                                                                                                                                            }
                                                                                                                                                                                                                |
-                                                                                                                                                                                                               ((mFocusRingOnAnything
+                                                                                                                                                                                                               ((mUseFocusColors
                                                                                                                                                                                                                      as
                                                                                                                                                                                                                      u32
                                                                                                                                                                                                                      as
                                                                                                                                                                                                                      u64)
                                                                                                                                                                                                                     <<
-                                                                                                                                                                                                                    8usize)
+                                                                                                                                                                                                                    7usize)
                                                                                                                                                                                                                    &
-                                                                                                                                                                                                                   (256u64
+                                                                                                                                                                                                                   (128u64
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         u64))
                                                                                                                                                                                                       }
                                                                                                                                                                                                           |
-                                                                                                                                                                                                          ((mFocusRingStyle
+                                                                                                                                                                                                          ((mFocusRingOnAnything
                                                                                                                                                                                                                 as
                                                                                                                                                                                                                 u32
                                                                                                                                                                                                                 as
                                                                                                                                                                                                                 u64)
                                                                                                                                                                                                                <<
-                                                                                                                                                                                                               9usize)
+                                                                                                                                                                                                               8usize)
                                                                                                                                                                                                               &
-                                                                                                                                                                                                              (512u64
+                                                                                                                                                                                                              (256u64
                                                                                                                                                                                                                    as
                                                                                                                                                                                                                    u64))
                                                                                                                                                                                                  }
                                                                                                                                                                                                      |
-                                                                                                                                                                                                     ((mDrawImageBackground
+                                                                                                                                                                                                     ((mFocusRingStyle
                                                                                                                                                                                                            as
                                                                                                                                                                                                            u32
                                                                                                                                                                                                            as
                                                                                                                                                                                                            u64)
                                                                                                                                                                                                           <<
-                                                                                                                                                                                                          10usize)
+                                                                                                                                                                                                          9usize)
                                                                                                                                                                                                          &
-                                                                                                                                                                                                         (1024u64
+                                                                                                                                                                                                         (512u64
                                                                                                                                                                                                               as
                                                                                                                                                                                                               u64))
                                                                                                                                                                                             }
                                                                                                                                                                                                 |
-                                                                                                                                                                                                ((mDrawColorBackground
+                                                                                                                                                                                                ((mDrawImageBackground
                                                                                                                                                                                                       as
                                                                                                                                                                                                       u32
                                                                                                                                                                                                       as
                                                                                                                                                                                                       u64)
                                                                                                                                                                                                      <<
-                                                                                                                                                                                                     11usize)
+                                                                                                                                                                                                     10usize)
                                                                                                                                                                                                     &
-                                                                                                                                                                                                    (2048u64
+                                                                                                                                                                                                    (1024u64
                                                                                                                                                                                                          as
                                                                                                                                                                                                          u64))
                                                                                                                                                                                        }
                                                                                                                                                                                            |
-                                                                                                                                                                                           ((mNeverAnimate
+                                                                                                                                                                                           ((mDrawColorBackground
                                                                                                                                                                                                  as
                                                                                                                                                                                                  u32
                                                                                                                                                                                                  as
                                                                                                                                                                                                  u64)
                                                                                                                                                                                                 <<
-                                                                                                                                                                                                12usize)
+                                                                                                                                                                                                11usize)
                                                                                                                                                                                                &
-                                                                                                                                                                                               (4096u64
+                                                                                                                                                                                               (2048u64
                                                                                                                                                                                                     as
                                                                                                                                                                                                     u64))
                                                                                                                                                                                   }
                                                                                                                                                                                       |
-                                                                                                                                                                                      ((mIsRenderingOnlySelection
+                                                                                                                                                                                      ((mNeverAnimate
                                                                                                                                                                                             as
                                                                                                                                                                                             u32
                                                                                                                                                                                             as
                                                                                                                                                                                             u64)
                                                                                                                                                                                            <<
-                                                                                                                                                                                           13usize)
+                                                                                                                                                                                           12usize)
                                                                                                                                                                                           &
-                                                                                                                                                                                          (8192u64
+                                                                                                                                                                                          (4096u64
                                                                                                                                                                                                as
                                                                                                                                                                                                u64))
                                                                                                                                                                              }
                                                                                                                                                                                  |
-                                                                                                                                                                                 ((mPaginated
+                                                                                                                                                                                 ((mIsRenderingOnlySelection
                                                                                                                                                                                        as
                                                                                                                                                                                        u32
                                                                                                                                                                                        as
                                                                                                                                                                                        u64)
                                                                                                                                                                                       <<
-                                                                                                                                                                                      14usize)
+                                                                                                                                                                                      13usize)
                                                                                                                                                                                      &
-                                                                                                                                                                                     (16384u64
+                                                                                                                                                                                     (8192u64
                                                                                                                                                                                           as
                                                                                                                                                                                           u64))
                                                                                                                                                                         }
                                                                                                                                                                             |
-                                                                                                                                                                            ((mCanPaginatedScroll
+                                                                                                                                                                            ((mPaginated
                                                                                                                                                                                   as
                                                                                                                                                                                   u32
                                                                                                                                                                                   as
                                                                                                                                                                                   u64)
                                                                                                                                                                                  <<
-                                                                                                                                                                                 15usize)
+                                                                                                                                                                                 14usize)
                                                                                                                                                                                 &
-                                                                                                                                                                                (32768u64
+                                                                                                                                                                                (16384u64
                                                                                                                                                                                      as
                                                                                                                                                                                      u64))
                                                                                                                                                                    }
                                                                                                                                                                        |
-                                                                                                                                                                       ((mDoScaledTwips
+                                                                                                                                                                       ((mCanPaginatedScroll
                                                                                                                                                                              as
                                                                                                                                                                              u32
                                                                                                                                                                              as
                                                                                                                                                                              u64)
                                                                                                                                                                             <<
-                                                                                                                                                                            16usize)
+                                                                                                                                                                            15usize)
                                                                                                                                                                            &
-                                                                                                                                                                           (65536u64
+                                                                                                                                                                           (32768u64
                                                                                                                                                                                 as
                                                                                                                                                                                 u64))
                                                                                                                                                               }
                                                                                                                                                                   |
-                                                                                                                                                                  ((mIsRootPaginatedDocument
+                                                                                                                                                                  ((mDoScaledTwips
                                                                                                                                                                         as
                                                                                                                                                                         u32
                                                                                                                                                                         as
                                                                                                                                                                         u64)
                                                                                                                                                                        <<
-                                                                                                                                                                       17usize)
+                                                                                                                                                                       16usize)
                                                                                                                                                                       &
-                                                                                                                                                                      (131072u64
+                                                                                                                                                                      (65536u64
                                                                                                                                                                            as
                                                                                                                                                                            u64))
                                                                                                                                                          }
                                                                                                                                                              |
-                                                                                                                                                             ((mPrefBidiDirection
+                                                                                                                                                             ((mIsRootPaginatedDocument
                                                                                                                                                                    as
                                                                                                                                                                    u32
                                                                                                                                                                    as
                                                                                                                                                                    u64)
                                                                                                                                                                   <<
-                                                                                                                                                                  18usize)
+                                                                                                                                                                  17usize)
                                                                                                                                                                  &
-                                                                                                                                                                 (262144u64
+                                                                                                                                                                 (131072u64
                                                                                                                                                                       as
                                                                                                                                                                       u64))
                                                                                                                                                     }
                                                                                                                                                         |
-                                                                                                                                                        ((mPrefScrollbarSide
+                                                                                                                                                        ((mPrefBidiDirection
                                                                                                                                                               as
                                                                                                                                                               u32
                                                                                                                                                               as
                                                                                                                                                               u64)
                                                                                                                                                              <<
-                                                                                                                                                             19usize)
+                                                                                                                                                             18usize)
                                                                                                                                                             &
-                                                                                                                                                            (1572864u64
+                                                                                                                                                            (262144u64
                                                                                                                                                                  as
                                                                                                                                                                  u64))
                                                                                                                                                }
                                                                                                                                                    |
-                                                                                                                                                   ((mPendingSysColorChanged
+                                                                                                                                                   ((mPrefScrollbarSide
                                                                                                                                                          as
                                                                                                                                                          u32
                                                                                                                                                          as
                                                                                                                                                          u64)
                                                                                                                                                         <<
-                                                                                                                                                        21usize)
+                                                                                                                                                        19usize)
                                                                                                                                                        &
-                                                                                                                                                       (2097152u64
+                                                                                                                                                       (1572864u64
                                                                                                                                                             as
                                                                                                                                                             u64))
                                                                                                                                           }
                                                                                                                                               |
-                                                                                                                                              ((mPendingThemeChanged
+                                                                                                                                              ((mPendingSysColorChanged
                                                                                                                                                     as
                                                                                                                                                     u32
                                                                                                                                                     as
                                                                                                                                                     u64)
                                                                                                                                                    <<
-                                                                                                                                                   22usize)
+                                                                                                                                                   21usize)
                                                                                                                                                   &
-                                                                                                                                                  (4194304u64
+                                                                                                                                                  (2097152u64
                                                                                                                                                        as
                                                                                                                                                        u64))
                                                                                                                                      }
                                                                                                                                          |
-                                                                                                                                         ((mPendingUIResolutionChanged
+                                                                                                                                         ((mPendingThemeChanged
                                                                                                                                                as
                                                                                                                                                u32
                                                                                                                                                as
                                                                                                                                                u64)
                                                                                                                                               <<
-                                                                                                                                              23usize)
+                                                                                                                                              22usize)
                                                                                                                                              &
-                                                                                                                                             (8388608u64
+                                                                                                                                             (4194304u64
                                                                                                                                                   as
                                                                                                                                                   u64))
                                                                                                                                 }
                                                                                                                                     |
-                                                                                                                                    ((mPendingMediaFeatureValuesChanged
+                                                                                                                                    ((mPendingUIResolutionChanged
                                                                                                                                           as
                                                                                                                                           u32
                                                                                                                                           as
                                                                                                                                           u64)
                                                                                                                                          <<
-                                                                                                                                         24usize)
+                                                                                                                                         23usize)
                                                                                                                                         &
-                                                                                                                                        (16777216u64
+                                                                                                                                        (8388608u64
                                                                                                                                              as
                                                                                                                                              u64))
                                                                                                                            }
                                                                                                                                |
-                                                                                                                               ((mPrefChangePendingNeedsReflow
+                                                                                                                               ((mPendingMediaFeatureValuesChanged
                                                                                                                                      as
                                                                                                                                      u32
                                                                                                                                      as
                                                                                                                                      u64)
                                                                                                                                     <<
-                                                                                                                                    25usize)
+                                                                                                                                    24usize)
                                                                                                                                    &
-                                                                                                                                   (33554432u64
+                                                                                                                                   (16777216u64
                                                                                                                                         as
                                                                                                                                         u64))
                                                                                                                       }
                                                                                                                           |
-                                                                                                                          ((mIsEmulatingMedia
+                                                                                                                          ((mPrefChangePendingNeedsReflow
                                                                                                                                 as
                                                                                                                                 u32
                                                                                                                                 as
                                                                                                                                 u64)
                                                                                                                                <<
-                                                                                                                               26usize)
+                                                                                                                               25usize)
                                                                                                                               &
-                                                                                                                              (67108864u64
+                                                                                                                              (33554432u64
                                                                                                                                    as
                                                                                                                                    u64))
                                                                                                                  }
                                                                                                                      |
-                                                                                                                     ((mIsGlyph
+                                                                                                                     ((mIsEmulatingMedia
                                                                                                                            as
                                                                                                                            u32
                                                                                                                            as
                                                                                                                            u64)
                                                                                                                           <<
-                                                                                                                          27usize)
+                                                                                                                          26usize)
                                                                                                                          &
-                                                                                                                         (134217728u64
+                                                                                                                         (67108864u64
                                                                                                                               as
                                                                                                                               u64))
                                                                                                             }
                                                                                                                 |
-                                                                                                                ((mUsesRootEMUnits
+                                                                                                                ((mIsGlyph
                                                                                                                       as
                                                                                                                       u32
                                                                                                                       as
                                                                                                                       u64)
                                                                                                                      <<
-                                                                                                                     28usize)
+                                                                                                                     27usize)
                                                                                                                     &
-                                                                                                                    (268435456u64
+                                                                                                                    (134217728u64
                                                                                                                          as
                                                                                                                          u64))
                                                                                                        }
                                                                                                            |
-                                                                                                           ((mUsesExChUnits
+                                                                                                           ((mUsesRootEMUnits
                                                                                                                  as
                                                                                                                  u32
                                                                                                                  as
                                                                                                                  u64)
                                                                                                                 <<
-                                                                                                                29usize)
+                                                                                                                28usize)
                                                                                                                &
-                                                                                                               (536870912u64
+                                                                                                               (268435456u64
                                                                                                                     as
                                                                                                                     u64))
                                                                                                   }
                                                                                                       |
-                                                                                                      ((mUsesViewportUnits
+                                                                                                      ((mUsesExChUnits
                                                                                                             as
                                                                                                             u32
                                                                                                             as
                                                                                                             u64)
                                                                                                            <<
-                                                                                                           30usize)
+                                                                                                           29usize)
                                                                                                           &
-                                                                                                          (1073741824u64
+                                                                                                          (536870912u64
                                                                                                                as
                                                                                                                u64))
                                                                                              }
                                                                                                  |
                                                                                                  ((mPendingViewportChange
                                                                                                        as
                                                                                                        u32
                                                                                                        as
                                                                                                        u64)
                                                                                                       <<
-                                                                                                      31usize)
+                                                                                                      30usize)
                                                                                                      &
-                                                                                                     (2147483648u64
+                                                                                                     (1073741824u64
                                                                                                           as
                                                                                                           u64))
                                                                                         }
                                                                                             |
                                                                                             ((mCounterStylesDirty
                                                                                                   as
                                                                                                   u32
                                                                                                   as
                                                                                                   u64)
                                                                                                  <<
-                                                                                                 32usize)
+                                                                                                 31usize)
                                                                                                 &
-                                                                                                (4294967296u64
+                                                                                                (2147483648u64
                                                                                                      as
                                                                                                      u64))
                                                                                    }
                                                                                        |
                                                                                        ((mPostedFlushCounterStyles
                                                                                              as
                                                                                              u32
                                                                                              as
                                                                                              u64)
                                                                                             <<
-                                                                                            33usize)
+                                                                                            32usize)
                                                                                            &
-                                                                                           (8589934592u64
+                                                                                           (4294967296u64
                                                                                                 as
                                                                                                 u64))
                                                                               }
                                                                                   |
                                                                                   ((mSuppressResizeReflow
                                                                                         as
                                                                                         u32
                                                                                         as
                                                                                         u64)
                                                                                        <<
-                                                                                       34usize)
+                                                                                       33usize)
                                                                                       &
-                                                                                      (17179869184u64
+                                                                                      (8589934592u64
                                                                                            as
                                                                                            u64))
                                                                          } |
                                                                              ((mIsVisual
                                                                                    as
                                                                                    u32
                                                                                    as
                                                                                    u64)
                                                                                   <<
-                                                                                  35usize)
+                                                                                  34usize)
                                                                                  &
-                                                                                 (34359738368u64
+                                                                                 (17179869184u64
                                                                                       as
                                                                                       u64))
                                                                     } |
                                                                         ((mFireAfterPaintEvents
                                                                               as
                                                                               u32
                                                                               as
                                                                               u64)
                                                                              <<
-                                                                             36usize)
+                                                                             35usize)
                                                                             &
-                                                                            (68719476736u64
+                                                                            (34359738368u64
                                                                                  as
                                                                                  u64))
                                                                } |
                                                                    ((mIsChrome
                                                                          as
                                                                          u32
                                                                          as
                                                                          u64)
                                                                         <<
-                                                                        37usize)
+                                                                        36usize)
                                                                        &
-                                                                       (137438953472u64
+                                                                       (68719476736u64
                                                                             as
                                                                             u64))
                                                           } |
                                                               ((mIsChromeOriginImage
                                                                     as u32 as
                                                                     u64) <<
-                                                                   38usize) &
-                                                                  (274877906944u64
+                                                                   37usize) &
+                                                                  (137438953472u64
                                                                        as
                                                                        u64))
                                                      } |
                                                          ((mPaintFlashing as
                                                                u32 as u64) <<
-                                                              39usize) &
-                                                             (549755813888u64
+                                                              38usize) &
+                                                             (274877906944u64
                                                                   as u64))
                                                 } |
                                                     ((mPaintFlashingInitialized
                                                           as u32 as u64) <<
-                                                         40usize) &
-                                                        (1099511627776u64 as
+                                                         39usize) &
+                                                        (549755813888u64 as
                                                              u64))
                                            } |
                                                ((mHasWarnedAboutPositionedTableParts
                                                      as u32 as u64) <<
-                                                    41usize) &
-                                                   (2199023255552u64 as u64))
+                                                    40usize) &
+                                                   (1099511627776u64 as u64))
                                       } |
                                           ((mHasWarnedAboutTooLargeDashedOrDottedRadius
-                                                as u32 as u64) << 42usize) &
-                                              (4398046511104u64 as u64))
+                                                as u32 as u64) << 41usize) &
+                                              (2199023255552u64 as u64))
                                  } |
                                      ((mQuirkSheetAdded as u32 as u64) <<
-                                          43usize) &
-                                         (8796093022208u64 as u64))
+                                          42usize) &
+                                         (4398046511104u64 as u64))
                             } |
-                                ((mNeedsPrefUpdate as u32 as u64) << 44usize)
-                                    & (17592186044416u64 as u64))
+                                ((mNeedsPrefUpdate as u32 as u64) << 43usize)
+                                    & (8796093022208u64 as u64))
                        } |
-                           ((mHadNonBlankPaint as u32 as u64) << 45usize) &
-                               (35184372088832u64 as u64))
+                           ((mHadNonBlankPaint as u32 as u64) << 44usize) &
+                               (17592186044416u64 as u64))
                   } |
-                      ((mRestyleLoggingEnabled as u32 as u64) << 46usize) &
-                          (70368744177664u64 as u64))
+                      ((mRestyleLoggingEnabled as u32 as u64) << 45usize) &
+                          (35184372088832u64 as u64))
              } |
-                 ((mInitialized as u32 as u64) << 47usize) &
-                     (140737488355328u64 as u64))
-        }
-    }
+                 ((mInitialized as u32 as u64) << 46usize) &
+                     (70368744177664u64 as u64))
+        }
+    }
+    pub type gfxSize = [u64; 2usize];
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsAttrName {
         pub mBits: usize,
     }
     #[test]
     fn bindgen_test_layout_nsAttrName() {
         assert_eq!(::std::mem::size_of::<nsAttrName>() , 8usize , concat ! (
@@ -30003,16 +28481,1284 @@ pub mod root {
     #[test]
     fn bindgen_test_layout_nsINodeList() {
         assert_eq!(::std::mem::size_of::<nsINodeList>() , 32usize , concat ! (
                    "Size of: " , stringify ! ( nsINodeList ) ));
         assert_eq! (::std::mem::align_of::<nsINodeList>() , 8usize , concat !
                     ( "Alignment of " , stringify ! ( nsINodeList ) ));
     }
     /**
+ * Presentation shell interface. Presentation shells are the
+ * controlling point for managing the presentation of a document. The
+ * presentation shell holds a live reference to the document, the
+ * presentation context, the style manager, the style set and the root
+ * frame. <p>
+ *
+ * When this object is Release'd, it will release the document, the
+ * presentation context, the style manager, the style set and the root
+ * frame.
+ */
+    #[repr(C)]
+    pub struct nsIPresShell {
+        pub _base: root::nsISupports,
+        pub mDocument: root::nsCOMPtr<root::nsIDocument>,
+        pub mPresContext: root::RefPtr<root::nsPresContext>,
+        pub mStyleSet: root::mozilla::StyleSetHandle,
+        pub mFrameConstructor: *mut root::nsCSSFrameConstructor,
+        pub mViewManager: *mut root::nsViewManager,
+        pub mFrameArena: root::nsPresArena,
+        pub mSelection: root::RefPtr<root::nsFrameSelection>,
+        pub mFrameManager: *mut root::nsFrameManagerBase,
+        pub mForwardingContainer: u64,
+        pub mDocAccessible: *mut root::mozilla::a11y::DocAccessible,
+        pub mReflowContinueTimer: root::nsCOMPtr<root::nsITimer>,
+        pub mDrawEventTargetFrame: *mut root::nsIFrame,
+        pub mAllocatedPointers: [u64; 6usize],
+        pub mPaintCount: u64,
+        pub mScrollPositionClampingScrollPortSize: root::nsSize,
+        pub mAutoWeakFrames: *mut root::AutoWeakFrame,
+        pub mWeakFrames: [u64; 6usize],
+        pub mCanvasBackgroundColor: root::nscolor,
+        pub mResolution: [u32; 2usize],
+        pub mSelectionFlags: i16,
+        pub mRenderFlags: root::nsIPresShell_RenderFlags,
+        pub _bitfield_1: [u8; 2usize],
+        pub mPresShellId: u32,
+        pub mFontSizeInflationEmPerLine: u32,
+        pub mFontSizeInflationMinTwips: u32,
+        pub mFontSizeInflationLineThreshold: u32,
+        pub mFontSizeInflationForceEnabled: bool,
+        pub mFontSizeInflationDisabledInMasterProcess: bool,
+        pub mFontSizeInflationEnabled: bool,
+        pub mFontSizeInflationEnabledIsDirty: bool,
+        pub mPaintingIsFrozen: bool,
+        pub mIsNeverPainting: bool,
+        pub mInFlush: bool,
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct nsIPresShell_COMTypeInfo {
+        pub _address: u8,
+    }
+    pub type nsIPresShell_LayerManager = root::mozilla::layers::LayerManager;
+    pub type nsIPresShell_SourceSurface = root::mozilla::gfx::SourceSurface;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_eRenderFlag {
+        STATE_IGNORING_VIEWPORT_SCROLLING = 1,
+        STATE_DRAWWINDOW_NOT_FLUSHING = 2,
+    }
+    pub type nsIPresShell_RenderFlags = u8;
+    #[repr(u32)]
+    /**
+   * Gets nearest scrollable frame from the specified content node. The frame
+   * is scrollable with overflow:scroll or overflow:auto in some direction when
+   * aDirection is eEither.  Otherwise, this returns a nearest frame that is
+   * scrollable in the specified direction.
+   */
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_ScrollDirection {
+        eHorizontal = 0,
+        eVertical = 1,
+        eEither = 2,
+    }
+    #[repr(u32)]
+    /**
+   * Tell the pres shell that a frame needs to be marked dirty and needs
+   * Reflow.  It's OK if this is an ancestor of the frame needing reflow as
+   * long as the ancestor chain between them doesn't cross a reflow root.
+   *
+   * The bit to add should be NS_FRAME_IS_DIRTY, NS_FRAME_HAS_DIRTY_CHILDREN
+   * or nsFrameState(0); passing 0 means that dirty bits won't be set on the
+   * frame or its ancestors/descendants, but that intrinsic widths will still
+   * be marked dirty.  Passing aIntrinsicDirty = eResize and aBitToAdd = 0
+   * would result in no work being done, so don't do that.
+   */
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_IntrinsicDirty {
+        eResize = 0,
+        eTreeChange = 1,
+        eStyleChange = 2,
+    }
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_ReflowRootHandling {
+        ePositionOrSizeChange = 0,
+        eNoPositionOrSizeChange = 1,
+        eInferFromBitToAdd = 2,
+    }
+    pub const nsIPresShell_SCROLL_TOP: root::nsIPresShell__bindgen_ty_1 =
+        nsIPresShell__bindgen_ty_1::SCROLL_TOP;
+    pub const nsIPresShell_SCROLL_BOTTOM: root::nsIPresShell__bindgen_ty_1 =
+        nsIPresShell__bindgen_ty_1::SCROLL_BOTTOM;
+    pub const nsIPresShell_SCROLL_LEFT: root::nsIPresShell__bindgen_ty_1 =
+        nsIPresShell__bindgen_ty_1::SCROLL_TOP;
+    pub const nsIPresShell_SCROLL_RIGHT: root::nsIPresShell__bindgen_ty_1 =
+        nsIPresShell__bindgen_ty_1::SCROLL_BOTTOM;
+    pub const nsIPresShell_SCROLL_CENTER: root::nsIPresShell__bindgen_ty_1 =
+        nsIPresShell__bindgen_ty_1::SCROLL_CENTER;
+    pub const nsIPresShell_SCROLL_MINIMUM: root::nsIPresShell__bindgen_ty_1 =
+        nsIPresShell__bindgen_ty_1::SCROLL_MINIMUM;
+    #[repr(i32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell__bindgen_ty_1 {
+        SCROLL_TOP = 0,
+        SCROLL_BOTTOM = 100,
+        SCROLL_CENTER = 50,
+        SCROLL_MINIMUM = -1,
+    }
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_WhenToScroll {
+        SCROLL_ALWAYS = 0,
+        SCROLL_IF_NOT_VISIBLE = 1,
+        SCROLL_IF_NOT_FULLY_VISIBLE = 2,
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsIPresShell_ScrollAxis {
+        pub _bindgen_opaque_blob: u32,
+    }
+    #[test]
+    fn bindgen_test_layout_nsIPresShell_ScrollAxis() {
+        assert_eq!(::std::mem::size_of::<nsIPresShell_ScrollAxis>() , 4usize ,
+                   concat ! (
+                   "Size of: " , stringify ! ( nsIPresShell_ScrollAxis ) ));
+        assert_eq! (::std::mem::align_of::<nsIPresShell_ScrollAxis>() , 4usize
+                    , concat ! (
+                    "Alignment of " , stringify ! ( nsIPresShell_ScrollAxis )
+                    ));
+    }
+    impl Clone for nsIPresShell_ScrollAxis {
+        fn clone(&self) -> Self { *self }
+    }
+    pub const nsIPresShell_SCROLL_FIRST_ANCESTOR_ONLY:
+              root::nsIPresShell__bindgen_ty_2 =
+        nsIPresShell__bindgen_ty_2::SCROLL_FIRST_ANCESTOR_ONLY;
+    pub const nsIPresShell_SCROLL_OVERFLOW_HIDDEN:
+              root::nsIPresShell__bindgen_ty_2 =
+        nsIPresShell__bindgen_ty_2::SCROLL_OVERFLOW_HIDDEN;
+    pub const nsIPresShell_SCROLL_NO_PARENT_FRAMES:
+              root::nsIPresShell__bindgen_ty_2 =
+        nsIPresShell__bindgen_ty_2::SCROLL_NO_PARENT_FRAMES;
+    pub const nsIPresShell_SCROLL_SMOOTH: root::nsIPresShell__bindgen_ty_2 =
+        nsIPresShell__bindgen_ty_2::SCROLL_SMOOTH;
+    pub const nsIPresShell_SCROLL_SMOOTH_AUTO:
+              root::nsIPresShell__bindgen_ty_2 =
+        nsIPresShell__bindgen_ty_2::SCROLL_SMOOTH_AUTO;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell__bindgen_ty_2 {
+        SCROLL_FIRST_ANCESTOR_ONLY = 1,
+        SCROLL_OVERFLOW_HIDDEN = 2,
+        SCROLL_NO_PARENT_FRAMES = 4,
+        SCROLL_SMOOTH = 8,
+        SCROLL_SMOOTH_AUTO = 16,
+    }
+    pub const nsIPresShell_RENDER_IS_UNTRUSTED:
+              root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_IS_UNTRUSTED;
+    pub const nsIPresShell_RENDER_IGNORE_VIEWPORT_SCROLLING:
+              root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_IGNORE_VIEWPORT_SCROLLING;
+    pub const nsIPresShell_RENDER_CARET: root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_CARET;
+    pub const nsIPresShell_RENDER_USE_WIDGET_LAYERS:
+              root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_USE_WIDGET_LAYERS;
+    pub const nsIPresShell_RENDER_ASYNC_DECODE_IMAGES:
+              root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_ASYNC_DECODE_IMAGES;
+    pub const nsIPresShell_RENDER_DOCUMENT_RELATIVE:
+              root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_DOCUMENT_RELATIVE;
+    pub const nsIPresShell_RENDER_DRAWWINDOW_NOT_FLUSHING:
+              root::nsIPresShell__bindgen_ty_3 =
+        nsIPresShell__bindgen_ty_3::RENDER_DRAWWINDOW_NOT_FLUSHING;
+    #[repr(u32)]
+    /**
+   * Render the document into an arbitrary gfxContext
+   * Designed for getting a picture of a document or a piece of a document
+   * Note that callers will generally want to call FlushPendingNotifications
+   * to get an up-to-date view of the document
+   * @param aRect is the region to capture into the offscreen buffer, in the
+   * root frame's coordinate system (if aIgnoreViewportScrolling is false)
+   * or in the root scrolled frame's coordinate system
+   * (if aIgnoreViewportScrolling is true). The coordinates are in appunits.
+   * @param aFlags see below;
+   *   set RENDER_IS_UNTRUSTED if the contents may be passed to malicious
+   * agents. E.g. we might choose not to paint the contents of sensitive widgets
+   * such as the file name in a file upload widget, and we might choose not
+   * to paint themes.
+   *   set RENDER_IGNORE_VIEWPORT_SCROLLING to ignore
+   * clipping and scrollbar painting due to scrolling in the viewport
+   *   set RENDER_CARET to draw the caret if one would be visible
+   * (by default the caret is never drawn)
+   *   set RENDER_USE_LAYER_MANAGER to force rendering to go through
+   * the layer manager for the window. This may be unexpectedly slow
+   * (if the layer manager must read back data from the GPU) or low-quality
+   * (if the layer manager reads back pixel data and scales it
+   * instead of rendering using the appropriate scaling). It may also
+   * slow everything down if the area rendered does not correspond to the
+   * normal visible area of the window.
+   *   set RENDER_ASYNC_DECODE_IMAGES to avoid having images synchronously
+   * decoded during rendering.
+   * (by default images decode synchronously with RenderDocument)
+   *   set RENDER_DOCUMENT_RELATIVE to render the document as if there has been
+   * no scrolling and interpret |aRect| relative to the document instead of the
+   * CSS viewport. Only considered if RENDER_IGNORE_VIEWPORT_SCROLLING is set
+   * or the document is in ignore viewport scrolling mode
+   * (nsIPresShell::SetIgnoreViewportScrolling/IgnoringViewportScrolling).
+   * @param aBackgroundColor a background color to render onto
+   * @param aRenderedContext the gfxContext to render to. We render so that
+   * one CSS pixel in the source document is rendered to one unit in the current
+   * transform.
+   */
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell__bindgen_ty_3 {
+        RENDER_IS_UNTRUSTED = 1,
+        RENDER_IGNORE_VIEWPORT_SCROLLING = 2,
+        RENDER_CARET = 4,
+        RENDER_USE_WIDGET_LAYERS = 8,
+        RENDER_ASYNC_DECODE_IMAGES = 16,
+        RENDER_DOCUMENT_RELATIVE = 32,
+        RENDER_DRAWWINDOW_NOT_FLUSHING = 64,
+    }
+    pub const nsIPresShell_RENDER_IS_IMAGE: root::nsIPresShell__bindgen_ty_4 =
+        nsIPresShell__bindgen_ty_4::RENDER_IS_IMAGE;
+    pub const nsIPresShell_RENDER_AUTO_SCALE: root::nsIPresShell__bindgen_ty_4
+              =
+        nsIPresShell__bindgen_ty_4::RENDER_AUTO_SCALE;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell__bindgen_ty_4 {
+        RENDER_IS_IMAGE = 256,
+        RENDER_AUTO_SCALE = 128,
+    }
+    pub const nsIPresShell_FORCE_DRAW: root::nsIPresShell__bindgen_ty_5 =
+        nsIPresShell__bindgen_ty_5::FORCE_DRAW;
+    pub const nsIPresShell_ADD_FOR_SUBDOC: root::nsIPresShell__bindgen_ty_5 =
+        nsIPresShell__bindgen_ty_5::ADD_FOR_SUBDOC;
+    pub const nsIPresShell_APPEND_UNSCROLLED_ONLY:
+              root::nsIPresShell__bindgen_ty_5 =
+        nsIPresShell__bindgen_ty_5::APPEND_UNSCROLLED_ONLY;
+    #[repr(u32)]
+    /**
+   * Add a solid color item to the bottom of aList with frame aFrame and bounds
+   * aBounds. Checks first if this needs to be done by checking if aFrame is a
+   * canvas frame (if the FORCE_DRAW flag is passed then this check is skipped).
+   * aBackstopColor is composed behind the background color of the canvas, it is
+   * transparent by default.
+   * We attempt to make the background color part of the scrolled canvas (to reduce
+   * transparent layers), and if async scrolling is enabled (and the background
+   * is opaque) then we add a second, unscrolled item to handle the checkerboarding
+   * case.
+   * ADD_FOR_SUBDOC shoud be specified when calling this for a subdocument, and
+   * LayoutUseContainersForRootFrame might cause the whole list to be scrolled. In
+   * that case the second unscrolled item will be elided.
+   * APPEND_UNSCROLLED_ONLY only attempts to add the unscrolled item, so that we
+   * can add it manually after LayoutUseContainersForRootFrame has built the
+   * scrolling ContainerLayer.
+   */
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell__bindgen_ty_5 {
+        FORCE_DRAW = 1,
+        ADD_FOR_SUBDOC = 2,
+        APPEND_UNSCROLLED_ONLY = 4,
+    }
+    #[repr(C)]
+    pub struct nsIPresShell_PointerCaptureInfo {
+        pub mPendingContent: root::nsCOMPtr<root::nsIContent>,
+        pub mOverrideContent: root::nsCOMPtr<root::nsIContent>,
+    }
+    #[test]
+    fn bindgen_test_layout_nsIPresShell_PointerCaptureInfo() {
+        assert_eq!(::std::mem::size_of::<nsIPresShell_PointerCaptureInfo>() ,
+                   16usize , concat ! (
+                   "Size of: " , stringify ! ( nsIPresShell_PointerCaptureInfo
+                   ) ));
+        assert_eq! (::std::mem::align_of::<nsIPresShell_PointerCaptureInfo>()
+                    , 8usize , concat ! (
+                    "Alignment of " , stringify ! (
+                    nsIPresShell_PointerCaptureInfo ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell_PointerCaptureInfo ) ) .
+                    mPendingContent as * const _ as usize } , 0usize , concat
+                    ! (
+                    "Alignment of field: " , stringify ! (
+                    nsIPresShell_PointerCaptureInfo ) , "::" , stringify ! (
+                    mPendingContent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell_PointerCaptureInfo ) ) .
+                    mOverrideContent as * const _ as usize } , 8usize , concat
+                    ! (
+                    "Alignment of field: " , stringify ! (
+                    nsIPresShell_PointerCaptureInfo ) , "::" , stringify ! (
+                    mOverrideContent ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsIPresShell_PointerInfo {
+        pub mPointerType: u16,
+        pub mActiveState: bool,
+        pub mPrimaryState: bool,
+        pub mPreventMouseEventByContent: bool,
+    }
+    #[test]
+    fn bindgen_test_layout_nsIPresShell_PointerInfo() {
+        assert_eq!(::std::mem::size_of::<nsIPresShell_PointerInfo>() , 6usize
+                   , concat ! (
+                   "Size of: " , stringify ! ( nsIPresShell_PointerInfo ) ));
+        assert_eq! (::std::mem::align_of::<nsIPresShell_PointerInfo>() ,
+                    2usize , concat ! (
+                    "Alignment of " , stringify ! ( nsIPresShell_PointerInfo )
+                    ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
+                    mPointerType as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
+                    mPointerType ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
+                    mActiveState as * const _ as usize } , 2usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
+                    mActiveState ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
+                    mPrimaryState as * const _ as usize } , 3usize , concat !
+                    (
+                    "Alignment of field: " , stringify ! (
+                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
+                    mPrimaryState ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell_PointerInfo ) ) .
+                    mPreventMouseEventByContent as * const _ as usize } ,
+                    4usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsIPresShell_PointerInfo ) , "::" , stringify ! (
+                    mPreventMouseEventByContent ) ));
+    }
+    impl Clone for nsIPresShell_PointerInfo {
+        fn clone(&self) -> Self { *self }
+    }
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_PaintFlags {
+        PAINT_LAYERS = 1,
+        PAINT_COMPOSITE = 2,
+        PAINT_SYNC_DECODE_IMAGES = 4,
+    }
+    #[repr(u32)]
+    /**
+   * Ensures that the refresh driver is running, and schedules a view
+   * manager flush on the next tick.
+   *
+   * @param aType PAINT_DELAYED_COMPRESS : Schedule a paint to be executed after a delay, and
+   * put FrameLayerBuilder in 'compressed' mode that avoids short cut optimizations.
+   */
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsIPresShell_PaintType {
+        PAINT_DEFAULT = 0,
+        PAINT_DELAYED_COMPRESS = 1,
+    }
+    extern "C" {
+        #[link_name = "_ZN12nsIPresShell12gCaptureInfoE"]
+        pub static mut nsIPresShell_gCaptureInfo: root::CapturingContentInfo;
+    }
+    extern "C" {
+        #[link_name = "_ZN12nsIPresShell14gKeyDownTargetE"]
+        pub static mut nsIPresShell_gKeyDownTarget: *mut root::nsIContent;
+    }
+    #[test]
+    fn bindgen_test_layout_nsIPresShell() {
+        assert_eq!(::std::mem::size_of::<nsIPresShell>() , 5456usize , concat
+                   ! ( "Size of: " , stringify ! ( nsIPresShell ) ));
+        assert_eq! (::std::mem::align_of::<nsIPresShell>() , 8usize , concat !
+                    ( "Alignment of " , stringify ! ( nsIPresShell ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mDocument as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mDocument ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mPresContext as *
+                    const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mPresContext ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mStyleSet as *
+                    const _ as usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mStyleSet ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mFrameConstructor
+                    as * const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFrameConstructor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mViewManager as *
+                    const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mViewManager ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mFrameArena as *
+                    const _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFrameArena ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mSelection as *
+                    const _ as usize } , 5240usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mSelection ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mFrameManager as *
+                    const _ as usize } , 5248usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFrameManager ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mForwardingContainer as * const _ as usize } , 5256usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mForwardingContainer ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mDocAccessible as
+                    * const _ as usize } , 5264usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mDocAccessible ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mReflowContinueTimer as * const _ as usize } , 5272usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mReflowContinueTimer ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mDrawEventTargetFrame as * const _ as usize } , 5280usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mDrawEventTargetFrame ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mAllocatedPointers
+                    as * const _ as usize } , 5288usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mAllocatedPointers ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mPaintCount as *
+                    const _ as usize } , 5336usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mPaintCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mScrollPositionClampingScrollPortSize as * const _ as
+                    usize } , 5344usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mScrollPositionClampingScrollPortSize
+                    ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mAutoWeakFrames as
+                    * const _ as usize } , 5352usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mAutoWeakFrames ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mWeakFrames as *
+                    const _ as usize } , 5360usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mWeakFrames ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mCanvasBackgroundColor as * const _ as usize } , 5408usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mCanvasBackgroundColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mResolution as *
+                    const _ as usize } , 5412usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mResolution ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mSelectionFlags as
+                    * const _ as usize } , 5420usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mSelectionFlags ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mRenderFlags as *
+                    const _ as usize } , 5422usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mRenderFlags ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mPresShellId as *
+                    const _ as usize } , 5428usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mPresShellId ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationEmPerLine as * const _ as usize } ,
+                    5432usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFontSizeInflationEmPerLine ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationMinTwips as * const _ as usize } ,
+                    5436usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFontSizeInflationMinTwips ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationLineThreshold as * const _ as usize } ,
+                    5440usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFontSizeInflationLineThreshold ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationForceEnabled as * const _ as usize } ,
+                    5444usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFontSizeInflationForceEnabled ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationDisabledInMasterProcess as * const _ as
+                    usize } , 5445usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! (
+                    mFontSizeInflationDisabledInMasterProcess ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationEnabled as * const _ as usize } ,
+                    5446usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFontSizeInflationEnabled ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) .
+                    mFontSizeInflationEnabledIsDirty as * const _ as usize } ,
+                    5447usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mFontSizeInflationEnabledIsDirty )
+                    ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mPaintingIsFrozen
+                    as * const _ as usize } , 5448usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mPaintingIsFrozen ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mIsNeverPainting
+                    as * const _ as usize } , 5449usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mIsNeverPainting ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsIPresShell ) ) . mInFlush as *
+                    const _ as usize } , 5450usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsIPresShell ) ,
+                    "::" , stringify ! ( mInFlush ) ));
+    }
+    impl nsIPresShell {
+        #[inline]
+        pub fn mDidInitialize(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 1u64 as u16;
+            let val = (unit_field_val & mask) >> 0usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mDidInitialize(&mut self, val: bool) {
+            let mask = 1u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 0usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mIsDestroying(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 2u64 as u16;
+            let val = (unit_field_val & mask) >> 1usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mIsDestroying(&mut self, val: bool) {
+            let mask = 2u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 1usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mIsReflowing(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 4u64 as u16;
+            let val = (unit_field_val & mask) >> 2usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mIsReflowing(&mut self, val: bool) {
+            let mask = 4u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 2usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mPaintingSuppressed(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 8u64 as u16;
+            let val = (unit_field_val & mask) >> 3usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mPaintingSuppressed(&mut self, val: bool) {
+            let mask = 8u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 3usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mIsActive(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 16u64 as u16;
+            let val = (unit_field_val & mask) >> 4usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mIsActive(&mut self, val: bool) {
+            let mask = 16u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 4usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mFrozen(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 32u64 as u16;
+            let val = (unit_field_val & mask) >> 5usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mFrozen(&mut self, val: bool) {
+            let mask = 32u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 5usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mIsFirstPaint(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 64u64 as u16;
+            let val = (unit_field_val & mask) >> 6usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mIsFirstPaint(&mut self, val: bool) {
+            let mask = 64u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 6usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mObservesMutationsForPrint(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 128u64 as u16;
+            let val = (unit_field_val & mask) >> 7usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mObservesMutationsForPrint(&mut self, val: bool) {
+            let mask = 128u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 7usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mSuppressInterruptibleReflows(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 256u64 as u16;
+            let val = (unit_field_val & mask) >> 8usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mSuppressInterruptibleReflows(&mut self, val: bool) {
+            let mask = 256u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 8usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mScrollPositionClampingScrollPortSizeSet(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 512u64 as u16;
+            let val = (unit_field_val & mask) >> 9usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mScrollPositionClampingScrollPortSizeSet(&mut self,
+                                                            val: bool) {
+            let mask = 512u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 9usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mNeedLayoutFlush(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 1024u64 as u16;
+            let val = (unit_field_val & mask) >> 10usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mNeedLayoutFlush(&mut self, val: bool) {
+            let mask = 1024u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 10usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mNeedStyleFlush(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 2048u64 as u16;
+            let val = (unit_field_val & mask) >> 11usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mNeedStyleFlush(&mut self, val: bool) {
+            let mask = 2048u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 11usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mObservingStyleFlushes(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 4096u64 as u16;
+            let val = (unit_field_val & mask) >> 12usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mObservingStyleFlushes(&mut self, val: bool) {
+            let mask = 4096u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 12usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mObservingLayoutFlushes(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 8192u64 as u16;
+            let val = (unit_field_val & mask) >> 13usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mObservingLayoutFlushes(&mut self, val: bool) {
+            let mask = 8192u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 13usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn mNeedThrottledAnimationFlush(&self) -> bool {
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            let mask = 16384u64 as u16;
+            let val = (unit_field_val & mask) >> 14usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mNeedThrottledAnimationFlush(&mut self, val: bool) {
+            let mask = 16384u64 as u16;
+            let val = val as u8 as u16;
+            let mut unit_field_val: u16 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u16 as *mut u8,
+                                                ::std::mem::size_of::<u16>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 14usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u16>());
+            }
+        }
+        #[inline]
+        pub fn new_bitfield_1(mDidInitialize: bool, mIsDestroying: bool,
+                              mIsReflowing: bool, mPaintingSuppressed: bool,
+                              mIsActive: bool, mFrozen: bool,
+                              mIsFirstPaint: bool,
+                              mObservesMutationsForPrint: bool,
+                              mSuppressInterruptibleReflows: bool,
+                              mScrollPositionClampingScrollPortSizeSet: bool,
+                              mNeedLayoutFlush: bool, mNeedStyleFlush: bool,
+                              mObservingStyleFlushes: bool,
+                              mObservingLayoutFlushes: bool,
+                              mNeedThrottledAnimationFlush: bool) -> u16 {
+            ({
+                 ({
+                      ({
+                           ({
+                                ({
+                                     ({
+                                          ({
+                                               ({
+                                                    ({
+                                                         ({
+                                                              ({
+                                                                   ({
+                                                                        ({
+                                                                             ({
+                                                                                  ({
+                                                                                       0
+                                                                                   }
+                                                                                       |
+                                                                                       ((mDidInitialize
+                                                                                             as
+                                                                                             u8
+                                                                                             as
+                                                                                             u16)
+                                                                                            <<
+                                                                                            0usize)
+                                                                                           &
+                                                                                           (1u64
+                                                                                                as
+                                                                                                u16))
+                                                                              }
+                                                                                  |
+                                                                                  ((mIsDestroying
+                                                                                        as
+                                                                                        u8
+                                                                                        as
+                                                                                        u16)
+                                                                                       <<
+                                                                                       1usize)
+                                                                                      &
+                                                                                      (2u64
+                                                                                           as
+                                                                                           u16))
+                                                                         } |
+                                                                             ((mIsReflowing
+                                                                                   as
+                                                                                   u8
+                                                                                   as
+                                                                                   u16)
+                                                                                  <<
+                                                                                  2usize)
+                                                                                 &
+                                                                                 (4u64
+                                                                                      as
+                                                                                      u16))
+                                                                    } |
+                                                                        ((mPaintingSuppressed
+                                                                              as
+                                                                              u8
+                                                                              as
+                                                                              u16)
+                                                                             <<
+                                                                             3usize)
+                                                                            &
+                                                                            (8u64
+                                                                                 as
+                                                                                 u16))
+                                                               } |
+                                                                   ((mIsActive
+                                                                         as u8
+                                                                         as
+                                                                         u16)
+                                                                        <<
+                                                                        4usize)
+                                                                       &
+                                                                       (16u64
+                                                                            as
+                                                                            u16))
+                                                          } |
+                                                              ((mFrozen as u8
+                                                                    as u16) <<
+                                                                   5usize) &
+                                                                  (32u64 as
+                                                                       u16))
+                                                     } |
+                                                         ((mIsFirstPaint as u8
+                                                               as u16) <<
+                                                              6usize) &
+                                                             (64u64 as u16))
+                                                } |
+                                                    ((mObservesMutationsForPrint
+                                                          as u8 as u16) <<
+                                                         7usize) &
+                                                        (128u64 as u16))
+                                           } |
+                                               ((mSuppressInterruptibleReflows
+                                                     as u8 as u16) << 8usize)
+                                                   & (256u64 as u16))
+                                      } |
+                                          ((mScrollPositionClampingScrollPortSizeSet
+                                                as u8 as u16) << 9usize) &
+                                              (512u64 as u16))
+                                 } |
+                                     ((mNeedLayoutFlush as u8 as u16) <<
+                                          10usize) & (1024u64 as u16))
+                            } |
+                                ((mNeedStyleFlush as u8 as u16) << 11usize) &
+                                    (2048u64 as u16))
+                       } |
+                           ((mObservingStyleFlushes as u8 as u16) << 12usize)
+                               & (4096u64 as u16))
+                  } |
+                      ((mObservingLayoutFlushes as u8 as u16) << 13usize) &
+                          (8192u64 as u16))
+             } |
+                 ((mNeedThrottledAnimationFlush as u8 as u16) << 14usize) &
+                     (16384u64 as u16))
+        }
+    }
+    /**
  * A class that implements nsIWeakReference
  */
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsNodeWeakReference {
         pub _base: root::nsIWeakReference,
         pub mRefCnt: root::nsAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
@@ -30045,67 +29791,72 @@ 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_85 =
-        _bindgen_ty_85::NODE_HAS_LISTENERMANAGER;
-    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_PROPERTIES;
-    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_ANONYMOUS_ROOT;
-    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
-    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_NATIVE_ANONYMOUS_ROOT;
-    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_FORCE_XBL_BINDINGS;
-    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_MAY_BE_IN_BINDING_MNGR;
-    pub const NODE_IS_EDITABLE: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_EDITABLE;
-    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_NATIVE_ANONYMOUS;
-    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_IN_SHADOW_TREE;
-    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_EMPTY_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_SLOW_SELECTOR;
-    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_EDGE_CHILD_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
-    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_ALL_SELECTOR_FLAGS;
-    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_NEEDS_FRAME;
-    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_DESCENDANTS_NEED_FRAMES;
-    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_ACCESSKEY;
-    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_DIRECTION_RTL;
-    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_HAS_DIRECTION_LTR;
-    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_ALL_DIRECTION_FLAGS;
-    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_CHROME_ONLY_ACCESS;
-    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
-    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_85 =
-        _bindgen_ty_85::NODE_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_85 {
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct nsRange {
+        _unused: [u8; 0],
+    }
+    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,
@@ -30522,16 +30273,17 @@ pub mod root {
                     mIsDestroyingFrames as * const _ as usize } , 32usize ,
                     concat ! (
                     "Alignment of field: " , stringify ! ( nsFrameManagerBase
                     ) , "::" , stringify ! ( mIsDestroyingFrames ) ));
     }
     impl Clone for nsFrameManagerBase {
         fn clone(&self) -> Self { *self }
     }
+    pub type nsIntRect = root::mozilla::gfx::IntRect;
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsIWeakReference {
         pub _base: root::nsISupports,
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIWeakReference_COMTypeInfo {
@@ -31033,16 +30785,116 @@ pub mod root {
         NS_STATE_EQUAL_SIZE = 1073741824,
         NS_STATE_IS_DIRECTION_NORMAL = 2147483648,
         NS_FRAME_MOUSE_THROUGH_ALWAYS = 1152921504606846976,
         NS_FRAME_MOUSE_THROUGH_NEVER = 2305843009213693952,
         TEXT_NO_RENDERED_GLYPHS = 4611686018427387904,
         TEXT_IN_OFFSET_CACHE = 9223372036854775808,
     }
     #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct pixman_region32_data {
+        pub size: ::std::os::raw::c_long,
+        pub numRects: ::std::os::raw::c_long,
+    }
+    #[test]
+    fn bindgen_test_layout_pixman_region32_data() {
+        assert_eq!(::std::mem::size_of::<pixman_region32_data>() , 16usize ,
+                   concat ! (
+                   "Size of: " , stringify ! ( pixman_region32_data ) ));
+        assert_eq! (::std::mem::align_of::<pixman_region32_data>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( pixman_region32_data ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_region32_data ) ) . size as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    pixman_region32_data ) , "::" , stringify ! ( size ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_region32_data ) ) . numRects
+                    as * const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    pixman_region32_data ) , "::" , stringify ! ( numRects )
+                    ));
+    }
+    impl Clone for pixman_region32_data {
+        fn clone(&self) -> Self { *self }
+    }
+    pub type pixman_region32_data_t = root::pixman_region32_data;
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct pixman_box32 {
+        pub x1: i32,
+        pub y1: i32,
+        pub x2: i32,
+        pub y2: i32,
+    }
+    #[test]
+    fn bindgen_test_layout_pixman_box32() {
+        assert_eq!(::std::mem::size_of::<pixman_box32>() , 16usize , concat !
+                   ( "Size of: " , stringify ! ( pixman_box32 ) ));
+        assert_eq! (::std::mem::align_of::<pixman_box32>() , 4usize , concat !
+                    ( "Alignment of " , stringify ! ( pixman_box32 ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_box32 ) ) . x1 as * const _ as
+                    usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
+                    "::" , stringify ! ( x1 ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_box32 ) ) . y1 as * const _ as
+                    usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
+                    "::" , stringify ! ( y1 ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_box32 ) ) . x2 as * const _ as
+                    usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
+                    "::" , stringify ! ( x2 ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_box32 ) ) . y2 as * const _ as
+                    usize } , 12usize , concat ! (
+                    "Alignment of field: " , stringify ! ( pixman_box32 ) ,
+                    "::" , stringify ! ( y2 ) ));
+    }
+    impl Clone for pixman_box32 {
+        fn clone(&self) -> Self { *self }
+    }
+    pub type pixman_box32_t = root::pixman_box32;
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct pixman_region32 {
+        pub extents: root::pixman_box32_t,
+        pub data: *mut root::pixman_region32_data_t,
+    }
+    #[test]
+    fn bindgen_test_layout_pixman_region32() {
+        assert_eq!(::std::mem::size_of::<pixman_region32>() , 24usize , concat
+                   ! ( "Size of: " , stringify ! ( pixman_region32 ) ));
+        assert_eq! (::std::mem::align_of::<pixman_region32>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( pixman_region32 ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_region32 ) ) . extents as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( pixman_region32 ) ,
+                    "::" , stringify ! ( extents ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const pixman_region32 ) ) . data as * const
+                    _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( pixman_region32 ) ,
+                    "::" , stringify ! ( data ) ));
+    }
+    impl Clone for pixman_region32 {
+        fn clone(&self) -> Self { *self }
+    }
+    pub type pixman_region32_t = root::pixman_region32;
+    #[repr(i32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum VisitSide { TOP = 0, BOTTOM = 1, LEFT = 2, RIGHT = 3, }
+    #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct gfxContext {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsDocShell {
         _unused: [u8; 0],
@@ -32370,21 +32222,16 @@ pub mod root {
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIStructuredCloneContainer {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
-    pub struct nsRange {
-        _unused: [u8; 0],
-    }
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
     pub struct nsSMILAnimationController {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsSVGElement {
         _unused: [u8; 0],
     }
@@ -35087,24 +34934,23 @@ pub mod root {
         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 mListener: *mut root::imgINotificationObserver,
         pub mLoadGroup: root::nsCOMPtr<root::nsILoadGroup>,
+        pub mTabGroup: root::RefPtr<root::mozilla::dom::TabGroup>,
+        pub mEventTarget: root::nsCOMPtr<root::nsIEventTarget>,
         pub mLoadFlags: root::nsLoadFlags,
         pub mLockCount: u32,
         pub mAnimationConsumers: u32,
-        pub mCanceled: bool,
-        pub mIsInLoadGroup: bool,
-        pub mListenerIsStrongRef: bool,
-        pub mDecodeRequested: bool,
-        pub mDeferNotifications: bool,
+        pub _bitfield_1: u8,
+        pub __bindgen_padding_0: [u8; 3usize],
     }
     pub type imgRequestProxy_Image = root::mozilla::image::Image;
     pub type imgRequestProxy_ImageURL = root::mozilla::image::ImageURL;
     pub type imgRequestProxy_ProgressTracker =
         root::mozilla::image::ProgressTracker;
     pub type imgRequestProxy_HasThreadSafeRefCnt = root::mozilla::FalseType;
     #[repr(C)]
     #[derive(Debug)]
@@ -35133,23 +34979,321 @@ pub mod root {
                     & ( * ( 0 as * const imgRequestProxy_imgCancelRunnable ) )
                     . mStatus as * const _ as usize } , 48usize , concat ! (
                     "Alignment of field: " , stringify ! (
                     imgRequestProxy_imgCancelRunnable ) , "::" , stringify ! (
                     mStatus ) ));
     }
     #[test]
     fn bindgen_test_layout_imgRequestProxy() {
-        assert_eq!(::std::mem::size_of::<imgRequestProxy>() , 120usize ,
+        assert_eq!(::std::mem::size_of::<imgRequestProxy>() , 128usize ,
                    concat ! ( "Size of: " , stringify ! ( imgRequestProxy )
                    ));
         assert_eq! (::std::mem::align_of::<imgRequestProxy>() , 8usize ,
                     concat ! (
                     "Alignment of " , stringify ! ( imgRequestProxy ) ));
     }
+    impl imgRequestProxy {
+        #[inline]
+        pub fn mCanceled(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 1u64 as u8;
+            let val = (unit_field_val & mask) >> 0usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mCanceled(&mut self, val: bool) {
+            let mask = 1u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 0usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn mIsInLoadGroup(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 2u64 as u8;
+            let val = (unit_field_val & mask) >> 1usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mIsInLoadGroup(&mut self, val: bool) {
+            let mask = 2u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 1usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn mListenerIsStrongRef(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 4u64 as u8;
+            let val = (unit_field_val & mask) >> 2usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mListenerIsStrongRef(&mut self, val: bool) {
+            let mask = 4u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 2usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn mDecodeRequested(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 8u64 as u8;
+            let val = (unit_field_val & mask) >> 3usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mDecodeRequested(&mut self, val: bool) {
+            let mask = 8u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 3usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn mDeferNotifications(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 16u64 as u8;
+            let val = (unit_field_val & mask) >> 4usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mDeferNotifications(&mut self, val: bool) {
+            let mask = 16u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 4usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn mHadListener(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 32u64 as u8;
+            let val = (unit_field_val & mask) >> 5usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mHadListener(&mut self, val: bool) {
+            let mask = 32u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 5usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn mHadDispatch(&self) -> bool {
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            let mask = 64u64 as u8;
+            let val = (unit_field_val & mask) >> 6usize;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mHadDispatch(&mut self, val: bool) {
+            let mask = 64u64 as u8;
+            let val = val as u8 as u8;
+            let mut unit_field_val: u8 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as *mut u8
+                                                    as *mut u8,
+                                                ::std::mem::size_of::<u8>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 6usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u8>());
+            }
+        }
+        #[inline]
+        pub fn new_bitfield_1(mCanceled: bool, mIsInLoadGroup: bool,
+                              mListenerIsStrongRef: bool,
+                              mDecodeRequested: bool,
+                              mDeferNotifications: bool, mHadListener: bool,
+                              mHadDispatch: bool) -> u8 {
+            ({
+                 ({
+                      ({
+                           ({
+                                ({
+                                     ({
+                                          ({ 0 } |
+                                               ((mCanceled as u8 as u8) <<
+                                                    0usize) & (1u64 as u8))
+                                      } |
+                                          ((mIsInLoadGroup as u8 as u8) <<
+                                               1usize) & (2u64 as u8))
+                                 } |
+                                     ((mListenerIsStrongRef as u8 as u8) <<
+                                          2usize) & (4u64 as u8))
+                            } |
+                                ((mDecodeRequested as u8 as u8) << 3usize) &
+                                    (8u64 as u8))
+                       } |
+                           ((mDeferNotifications as u8 as u8) << 4usize) &
+                               (16u64 as u8))
+                  } | ((mHadListener as u8 as u8) << 5usize) & (32u64 as u8))
+             } | ((mHadDispatch as u8 as u8) << 6usize) & (64u64 as u8))
+        }
+    }
     #[repr(u32)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
     pub enum nsCSSUnit {
         eCSSUnit_Null = 0,
         eCSSUnit_Auto = 1,
         eCSSUnit_Inherit = 2,
         eCSSUnit_Initial = 3,
         eCSSUnit_Unset = 4,
@@ -39344,56 +39488,56 @@ 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_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_87 =
-        _bindgen_ty_87::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_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_87
-              =
-        _bindgen_ty_87::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_87 =
-        _bindgen_ty_87::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
-    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_PENDING_RESTYLE_FLAGS;
-    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
-    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_ALL_RESTYLE_FLAGS;
-    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_87 =
-        _bindgen_ty_87::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_87 {
+              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_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,
@@ -40036,1586 +40180,1680 @@ 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_90() {
+    fn __bindgen_test_layout_IntegralConstant_instantiation_82() {
         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_91() {
+    fn __bindgen_test_layout_IntegralConstant_instantiation_83() {
         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_nsCharTraits_instantiation_92() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_84() {
         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_nsReadingIterator_instantiation_93() {
+    fn __bindgen_test_layout_nsReadingIterator_instantiation_85() {
         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_94() {
+    fn __bindgen_test_layout_nsWritingIterator_instantiation_86() {
         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_nsCharTraits_instantiation_95() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_87() {
         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_nsReadingIterator_instantiation_96() {
+    fn __bindgen_test_layout_nsReadingIterator_instantiation_88() {
         assert_eq!(::std::mem::size_of::<root::nsReadingIterator<::std::os::raw::c_char>>()
                    , 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_97() {
+    fn __bindgen_test_layout_nsWritingIterator_instantiation_89() {
         assert_eq!(::std::mem::size_of::<root::nsWritingIterator<::std::os::raw::c_char>>()
                    , 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_nsCharTraits_instantiation_98() {
+    fn __bindgen_test_layout_nsCharTraits_instantiation_90() {
+        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_91() {
         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_99() {
-        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__bindgen_ty_id_221270_instantiation_100() {
+    fn __bindgen_test_layout__bindgen_ty_id_196644_instantiation_92() {
         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__bindgen_ty_id_221306_instantiation_101() {
+    fn __bindgen_test_layout__bindgen_ty_id_196680_instantiation_93() {
         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_nsTArray_instantiation_102() {
+    fn __bindgen_test_layout_nsTArray_instantiation_94() {
         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_103() {
+    fn __bindgen_test_layout_Handle_instantiation_95() {
         assert_eq!(::std::mem::size_of::<root::JS::Handle<root::jsid>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Handle<root::jsid> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Handle<root::jsid>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Handle<root::jsid> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Handle_instantiation_104() {
+    fn __bindgen_test_layout_Handle_instantiation_96() {
         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_105() {
+    fn __bindgen_test_layout_Handle_instantiation_97() {
         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_106() {
+    fn __bindgen_test_layout_MutableHandle_instantiation_98() {
         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_107() {
+    fn __bindgen_test_layout_Rooted_instantiation_99() {
         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_108() {
+    fn __bindgen_test_layout_DeletePolicy_instantiation_100() {
         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_101() {
+        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_102() {
+        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_103() {
+        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_nsTArray_instantiation_104() {
+        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_already_AddRefed_instantiation_105() {
+        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_already_AddRefed_instantiation_106() {
+        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_nsCOMPtr_instantiation_107() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIAtom>>() ,
+                   8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIAtom> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIAtom>>() ,
+                   8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIAtom> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_BaseTimeDuration_instantiation_108() {
+        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_109() {
         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_110() {
-        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_111() {
-        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_nsTArray_instantiation_112() {
-        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_PointTyped_instantiation_113() {
-        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_114() {
-        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_115() {
-        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_116() {
-        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_117() {
-        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_118() {
-        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_119() {
-        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_120() {
-        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_121() {
-        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_122() {
-        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_123() {
-        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_124() {
-        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_125() {
-        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_126() {
-        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_BaseTimeDuration_instantiation_127() {
-        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_already_AddRefed_instantiation_128() {
-        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_already_AddRefed_instantiation_129() {
-        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_RefPtr_instantiation_130() {
+    fn __bindgen_test_layout_TErrorResult_instantiation_110() {
+        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_111() {
+        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_112() {
+        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_Handle_instantiation_113() {
+        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_MutableHandle_instantiation_114() {
+        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_Handle_instantiation_115() {
+        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_nsTArray_instantiation_116() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_Handle_instantiation_117() {
+        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_RefPtr_instantiation_118() {
         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_nsTArray_instantiation_131() {
-        assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
-                   ));
-        assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
-                   ));
-    }
-    #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_132() {
-        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_nsTArray_instantiation_133() {
-        assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
-                   ));
-        assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
-                   ));
-    }
-    #[test]
-    fn __bindgen_test_layout_WeakPtr_instantiation_134() {
-        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_nsPtrHashKey_instantiation_135() {
-        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_136() {
-        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_already_AddRefed_instantiation_137() {
-        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_already_AddRefed_instantiation_138() {
+    fn __bindgen_test_layout_Handle_instantiation_119() {
+        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_120() {
+        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_DefaultDelete_instantiation_121() {
+        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_122() {
+        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_123() {
         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_nsCOMPtr_instantiation_139() {
-        assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIAtom>>() ,
-                   8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsCOMPtr<root::nsIAtom> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIAtom>>() ,
-                   8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsCOMPtr<root::nsIAtom> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_140() {
-        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_TErrorResult_instantiation_141() {
-        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_142() {
-        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_143() {
-        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_Handle_instantiation_144() {
-        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_MutableHandle_instantiation_145() {
+    fn __bindgen_test_layout_already_AddRefed_instantiation_124() {
+        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_Handle_instantiation_125() {
+        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_126() {
+        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_MutableHandle_instantiation_127() {
         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_DefaultDelete_instantiation_128() {
+        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_129() {
+        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_DeletePolicy_instantiation_130() {
+        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_131() {
+        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_DeletePolicy_instantiation_132() {
+        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_133() {
+        assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::JSErrorNotes>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::mozilla::UniquePtr<root::JSErrorNotes> ) ));
+        assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::JSErrorNotes>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::mozilla::UniquePtr<root::JSErrorNotes> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_DeletePolicy_instantiation_134() {
+        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_135() {
+        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_DeletePolicy_instantiation_136() {
+        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_137() {
+        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_DeletePolicy_instantiation_138() {
+        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_139() {
+        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_140() {
+        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_DeletePolicy_instantiation_141() {
+        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_142() {
+        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_DeletePolicy_instantiation_143() {
+        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_144() {
+        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_nsCOMPtr_instantiation_145() {
+        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_Handle_instantiation_146() {
-        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_nsTArray_instantiation_147() {
-        assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
-        assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_Handle_instantiation_148() {
-        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_RefPtr_instantiation_149() {
-        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_Handle_instantiation_150() {
-        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_151() {
-        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_already_AddRefed_instantiation_152() {
-        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> ) ));
+        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_147() {
+        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_nsTArray_instantiation_148() {
+        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_nsTArray_instantiation_149() {
+        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_Heap_instantiation_150() {
+        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_Heap_instantiation_151() {
+        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_TenuredHeap_instantiation_152() {
+        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_already_AddRefed_instantiation_153() {
         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_154() {
-        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_Handle_instantiation_155() {
-        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_156() {
-        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_MutableHandle_instantiation_157() {
-        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_DeletePolicy_instantiation_158() {
-        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_159() {
-        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_DeletePolicy_instantiation_160() {
-        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_161() {
-        assert_eq!(::std::mem::size_of::<root::mozilla::UniquePtr<root::JSErrorNotes>>()
-                   , 8usize , concat ! (
-                   "Size of template specialization: " , stringify ! (
-                   root::mozilla::UniquePtr<root::JSErrorNotes> ) ));
-        assert_eq!(::std::mem::align_of::<root::mozilla::UniquePtr<root::JSErrorNotes>>()
-                   , 8usize , concat ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::mozilla::UniquePtr<root::JSErrorNotes> ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_DeletePolicy_instantiation_162() {
-        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_163() {
-        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_DeletePolicy_instantiation_164() {
-        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_165() {
-        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_DeletePolicy_instantiation_166() {
-        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_167() {
-        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_168() {
-        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_DeletePolicy_instantiation_169() {
-        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_170() {
-        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_DeletePolicy_instantiation_171() {
-        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_172() {
-        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_nsCOMPtr_instantiation_173() {
-        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_Handle_instantiation_174() {
-        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_175() {
-        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_nsTArray_instantiation_176() {
-        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_nsTArray_instantiation_177() {
-        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_Heap_instantiation_178() {
-        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_Heap_instantiation_179() {
-        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_TenuredHeap_instantiation_180() {
-        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_already_AddRefed_instantiation_181() {
-        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_NotNull_instantiation_182() {
+    fn __bindgen_test_layout_NotNull_instantiation_154() {
         assert_eq!(::std::mem::size_of::<root::mozilla::NotNull<*const root::mozilla::Encoding>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::NotNull<*const root::mozilla::Encoding> )
                    ));
         assert_eq!(::std::mem::align_of::<root::mozilla::NotNull<*const root::mozilla::Encoding>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::NotNull<*const root::mozilla::Encoding> )
                    ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_instantiation_183() {
+    fn __bindgen_test_layout_nsTArray_instantiation_155() {
         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_RefPtr_instantiation_184() {
+    fn __bindgen_test_layout_RefPtr_instantiation_156() {
         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_nsTArray_instantiation_185() {
+    fn __bindgen_test_layout_nsTArray_instantiation_157() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
+                   ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
+                   ));
+    }
+    #[test]
+    fn __bindgen_test_layout_RefPtr_instantiation_158() {
+        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_nsTArray_instantiation_159() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
                    ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::StyleSheet>> )
                    ));
     }
     #[test]
-    fn __bindgen_test_layout_RefPtr_instantiation_186() {
+    fn __bindgen_test_layout_nsTArray_instantiation_160() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<*mut root::mozilla::dom::Element> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<*mut root::mozilla::dom::Element> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_RefPtr_instantiation_161() {
+        assert_eq!(::std::mem::size_of::<root::RefPtr<root::mozilla::dom::Element>>()
+