servo: Merge #17767 - stylo: Fuse ServoStyleContext and ServoComputedValues (from Manishearth:stylo-fuse); r=bholley
authorManish Goregaokar <manishsmail@gmail.com>
Mon, 17 Jul 2017 19:44:25 -0700
changeset 420413 2d5674f3b7422923f86e6df93fb7d8ef999a5f36
parent 420412 e4d9cb334352a1209d84f603ece6684e41313ae9
child 420414 550a24fe481217d165e9e1b8b5b3c076031d9a7f
push id1517
push userjlorenzo@mozilla.com
push dateThu, 14 Sep 2017 16:50:54 +0000
treeherdermozilla-release@3b41fd564418 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbholley
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 #17767 - stylo: Fuse ServoStyleContext and ServoComputedValues (from Manishearth:stylo-fuse); r=bholley r=bholley https://bugzilla.mozilla.org/show_bug.cgi?id=1367904 Source-Repo: https://github.com/servo/servo Source-Revision: d746abaa9e69e6cf0ad187d2b46be661bbe03a9f
servo/components/layout/block.rs
servo/components/layout/construct.rs
servo/components/layout/display_list_builder.rs
servo/components/layout/flex.rs
servo/components/layout/flow.rs
servo/components/layout/fragment.rs
servo/components/layout/generated_content.rs
servo/components/layout/inline.rs
servo/components/layout/list_item.rs
servo/components/layout/model.rs
servo/components/layout/multicol.rs
servo/components/layout/table.rs
servo/components/layout/table_caption.rs
servo/components/layout/table_cell.rs
servo/components/layout/table_colgroup.rs
servo/components/layout/table_row.rs
servo/components/layout/table_rowgroup.rs
servo/components/layout/table_wrapper.rs
servo/components/layout/text.rs
servo/components/layout_thread/dom_wrapper.rs
servo/components/script/dom/cssrulelist.rs
servo/components/script_layout_interface/wrapper_traits.rs
servo/components/servo_arc/lib.rs
servo/components/style/animation.rs
servo/components/style/dom.rs
servo/components/style/gecko/arc_types.rs
servo/components/style/gecko/data.rs
servo/components/style/gecko/generated/bindings.rs
servo/components/style/gecko/generated/pseudo_element_definition.rs
servo/components/style/gecko/generated/structs_debug.rs
servo/components/style/gecko/generated/structs_release.rs
servo/components/style/gecko/media_queries.rs
servo/components/style/gecko/pseudo_element_definition.mako.rs
servo/components/style/gecko/restyle_damage.rs
servo/components/style/gecko/wrapper.rs
servo/components/style/gecko_bindings/sugar/ownership.rs
servo/components/style/gecko_bindings/sugar/refptr.rs
servo/components/style/matching.rs
servo/components/style/properties/declaration_block.rs
servo/components/style/properties/gecko.mako.rs
servo/components/style/properties/helpers.mako.rs
servo/components/style/properties/helpers/animated_properties.mako.rs
servo/components/style/properties/longhand/box.mako.rs
servo/components/style/properties/longhand/text.mako.rs
servo/components/style/properties/properties.mako.rs
servo/components/style/rule_tree/mod.rs
servo/components/style/selector_parser.rs
servo/components/style/servo/media_queries.rs
servo/components/style/servo/restyle_damage.rs
servo/components/style/servo/selector_parser.rs
servo/components/style/sharing/checks.rs
servo/components/style/style_adjuster.rs
servo/components/style/style_resolver.rs
servo/components/style/stylesheets/rule_list.rs
servo/components/style/stylist.rs
servo/components/style/traversal.rs
servo/components/style/values/computed/mod.rs
servo/ports/geckolib/glue.rs
servo/tests/unit/style/parsing/mod.rs
--- a/servo/components/layout/block.rs
+++ b/servo/components/layout/block.rs
@@ -51,17 +51,17 @@ use serde::{Serialize, Serializer};
 use servo_geometry::max_rect;
 use std::cmp::{max, min};
 use std::fmt;
 use std::sync::Arc;
 use style::computed_values::{border_collapse, box_sizing, display, float, overflow_x};
 use style::computed_values::{position, text_align};
 use style::context::SharedStyleContext;
 use style::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::servo::restyle_damage::{BUBBLE_ISIZES, REFLOW, REFLOW_OUT_OF_FLOW, REPOSITION};
 use style::values::computed::{LengthOrPercentageOrNone, LengthOrPercentage};
 use style::values::computed::LengthOrPercentageOrAuto;
 
 /// Information specific to floated blocks.
 #[derive(Clone, Serialize)]
 pub struct FloatedBlockInfo {
     /// The amount of inline size that is available for the float.
@@ -2134,17 +2134,17 @@ impl Flow for BlockFlow {
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.collect_stacking_contexts_for_block(state);
     }
 
     fn build_display_list(&mut self, state: &mut DisplayListBuildState) {
         self.build_display_list_for_block(state, BorderPaintingMode::Separate);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.fragment.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         let flow_size = self.base.position.size.to_physical(self.base.writing_mode);
         let overflow = self.fragment.compute_overflow(&flow_size,
                                        &self.base
                                             .early_absolute_position_info
--- a/servo/components/layout/construct.rs
+++ b/servo/components/layout/construct.rs
@@ -47,17 +47,17 @@ use std::marker::PhantomData;
 use std::mem;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use style::computed_values::{caption_side, display, empty_cells, float, list_style_position};
 use style::computed_values::content::ContentItem;
 use style::computed_values::position;
 use style::context::SharedStyleContext;
 use style::logical_geometry::Direction;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::properties::longhands::list_style_image;
 use style::selector_parser::{PseudoElement, RestyleDamage};
 use style::servo::restyle_damage::{BUBBLE_ISIZES, RECONSTRUCT_FLOW};
 use style::values::Either;
 use table::TableFlow;
 use table_caption::TableCaptionFlow;
 use table_cell::TableCellFlow;
 use table_colgroup::TableColGroupFlow;
@@ -104,17 +104,17 @@ impl ConstructionResult {
 /// Represents the output of flow construction for a DOM node that has not yet resulted in a
 /// complete flow. Construction items bubble up the tree until they find a `Flow` to be attached
 /// to.
 #[derive(Clone)]
 pub enum ConstructionItem {
     /// Inline fragments and associated {ib} splits that have not yet found flows.
     InlineFragments(InlineFragmentsConstructionResult),
     /// Potentially ignorable whitespace.
-    Whitespace(OpaqueNode, PseudoElementType<()>, StyleArc<ServoComputedValues>, RestyleDamage),
+    Whitespace(OpaqueNode, PseudoElementType<()>, StyleArc<ComputedValues>, RestyleDamage),
     /// TableColumn Fragment
     TableColumnFragment(Fragment),
 }
 
 /// Represents inline fragments and {ib} splits that are bubbling up from an inline.
 #[derive(Clone)]
 pub struct InlineFragmentsConstructionResult {
     /// Any {ib} splits that we're bubbling up.
@@ -672,17 +672,17 @@ impl<'a, ConcreteThreadSafeLayoutNode: T
         }
         self.build_flow_for_block_starting_with_fragments(flow, node, fragments)
     }
 
     /// Pushes fragments appropriate for the content of the given node onto the given list.
     fn create_fragments_for_node_text_content(&self,
                                               fragments: &mut IntermediateInlineFragments,
                                               node: &ConcreteThreadSafeLayoutNode,
-                                              style: &StyleArc<ServoComputedValues>) {
+                                              style: &StyleArc<ComputedValues>) {
         // Fast path: If there is no text content, return immediately.
         let text_content = node.text_content();
         if text_content.is_empty() {
             return
         }
 
         let style = (*style).clone();
         let selected_style = node.selected_style();
@@ -1801,17 +1801,17 @@ pub fn strip_ignorable_whitespace_from_e
             }
         }
     }
     this.append(&mut trailing_fragments_consisting_of_solely_bidi_control_characters);
 }
 
 /// If the 'unicode-bidi' property has a value other than 'normal', return the bidi control codes
 /// to inject before and after the text content of the element.
-fn bidi_control_chars(style: &StyleArc<ServoComputedValues>) -> Option<(&'static str, &'static str)> {
+fn bidi_control_chars(style: &StyleArc<ComputedValues>) -> Option<(&'static str, &'static str)> {
     use style::computed_values::direction::T::*;
     use style::computed_values::unicode_bidi::T::*;
 
     let unicode_bidi = style.get_text().unicode_bidi;
     let direction = style.get_inheritedbox().direction;
 
     // See the table in http://dev.w3.org/csswg/css-writing-modes/#unicode-bidi
     match (unicode_bidi, direction) {
@@ -1846,17 +1846,17 @@ fn control_chars_to_fragment(node: &Inli
 }
 
 /// Convenience methods for computed CSS values
 trait ComputedValueUtils {
     /// Returns true if this node has non-zero padding or border.
     fn has_padding_or_border(&self) -> bool;
 }
 
-impl ComputedValueUtils for ServoComputedValues {
+impl ComputedValueUtils for ComputedValues {
     fn has_padding_or_border(&self) -> bool {
         let padding = self.get_padding();
         let border = self.get_border();
 
         !padding.padding_top.is_definitely_zero() ||
            !padding.padding_right.is_definitely_zero() ||
            !padding.padding_bottom.is_definitely_zero() ||
            !padding.padding_left.is_definitely_zero() ||
--- a/servo/components/layout/display_list_builder.rs
+++ b/servo/components/layout/display_list_builder.rs
@@ -46,17 +46,17 @@ use std::{cmp, f32};
 use std::collections::HashMap;
 use std::default::Default;
 use std::mem;
 use std::sync::Arc;
 use style::computed_values::{background_attachment, background_clip, background_origin};
 use style::computed_values::{background_repeat, border_style, cursor};
 use style::computed_values::{image_rendering, overflow_x, pointer_events, position, visibility};
 use style::logical_geometry::{LogicalPoint, LogicalRect, LogicalSize, WritingMode};
-use style::properties::{self, ServoComputedValues};
+use style::properties::{self, ComputedValues};
 use style::properties::longhands::border_image_repeat::computed_value::RepeatKeyword;
 use style::properties::style_structs;
 use style::servo::restyle_damage::REPAINT;
 use style::values::{Either, RGBA};
 use style::values::computed::{Angle, Gradient, GradientItem, LengthOrPercentage, Percentage};
 use style::values::computed::{LengthOrPercentageOrAuto, NumberOrPercentage, Position};
 use style::values::computed::effects::SimpleShadow;
 use style::values::computed::image::{EndingShape, LineDirection};
@@ -370,55 +370,55 @@ pub enum IdType {
     CSSClip,
 }
 
 pub trait FragmentDisplayListBuilding {
     /// Adds the display items necessary to paint the background of this fragment to the display
     /// list if necessary.
     fn build_display_list_for_background_if_applicable(&self,
                                                        state: &mut DisplayListBuildState,
-                                                       style: &ServoComputedValues,
+                                                       style: &ComputedValues,
                                                        display_list_section: DisplayListSection,
                                                        absolute_bounds: &Rect<Au>);
 
     /// Computes the background size for an image with the given background area according to the
     /// rules in CSS-BACKGROUNDS § 3.9.
     fn compute_background_image_size(&self,
-                                     style: &ServoComputedValues,
+                                     style: &ComputedValues,
                                      bounds: &Rect<Au>,
                                      image: &WebRenderImageInfo, index: usize)
                                      -> Size2D<Au>;
 
     /// Adds the display items necessary to paint the background image of this fragment to the
     /// appropriate section of the display list.
     fn build_display_list_for_background_image(&self,
                                                state: &mut DisplayListBuildState,
-                                               style: &ServoComputedValues,
+                                               style: &ComputedValues,
                                                display_list_section: DisplayListSection,
                                                absolute_bounds: &Rect<Au>,
                                                clip: &LocalClip,
                                                image_url: &ServoUrl,
                                                background_index: usize);
 
     /// Adds the display items necessary to paint a webrender image of this fragment to the
     /// appropriate section of the display list.
     fn build_display_list_for_webrender_image(&self,
                                               state: &mut DisplayListBuildState,
-                                              style: &ServoComputedValues,
+                                              style: &ComputedValues,
                                               display_list_section: DisplayListSection,
                                               absolute_bounds: &Rect<Au>,
                                               clip: &LocalClip,
                                               webrender_image: WebRenderImageInfo,
                                               index: usize);
 
     /// Adds the display items necessary to paint the background image created by this fragment's
     /// worklet to the appropriate section of the display list.
     fn build_display_list_for_background_paint_worklet(&self,
                                                        state: &mut DisplayListBuildState,
-                                                       style: &ServoComputedValues,
+                                                       style: &ComputedValues,
                                                        display_list_section: DisplayListSection,
                                                        absolute_bounds: &Rect<Au>,
                                                        clip: &LocalClip,
                                                        paint_worklet: &PaintWorklet,
                                                        index: usize);
 
     fn convert_linear_gradient(&self,
                                bounds: &Rect<Au>,
@@ -438,50 +438,50 @@ pub trait FragmentDisplayListBuilding {
     /// Adds the display items necessary to paint the background linear gradient of this fragment
     /// to the appropriate section of the display list.
     fn build_display_list_for_background_gradient(&self,
                                                   state: &mut DisplayListBuildState,
                                                   display_list_section: DisplayListSection,
                                                   absolute_bounds: &Rect<Au>,
                                                   clip: &LocalClip,
                                                   gradient: &Gradient,
-                                                  style: &ServoComputedValues);
+                                                  style: &ComputedValues);
 
     /// Adds the display items necessary to paint the borders of this fragment to a display list if
     /// necessary.
     fn build_display_list_for_borders_if_applicable(
             &self,
             state: &mut DisplayListBuildState,
-            style: &ServoComputedValues,
+            style: &ComputedValues,
             border_painting_mode: BorderPaintingMode,
             bounds: &Rect<Au>,
             display_list_section: DisplayListSection,
             clip: &Rect<Au>);
 
     /// Adds the display items necessary to paint the outline of this fragment to the display list
     /// if necessary.
     fn build_display_list_for_outline_if_applicable(&self,
                                                     state: &mut DisplayListBuildState,
-                                                    style: &ServoComputedValues,
+                                                    style: &ComputedValues,
                                                     bounds: &Rect<Au>,
                                                     clip: &Rect<Au>);
 
     /// Adds the display items necessary to paint the box shadow of this fragment to the display
     /// list if necessary.
     fn build_display_list_for_box_shadow_if_applicable(&self,
                                                        state: &mut DisplayListBuildState,
-                                                       style: &ServoComputedValues,
+                                                       style: &ComputedValues,
                                                        display_list_section: DisplayListSection,
                                                        absolute_bounds: &Rect<Au>,
                                                        clip: &Rect<Au>);
 
     /// Adds display items necessary to draw debug boxes around a scanned text fragment.
     fn build_debug_borders_around_text_fragments(&self,
                                                  state: &mut DisplayListBuildState,
-                                                 style: &ServoComputedValues,
+                                                 style: &ComputedValues,
                                                  stacking_relative_border_box: &Rect<Au>,
                                                  stacking_relative_content_box: &Rect<Au>,
                                                  text_fragment: &ScannedTextFragmentInfo,
                                                  clip: &Rect<Au>);
 
     /// Adds display items necessary to draw debug boxes around this fragment.
     fn build_debug_borders_around_fragment(&self,
                                            state: &mut DisplayListBuildState,
@@ -602,17 +602,17 @@ fn build_border_radius(abs_bounds: &Rect
         bottom_left:  model::specified_border_radius(border_style.border_bottom_left_radius,
                                                      abs_bounds.size),
     })
 }
 
 /// Get the border radius for the rectangle inside of a rounded border. This is useful
 /// for building the clip for the content inside the border.
 fn build_border_radius_for_inner_rect(outer_rect: &Rect<Au>,
-                                      style: &ServoComputedValues)
+                                      style: &ComputedValues)
                                       -> BorderRadii<Au> {
     let mut radii = build_border_radius(&outer_rect, style.get_border());
     if radii.is_square() {
         return radii;
     }
 
     // Since we are going to using the inner rectangle (outer rectangle minus
     // border width), we need to adjust to border radius so that we are smaller
@@ -628,17 +628,17 @@ fn build_border_radius_for_inner_rect(ou
     radii.top_right.height = cmp::max(Au(0), radii.top_right.height - border_widths.top);
 
     radii.bottom_left.height = cmp::max(Au(0), radii.bottom_left.height - border_widths.bottom);
     radii.bottom_right.height = cmp::max(Au(0), radii.bottom_right.height - border_widths.bottom);
     radii
 }
 
 fn build_inner_border_box_for_border_rect(border_box: &Rect<Au>,
-                                          style: &ServoComputedValues)
+                                          style: &ComputedValues)
                                           -> Rect<Au> {
     let border_widths = style.logical_border_width().to_physical(style.writing_mode);
     let mut inner_border_box = *border_box;
     inner_border_box.origin.x += border_widths.left;
     inner_border_box.origin.y += border_widths.top;
     inner_border_box.size.width -= border_widths.right + border_widths.left;
     inner_border_box.size.height -= border_widths.bottom + border_widths.top;
     inner_border_box
@@ -840,17 +840,17 @@ fn convert_ellipse_size_keyword(keyword:
             get_ellipse_radius(size, center, ::std::cmp::max)
         },
     }
 }
 
 impl FragmentDisplayListBuilding for Fragment {
     fn build_display_list_for_background_if_applicable(&self,
                                                        state: &mut DisplayListBuildState,
-                                                       style: &ServoComputedValues,
+                                                       style: &ComputedValues,
                                                        display_list_section: DisplayListSection,
                                                        absolute_bounds: &Rect<Au>) {
         // FIXME: This causes a lot of background colors to be displayed when they are clearly not
         // needed. We could use display list optimization to clean this up, but it still seems
         // inefficient. What we really want is something like "nearest ancestor element that
         // doesn't have a fragment".
         let background = style.get_background();
         let background_color = style.resolve_color(background.background_color);
@@ -945,17 +945,17 @@ impl FragmentDisplayListBuilding for Fra
                 Either::Second(Image::Element(_)) => {
                     // TODO: Implement `-moz-element`
                 }
             }
         }
     }
 
     fn compute_background_image_size(&self,
-                                     style: &ServoComputedValues,
+                                     style: &ComputedValues,
                                      bounds: &Rect<Au>,
                                      image: &WebRenderImageInfo,
                                      index: usize)
                                      -> Size2D<Au> {
         // If `image_aspect_ratio` < `bounds_aspect_ratio`, the image is tall; otherwise, it is
         // wide.
         let image_aspect_ratio = (image.width as f64) / (image.height as f64);
         let bounds_aspect_ratio = bounds.size.width.to_f64_px() / bounds.size.height.to_f64_px();
@@ -991,17 +991,17 @@ impl FragmentDisplayListBuilding for Fra
                        MaybeAuto::from_style(height, bounds.size.height)
                                  .specified_or_default(intrinsic_size.height))
             }
         }
     }
 
     fn build_display_list_for_background_image(&self,
                                                state: &mut DisplayListBuildState,
-                                               style: &ServoComputedValues,
+                                               style: &ComputedValues,
                                                display_list_section: DisplayListSection,
                                                absolute_bounds: &Rect<Au>,
                                                clip: &LocalClip,
                                                image_url: &ServoUrl,
                                                index: usize) {
         let webrender_image = state.layout_context
                                    .get_webrender_image_for_url(self.node,
                                                                 image_url.clone(),
@@ -1015,17 +1015,17 @@ impl FragmentDisplayListBuilding for Fra
                                                         clip,
                                                         webrender_image,
                                                         index);
         }
     }
 
     fn build_display_list_for_webrender_image(&self,
                                               state: &mut DisplayListBuildState,
-                                              style: &ServoComputedValues,
+                                              style: &ComputedValues,
                                               display_list_section: DisplayListSection,
                                               absolute_bounds: &Rect<Au>,
                                               clip: &LocalClip,
                                               webrender_image: WebRenderImageInfo,
                                               index: usize) {
         debug!("(building display list) building background image");
         let background = style.get_background();
 
@@ -1152,17 +1152,17 @@ impl FragmentDisplayListBuilding for Fra
             tile_spacing: tile_spacing,
             image_rendering: style.get_inheritedbox().image_rendering.clone(),
         }));
 
     }
 
     fn build_display_list_for_background_paint_worklet(&self,
                                                        state: &mut DisplayListBuildState,
-                                                       style: &ServoComputedValues,
+                                                       style: &ComputedValues,
                                                        display_list_section: DisplayListSection,
                                                        absolute_bounds: &Rect<Au>,
                                                        clip: &LocalClip,
                                                        paint_worklet: &PaintWorklet,
                                                        index: usize)
     {
         // This should be the "concrete object size" of the fragment.
         // https://drafts.css-houdini.org/css-paint-api/#draw-a-paint-image
@@ -1333,17 +1333,17 @@ impl FragmentDisplayListBuilding for Fra
     }
 
     fn build_display_list_for_background_gradient(&self,
                                                   state: &mut DisplayListBuildState,
                                                   display_list_section: DisplayListSection,
                                                   absolute_bounds: &Rect<Au>,
                                                   clip: &LocalClip,
                                                   gradient: &Gradient,
-                                                  style: &ServoComputedValues) {
+                                                  style: &ComputedValues) {
         let border = self.border_width().to_physical(style.writing_mode);
         let mut bounds = *absolute_bounds;
         bounds.origin.x = bounds.origin.x + border.left;
         bounds.origin.y = bounds.origin.y + border.top;
         bounds.size.width = bounds.size.width - border.horizontal();
         bounds.size.height = bounds.size.height - border.vertical();
 
         let base = state.create_base_display_item(&bounds,
@@ -1375,17 +1375,17 @@ impl FragmentDisplayListBuilding for Fra
                 })
             }
         };
         state.add_display_item(display_item);
     }
 
     fn build_display_list_for_box_shadow_if_applicable(&self,
                                                        state: &mut DisplayListBuildState,
-                                                       style: &ServoComputedValues,
+                                                       style: &ComputedValues,
                                                        display_list_section: DisplayListSection,
                                                        absolute_bounds: &Rect<Au>,
                                                        clip: &Rect<Au>) {
         // NB: According to CSS-BACKGROUNDS, box shadows render in *reverse* order (front to back).
         for box_shadow in style.get_effects().box_shadow.0.iter().rev() {
             let bounds = shadow_bounds(
                 &absolute_bounds.translate(&Vector2D::new(
                     box_shadow.base.horizontal,
@@ -1418,17 +1418,17 @@ impl FragmentDisplayListBuilding for Fra
                 },
             }));
         }
     }
 
     fn build_display_list_for_borders_if_applicable(
             &self,
             state: &mut DisplayListBuildState,
-            style: &ServoComputedValues,
+            style: &ComputedValues,
             border_painting_mode: BorderPaintingMode,
             bounds: &Rect<Au>,
             display_list_section: DisplayListSection,
             clip: &Rect<Au>) {
         let mut border = style.logical_border_width();
 
         match border_painting_mode {
             BorderPaintingMode::Separate => {}
@@ -1565,17 +1565,17 @@ impl FragmentDisplayListBuilding for Fra
                     }
                 }
             }
         }
     }
 
     fn build_display_list_for_outline_if_applicable(&self,
                                                     state: &mut DisplayListBuildState,
-                                                    style: &ServoComputedValues,
+                                                    style: &ComputedValues,
                                                     bounds: &Rect<Au>,
                                                     clip: &Rect<Au>) {
         use style::values::Either;
 
         let width = style.get_outline().outline_width;
         if width == Au(0) {
             return
         }
@@ -1610,17 +1610,17 @@ impl FragmentDisplayListBuilding for Fra
                 style: SideOffsets2D::new_all_same(outline_style),
                 radius: Default::default(),
             }),
         }));
     }
 
     fn build_debug_borders_around_text_fragments(&self,
                                                  state: &mut DisplayListBuildState,
-                                                 style: &ServoComputedValues,
+                                                 style: &ComputedValues,
                                                  stacking_relative_border_box: &Rect<Au>,
                                                  stacking_relative_content_box: &Rect<Au>,
                                                  text_fragment: &ScannedTextFragmentInfo,
                                                  clip: &Rect<Au>) {
         // FIXME(pcwalton, #2795): Get the real container size.
         let container_size = Size2D::zero();
 
         // Compute the text fragment bounds and draw a border surrounding them.
@@ -2881,22 +2881,22 @@ impl BaseFlowDisplayListBuilding for Bas
                 color: SideOffsets2D::new_all_same(color),
                 style: SideOffsets2D::new_all_same(border_style::T::solid),
                 radius: BorderRadii::all_same(Au(0)),
             }),
         }));
     }
 }
 
-trait ServoComputedValuesCursorUtility {
+trait ComputedValuesCursorUtility {
     fn get_cursor(&self, default_cursor: Cursor) -> Option<Cursor>;
 }
 
-impl ServoComputedValuesCursorUtility for ServoComputedValues {
-    /// Gets the cursor to use given the specific ServoComputedValues.  `default_cursor` specifies
+impl ComputedValuesCursorUtility for ComputedValues {
+    /// Gets the cursor to use given the specific ComputedValues.  `default_cursor` specifies
     /// the cursor to use if `cursor` is `auto`. Typically, this will be `PointerCursor`, but for
     /// text display items it may be `TextCursor` or `VerticalTextCursor`.
     #[inline]
     fn get_cursor(&self, default_cursor: Cursor) -> Option<Cursor> {
         match (self.get_pointing().pointer_events, self.get_pointing().cursor) {
             (pointer_events::T::none, _) => None,
             (pointer_events::T::auto, cursor::Keyword::Auto) => Some(default_cursor),
             (pointer_events::T::auto, cursor::Keyword::Cursor(cursor)) => Some(cursor),
--- a/servo/components/layout/flex.rs
+++ b/servo/components/layout/flex.rs
@@ -18,17 +18,17 @@ use flow::{INLINE_POSITION_IS_STATIC, IS
 use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
 use layout_debug;
 use model::{IntrinsicISizes, MaybeAuto, SizeConstraint};
 use std::cmp::{max, min};
 use std::ops::Range;
 use style::computed_values::{align_content, align_self, flex_direction, flex_wrap, justify_content};
 use style::computed_values::border_collapse;
 use style::logical_geometry::{Direction, LogicalSize};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
 use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
 use style::values::computed::flex::FlexBasis;
 use style::values::generics::flex::FlexBasis as GenericFlexBasis;
 
 /// The size of an axis. May be a specified size, a min/max
 /// constraint, or an unlimited size
 #[derive(Debug, Serialize)]
@@ -968,17 +968,17 @@ impl Flow for FlexFlow {
     fn build_display_list(&mut self, state: &mut DisplayListBuildState) {
         self.build_display_list_for_flex(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
--- a/servo/components/layout/flow.rs
+++ b/servo/components/layout/flow.rs
@@ -47,17 +47,17 @@ use servo_geometry::{au_rect_to_f32_rect
 use std::{fmt, mem, raw};
 use std::iter::Zip;
 use std::slice::IterMut;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use style::computed_values::{clear, float, overflow_x, position, text_align};
 use style::context::SharedStyleContext;
 use style::logical_geometry::{LogicalRect, LogicalSize, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::selector_parser::RestyleDamage;
 use style::servo::restyle_damage::{RECONSTRUCT_FLOW, REFLOW, REFLOW_OUT_OF_FLOW, REPAINT, REPOSITION};
 use style::values::computed::LengthOrPercentageOrAuto;
 use table::TableFlow;
 use table_caption::TableCaptionFlow;
 use table_cell::TableCellFlow;
 use table_colgroup::TableColGroupFlow;
 use table_row::TableRowFlow;
@@ -419,17 +419,17 @@ pub trait Flow: fmt::Debug + Sync + Send
     /// positioned descendant referenced by `for_flow`. For block flows, this is the padding box.
     ///
     /// NB: Do not change this `&self` to `&mut self` under any circumstances! It has security
     /// implications because this can be called on parents concurrently from descendants!
     fn generated_containing_block_size(&self, _: OpaqueFlow) -> LogicalSize<Au>;
 
     /// Attempts to perform incremental fixup of this flow by replacing its fragment's style with
     /// the new style. This can only succeed if the flow has exactly one fragment.
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>);
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>);
 
     /// Print any extra children (such as fragments) contained in this Flow
     /// for debugging purposes. Any items inserted into the tree will become
     /// children of this flow.
     fn print_extra_flow_children(&self, _: &mut PrintTree) { }
 
     fn scroll_root_id(&self, pipeline_id: PipelineId) -> ClipId {
         match base(self).scroll_root_id {
@@ -556,17 +556,17 @@ pub trait MutableFlowUtils {
     /// Return true if the traversal is to continue or false to stop.
     fn traverse_postorder_absolute_flows<T>(&mut self, traversal: &mut T)
                                             where T: PostorderFlowTraversal;
 
     // Mutators
 
     /// Calls `repair_style` and `bubble_inline_sizes`. You should use this method instead of
     /// calling them individually, since there is no reason not to perform both operations.
-    fn repair_style_and_bubble_inline_sizes(self, style: &::StyleArc<ServoComputedValues>);
+    fn repair_style_and_bubble_inline_sizes(self, style: &::StyleArc<ComputedValues>);
 }
 
 pub trait MutableOwnedFlowUtils {
     /// Set absolute descendants for this flow.
     ///
     /// Set this flow as the Containing Block for all the absolute descendants.
     fn set_absolute_descendants(&mut self, abs_descendants: AbsoluteDescendants);
 
@@ -1028,17 +1028,17 @@ pub enum ForceNonfloatedFlag {
     /// The flow should be floated if the node has a `float` property.
     FloatIfNecessary,
     /// The flow should be forced to be nonfloated.
     ForceNonfloated,
 }
 
 impl BaseFlow {
     #[inline]
-    pub fn new(style: Option<&ServoComputedValues>,
+    pub fn new(style: Option<&ComputedValues>,
                writing_mode: WritingMode,
                force_nonfloated: ForceNonfloatedFlag)
                -> BaseFlow {
         let mut flags = FlowFlags::empty();
         match style {
             Some(style) => {
                 match style.get_box().position {
                     position::T::absolute | position::T::fixed => {
@@ -1114,17 +1114,17 @@ impl BaseFlow {
             scroll_root_id: None,
         }
     }
 
     /// Update the 'flags' field when computed styles have changed.
     ///
     /// These flags are initially set during flow construction.  They only need to be updated here
     /// if they are based on properties that can change without triggering `RECONSTRUCT_FLOW`.
-    pub fn update_flags_if_needed(&mut self, style: &ServoComputedValues) {
+    pub fn update_flags_if_needed(&mut self, style: &ComputedValues) {
         // For absolutely-positioned flows, changes to top/bottom/left/right can cause these flags
         // to get out of date:
         if self.restyle_damage.contains(REFLOW_OUT_OF_FLOW) {
             // Note: We don't need to check whether IS_ABSOLUTELY_POSITIONED has changed, because
             // changes to the 'position' property trigger flow reconstruction.
             if self.flags.contains(IS_ABSOLUTELY_POSITIONED) {
                 let logical_position = style.logical_position();
                 self.flags.set(INLINE_POSITION_IS_STATIC,
@@ -1376,17 +1376,17 @@ impl<'a> MutableFlowUtils for &'a mut Fl
         if traversal.should_process(self) {
             traversal.process(self)
         }
     }
 
 
     /// Calls `repair_style` and `bubble_inline_sizes`. You should use this method instead of
     /// calling them individually, since there is no reason not to perform both operations.
-    fn repair_style_and_bubble_inline_sizes(self, style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style_and_bubble_inline_sizes(self, style: &::StyleArc<ComputedValues>) {
         self.repair_style(style);
         mut_base(self).update_flags_if_needed(style);
         self.bubble_inline_sizes();
     }
 
     /// Traverse the Absolute flow tree in preorder.
     ///
     /// Traverse all your direct absolute descendants, who will then traverse
--- a/servo/components/layout/fragment.rs
+++ b/servo/components/layout/fragment.rs
@@ -40,17 +40,17 @@ use std::borrow::ToOwned;
 use std::cmp::{Ordering, max, min};
 use std::collections::LinkedList;
 use std::sync::{Arc, Mutex};
 use style::computed_values::{border_collapse, box_sizing, clear, color, display, mix_blend_mode};
 use style::computed_values::{overflow_wrap, overflow_x, position, text_decoration_line, transform};
 use style::computed_values::{transform_style, vertical_align, white_space, word_break};
 use style::computed_values::content::ContentItem;
 use style::logical_geometry::{Direction, LogicalMargin, LogicalRect, LogicalSize, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::selector_parser::RestyleDamage;
 use style::servo::restyle_damage::RECONSTRUCT_FLOW;
 use style::str::char_is_whitespace;
 use style::values::{self, Either, Auto};
 use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrAuto};
 use text;
 use text::TextRunScanner;
 use wrapper::ThreadSafeLayoutNodeHelpers;
@@ -90,20 +90,20 @@ static DEFAULT_REPLACED_HEIGHT: i32 = 15
 /// FIXME(#2260, pcwalton): This can be slimmed down some by (at least) moving `inline_context`
 /// to be on `InlineFlow` only.
 #[derive(Clone)]
 pub struct Fragment {
     /// An opaque reference to the DOM node that this `Fragment` originates from.
     pub node: OpaqueNode,
 
     /// The CSS style of this fragment.
-    pub style: StyleArc<ServoComputedValues>,
+    pub style: StyleArc<ComputedValues>,
 
     /// The CSS style of this fragment when it's selected
-    pub selected_style: StyleArc<ServoComputedValues>,
+    pub selected_style: StyleArc<ComputedValues>,
 
     /// The position of this fragment relative to its owning flow. The size includes padding and
     /// border, but not margin.
     ///
     /// NB: This does not account for relative positioning.
     /// NB: Collapsed borders are not included in this.
     pub border_box: LogicalRect<Au>,
 
@@ -671,18 +671,18 @@ impl Fragment {
             debug_id: DebugId::new(),
             stacking_context_id: StackingContextId::root(),
         }
     }
 
     /// Constructs a new `Fragment` instance from an opaque node.
     pub fn from_opaque_node_and_style(node: OpaqueNode,
                                       pseudo: PseudoElementType<()>,
-                                      style: StyleArc<ServoComputedValues>,
-                                      selected_style: StyleArc<ServoComputedValues>,
+                                      style: StyleArc<ComputedValues>,
+                                      selected_style: StyleArc<ComputedValues>,
                                       mut restyle_damage: RestyleDamage,
                                       specific: SpecificFragmentInfo)
                                       -> Fragment {
         let writing_mode = style.writing_mode;
 
         restyle_damage.remove(RECONSTRUCT_FLOW);
 
         Fragment {
@@ -701,17 +701,17 @@ impl Fragment {
             stacking_context_id: StackingContextId::root(),
         }
     }
 
     /// Creates an anonymous fragment just like this one but with the given style and fragment
     /// type. For the new anonymous fragment, layout-related values (border box, etc.) are reset to
     /// initial values.
     pub fn create_similar_anonymous_fragment(&self,
-                                             style: StyleArc<ServoComputedValues>,
+                                             style: StyleArc<ComputedValues>,
                                              specific: SpecificFragmentInfo)
                                              -> Fragment {
         let writing_mode = style.writing_mode;
         Fragment {
             node: self.node,
             style: style,
             selected_style: self.selected_style.clone(),
             restyle_damage: self.restyle_damage,
@@ -1334,17 +1334,17 @@ impl Fragment {
             }
         };
 
         self.border_padding = border + padding_from_style + padding_from_inline_fragment_context
     }
 
     // Return offset from original position because of `position: relative`.
     pub fn relative_position(&self, containing_block_size: &LogicalSize<Au>) -> LogicalSize<Au> {
-        fn from_style(style: &ServoComputedValues, container_size: &LogicalSize<Au>)
+        fn from_style(style: &ComputedValues, container_size: &LogicalSize<Au>)
                       -> LogicalSize<Au> {
             let offsets = style.logical_position();
             let offset_i = if offsets.inline_start != LengthOrPercentageOrAuto::Auto {
                 MaybeAuto::from_style(offsets.inline_start,
                                       container_size.inline).specified_or_zero()
             } else {
                 -MaybeAuto::from_style(offsets.inline_end,
                                        container_size.inline).specified_or_zero()
@@ -1387,22 +1387,22 @@ impl Fragment {
             clear::T::none => None,
             clear::T::left => Some(ClearType::Left),
             clear::T::right => Some(ClearType::Right),
             clear::T::both => Some(ClearType::Both),
         }
     }
 
     #[inline(always)]
-    pub fn style(&self) -> &ServoComputedValues {
+    pub fn style(&self) -> &ComputedValues {
         &*self.style
     }
 
     #[inline(always)]
-    pub fn selected_style(&self) -> &ServoComputedValues {
+    pub fn selected_style(&self) -> &ComputedValues {
         &*self.selected_style
     }
 
     pub fn white_space(&self) -> white_space::T {
         self.style().get_inheritedtext().white_space
     }
 
     pub fn color(&self) -> color::T {
@@ -2137,17 +2137,17 @@ impl Fragment {
             SpecificFragmentInfo::Multicol |
             SpecificFragmentInfo::MulticolColumn |
             SpecificFragmentInfo::UnscannedText(_) => {
                 unreachable!("Shouldn't see fragments of this type here!")
             }
         };
         return inline_metrics;
 
-        fn inline_metrics_of_block(flow: &FlowRef, style: &ServoComputedValues) -> InlineMetrics {
+        fn inline_metrics_of_block(flow: &FlowRef, style: &ComputedValues) -> InlineMetrics {
             // CSS 2.1 § 10.8: "The height of each inline-level box in the line box is calculated.
             // For replaced elements, inline-block elements, and inline-table elements, this is the
             // height of their margin box."
             //
             // CSS 2.1 § 10.8.1: "The baseline of an 'inline-block' is the baseline of its last
             // line box in the normal flow, unless it has either no in-flow line boxes or if its
             // 'overflow' property has a computed value other than 'visible', in which case the
             // baseline is the bottom margin edge."
@@ -2418,17 +2418,17 @@ impl Fragment {
     pub fn update_late_computed_block_position_if_necessary(&mut self) {
         if let SpecificFragmentInfo::InlineAbsoluteHypothetical(ref mut info) = self.specific {
             let position = self.border_box.start.b;
             FlowRef::deref_mut(&mut info.flow_ref)
                 .update_late_computed_block_position_if_necessary(position)
         }
     }
 
-    pub fn repair_style(&mut self, new_style: &StyleArc<ServoComputedValues>) {
+    pub fn repair_style(&mut self, new_style: &StyleArc<ComputedValues>) {
         self.style = (*new_style).clone()
     }
 
     /// Given the stacking-context-relative position of the containing flow, returns the border box
     /// of this fragment relative to the parent stacking context. This takes `position: relative`
     /// into account.
     ///
     /// If `coordinate_system` is `Parent`, this returns the border box in the parent stacking
@@ -3033,19 +3033,19 @@ pub enum CoordinateSystem {
 
 pub struct InlineStyleIterator<'a> {
     fragment: &'a Fragment,
     inline_style_index: usize,
     primary_style_yielded: bool,
 }
 
 impl<'a> Iterator for InlineStyleIterator<'a> {
-    type Item = &'a ServoComputedValues;
+    type Item = &'a ComputedValues;
 
-    fn next(&mut self) -> Option<&'a ServoComputedValues> {
+    fn next(&mut self) -> Option<&'a ComputedValues> {
         if !self.primary_style_yielded {
             self.primary_style_yielded = true;
             return Some(&*self.fragment.style)
         }
         let inline_context = match self.fragment.inline_context {
             None => return None,
             Some(ref inline_context) => inline_context,
         };
--- a/servo/components/layout/generated_content.rs
+++ b/servo/components/layout/generated_content.rs
@@ -13,17 +13,17 @@ use flow::{self, AFFECTS_COUNTERS, Flow,
 use flow::InorderFlowTraversal;
 use fragment::{Fragment, GeneratedContentInfo, SpecificFragmentInfo, UnscannedTextFragmentInfo};
 use gfx::display_list::OpaqueNode;
 use script_layout_interface::wrapper_traits::PseudoElementType;
 use smallvec::SmallVec;
 use std::collections::{HashMap, LinkedList};
 use style::computed_values::{display, list_style_type};
 use style::computed_values::content::ContentItem;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::selector_parser::RestyleDamage;
 use style::servo::restyle_damage::RESOLVE_GENERATED_CONTENT;
 use text::TextRunScanner;
 
 // Decimal styles per CSS-COUNTER-STYLES § 6.1:
 static DECIMAL: [char; 10] = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ];
 // TODO(pcwalton): `decimal-leading-zero`
 static ARABIC_INDIC: [char; 10] = [ '٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨', '٩' ];
@@ -293,17 +293,17 @@ impl<'a,'b> ResolveGeneratedContentFragm
             let mut counter = Counter::new();
             counter.increment(self.level, value);
             self.traversal.counters.insert(counter_name.to_owned(), counter);
         }
 
         self.incremented = true
     }
 
-    fn quote(&self, style: &ServoComputedValues, close: bool) -> String {
+    fn quote(&self, style: &ComputedValues, close: bool) -> String {
         let quotes = &style.get_list().quotes;
         if quotes.0.is_empty() {
             return String::new()
         }
         let &(ref open_quote, ref close_quote) =
             if self.traversal.quote as usize >= quotes.0.len() {
                 quotes.0.last().unwrap()
             } else {
@@ -363,17 +363,17 @@ impl Counter {
             value: amount,
         })
     }
 
     fn render(&self,
               layout_context: &LayoutContext,
               node: OpaqueNode,
               pseudo: PseudoElementType<()>,
-              style: ::StyleArc<ServoComputedValues>,
+              style: ::StyleArc<ComputedValues>,
               list_style_type: list_style_type::T,
               mode: RenderingMode)
               -> Option<SpecificFragmentInfo> {
         let mut string = String::new();
         match mode {
             RenderingMode::Plain => {
                 let value = match self.values.last() {
                     Some(ref value) => value.value,
@@ -426,17 +426,17 @@ struct CounterValue {
     /// The value of the counter at this level.
     value: i32,
 }
 
 /// Creates fragment info for a literal string.
 fn render_text(layout_context: &LayoutContext,
                node: OpaqueNode,
                pseudo: PseudoElementType<()>,
-               style: ::StyleArc<ServoComputedValues>,
+               style: ::StyleArc<ComputedValues>,
                string: String)
                -> Option<SpecificFragmentInfo> {
     let mut fragments = LinkedList::new();
     let info = SpecificFragmentInfo::UnscannedText(
         box UnscannedTextFragmentInfo::new(string, None));
     fragments.push_back(Fragment::from_opaque_node_and_style(node,
                                                              pseudo,
                                                              style.clone(),
--- a/servo/components/layout/inline.rs
+++ b/servo/components/layout/inline.rs
@@ -28,17 +28,17 @@ use range::{Range, RangeIndex};
 use script_layout_interface::wrapper_traits::PseudoElementType;
 use std::{fmt, i32, isize, mem};
 use std::cmp::max;
 use std::collections::VecDeque;
 use std::sync::Arc;
 use style::computed_values::{display, overflow_x, position, text_align, text_justify};
 use style::computed_values::{vertical_align, white_space};
 use style::logical_geometry::{LogicalRect, LogicalSize, WritingMode};
-use style::properties::{longhands, ServoComputedValues};
+use style::properties::{longhands, ComputedValues};
 use style::servo::restyle_damage::{BUBBLE_ISIZES, REFLOW, REFLOW_OUT_OF_FLOW, REPOSITION, RESOLVE_GENERATED_CONTENT};
 use text;
 use unicode_bidi as bidi;
 
 /// `Line`s are represented as offsets into the child list, rather than
 /// as an object that "owns" fragments. Choosing a different set of line
 /// breaks requires a new list of offsets, and possibly some splitting and
 /// merging of TextFragments.
@@ -1101,30 +1101,30 @@ impl InlineFlow {
 
             fragment.update_late_computed_block_position_if_necessary();
         }
     }
 
     /// Computes the minimum metrics for each line. This is done during flow construction.
     ///
     /// `style` is the style of the block.
-    pub fn minimum_line_metrics(&self, font_context: &mut FontContext, style: &ServoComputedValues)
+    pub fn minimum_line_metrics(&self, font_context: &mut FontContext, style: &ComputedValues)
                                 -> LineMetrics {
         InlineFlow::minimum_line_metrics_for_fragments(&self.fragments.fragments,
                                                        font_context,
                                                        style)
     }
 
     /// Computes the minimum line metrics for the given fragments. This is typically done during
     /// flow construction.
     ///
     /// `style` is the style of the block that these fragments belong to.
     pub fn minimum_line_metrics_for_fragments(fragments: &[Fragment],
                                               font_context: &mut FontContext,
-                                              style: &ServoComputedValues)
+                                              style: &ComputedValues)
                                               -> LineMetrics {
         // As a special case, if this flow contains only hypothetical fragments, then the entire
         // flow is hypothetical and takes up no space. See CSS 2.1 § 10.3.7.
         if fragments.iter().all(Fragment::is_hypothetical) {
             return LineMetrics::new(Au(0), Au(0))
         }
 
         let font_style = style.clone_font();
@@ -1660,17 +1660,17 @@ impl Flow for InlineFlow {
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.collect_stacking_contexts_for_inline(state);
     }
 
     fn build_display_list(&mut self, state: &mut DisplayListBuildState) {
         self.build_display_list_for_inline(state);
     }
 
-    fn repair_style(&mut self, _: &StyleArc<ServoComputedValues>) {}
+    fn repair_style(&mut self, _: &StyleArc<ComputedValues>) {}
 
     fn compute_overflow(&self) -> Overflow {
         let mut overflow = Overflow::new();
         let flow_size = self.base.position.size.to_physical(self.base.writing_mode);
         let relative_containing_block_size =
             &self.base.early_absolute_position_info.relative_containing_block_size;
         for fragment in &self.fragments.fragments {
             overflow.union(&fragment.compute_overflow(&flow_size, &relative_containing_block_size))
@@ -1749,18 +1749,18 @@ impl fmt::Debug for InlineFlow {
                self.base.debug_id(),
                flow::base(self))
     }
 }
 
 #[derive(Clone)]
 pub struct InlineFragmentNodeInfo {
     pub address: OpaqueNode,
-    pub style: StyleArc<ServoComputedValues>,
-    pub selected_style: StyleArc<ServoComputedValues>,
+    pub style: StyleArc<ComputedValues>,
+    pub selected_style: StyleArc<ComputedValues>,
     pub pseudo: PseudoElementType<()>,
     pub flags: InlineFragmentNodeFlags,
 }
 
 bitflags! {
     pub flags InlineFragmentNodeFlags: u8 {
         const FIRST_FRAGMENT_OF_ELEMENT = 0x01,
         const LAST_FRAGMENT_OF_ELEMENT = 0x02,
--- a/servo/components/layout/list_item.rs
+++ b/servo/components/layout/list_item.rs
@@ -15,17 +15,17 @@ use euclid::Point2D;
 use floats::FloatKind;
 use flow::{Flow, FlowClass, OpaqueFlow};
 use fragment::{CoordinateSystem, Fragment, FragmentBorderBoxIterator, GeneratedContentInfo};
 use fragment::Overflow;
 use generated_content;
 use inline::InlineFlow;
 use style::computed_values::{list_style_type, position};
 use style::logical_geometry::LogicalSize;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::servo::restyle_damage::RESOLVE_GENERATED_CONTENT;
 
 /// A block with the CSS `display` property equal to `list-item`.
 #[derive(Debug)]
 pub struct ListItemFlow {
     /// Data common to all block flows.
     pub block_flow: BlockFlow,
     /// The marker, if outside. (Markers that are inside are instead just fragments on the interior
@@ -142,17 +142,17 @@ impl Flow for ListItemFlow {
     fn build_display_list(&mut self, state: &mut DisplayListBuildState) {
         self.build_display_list_for_list_item(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         let mut overflow = self.block_flow.compute_overflow();
         let flow_size = self.block_flow.base.position.size.to_physical(self.block_flow.base.writing_mode);
         let relative_containing_block_size =
             &self.block_flow.base.early_absolute_position_info.relative_containing_block_size;
--- a/servo/components/layout/model.rs
+++ b/servo/components/layout/model.rs
@@ -8,17 +8,17 @@
 
 use app_units::Au;
 use euclid::{Transform3D, SideOffsets2D, Size2D};
 use fragment::Fragment;
 use std::cmp::{max, min};
 use std::fmt;
 use style::computed_values::transform::ComputedMatrix;
 use style::logical_geometry::{LogicalMargin, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::values::computed::{BorderCornerRadius, LengthOrPercentageOrAuto};
 use style::values::computed::{LengthOrPercentage, LengthOrPercentageOrNone};
 
 /// A collapsible margin. See CSS 2.1 § 8.3.1.
 #[derive(Copy, Clone, Debug)]
 pub struct AdjoiningMargins {
     /// The value of the greatest positive margin.
     pub most_positive: Au,
@@ -476,34 +476,34 @@ pub fn specified_border_radius(
     -> Size2D<Au>
 {
     let w = radius.0.width.to_used_value(containing_size.width);
     let h = radius.0.height.to_used_value(containing_size.height);
     Size2D::new(w, h)
 }
 
 #[inline]
-pub fn padding_from_style(style: &ServoComputedValues,
+pub fn padding_from_style(style: &ComputedValues,
                           containing_block_inline_size: Au,
                           writing_mode: WritingMode)
                           -> LogicalMargin<Au> {
     let padding_style = style.get_padding();
     LogicalMargin::from_physical(writing_mode, SideOffsets2D::new(
         padding_style.padding_top.to_used_value(containing_block_inline_size),
         padding_style.padding_right.to_used_value(containing_block_inline_size),
         padding_style.padding_bottom.to_used_value(containing_block_inline_size),
         padding_style.padding_left.to_used_value(containing_block_inline_size)))
 }
 
 /// Returns the explicitly-specified margin lengths from the given style. Percentage and auto
 /// margins are returned as zero.
 ///
 /// This is used when calculating intrinsic inline sizes.
 #[inline]
-pub fn specified_margin_from_style(style: &ServoComputedValues,
+pub fn specified_margin_from_style(style: &ComputedValues,
                                    writing_mode: WritingMode) -> LogicalMargin<Au> {
     let margin_style = style.get_margin();
     LogicalMargin::from_physical(writing_mode, SideOffsets2D::new(
         MaybeAuto::from_style(margin_style.margin_top, Au(0)).specified_or_zero(),
         MaybeAuto::from_style(margin_style.margin_right, Au(0)).specified_or_zero(),
         MaybeAuto::from_style(margin_style.margin_bottom, Au(0)).specified_or_zero(),
         MaybeAuto::from_style(margin_style.margin_left, Au(0)).specified_or_zero()))
 }
--- a/servo/components/layout/multicol.rs
+++ b/servo/components/layout/multicol.rs
@@ -15,17 +15,17 @@ use euclid::{Point2D, Vector2D};
 use floats::FloatKind;
 use flow::{Flow, FlowClass, OpaqueFlow, mut_base, FragmentationContext};
 use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
 use gfx_traits::print_tree::PrintTree;
 use std::cmp::{min, max};
 use std::fmt;
 use std::sync::Arc;
 use style::logical_geometry::LogicalSize;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::values::Either;
 use style::values::computed::{LengthOrPercentageOrAuto, LengthOrPercentageOrNone};
 
 pub struct MulticolFlow {
     pub block_flow: BlockFlow,
 
     /// Length between the inline-start edge of a column and that of the next.
     /// That is, the used column-width + used column-gap.
@@ -188,17 +188,17 @@ impl Flow for MulticolFlow {
         debug!("build_display_list_multicol");
         self.block_flow.build_display_list(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
@@ -270,17 +270,17 @@ impl Flow for MulticolColumnFlow {
         debug!("build_display_list_multicol column");
         self.block_flow.build_display_list(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
--- a/servo/components/layout/table.rs
+++ b/servo/components/layout/table.rs
@@ -19,17 +19,17 @@ use fragment::{Fragment, FragmentBorderB
 use gfx_traits::print_tree::PrintTree;
 use layout_debug;
 use model::{IntrinsicISizes, IntrinsicISizesContribution, MaybeAuto};
 use std::cmp;
 use std::fmt;
 use style::computed_values::{border_collapse, border_spacing, table_layout};
 use style::context::SharedStyleContext;
 use style::logical_geometry::LogicalSize;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
 use style::values::CSSFloat;
 use style::values::computed::LengthOrPercentageOrAuto;
 use table_row::{self, CellIntrinsicInlineSize, CollapsedBorder, CollapsedBorderProvenance};
 use table_row::TableRowFlow;
 use table_wrapper::TableLayout;
 
 /// A table flow corresponded to the table's internal table fragment under a table wrapper flow.
@@ -501,17 +501,17 @@ impl Flow for TableFlow {
 
         self.block_flow.build_display_list_for_block(state, border_painting_mode);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn iterate_through_fragment_border_boxes(&self,
--- a/servo/components/layout/table_caption.rs
+++ b/servo/components/layout/table_caption.rs
@@ -11,17 +11,17 @@ use block::BlockFlow;
 use context::LayoutContext;
 use display_list_builder::DisplayListBuildState;
 use euclid::Point2D;
 use flow::{Flow, FlowClass, OpaqueFlow};
 use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
 use gfx_traits::print_tree::PrintTree;
 use std::fmt;
 use style::logical_geometry::LogicalSize;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 
 /// A table formatting context.
 pub struct TableCaptionFlow {
     pub block_flow: BlockFlow,
 }
 
 impl TableCaptionFlow {
     pub fn from_fragment(fragment: Fragment) -> TableCaptionFlow {
@@ -78,17 +78,17 @@ impl Flow for TableCaptionFlow {
         debug!("build_display_list_table_caption: same process as block flow");
         self.block_flow.build_display_list(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
--- a/servo/components/layout/table_cell.rs
+++ b/servo/components/layout/table_cell.rs
@@ -15,17 +15,17 @@ use flow::{self, Flow, FlowClass, IS_ABS
 use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
 use gfx_traits::print_tree::PrintTree;
 use layout_debug;
 use model::MaybeAuto;
 use script_layout_interface::wrapper_traits::ThreadSafeLayoutNode;
 use std::fmt;
 use style::computed_values::{border_collapse, border_top_style, vertical_align};
 use style::logical_geometry::{LogicalMargin, LogicalRect, LogicalSize, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::values::computed::Color;
 use table::InternalTable;
 use table_row::{CollapsedBorder, CollapsedBorderProvenance};
 
 /// A table formatting context.
 #[derive(Serialize)]
 pub struct TableCellFlow {
     /// Data common to all block flows.
@@ -258,17 +258,17 @@ impl Flow for TableCellFlow {
 
         self.block_flow.build_display_list_for_block(state, border_painting_mode)
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
--- a/servo/components/layout/table_colgroup.rs
+++ b/servo/components/layout/table_colgroup.rs
@@ -11,17 +11,17 @@ use context::LayoutContext;
 use display_list_builder::DisplayListBuildState;
 use euclid::Point2D;
 use flow::{BaseFlow, Flow, FlowClass, ForceNonfloatedFlag, OpaqueFlow};
 use fragment::{Fragment, FragmentBorderBoxIterator, Overflow, SpecificFragmentInfo};
 use layout_debug;
 use std::cmp::max;
 use std::fmt;
 use style::logical_geometry::LogicalSize;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::values::computed::LengthOrPercentageOrAuto;
 
 /// A table formatting context.
 pub struct TableColGroupFlow {
     /// Data common to all flows.
     pub base: BaseFlow,
 
     /// The associated fragment.
@@ -89,17 +89,17 @@ impl Flow for TableColGroupFlow {
 
     fn update_late_computed_block_position_if_necessary(&mut self, _: Au) {}
 
     // Table columns are invisible.
     fn build_display_list(&mut self, _: &mut DisplayListBuildState) { }
 
     fn collect_stacking_contexts(&mut self, _: &mut DisplayListBuildState) {}
 
-    fn repair_style(&mut self, _: &::StyleArc<ServoComputedValues>) {}
+    fn repair_style(&mut self, _: &::StyleArc<ComputedValues>) {}
 
     fn compute_overflow(&self) -> Overflow {
         Overflow::new()
     }
 
     fn generated_containing_block_size(&self, _: OpaqueFlow) -> LogicalSize<Au> {
         panic!("Table column groups can't be containing blocks!")
     }
--- a/servo/components/layout/table_row.rs
+++ b/servo/components/layout/table_row.rs
@@ -18,17 +18,17 @@ use gfx_traits::print_tree::PrintTree;
 use layout_debug;
 use model::MaybeAuto;
 use serde::{Serialize, Serializer};
 use std::cmp::max;
 use std::fmt;
 use std::iter::{Enumerate, IntoIterator, Peekable};
 use style::computed_values::{border_collapse, border_spacing, border_top_style};
 use style::logical_geometry::{LogicalSize, PhysicalSide, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW};
 use style::values::computed::{Color, LengthOrPercentageOrAuto};
 use table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize, InternalTable, VecExt};
 use table_cell::{CollapsedBordersForCell, TableCellFlow};
 
 /// A single row of a table.
 pub struct TableRowFlow {
     /// Fields common to all block flows.
@@ -476,17 +476,17 @@ impl Flow for TableRowFlow {
 
         self.block_flow.build_display_list_for_block(state, border_painting_mode);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
@@ -607,105 +607,105 @@ impl CollapsedBorder {
             width: Au(0),
             color: Color::transparent(),
             provenance: CollapsedBorderProvenance::FromTable,
         }
     }
 
     /// Creates a collapsed border from the block-start border described in the given CSS style
     /// object.
-    fn top(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    fn top(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
            -> CollapsedBorder {
         CollapsedBorder {
             style: css_style.get_border().border_top_style,
             width: css_style.get_border().border_top_width,
             color: css_style.get_border().border_top_color,
             provenance: provenance,
         }
     }
 
     /// Creates a collapsed border style from the right border described in the given CSS style
     /// object.
-    fn right(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    fn right(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
              -> CollapsedBorder {
         CollapsedBorder {
             style: css_style.get_border().border_right_style,
             width: css_style.get_border().border_right_width,
             color: css_style.get_border().border_right_color,
             provenance: provenance,
         }
     }
 
     /// Creates a collapsed border style from the bottom border described in the given CSS style
     /// object.
-    fn bottom(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    fn bottom(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
               -> CollapsedBorder {
         CollapsedBorder {
             style: css_style.get_border().border_bottom_style,
             width: css_style.get_border().border_bottom_width,
             color: css_style.get_border().border_bottom_color,
             provenance: provenance,
         }
     }
 
     /// Creates a collapsed border style from the left border described in the given CSS style
     /// object.
-    fn left(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    fn left(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
             -> CollapsedBorder {
         CollapsedBorder {
             style: css_style.get_border().border_left_style,
             width: css_style.get_border().border_left_width,
             color: css_style.get_border().border_left_color,
             provenance: provenance,
         }
     }
 
     /// Creates a collapsed border style from the given physical side.
     fn from_side(side: PhysicalSide,
-                 css_style: &ServoComputedValues,
+                 css_style: &ComputedValues,
                  provenance: CollapsedBorderProvenance)
                  -> CollapsedBorder {
         match side {
             PhysicalSide::Top => CollapsedBorder::top(css_style, provenance),
             PhysicalSide::Right => CollapsedBorder::right(css_style, provenance),
             PhysicalSide::Bottom => CollapsedBorder::bottom(css_style, provenance),
             PhysicalSide::Left => CollapsedBorder::left(css_style, provenance),
         }
     }
 
     /// Creates a collapsed border style from the inline-start border described in the given CSS
     /// style object.
-    pub fn inline_start(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    pub fn inline_start(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
                         -> CollapsedBorder {
         CollapsedBorder::from_side(css_style.writing_mode.inline_start_physical_side(),
                                    css_style,
                                    provenance)
     }
 
     /// Creates a collapsed border style from the inline-start border described in the given CSS
     /// style object.
-    pub fn inline_end(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    pub fn inline_end(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
                       -> CollapsedBorder {
         CollapsedBorder::from_side(css_style.writing_mode.inline_end_physical_side(),
                                    css_style,
                                    provenance)
     }
 
     /// Creates a collapsed border style from the block-start border described in the given CSS
     /// style object.
-    pub fn block_start(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    pub fn block_start(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
                        -> CollapsedBorder {
         CollapsedBorder::from_side(css_style.writing_mode.block_start_physical_side(),
                                    css_style,
                                    provenance)
     }
 
     /// Creates a collapsed border style from the block-end border described in the given CSS style
     /// object.
-    pub fn block_end(css_style: &ServoComputedValues, provenance: CollapsedBorderProvenance)
+    pub fn block_end(css_style: &ComputedValues, provenance: CollapsedBorderProvenance)
                      -> CollapsedBorder {
         CollapsedBorder::from_side(css_style.writing_mode.block_end_physical_side(),
                                    css_style,
                                    provenance)
     }
 
     /// If `other` has a higher priority per CSS 2.1 § 17.6.2.1, replaces `self` with it.
     pub fn combine(&mut self, other: &CollapsedBorder) {
@@ -904,17 +904,17 @@ pub struct BorderCollapseInfoForChildTab
     collapsed_border_spacing_for_row: &'a CollapsedBorderSpacingForRow,
 }
 
 /// Performs border-collapse in the inline direction for all the cells' inside borders in the
 /// inline-direction cells and propagates the outside borders (the far left and right) up to the
 /// table row. This is done eagerly here so that at least the inline inside border collapse
 /// computations can be parallelized across all the rows of the table.
 fn perform_inline_direction_border_collapse_for_row(
-        row_style: &ServoComputedValues,
+        row_style: &ComputedValues,
         children_count: usize,
         child_index: usize,
         child_table_cell: &mut TableCellFlow,
         iterator: &mut Peekable<Enumerate<MutFlowListIterator>>,
         preliminary_collapsed_borders: &mut CollapsedBordersForRow) {
     // In the first cell, combine its border with the one coming from the row.
     if child_index == 0 {
         let first_inline_border = &mut preliminary_collapsed_borders.inline[0];
--- a/servo/components/layout/table_rowgroup.rs
+++ b/servo/components/layout/table_rowgroup.rs
@@ -15,17 +15,17 @@ use flow::{Flow, FlowClass, OpaqueFlow};
 use fragment::{Fragment, FragmentBorderBoxIterator, Overflow};
 use gfx_traits::print_tree::PrintTree;
 use layout_debug;
 use serde::{Serialize, Serializer};
 use std::fmt;
 use std::iter::{IntoIterator, Iterator, Peekable};
 use style::computed_values::{border_collapse, border_spacing};
 use style::logical_geometry::LogicalSize;
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use table::{ColumnIntrinsicInlineSize, InternalTable, TableLikeFlow};
 
 /// A table formatting context.
 pub struct TableRowGroupFlow {
     /// Fields common to all block flows.
     pub block_flow: BlockFlow,
 
     /// Information about the intrinsic inline-sizes of each column.
@@ -180,17 +180,17 @@ impl Flow for TableRowGroupFlow {
         debug!("build_display_list_table_rowgroup: same process as block flow");
         self.block_flow.build_display_list(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn generated_containing_block_size(&self, flow: OpaqueFlow) -> LogicalSize<Au> {
--- a/servo/components/layout/table_wrapper.rs
+++ b/servo/components/layout/table_wrapper.rs
@@ -25,17 +25,17 @@ use fragment::{Fragment, FragmentBorderB
 use gfx_traits::print_tree::PrintTree;
 use model::MaybeAuto;
 use std::cmp::{max, min};
 use std::fmt;
 use std::ops::Add;
 use style::computed_values::{border_collapse, position, table_layout};
 use style::context::SharedStyleContext;
 use style::logical_geometry::{LogicalRect, LogicalSize};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::values::CSSFloat;
 use style::values::computed::LengthOrPercentageOrAuto;
 use table::{ColumnComputedInlineSize, ColumnIntrinsicInlineSize};
 
 #[derive(Copy, Clone, Serialize, Debug)]
 pub enum TableLayout {
     Fixed,
     Auto
@@ -461,17 +461,17 @@ impl Flow for TableWrapperFlow {
     fn build_display_list(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.build_display_list(state);
     }
 
     fn collect_stacking_contexts(&mut self, state: &mut DisplayListBuildState) {
         self.block_flow.collect_stacking_contexts(state);
     }
 
-    fn repair_style(&mut self, new_style: &::StyleArc<ServoComputedValues>) {
+    fn repair_style(&mut self, new_style: &::StyleArc<ComputedValues>) {
         self.block_flow.repair_style(new_style)
     }
 
     fn compute_overflow(&self) -> Overflow {
         self.block_flow.compute_overflow()
     }
 
     fn iterate_through_fragment_border_boxes(&self,
--- a/servo/components/layout/text.rs
+++ b/servo/components/layout/text.rs
@@ -21,17 +21,17 @@ use ordered_float::NotNaN;
 use range::Range;
 use std::borrow::ToOwned;
 use std::collections::LinkedList;
 use std::mem;
 use std::sync::Arc;
 use style::computed_values::{text_rendering, text_transform};
 use style::computed_values::{word_break, white_space};
 use style::logical_geometry::{LogicalSize, WritingMode};
-use style::properties::ServoComputedValues;
+use style::properties::ComputedValues;
 use style::properties::style_structs;
 use style::values::generics::text::LineHeight;
 use unicode_bidi as bidi;
 use unicode_script::{Script, get_script};
 
 /// Returns the concatenated text of a list of unscanned text fragments.
 fn text(fragments: &LinkedList<Fragment>) -> String {
     // FIXME: Some of this work is later duplicated in split_first_fragment_at_newline_if_necessary
@@ -440,17 +440,17 @@ pub fn font_metrics_for_style(font_conte
                               -> FontMetrics {
     let fontgroup = font_context.layout_font_group_for_style(font_style);
     // FIXME(https://github.com/rust-lang/rust/issues/23338)
     let font = fontgroup.fonts[0].borrow();
     font.metrics.clone()
 }
 
 /// Returns the line block-size needed by the given computed style and font size.
-pub fn line_height_from_style(style: &ServoComputedValues, metrics: &FontMetrics) -> Au {
+pub fn line_height_from_style(style: &ComputedValues, metrics: &FontMetrics) -> Au {
     let font_size = style.get_font().font_size;
     match style.get_inheritedtext().line_height {
         LineHeight::Normal => metrics.line_gap,
         LineHeight::Number(l) => font_size.scale_by(l),
         LineHeight::Length(l) => l
     }
 }
 
--- a/servo/components/layout_thread/dom_wrapper.rs
+++ b/servo/components/layout_thread/dom_wrapper.rs
@@ -73,17 +73,17 @@ use style::dom::{DescendantsBit, DirtyDe
 use style::dom::{PresentationalHintsSynthesizer, TElement, TNode, UnsafeNode};
 use style::element_state::*;
 use style::font_metrics::ServoMetricsProvider;
 use style::properties::{ComputedValues, PropertyDeclarationBlock};
 use style::selector_parser::{AttrValue as SelectorAttrValue, NonTSPseudoClass, PseudoClassStringArg};
 use style::selector_parser::{PseudoElement, SelectorImpl, extended_filtering};
 use style::shared_lock::{SharedRwLock as StyleSharedRwLock, Locked as StyleLocked};
 use style::str::is_whitespace;
-use style::stylearc::Arc;
+use style::stylearc::{Arc, ArcBorrow};
 
 pub unsafe fn drop_style_and_layout_data(data: OpaqueStyleAndLayoutData) {
     let ptr: *mut StyleData = data.ptr.get();
     let non_opaque: *mut StyleAndLayoutData = ptr as *mut _;
     let _ = Box::from_raw(non_opaque);
 }
 
 #[derive(Copy, Clone)]
@@ -407,19 +407,19 @@ impl<'le> TElement for ServoLayoutElemen
     type ConcreteNode = ServoLayoutNode<'le>;
 
     type FontMetricsProvider = ServoMetricsProvider;
 
     fn as_node(&self) -> ServoLayoutNode<'le> {
         ServoLayoutNode::from_layout_js(self.element.upcast())
     }
 
-    fn style_attribute(&self) -> Option<&Arc<StyleLocked<PropertyDeclarationBlock>>> {
+    fn style_attribute(&self) -> Option<ArcBorrow<StyleLocked<PropertyDeclarationBlock>>> {
         unsafe {
-            (*self.element.style_attribute()).as_ref()
+            (*self.element.style_attribute()).as_ref().map(|x| x.borrow_arc())
         }
     }
 
     fn get_state(&self) -> ElementState {
         self.element.get_state_for_layout()
     }
 
     #[inline]
--- a/servo/components/script/dom/cssrulelist.rs
+++ b/servo/components/script/dom/cssrulelist.rs
@@ -85,23 +85,25 @@ impl CSSRuleList {
             panic!("Called insert_rule on non-CssRule-backed CSSRuleList");
         };
 
         let global = self.global();
         let window = global.as_window();
         let index = idx as usize;
 
         let parent_stylesheet = self.parent_stylesheet.style_stylesheet();
-        let new_rule =
-            css_rules.insert_rule(&parent_stylesheet.shared_lock,
-                                  rule,
-                                  &parent_stylesheet.contents,
-                                  index,
-                                  nested,
-                                  None)?;
+        let new_rule = css_rules.with_raw_offset_arc(|arc| {
+            arc.insert_rule(&parent_stylesheet.shared_lock,
+                            rule,
+                            &parent_stylesheet.contents,
+                            index,
+                            nested,
+                            None)
+        })?;
+
 
         let parent_stylesheet = &*self.parent_stylesheet;
         let dom_rule = CSSRule::new_specific(&window, parent_stylesheet, new_rule);
         self.dom_rules.borrow_mut().insert(index, MutNullableJS::new(Some(&*dom_rule)));
         Ok((idx))
     }
 
     // In case of a keyframe rule, index must be valid.
--- a/servo/components/script_layout_interface/wrapper_traits.rs
+++ b/servo/components/script_layout_interface/wrapper_traits.rs
@@ -17,17 +17,17 @@ use servo_url::ServoUrl;
 use std::fmt::Debug;
 use style::attr::AttrValue;
 use style::computed_values::display;
 use style::context::SharedStyleContext;
 use style::data::ElementData;
 use style::dom::{LayoutIterator, NodeInfo, PresentationalHintsSynthesizer, TNode};
 use style::dom::OpaqueNode;
 use style::font_metrics::ServoMetricsProvider;
-use style::properties::{CascadeFlags, ServoComputedValues};
+use style::properties::{CascadeFlags, ComputedValues};
 use style::selector_parser::{PseudoElement, PseudoElementCascadeType, SelectorImpl};
 use style::stylearc::Arc;
 use style::stylist::RuleInclusion;
 use webrender_api::ClipId;
 
 #[derive(Copy, PartialEq, Clone, Debug)]
 pub enum PseudoElementType<T> {
     Normal,
@@ -176,17 +176,17 @@ pub trait ThreadSafeLayoutNode: Clone + 
     /// Returns the style for a text node. This is computed on the fly from the
     /// parent style to avoid traversing text nodes in the style system.
     ///
     /// Note that this does require accessing the parent, which this interface
     /// technically forbids. But accessing the parent is only unsafe insofar as
     /// it can be used to reach siblings and cousins. A simple immutable borrow
     /// of the parent data is fine, since the bottom-up traversal will not process
     /// the parent until all the children have been processed.
-    fn parent_style(&self) -> Arc<ServoComputedValues>;
+    fn parent_style(&self) -> Arc<ComputedValues>;
 
     #[inline]
     fn is_element_or_elements_pseudo(&self) -> bool {
         match self.type_id_without_excluding_pseudo_elements() {
             LayoutNodeType::Element(..) => true,
             _ => false,
         }
     }
@@ -218,28 +218,28 @@ pub trait ThreadSafeLayoutNode: Clone + 
 
     #[inline]
     fn get_pseudo_element_type(&self) -> PseudoElementType<Option<display::T>> {
         self.as_element().map_or(PseudoElementType::Normal, |el| el.get_pseudo_element_type())
     }
 
     fn get_style_and_layout_data(&self) -> Option<OpaqueStyleAndLayoutData>;
 
-    fn style(&self, context: &SharedStyleContext) -> Arc<ServoComputedValues> {
+    fn style(&self, context: &SharedStyleContext) -> Arc<ComputedValues> {
         if let Some(el) = self.as_element() {
             el.style(context)
         } else {
             // Text nodes are not styled during traversal,instead we simply
             // return parent style here and do cascading during layout.
             debug_assert!(self.is_text_node());
             self.parent_style()
         }
     }
 
-    fn selected_style(&self) -> Arc<ServoComputedValues> {
+    fn selected_style(&self) -> Arc<ComputedValues> {
         if let Some(el) = self.as_element() {
             el.selected_style()
         } else {
             debug_assert!(self.is_text_node());
             // TODO(stshine): What should the selected style be for text?
             self.parent_style()
         }
     }
@@ -388,17 +388,17 @@ pub trait ThreadSafeLayoutElement: Clone
         }
     }
 
     /// Returns the style results for the given node. If CSS selector matching
     /// has not yet been performed, fails.
     ///
     /// Unlike the version on TNode, this handles pseudo-elements.
     #[inline]
-    fn style(&self, context: &SharedStyleContext) -> Arc<ServoComputedValues> {
+    fn style(&self, context: &SharedStyleContext) -> Arc<ComputedValues> {
         let data = self.style_data();
         match self.get_pseudo_element_type() {
             PseudoElementType::Normal => {
                 data.styles.primary().clone()
             },
             other => {
                 // Precompute non-eagerly-cascaded pseudo-element styles if not
                 // cached before.
@@ -411,55 +411,55 @@ pub trait ThreadSafeLayoutElement: Clone
                             .unwrap().clone()
                     },
                     PseudoElementCascadeType::Precomputed => {
                         context.stylist.precomputed_values_for_pseudo(
                             &context.guards,
                             &style_pseudo,
                             Some(data.styles.primary()),
                             CascadeFlags::empty(),
-                            &ServoMetricsProvider)
+                            &ServoMetricsProvider, (), ())
                             .clone()
                     }
                     PseudoElementCascadeType::Lazy => {
                         context.stylist
                                .lazily_compute_pseudo_element_style(
                                    &context.guards,
                                    unsafe { &self.unsafe_get() },
                                    &style_pseudo,
                                    RuleInclusion::All,
                                    data.styles.primary(),
                                    /* is_probe = */ false,
-                                   &ServoMetricsProvider)
+                                   &ServoMetricsProvider, (), ())
                                .unwrap()
                                .clone()
                     }
                 }
             }
         }
     }
 
     #[inline]
-    fn selected_style(&self) -> Arc<ServoComputedValues> {
+    fn selected_style(&self) -> Arc<ComputedValues> {
         let data = self.style_data();
         data.styles.pseudos
             .get(&PseudoElement::Selection).map(|s| s)
             .unwrap_or(data.styles.primary())
             .clone()
     }
 
     /// Returns the already resolved style of the node.
     ///
     /// This differs from `style(ctx)` in that if the pseudo-element has not yet
     /// been computed it would panic.
     ///
     /// This should be used just for querying layout, or when we know the
     /// element style is precomputed, not from general layout itself.
     #[inline]
-    fn resolved_style(&self) -> Arc<ServoComputedValues> {
+    fn resolved_style(&self) -> Arc<ComputedValues> {
         let data = self.style_data();
         match self.get_pseudo_element_type() {
             PseudoElementType::Normal
                 => data.styles.primary().clone(),
             other
                 => data.styles.pseudos
                        .get(&other.style_pseudo_element()).unwrap().clone(),
         }
--- a/servo/components/servo_arc/lib.rs
+++ b/servo/components/servo_arc/lib.rs
@@ -189,16 +189,40 @@ impl<T> Arc<T> {
     pub unsafe fn from_raw(ptr: *const T) -> Self {
         // To find the corresponding pointer to the `ArcInner` we need
         // to subtract the offset of the `data` field from the pointer.
         let ptr = (ptr as *const u8).offset(-offset_of!(ArcInner<T>, data));
         Arc {
             p: NonZeroPtrMut::new(ptr as *mut ArcInner<T>),
         }
     }
+
+    /// Produce a pointer to the data that can be converted back
+    /// to an arc
+    pub fn borrow_arc<'a>(&'a self) -> ArcBorrow<'a, T> {
+        ArcBorrow(&**self)
+    }
+    /// Temporarily converts |self| into a bonafide RawOffsetArc and exposes it to the
+    /// provided callback. The refcount is not modified.
+    #[inline(always)]
+    pub fn with_raw_offset_arc<F, U>(&self, f: F) -> U
+        where F: FnOnce(&RawOffsetArc<T>) -> U
+    {
+        // Synthesize transient Arc, which never touches the refcount of the ArcInner.
+        let transient = unsafe { NoDrop::new(Arc::into_raw_offset(ptr::read(self))) };
+
+        // Expose the transient Arc to the callback, which may clone it if it wants.
+        let result = f(&transient);
+
+        // Forget the transient Arc to leave the refcount untouched.
+        mem::forget(transient);
+
+        // Forward the result.
+        result
+    }
 }
 
 impl<T: ?Sized> Arc<T> {
     #[inline]
     fn inner(&self) -> &ArcInner<T> {
         // This unsafety is ok because while this arc is alive we're guaranteed
         // that the inner pointer is valid. Furthermore, we know that the
         // `ArcInner` structure itself is `Sync` because the inner data is
@@ -632,16 +656,18 @@ impl<H: 'static, T: 'static> ThinArc<H, 
         let transient = NoDrop::new(Arc {
             p: NonZeroPtrMut::new(thin_to_thick(self.ptr))
         });
 
         // Expose the transient Arc to the callback, which may clone it if it wants.
         let result = f(&transient);
 
         // Forget the transient Arc to leave the refcount untouched.
+        // XXXManishearth this can be removed when unions stabilize,
+        // since then NoDrop becomes zero overhead
         mem::forget(transient);
 
         // Forward the result.
         result
     }
 }
 
 impl<H, T> Deref for ThinArc<H, T> {
@@ -695,16 +721,203 @@ impl<H: PartialEq + 'static, T: PartialE
                 *a == *b
             })
         })
     }
 }
 
 impl<H: Eq + 'static, T: Eq + 'static> Eq for ThinArc<H, T> {}
 
+/// An Arc, except it holds a pointer to the T instead of to the
+/// entire ArcInner.
+///
+/// ```text
+///  Arc<T>    RawOffsetArc<T>
+///   |          |
+///   v          v
+///  ---------------------
+/// | RefCount | T (data) | [ArcInner<T>]
+///  ---------------------
+/// ```
+///
+/// This means that this is a direct pointer to
+/// its contained data (and can be read from by both C++ and Rust),
+/// but we can also convert it to a "regular" Arc<T> by removing the offset
+#[derive(Eq)]
+pub struct RawOffsetArc<T: 'static> {
+    ptr: NonZeroPtrMut<T>,
+}
+
+unsafe impl<T: 'static + Sync + Send> Send for RawOffsetArc<T> {}
+unsafe impl<T: 'static + Sync + Send> Sync for RawOffsetArc<T> {}
+
+impl<T: 'static> Deref for RawOffsetArc<T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.ptr.ptr() }
+    }
+}
+
+impl<T: 'static> Clone for RawOffsetArc<T> {
+    fn clone(&self) -> Self {
+        Arc::into_raw_offset(self.clone_arc())
+    }
+}
+
+impl<T: 'static> Drop for RawOffsetArc<T> {
+    fn drop(&mut self) {
+        let _ = Arc::from_raw_offset(RawOffsetArc { ptr: self.ptr.clone() });
+    }
+}
+
+
+impl<T: fmt::Debug + 'static> fmt::Debug for RawOffsetArc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+impl<T: PartialEq> PartialEq for RawOffsetArc<T> {
+    fn eq(&self, other: &RawOffsetArc<T>) -> bool {
+        *(*self) == *(*other)
+    }
+
+    fn ne(&self, other: &RawOffsetArc<T>) -> bool {
+        *(*self) != *(*other)
+    }
+}
+
+impl<T: 'static> RawOffsetArc<T> {
+    /// Temporarily converts |self| into a bonafide Arc and exposes it to the
+    /// provided callback. The refcount is not modified.
+    #[inline(always)]
+    pub fn with_arc<F, U>(&self, f: F) -> U
+        where F: FnOnce(&Arc<T>) -> U
+    {
+        // Synthesize transient Arc, which never touches the refcount of the ArcInner.
+        let transient = unsafe { NoDrop::new(Arc::from_raw(self.ptr.ptr())) };
+
+        // Expose the transient Arc to the callback, which may clone it if it wants.
+        let result = f(&transient);
+
+        // Forget the transient Arc to leave the refcount untouched.
+        // XXXManishearth this can be removed when unions stabilize,
+        // since then NoDrop becomes zero overhead
+        mem::forget(transient);
+
+        // Forward the result.
+        result
+    }
+
+    /// If uniquely owned, provide a mutable reference
+    /// Else create a copy, and mutate that
+    pub fn make_mut(&mut self) -> &mut T where T: Clone {
+        unsafe {
+            // extract the RawOffsetArc as an owned variable
+            let this = ptr::read(self);
+            // treat it as a real Arc
+            let mut arc = Arc::from_raw_offset(this);
+            // obtain the mutable reference. Cast away the lifetime
+            // This may mutate `arc`
+            let ret = Arc::make_mut(&mut arc) as *mut _;
+            // Store the possibly-mutated arc back inside, after converting
+            // it to a RawOffsetArc again
+            ptr::write(self, Arc::into_raw_offset(arc));
+            &mut *ret
+        }
+    }
+
+    /// Clone it as an Arc
+    pub fn clone_arc(&self) -> Arc<T> {
+        RawOffsetArc::with_arc(self, |a| a.clone())
+    }
+
+    /// Produce a pointer to the data that can be converted back
+    /// to an arc
+    pub fn borrow_arc<'a>(&'a self) -> ArcBorrow<'a, T> {
+        ArcBorrow(&**self)
+    }
+}
+
+impl<T: 'static> Arc<T> {
+    /// Converts an Arc into a RawOffsetArc. This consumes the Arc, so the refcount
+    /// is not modified.
+    #[inline]
+    pub fn into_raw_offset(a: Self) -> RawOffsetArc<T> {
+        RawOffsetArc {
+            ptr: NonZeroPtrMut::new(Arc::into_raw(a) as *mut T),
+        }
+    }
+
+    /// Converts a RawOffsetArc into an Arc. This consumes the RawOffsetArc, so the refcount
+    /// is not modified.
+    #[inline]
+    pub fn from_raw_offset(a: RawOffsetArc<T>) -> Self {
+        let ptr = a.ptr.ptr();
+        mem::forget(a);
+        unsafe { Arc::from_raw(ptr) }
+    }
+}
+
+/// A "borrowed Arc". This is a pointer to
+/// a T that is known to have been allocated within an
+/// Arc.
+///
+/// This is equivalent in guarantees to `&Arc<T>`, however it is
+/// a bit more flexible. To obtain an `&Arc<T>` you must have
+/// an Arc<T> instance somewhere pinned down until we're done with it.
+///
+/// However, Gecko hands us refcounted things as pointers to T directly,
+/// so we have to conjure up a temporary Arc on the stack each time. The
+/// same happens for when the object is managed by a RawOffsetArc.
+///
+/// ArcBorrow lets us deal with borrows of known-refcounted objects
+/// without needing to worry about how they're actually stored.
+#[derive(PartialEq, Eq)]
+pub struct ArcBorrow<'a, T: 'a>(&'a T);
+
+impl<'a, T> Copy for ArcBorrow<'a, T> {}
+impl<'a, T> Clone for ArcBorrow<'a, T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, T> ArcBorrow<'a, T> {
+    pub fn clone_arc(&self) -> Arc<T> {
+        let arc = unsafe { Arc::from_raw(self.0) };
+        // addref it!
+        mem::forget(arc.clone());
+        arc
+    }
+
+    pub fn with_arc<F, U>(&self, f: F) -> U where F: FnOnce(&Arc<T>) -> U, T: 'static {
+        // Synthesize transient Arc, which never touches the refcount.
+        let transient = unsafe { NoDrop::new(Arc::from_raw(self.0)) };
+
+        // Expose the transient Arc to the callback, which may clone it if it wants.
+        let result = f(&transient);
+
+        // Forget the transient Arc to leave the refcount untouched.
+        // XXXManishearth this can be removed when unions stabilize,
+        // since then NoDrop becomes zero overhead
+        mem::forget(transient);
+
+        // Forward the result.
+        result
+    }
+}
+
+impl<'a, T> Deref for ArcBorrow<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        &*self.0
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::clone::Clone;
     use std::ops::Drop;
     use std::sync::atomic;
     use std::sync::atomic::Ordering::{Acquire, SeqCst};
     use super::{Arc, HeaderWithLength, ThinArc};
 
--- a/servo/components/style/animation.rs
+++ b/servo/components/style/animation.rs
@@ -6,17 +6,17 @@
 #![deny(missing_docs)]
 
 use Atom;
 use bezier::Bezier;
 use context::SharedStyleContext;
 use dom::OpaqueNode;
 use euclid::Point2D;
 use font_metrics::FontMetricsProvider;
-use properties::{self, CascadeFlags, ComputedValues, Importance};
+use properties::{self, CascadeFlags, ComputedValues, ComputedValuesInner, Importance};
 use properties::animated_properties::{AnimatableLonghand, AnimatedProperty, TransitionProperty};
 use properties::longhands::animation_direction::computed_value::single_value::T as AnimationDirection;
 use properties::longhands::animation_iteration_count::single_value::computed_value::T as AnimationIterationCount;
 use properties::longhands::animation_play_state::computed_value::single_value::T as AnimationPlayState;
 use rule_tree::CascadeLevel;
 use std::sync::mpsc::Sender;
 use stylearc::Arc;
 use stylesheets::keyframes_rule::{KeyframesStep, KeyframesStepValue};
@@ -342,18 +342,18 @@ impl PropertyAnimation {
                                                     duration,
                                                     old_style,
                                                     new_style)
     }
 
     fn from_animatable_longhand(animatable_longhand: &AnimatableLonghand,
                                 timing_function: TimingFunction,
                                 duration: Time,
-                                old_style: &ComputedValues,
-                                new_style: &ComputedValues)
+                                old_style: &ComputedValuesInner,
+                                new_style: &ComputedValuesInner)
                                 -> Option<PropertyAnimation> {
         let animated_property = AnimatedProperty::from_animatable_longhand(animatable_longhand,
                                                                            old_style,
                                                                            new_style);
 
         let property_animation = PropertyAnimation {
             property: animated_property,
             timing_function: timing_function,
@@ -475,20 +475,20 @@ pub fn start_transitions_if_applicable(n
         }
     }
 
     had_animations
 }
 
 fn compute_style_for_animation_step(context: &SharedStyleContext,
                                     step: &KeyframesStep,
-                                    previous_style: &ComputedValues,
-                                    style_from_cascade: &ComputedValues,
+                                    previous_style: &ComputedValuesInner,
+                                    style_from_cascade: &ComputedValuesInner,
                                     font_metrics_provider: &FontMetricsProvider)
-                                    -> ComputedValues {
+                                    -> ComputedValuesInner {
     match step.value {
         KeyframesStepValue::ComputedValues => style_from_cascade.clone(),
         KeyframesStepValue::Declarations { block: ref declarations } => {
             let guard = declarations.read_with(context.guards.author);
 
             // No !important in keyframes.
             debug_assert!(guard.declarations().iter()
                             .all(|&(_, importance)| importance == Importance::Normal));
--- a/servo/components/style/dom.rs
+++ b/servo/components/style/dom.rs
@@ -10,32 +10,32 @@
 use {Atom, Namespace, LocalName};
 use applicable_declarations::ApplicableDeclarationBlock;
 use atomic_refcell::{AtomicRef, AtomicRefCell, AtomicRefMut};
 #[cfg(feature = "gecko")] use context::UpdateAnimationsTasks;
 use data::ElementData;
 use element_state::ElementState;
 use font_metrics::FontMetricsProvider;
 use media_queries::Device;
-use properties::{AnimationRules, ComputedValues, PropertyDeclarationBlock};
+use properties::{AnimationRules, ComputedValues, ComputedValuesInner, PropertyDeclarationBlock};
 #[cfg(feature = "gecko")] use properties::animated_properties::AnimationValue;
 #[cfg(feature = "gecko")] use properties::animated_properties::TransitionProperty;
 use rule_tree::CascadeLevel;
 use selector_parser::{AttrValue, ElementExt, PreExistingComputedValues};
 use selector_parser::{PseudoClassStringArg, PseudoElement};
 use selectors::matching::{ElementSelectorFlags, VisitedHandlingMode};
 use selectors::sink::Push;
 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 stylearc::Arc;
+use stylearc::{Arc, ArcBorrow};
 use stylist::Stylist;
 use thread_state;
 
 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
@@ -355,25 +355,25 @@ pub trait TElement : Eq + PartialEq + De
 
     /// For a given NAC element, return the closest non-NAC ancestor, which is
     /// guaranteed to exist.
     fn closest_non_native_anonymous_ancestor(&self) -> Option<Self> {
         unreachable!("Servo doesn't know about NAC");
     }
 
     /// Get this element's style attribute.
-    fn style_attribute(&self) -> Option<&Arc<Locked<PropertyDeclarationBlock>>>;
+    fn style_attribute(&self) -> Option<ArcBorrow<Locked<PropertyDeclarationBlock>>>;
 
     /// Unset the style attribute's dirty bit.
     /// Servo doesn't need to manage ditry bit for style attribute.
     fn unset_dirty_style_attribute(&self) {
     }
 
     /// Get this element's SMIL override declarations.
-    fn get_smil_override(&self) -> Option<&Arc<Locked<PropertyDeclarationBlock>>> {
+    fn get_smil_override(&self) -> Option<ArcBorrow<Locked<PropertyDeclarationBlock>>> {
         None
     }
 
     /// Get this element's animation rule by the cascade level.
     fn get_animation_rule_by_cascade(&self,
                                      _cascade_level: CascadeLevel)
                                      -> Option<Arc<Locked<PropertyDeclarationBlock>>> {
         None
@@ -431,17 +431,17 @@ pub trait TElement : Eq + PartialEq + De
     ///
     /// This is useful to avoid computing, for example, pseudo styles for
     /// `::-first-line` or `::-first-letter`, when we know it won't affect us.
     ///
     /// TODO(emilio, bz): actually implement the logic for it.
     fn may_generate_pseudo(
         &self,
         pseudo: &PseudoElement,
-        _primary_style: &ComputedValues,
+        _primary_style: &ComputedValuesInner,
     ) -> bool {
         // ::before/::after are always supported for now, though we could try to
         // optimize out leaf elements.
 
         // ::first-letter and ::first-line are only supported for block-inside
         // things, and only in Gecko, not Servo.  Unfortunately, Gecko has
         // block-inside things that might have any computed display value due to
         // things like fieldsets, legends, etc.  Need to figure out how this
--- a/servo/components/style/gecko/arc_types.rs
+++ b/servo/components/style/gecko/arc_types.rs
@@ -5,21 +5,21 @@
 //! This file lists all arc FFI types and defines corresponding addref
 //! and release functions. This list corresponds to ServoArcTypeList.h
 //! file in Gecko.
 
 #![allow(non_snake_case, missing_docs)]
 
 use gecko_bindings::bindings::{RawServoImportRule, RawServoSupportsRule};
 use gecko_bindings::bindings::{RawServoKeyframe, RawServoKeyframesRule};
-use gecko_bindings::bindings::{RawServoNamespaceRule, RawServoPageRule};
-use gecko_bindings::bindings::{RawServoRuleNode, RawServoRuleNodeStrong, RawServoDocumentRule, RawServoMediaRule};
-use gecko_bindings::bindings::{ServoComputedValues, ServoCssRules};
+use gecko_bindings::bindings::{RawServoMediaRule, RawServoNamespaceRule, RawServoPageRule};
+use gecko_bindings::bindings::{RawServoRuleNode, RawServoRuleNodeStrong, RawServoDocumentRule};
+use gecko_bindings::bindings::ServoCssRules;
 use gecko_bindings::structs::{RawServoAnimationValue, RawServoDeclarationBlock, RawServoStyleRule, RawServoMediaList};
-use gecko_bindings::structs::RawServoStyleSheetContents;
+use gecko_bindings::structs::{RawServoStyleSheetContents, ServoStyleContext};
 use gecko_bindings::sugar::ownership::{HasArcFFI, HasFFI};
 use media_queries::MediaList;
 use properties::{ComputedValues, PropertyDeclarationBlock};
 use properties::animated_properties::AnimationValue;
 use rule_tree::StrongRuleNode;
 use shared_lock::Locked;
 use std::{mem, ptr};
 use stylesheets::{CssRules, StylesheetContents, StyleRule, ImportRule, KeyframesRule, MediaRule};
@@ -46,18 +46,18 @@ macro_rules! impl_arc_ffi {
 }
 
 impl_arc_ffi!(Locked<CssRules> => ServoCssRules
               [Servo_CssRules_AddRef, Servo_CssRules_Release]);
 
 impl_arc_ffi!(StylesheetContents => RawServoStyleSheetContents
               [Servo_StyleSheetContents_AddRef, Servo_StyleSheetContents_Release]);
 
-impl_arc_ffi!(ComputedValues => ServoComputedValues
-              [Servo_ComputedValues_AddRef, Servo_ComputedValues_Release]);
+impl_arc_ffi!(ComputedValues => ServoStyleContext
+              [Servo_StyleContext_AddRef, Servo_StyleContext_Release]);
 
 impl_arc_ffi!(Locked<PropertyDeclarationBlock> => RawServoDeclarationBlock
               [Servo_DeclarationBlock_AddRef, Servo_DeclarationBlock_Release]);
 
 impl_arc_ffi!(Locked<StyleRule> => RawServoStyleRule
               [Servo_StyleRule_AddRef, Servo_StyleRule_Release]);
 
 impl_arc_ffi!(Locked<ImportRule> => RawServoImportRule
--- a/servo/components/style/gecko/data.rs
+++ b/servo/components/style/gecko/data.rs
@@ -11,17 +11,17 @@ use fnv::FnvHashMap;
 use gecko::rules::{CounterStyleRule, FontFaceRule};
 use gecko_bindings::bindings::{self, RawServoStyleSet};
 use gecko_bindings::structs::{ServoStyleSheet, StyleSheetInfo, ServoStyleSheetInner};
 use gecko_bindings::structs::RawGeckoPresContextOwned;
 use gecko_bindings::structs::nsIDocument;
 use gecko_bindings::sugar::ownership::{HasArcFFI, HasBoxFFI, HasFFI, HasSimpleFFI};
 use invalidation::media_queries::{MediaListKey, ToMediaListKey};
 use media_queries::{Device, MediaList};
-use properties::ComputedValues;
+use properties::ComputedValuesInner;
 use shared_lock::{Locked, StylesheetGuards, SharedRwLockReadGuard};
 use stylearc::Arc;
 use stylesheet_set::StylesheetSet;
 use stylesheets::{Origin, StylesheetContents, StylesheetInDocument};
 use stylist::{ExtraStyleData, Stylist};
 
 /// Little wrapper to a Gecko style sheet.
 #[derive(PartialEq, Eq, Debug)]
@@ -183,18 +183,18 @@ impl PerDocumentStyleDataImpl {
             /* ua_sheets = */ None,
             /* stylesheets_changed = */ true,
             author_style_disabled,
             &mut extra_data
         );
     }
 
     /// Get the default computed values for this document.
-    pub fn default_computed_values(&self) -> &Arc<ComputedValues> {
-        self.stylist.device().default_computed_values_arc()
+    pub fn default_computed_values(&self) -> &ComputedValuesInner {
+        self.stylist.device().default_computed_values()
     }
 
     /// Clear the stylist.  This will be a no-op if the stylist is
     /// already cleared; the stylist handles that.
     pub fn clear_stylist(&mut self) {
         self.stylist.clear();
     }
 }
--- a/servo/components/style/gecko/generated/bindings.rs
+++ b/servo/components/style/gecko/generated/bindings.rs
@@ -1,15 +1,19 @@
 /* automatically generated by rust-bindgen */
 
 pub use nsstring::{nsACString, nsAString, nsString, nsStringRepr};
 use gecko_bindings::structs::nsStyleTransformMatrix;
 use gecko_bindings::structs::nsTArray;
 type nsACString_internal = nsACString;
 type nsAString_internal = nsAString;
+pub type ServoStyleContextBorrowed<'a> = &'a ServoStyleContext;
+pub type ServoStyleContextBorrowedOrNull<'a> = Option<&'a ::properties::ComputedValues>;
+pub type ServoComputedValuesBorrowed<'a> = &'a ServoComputedValues;
+pub type ServoComputedValuesBorrowedOrNull<'a> = Option<&'a ServoComputedValues>;
 use gecko_bindings::structs::mozilla::css::GridTemplateAreasValue;
 use gecko_bindings::structs::mozilla::css::ErrorReporter;
 use gecko_bindings::structs::mozilla::css::ImageValue;
 use gecko_bindings::structs::mozilla::css::URLValue;
 use gecko_bindings::structs::mozilla::css::URLValueData;
 use gecko_bindings::structs::mozilla::MallocSizeOf;
 use gecko_bindings::structs::mozilla::Side;
 use gecko_bindings::structs::nsIContent;
@@ -210,16 +214,19 @@ unsafe impl Send for nsStyleXUL {}
 unsafe impl Sync for nsStyleXUL {}
 use gecko_bindings::structs::nsTimingFunction;
 use gecko_bindings::structs::nscolor;
 use gecko_bindings::structs::nscoord;
 use gecko_bindings::structs::nsresult;
 use gecko_bindings::structs::Loader;
 use gecko_bindings::structs::LoaderReusableStyleSheets;
 use gecko_bindings::structs::ServoStyleSheet;
+use gecko_bindings::structs::ServoComputedValues;
+use gecko_bindings::structs::ServoStyleContext;
+use gecko_bindings::structs::ServoStyleContextStrong;
 use gecko_bindings::structs::EffectCompositor_CascadeLevel;
 use gecko_bindings::structs::UpdateAnimationsTasks;
 use gecko_bindings::structs::ParsingMode;
 use gecko_bindings::structs::InheritTarget;
 use gecko_bindings::structs::URLMatchingFunction;
 use gecko_bindings::structs::StyleRuleInclusion;
 use gecko_bindings::structs::nsStyleTransformMatrix::MatrixTransformOperator;
 unsafe impl Send for nsStyleTransformMatrix::MatrixTransformOperator {}
@@ -309,21 +316,16 @@ pub type RawGeckoServoAnimationValueList
 pub type ServoCssRulesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoCssRules>;
 pub type ServoCssRulesBorrowed<'a> = &'a ServoCssRules;
 pub type ServoCssRulesBorrowedOrNull<'a> = Option<&'a ServoCssRules>;
 enum ServoCssRulesVoid { }
 pub struct ServoCssRules(ServoCssRulesVoid);
 pub type RawServoStyleSheetContentsStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleSheetContents>;
 pub type RawServoStyleSheetContentsBorrowed<'a> = &'a RawServoStyleSheetContents;
 pub type RawServoStyleSheetContentsBorrowedOrNull<'a> = Option<&'a RawServoStyleSheetContents>;
-pub type ServoComputedValuesStrong = ::gecko_bindings::sugar::ownership::Strong<ServoComputedValues>;
-pub type ServoComputedValuesBorrowed<'a> = &'a ServoComputedValues;
-pub type ServoComputedValuesBorrowedOrNull<'a> = Option<&'a ServoComputedValues>;
-enum ServoComputedValuesVoid { }
-pub struct ServoComputedValues(ServoComputedValuesVoid);
 pub type RawServoDeclarationBlockStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoDeclarationBlock>;
 pub type RawServoDeclarationBlockBorrowed<'a> = &'a RawServoDeclarationBlock;
 pub type RawServoDeclarationBlockBorrowedOrNull<'a> = Option<&'a RawServoDeclarationBlock>;
 pub type RawServoStyleRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoStyleRule>;
 pub type RawServoStyleRuleBorrowed<'a> = &'a RawServoStyleRule;
 pub type RawServoStyleRuleBorrowedOrNull<'a> = Option<&'a RawServoStyleRule>;
 pub type RawServoImportRuleStrong = ::gecko_bindings::sugar::ownership::Strong<RawServoImportRule>;
 pub type RawServoImportRuleBorrowed<'a> = &'a RawServoImportRule;
@@ -395,22 +397,16 @@ extern "C" {
     pub fn Servo_StyleSheetContents_AddRef(ptr:
                                                RawServoStyleSheetContentsBorrowed);
 }
 extern "C" {
     pub fn Servo_StyleSheetContents_Release(ptr:
                                                 RawServoStyleSheetContentsBorrowed);
 }
 extern "C" {
-    pub fn Servo_ComputedValues_AddRef(ptr: ServoComputedValuesBorrowed);
-}
-extern "C" {
-    pub fn Servo_ComputedValues_Release(ptr: ServoComputedValuesBorrowed);
-}
-extern "C" {
     pub fn Servo_DeclarationBlock_AddRef(ptr:
                                              RawServoDeclarationBlockBorrowed);
 }
 extern "C" {
     pub fn Servo_DeclarationBlock_Release(ptr:
                                               RawServoDeclarationBlockBorrowed);
 }
 extern "C" {
@@ -524,16 +520,29 @@ extern "C" {
                                                    RawGeckoElementBorrowed)
      -> *mut nsTArray<*mut nsIContent>;
 }
 extern "C" {
     pub fn Gecko_DestroyAnonymousContentList(anon_content:
                                                  *mut nsTArray<*mut nsIContent>);
 }
 extern "C" {
+    pub fn Gecko_ServoStyleContext_Init(context: *mut ServoStyleContext,
+                                        parent_context:
+                                            ServoStyleContextBorrowedOrNull,
+                                        pres_context:
+                                            RawGeckoPresContextBorrowed,
+                                        values: ServoComputedValuesBorrowed,
+                                        pseudo_type: CSSPseudoElementType,
+                                        pseudo_tag: *mut nsIAtom);
+}
+extern "C" {
+    pub fn Gecko_ServoStyleContext_Destroy(context: *mut ServoStyleContext);
+}
+extern "C" {
     pub fn Gecko_ConstructStyleChildrenIterator(aElement:
                                                     RawGeckoElementBorrowed,
                                                 aIterator:
                                                     RawGeckoStyleChildrenIteratorBorrowedMut);
 }
 extern "C" {
     pub fn Gecko_DestroyStyleChildrenIterator(aIterator:
                                                   RawGeckoStyleChildrenIteratorBorrowedMut);
@@ -750,19 +759,19 @@ extern "C" {
                                            RawGeckoStyleAnimationListBorrowed,
                                        arg2:
                                            RawGeckoStyleAnimationListBorrowed)
      -> bool;
 }
 extern "C" {
     pub fn Gecko_UpdateAnimations(aElementOrPseudo: RawGeckoElementBorrowed,
                                   aOldComputedValues:
-                                      ServoComputedValuesBorrowedOrNull,
+                                      ServoStyleContextBorrowedOrNull,
                                   aComputedValues:
-                                      ServoComputedValuesBorrowedOrNull,
+                                      ServoStyleContextBorrowedOrNull,
                                   aTasks: UpdateAnimationsTasks);
 }
 extern "C" {
     pub fn Gecko_ElementHasAnimations(aElementOrPseudo:
                                           RawGeckoElementBorrowed) -> bool;
 }
 extern "C" {
     pub fn Gecko_ElementHasCSSAnimations(aElementOrPseudo:
@@ -1952,20 +1961,20 @@ extern "C" {
     pub fn Servo_StyleSet_GetCounterStyleRule(set: RawServoStyleSetBorrowed,
                                               name: *mut nsIAtom)
      -> *mut nsCSSCounterStyleRule;
 }
 extern "C" {
     pub fn Servo_StyleSet_ResolveForDeclarations(set:
                                                      RawServoStyleSetBorrowed,
                                                  parent_style:
-                                                     ServoComputedValuesBorrowedOrNull,
+                                                     ServoStyleContextBorrowedOrNull,
                                                  declarations:
                                                      RawServoDeclarationBlockBorrowed)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_StyleSet_MightHaveAttributeDependency(set:
                                                            RawServoStyleSetBorrowed,
                                                        element:
                                                            RawGeckoElementBorrowed,
                                                        local_name:
                                                            *mut nsIAtom)
@@ -2656,33 +2665,32 @@ extern "C" {
     pub fn Servo_CSSSupports2(name: *const nsACString,
                               value: *const nsACString) -> bool;
 }
 extern "C" {
     pub fn Servo_CSSSupports(cond: *const nsACString) -> bool;
 }
 extern "C" {
     pub fn Servo_ComputedValues_GetForAnonymousBox(parent_style_or_null:
-                                                       ServoComputedValuesBorrowedOrNull,
+                                                       ServoStyleContextBorrowedOrNull,
+                                                   pseudo_type:
+                                                       CSSPseudoElementType,
                                                    pseudo_tag: *mut nsIAtom,
                                                    set:
                                                        RawServoStyleSetBorrowed)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_ComputedValues_Inherit(set: RawServoStyleSetBorrowed,
+                                        pseudo_type: CSSPseudoElementType,
+                                        pseudo_tag: *mut nsIAtom,
                                         parent_style:
-                                            ServoComputedValuesBorrowedOrNull,
+                                            ServoStyleContextBorrowedOrNull,
                                         target: InheritTarget)
-     -> ServoComputedValuesStrong;
-}
-extern "C" {
-    pub fn Servo_ComputedValues_GetVisitedStyle(values:
-                                                    ServoComputedValuesBorrowed)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_ComputedValues_GetStyleBits(values:
                                                  ServoComputedValuesBorrowed)
      -> u64;
 }
 extern "C" {
     pub fn Servo_ComputedValues_EqualCustomProperties(first:
@@ -2693,16 +2701,26 @@ extern "C" {
 }
 extern "C" {
     pub fn Servo_ComputedValues_GetStyleRuleList(values:
                                                      ServoComputedValuesBorrowed,
                                                  rules:
                                                      RawGeckoServoStyleRuleListBorrowedMut);
 }
 extern "C" {
+    pub fn Servo_StyleContext_NewContext(values: ServoComputedValuesBorrowed,
+                                         parent:
+                                             ServoStyleContextBorrowedOrNull,
+                                         pres_context:
+                                             RawGeckoPresContextBorrowed,
+                                         pseudo_type: CSSPseudoElementType,
+                                         pseudo_tag: *mut nsIAtom)
+     -> ServoStyleContextStrong;
+}
+extern "C" {
     pub fn Servo_Initialize(dummy_url_data: *mut RawGeckoURLExtraData);
 }
 extern "C" {
     pub fn Servo_Shutdown();
 }
 extern "C" {
     pub fn Servo_NoteExplicitHints(element: RawGeckoElementBorrowed,
                                    restyle_hint: nsRestyleHint,
@@ -2711,44 +2729,49 @@ extern "C" {
 extern "C" {
     pub fn Servo_TakeChangeHint(element: RawGeckoElementBorrowed,
                                 restyle_behavior: TraversalRestyleBehavior,
                                 was_restyled: *mut bool) -> nsChangeHint;
 }
 extern "C" {
     pub fn Servo_ResolveStyle(element: RawGeckoElementBorrowed,
                               set: RawServoStyleSetBorrowed)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_ResolvePseudoStyle(element: RawGeckoElementBorrowed,
                                     pseudo_type: CSSPseudoElementType,
-                                    is_probe: bool,
+                                    pseudo_tag: *mut nsIAtom, is_probe: bool,
                                     inherited_style:
                                         ServoComputedValuesBorrowedOrNull,
+                                    parent_style_context:
+                                        ServoStyleContextBorrowedOrNull,
                                     set: RawServoStyleSetBorrowed)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_SetExplicitStyle(element: RawGeckoElementBorrowed,
-                                  primary_style: ServoComputedValuesBorrowed);
+                                  primary_style: ServoStyleContextBorrowed);
 }
 extern "C" {
     pub fn Servo_HasAuthorSpecifiedRules(element: RawGeckoElementBorrowed,
                                          rule_type_mask: u32,
                                          author_colors_allowed: bool) -> bool;
 }
 extern "C" {
     pub fn Servo_ResolveStyleLazily(element: RawGeckoElementBorrowed,
                                     pseudo_type: CSSPseudoElementType,
+                                    pseudo_tag: *mut nsIAtom,
+                                    parent_style_context:
+                                        ServoStyleContextBorrowedOrNull,
                                     rule_inclusion: StyleRuleInclusion,
                                     snapshots:
                                         *const ServoElementSnapshotTable,
                                     set: RawServoStyleSetBorrowed)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_TraverseSubtree(root: RawGeckoElementBorrowed,
                                  set: RawServoStyleSetBorrowed,
                                  snapshots: *const ServoElementSnapshotTable,
                                  root_behavior: TraversalRootBehavior,
                                  restyle_behavior: TraversalRestyleBehavior)
      -> bool;
@@ -2760,22 +2783,22 @@ extern "C" {
     pub fn Servo_MaybeGCRuleTree(set: RawServoStyleSetBorrowed);
 }
 extern "C" {
     pub fn Servo_StyleSet_GetBaseComputedValuesForElement(set:
                                                               RawServoStyleSetBorrowed,
                                                           element:
                                                               RawGeckoElementBorrowed,
                                                           existing_style:
-                                                              ServoComputedValuesBorrowed,
+                                                              ServoStyleContextBorrowed,
                                                           snapshots:
                                                               *const ServoElementSnapshotTable,
                                                           pseudo_type:
                                                               CSSPseudoElementType)
-     -> ServoComputedValuesStrong;
+     -> ServoStyleContextStrong;
 }
 extern "C" {
     pub fn Servo_SerializeFontValueForCanvas(declarations:
                                                  RawServoDeclarationBlockBorrowed,
                                              buffer: *mut nsAString);
 }
 extern "C" {
     pub fn Servo_GetCustomPropertyValue(computed_values:
@@ -2789,134 +2812,17 @@ extern "C" {
      -> u32;
 }
 extern "C" {
     pub fn Servo_GetCustomPropertyNameAt(arg1: ServoComputedValuesBorrowed,
                                          index: u32, name: *mut nsAString)
      -> bool;
 }
 extern "C" {
-    pub fn Servo_GetStyleFont(computed_values:
-                                  ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleFont;
-}
-extern "C" {
-    pub fn Servo_GetStyleColor(computed_values:
-                                   ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleColor;
-}
-extern "C" {
-    pub fn Servo_GetStyleList(computed_values:
-                                  ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleList;
-}
-extern "C" {
-    pub fn Servo_GetStyleText(computed_values:
-                                  ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleText;
-}
-extern "C" {
-    pub fn Servo_GetStyleVisibility(computed_values:
-                                        ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleVisibility;
-}
-extern "C" {
-    pub fn Servo_GetStyleUserInterface(computed_values:
-                                           ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleUserInterface;
-}
-extern "C" {
-    pub fn Servo_GetStyleTableBorder(computed_values:
-                                         ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleTableBorder;
-}
-extern "C" {
-    pub fn Servo_GetStyleSVG(computed_values:
-                                 ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleSVG;
-}
-extern "C" {
-    pub fn Servo_GetStyleVariables(computed_values:
-                                       ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleVariables;
-}
-extern "C" {
-    pub fn Servo_GetStyleBackground(computed_values:
-                                        ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleBackground;
-}
-extern "C" {
-    pub fn Servo_GetStylePosition(computed_values:
-                                      ServoComputedValuesBorrowedOrNull)
-     -> *const nsStylePosition;
-}
-extern "C" {
-    pub fn Servo_GetStyleTextReset(computed_values:
-                                       ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleTextReset;
-}
-extern "C" {
-    pub fn Servo_GetStyleDisplay(computed_values:
-                                     ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleDisplay;
-}
-extern "C" {
-    pub fn Servo_GetStyleContent(computed_values:
-                                     ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleContent;
-}
-extern "C" {
-    pub fn Servo_GetStyleUIReset(computed_values:
-                                     ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleUIReset;
-}
-extern "C" {
-    pub fn Servo_GetStyleTable(computed_values:
-                                   ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleTable;
-}
-extern "C" {
-    pub fn Servo_GetStyleMargin(computed_values:
-                                    ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleMargin;
-}
-extern "C" {
-    pub fn Servo_GetStylePadding(computed_values:
-                                     ServoComputedValuesBorrowedOrNull)
-     -> *const nsStylePadding;
-}
-extern "C" {
-    pub fn Servo_GetStyleBorder(computed_values:
-                                    ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleBorder;
-}
-extern "C" {
-    pub fn Servo_GetStyleOutline(computed_values:
-                                     ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleOutline;
-}
-extern "C" {
-    pub fn Servo_GetStyleXUL(computed_values:
-                                 ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleXUL;
-}
-extern "C" {
-    pub fn Servo_GetStyleSVGReset(computed_values:
-                                      ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleSVGReset;
-}
-extern "C" {
-    pub fn Servo_GetStyleColumn(computed_values:
-                                    ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleColumn;
-}
-extern "C" {
-    pub fn Servo_GetStyleEffects(computed_values:
-                                     ServoComputedValuesBorrowedOrNull)
-     -> *const nsStyleEffects;
+    pub fn Servo_GetEmptyVariables() -> *const nsStyleVariables;
 }
 extern "C" {
     pub fn Gecko_CreateCSSErrorReporter(sheet: *mut ServoStyleSheet,
                                         loader: *mut Loader, uri: *mut nsIURI)
      -> *mut ErrorReporter;
 }
 extern "C" {
     pub fn Gecko_DestroyCSSErrorReporter(reporter: *mut ErrorReporter);
--- a/servo/components/style/gecko/generated/pseudo_element_definition.rs
+++ b/servo/components/style/gecko/generated/pseudo_element_definition.rs
@@ -684,16 +684,55 @@ impl PseudoElement {
                     },
                     CSSPseudoElementType::mozColorSwatch => {
                         Some(PseudoElement::MozColorSwatch)
                     },
             _ => None,
         }
     }
 
+
+    /// Construct a `CSSPseudoElementType` from a pseudo-element
+    #[inline]
+    pub fn pseudo_type(&self) -> CSSPseudoElementType {
+        match *self {
+                    PseudoElement::After => CSSPseudoElementType::after,
+                    PseudoElement::Before => CSSPseudoElementType::before,
+                    PseudoElement::Backdrop => CSSPseudoElementType::backdrop,
+                    PseudoElement::Cue => CSSPseudoElementType::cue,
+                    PseudoElement::FirstLetter => CSSPseudoElementType::firstLetter,
+                    PseudoElement::FirstLine => CSSPseudoElementType::firstLine,
+                    PseudoElement::MozSelection => CSSPseudoElementType::mozSelection,
+                    PseudoElement::MozFocusInner => CSSPseudoElementType::mozFocusInner,
+                    PseudoElement::MozFocusOuter => CSSPseudoElementType::mozFocusOuter,
+                    PseudoElement::MozListBullet => CSSPseudoElementType::mozListBullet,
+                    PseudoElement::MozListNumber => CSSPseudoElementType::mozListNumber,
+                    PseudoElement::MozMathAnonymous => CSSPseudoElementType::mozMathAnonymous,
+                    PseudoElement::MozNumberWrapper => CSSPseudoElementType::mozNumberWrapper,
+                    PseudoElement::MozNumberText => CSSPseudoElementType::mozNumberText,
+                    PseudoElement::MozNumberSpinBox => CSSPseudoElementType::mozNumberSpinBox,
+                    PseudoElement::MozNumberSpinUp => CSSPseudoElementType::mozNumberSpinUp,
+                    PseudoElement::MozNumberSpinDown => CSSPseudoElementType::mozNumberSpinDown,
+                    PseudoElement::MozProgressBar => CSSPseudoElementType::mozProgressBar,
+                    PseudoElement::MozRangeTrack => CSSPseudoElementType::mozRangeTrack,
+                    PseudoElement::MozRangeProgress => CSSPseudoElementType::mozRangeProgress,
+                    PseudoElement::MozRangeThumb => CSSPseudoElementType::mozRangeThumb,
+                    PseudoElement::MozMeterBar => CSSPseudoElementType::mozMeterBar,
+                    PseudoElement::MozPlaceholder => CSSPseudoElementType::mozPlaceholder,
+                    PseudoElement::Placeholder => CSSPseudoElementType::placeholder,
+                    PseudoElement::MozColorSwatch => CSSPseudoElementType::mozColorSwatch,
+            _ => CSSPseudoElementType::NotPseudo
+        }
+    }
+
+    /// Get a PseudoInfo for a pseudo
+    pub fn pseudo_info(&self) -> (*mut structs::nsIAtom, CSSPseudoElementType) {
+        (self.atom().as_ptr(), self.pseudo_type())
+    }
+
     /// Construct a pseudo-element from an anonymous box `Atom`.
     #[inline]
     pub fn from_anon_box_atom(atom: &Atom) -> Option<Self> {
                 if atom == &atom!(":-moz-text") {
                     return Some(PseudoElement::MozText);
                 }
                 if atom == &atom!(":-moz-oof-placeholder") {
                     return Some(PseudoElement::OofPlaceholder);
--- a/servo/components/style/gecko/generated/structs_debug.rs
+++ b/servo/components/style/gecko/generated/structs_debug.rs
@@ -4,16 +4,24 @@ pub use self::root::*;
 pub use self::root::mozilla::*;
 pub use self::root::mozilla::css::*;
 pub use self::root::mozilla::dom::*;
 use atomic_refcell::AtomicRefCell;
 use data::ElementData;
 pub type ServoUnsafeCell<T> = ::std::cell::UnsafeCell<T>;
 pub type ServoCell<T> = ::std::cell::Cell<T>;
 pub type ServoNodeData = AtomicRefCell<ElementData>;
+pub type ServoWritingMode = ::logical_geometry::WritingMode;
+pub type ServoFontComputationData = ::properties::FontComputationData;
+pub type ServoCustomPropertiesMap = Option<::stylearc::Arc<::custom_properties::CustomPropertiesMap>>;
+pub type ServoRuleNode = Option<::rule_tree::StrongRuleNode>;
+pub type ServoVisitedStyle = Option<::stylearc::RawOffsetArc<::properties::ComputedValues>>;
+pub type ServoComputedValueFlags = ::properties::computed_value_flags::ComputedValueFlags;
+pub type ServoRawOffsetArc<T> = ::stylearc::RawOffsetArc<T>;
+pub type ServoStyleContextStrong = ::gecko_bindings::sugar::ownership::Strong<ServoStyleContext>;
 
 #[allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 pub mod root {
     #[repr(C)]
     pub struct __BindgenUnionField<T>(::std::marker::PhantomData<T>);
     impl <T> __BindgenUnionField<T> {
         #[inline]
         pub fn new() -> Self {
@@ -1031,36 +1039,24 @@ pub mod root {
     pub const NS_STYLE_CONTEXT_IS_GECKO: ::std::os::raw::c_ulonglong =
         68719476736;
     pub const NS_STYLE_CONTEXT_TYPE_SHIFT: ::std::os::raw::c_uint = 37;
     pub mod std {
         #[allow(unused_imports)]
         use self::super::super::root;
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
-        pub struct __is_swappable {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
-        pub struct __is_nothrow_swappable {
-            pub _address: u8,
-        }
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
         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 ,
@@ -1070,64 +1066,111 @@ pub mod root {
                         , concat ! (
                         "Alignment of " , stringify ! ( input_iterator_tag )
                         ));
         }
         impl Clone for input_iterator_tag {
             fn clone(&self) -> Self { *self }
         }
         #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct forward_iterator_tag {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_forward_iterator_tag() {
+            assert_eq!(::std::mem::size_of::<forward_iterator_tag>() , 1usize
+                       , concat ! (
+                       "Size of: " , stringify ! ( forward_iterator_tag ) ));
+            assert_eq! (::std::mem::align_of::<forward_iterator_tag>() ,
+                        1usize , concat ! (
+                        "Alignment of " , stringify ! ( forward_iterator_tag )
+                        ));
+        }
+        impl Clone for forward_iterator_tag {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct bidirectional_iterator_tag {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_bidirectional_iterator_tag() {
+            assert_eq!(::std::mem::size_of::<bidirectional_iterator_tag>() ,
+                       1usize , concat ! (
+                       "Size of: " , stringify ! ( bidirectional_iterator_tag
+                       ) ));
+            assert_eq! (::std::mem::align_of::<bidirectional_iterator_tag>() ,
+                        1usize , concat ! (
+                        "Alignment of " , stringify ! (
+                        bidirectional_iterator_tag ) ));
+        }
+        impl Clone for bidirectional_iterator_tag {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct random_access_iterator_tag {
+            pub _address: u8,
+        }
+        #[test]
+        fn bindgen_test_layout_random_access_iterator_tag() {
+            assert_eq!(::std::mem::size_of::<random_access_iterator_tag>() ,
+                       1usize , concat ! (
+                       "Size of: " , stringify ! ( random_access_iterator_tag
+                       ) ));
+            assert_eq! (::std::mem::align_of::<random_access_iterator_tag>() ,
+                        1usize , concat ! (
+                        "Alignment of " , stringify ! (
+                        random_access_iterator_tag ) ));
+        }
+        impl Clone for random_access_iterator_tag {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        pub struct iterator_traits {
+            pub _address: u8,
+        }
+        #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct iterator {
             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 iterator_iterator_category<_Category> = _Category;
+        #[repr(C)]
+        pub struct reverse_iterator<_Iter> {
+            pub __t: _Iter,
+            pub current: _Iter,
+            pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_Iter>>,
+        }
+        pub type reverse_iterator_iterator_type<_Iter> = _Iter;
         pub type reverse_iterator_difference_type =
-            root::std::reverse_iterator___traits_type;
-        pub type reverse_iterator_pointer =
-            root::std::reverse_iterator___traits_type;
-        pub type reverse_iterator_reference =
-            root::std::reverse_iterator___traits_type;
+            root::std::iterator_traits;
+        pub type reverse_iterator_reference = root::std::iterator_traits;
+        pub type reverse_iterator_pointer = root::std::iterator_traits;
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct atomic {
         }
-        pub mod chrono {
-            #[allow(unused_imports)]
-            use self::super::super::super::root;
-        }
-    }
-    pub mod __gnu_cxx {
-        #[allow(unused_imports)]
-        use self::super::super::root;
-    }
-    pub type __off_t = ::std::os::raw::c_long;
-    pub type __off64_t = ::std::os::raw::c_long;
+        pub type atomic___base = u8;
+        #[repr(C)]
+        pub struct __bit_const_reference {
+            pub __seg_: root::std::__bit_const_reference___storage_pointer,
+            pub __mask_: root::std::__bit_const_reference___storage_type,
+        }
+        pub type __bit_const_reference___storage_type = [u8; 0usize];
+        pub type __bit_const_reference___storage_pointer = [u8; 0usize];
+    }
+    pub type __int64_t = ::std::os::raw::c_longlong;
+    pub type __darwin_off_t = root::__int64_t;
     pub mod mozilla {
         #[allow(unused_imports)]
         use self::super::super::root;
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct fallible_t {
             pub _address: u8,
         }
@@ -1161,19 +1204,18 @@ pub mod root {
                 root::mozilla::detail::nsStringRepr;
             pub type nsStringRepr_base_string_type =
                 root::mozilla::detail::nsStringRepr_self_type;
             pub type nsStringRepr_substring_type = root::nsAString;
             pub type nsStringRepr_substring_tuple_type =
                 root::nsSubstringTuple;
             pub type nsStringRepr_string_type = ::nsstring::nsStringRepr;
             pub type nsStringRepr_const_iterator =
-                root::nsReadingIterator<root::mozilla::detail::nsStringRepr_char_type>;
-            pub type nsStringRepr_iterator =
-                root::nsWritingIterator<root::mozilla::detail::nsStringRepr_char_type>;
+                root::nsReadingIterator<u16>;
+            pub type nsStringRepr_iterator = root::nsWritingIterator<u16>;
             pub type nsStringRepr_comparator_type = root::nsStringComparator;
             pub type nsStringRepr_char_iterator =
                 *mut root::mozilla::detail::nsStringRepr_char_type;
             pub type nsStringRepr_const_char_iterator =
                 *const root::mozilla::detail::nsStringRepr_char_type;
             pub type nsStringRepr_index_type = u32;
             pub type nsStringRepr_size_type = u32;
             pub use self::super::super::super::root::mozilla::detail::StringDataFlags
@@ -1230,19 +1272,19 @@ pub mod root {
                 root::mozilla::detail::nsCStringRepr;
             pub type nsCStringRepr_base_string_type =
                 root::mozilla::detail::nsCStringRepr_self_type;
             pub type nsCStringRepr_substring_type = root::nsACString;
             pub type nsCStringRepr_substring_tuple_type =
                 root::nsCSubstringTuple;
             pub type nsCStringRepr_string_type = root::nsCString;
             pub type nsCStringRepr_const_iterator =
-                root::nsReadingIterator<root::mozilla::detail::nsCStringRepr_char_type>;
+                root::nsReadingIterator<::std::os::raw::c_char>;
             pub type nsCStringRepr_iterator =
-                root::nsWritingIterator<root::mozilla::detail::nsCStringRepr_char_type>;
+                root::nsWritingIterator<::std::os::raw::c_char>;
             pub type nsCStringRepr_comparator_type =
                 root::nsCStringComparator;
             pub type nsCStringRepr_char_iterator =
                 *mut root::mozilla::detail::nsCStringRepr_char_type;
             pub type nsCStringRepr_const_char_iterator =
                 *const root::mozilla::detail::nsCStringRepr_char_type;
             pub type nsCStringRepr_index_type = u32;
             pub type nsCStringRepr_size_type = u32;
@@ -1369,26 +1411,26 @@ pub mod root {
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct WeakReference {
             }
             #[repr(C)]
             #[derive(Debug)]
             pub struct MutexImpl {
-                pub platformData_: [*mut ::std::os::raw::c_void; 5usize],
+                pub platformData_: [*mut ::std::os::raw::c_void; 8usize],
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct MutexImpl_PlatformData {
                 _unused: [u8; 0],
             }
             #[test]
             fn bindgen_test_layout_MutexImpl() {
-                assert_eq!(::std::mem::size_of::<MutexImpl>() , 40usize ,
+                assert_eq!(::std::mem::size_of::<MutexImpl>() , 64usize ,
                            concat ! ( "Size of: " , stringify ! ( MutexImpl )
                            ));
                 assert_eq! (::std::mem::align_of::<MutexImpl>() , 8usize ,
                             concat ! (
                             "Alignment of " , stringify ! ( MutexImpl ) ));
                 assert_eq! (unsafe {
                             & ( * ( 0 as * const MutexImpl ) ) . platformData_
                             as * const _ as usize } , 0usize , concat ! (
@@ -2302,17 +2344,17 @@ pub mod root {
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct DocumentRule {
                 _unused: [u8; 0],
             }
         }
         #[repr(C)]
-        #[derive(Debug)]
+        #[derive(Debug, Copy)]
         pub struct ThreadSafeAutoRefCnt {
             pub mValue: u64,
         }
         pub const ThreadSafeAutoRefCnt_isThreadSafe: bool = true;
         #[test]
         fn bindgen_test_layout_ThreadSafeAutoRefCnt() {
             assert_eq!(::std::mem::size_of::<ThreadSafeAutoRefCnt>() , 8usize
                        , concat ! (
@@ -2323,16 +2365,19 @@ pub mod root {
                         ));
             assert_eq! (unsafe {
                         & ( * ( 0 as * const ThreadSafeAutoRefCnt ) ) . mValue
                         as * const _ as usize } , 0usize , concat ! (
                         "Alignment of field: " , stringify ! (
                         ThreadSafeAutoRefCnt ) , "::" , stringify ! ( mValue )
                         ));
         }
+        impl Clone for ThreadSafeAutoRefCnt {
+            fn clone(&self) -> Self { *self }
+        }
         #[repr(C)]
         #[derive(Debug)]
         pub struct OwningNonNull<T> {
             pub mPtr: root::RefPtr<T>,
             pub mInited: bool,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
         }
         #[repr(C)]
@@ -4037,17 +4082,16 @@ pub mod root {
                             ) , "::" , stringify ! ( mAlgorithmType ) ));
                 assert_eq! (unsafe {
                             & ( * ( 0 as * const SRIMetadata ) ) . mEmpty as *
                             const _ as usize } , 41usize , concat ! (
                             "Alignment of field: " , stringify ! ( SRIMetadata
                             ) , "::" , stringify ! ( mEmpty ) ));
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct Element {
                 pub _base: root::mozilla::dom::FragmentOrElement,
                 pub mState: root::mozilla::EventStates,
                 pub mServoData: ::gecko_bindings::structs::ServoCell<*mut ::gecko_bindings::structs::ServoNodeData>,
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct Element_COMTypeInfo {
@@ -4183,17 +4227,16 @@ pub mod root {
                             "Alignment of field: " , stringify ! (
                             BorrowedAttrInfo ) , "::" , stringify ! ( mValue )
                             ));
             }
             impl Clone for BorrowedAttrInfo {
                 fn clone(&self) -> Self { *self }
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct NodeInfo {
                 pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
                 pub _mOwningThread: root::nsAutoOwningThread,
                 pub mDocument: *mut root::nsIDocument,
                 pub mInner: root::mozilla::dom::NodeInfo_NodeInfoInner,
                 pub mOwnerManager: root::RefPtr<root::nsNodeInfoManager>,
                 pub mQualifiedName: ::nsstring::nsStringRepr,
                 pub mNodeName: ::nsstring::nsStringRepr,
@@ -5256,17 +5299,16 @@ pub mod root {
                 _unused: [u8; 0],
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct AnonymousContent {
                 _unused: [u8; 0],
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct Attr {
                 pub _base: root::nsIAttribute,
                 pub _base_1: root::nsIDOMAttr,
                 pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
                 pub _mOwningThread: root::nsAutoOwningThread,
                 pub mValue: ::nsstring::nsStringRepr,
             }
             pub type Attr_HasThreadSafeRefCnt = root::mozilla::FalseType;
@@ -5715,17 +5757,16 @@ pub mod root {
                 _unused: [u8; 0],
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct CustomElementData {
                 _unused: [u8; 0],
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct FragmentOrElement {
                 pub _base: root::nsIContent,
                 pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
                 pub _mOwningThread: root::nsAutoOwningThread,
                 /**
    * Array containing all attributes and children for this element
    */
                 pub mAttrsAndChildren: root::nsAttrAndChildArray,
@@ -5755,17 +5796,16 @@ pub mod root {
    * There are a set of DOM- and scripting-specific instance variables
    * that may only be instantiated when a content object is accessed
    * through the DOM. Rather than burn actual slots in the content
    * objects for each of these instance variables, we put them off
    * in a side structure that's only allocated when the content is
    * accessed through the DOM.
    */
             #[repr(C)]
-            #[derive(Debug)]
             pub struct FragmentOrElement_nsExtendedDOMSlots {
                 /**
      * SMIL Overridde style rules (for SMIL animation of CSS properties)
      * @see Element::GetSMILOverrideStyle
      */
                 pub mSMILOverrideStyle: root::nsCOMPtr<root::nsICSSDeclaration>,
                 /**
      * Holds any SMIL override style declaration for this element.
@@ -5943,17 +5983,16 @@ pub mod root {
                             0 as * const FragmentOrElement_nsExtendedDOMSlots
                             ) ) . mFrameLoaderOrOpener as * const _ as usize }
                             , 136usize , concat ! (
                             "Alignment of field: " , stringify ! (
                             FragmentOrElement_nsExtendedDOMSlots ) , "::" ,
                             stringify ! ( mFrameLoaderOrOpener ) ));
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct FragmentOrElement_nsDOMSlots {
                 pub _base: root::nsINode_nsSlots,
                 /**
      * The .style attribute (an interface that forwards to the actual
      * style rules)
      * @see nsGenericHTMLElement::GetStyle
      */
                 pub mStyle: root::nsCOMPtr<root::nsICSSDeclaration>,
@@ -6176,17 +6215,16 @@ pub mod root {
                             "Alignment of field: " , stringify ! (
                             ScrollIntoViewOptions ) , "::" , stringify ! (
                             mBlock ) ));
             }
             impl Clone for ScrollIntoViewOptions {
                 fn clone(&self) -> Self { *self }
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct DOMIntersectionObserverEntry {
                 pub _base: root::nsISupports,
                 pub _base_1: root::nsWrapperCache,
                 pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
                 pub _mOwningThread: root::nsAutoOwningThread,
                 pub mOwner: root::nsCOMPtr<root::nsISupports>,
                 pub mTime: root::DOMHighResTimeStamp,
                 pub mRootBounds: root::RefPtr<root::mozilla::dom::DOMRect>,
@@ -6326,17 +6364,16 @@ pub mod root {
                             * ( 0 as * const OwningDoubleOrDoubleSequence ) )
                             . mValue as * const _ as usize } , 8usize , concat
                             ! (
                             "Alignment of field: " , stringify ! (
                             OwningDoubleOrDoubleSequence ) , "::" , stringify
                             ! ( mValue ) ));
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct IntersectionObserverInit {
                 pub _base: root::mozilla::dom::DictionaryBase,
                 pub mRoot: root::RefPtr<root::mozilla::dom::Element>,
                 pub mRootMargin: ::nsstring::nsStringRepr,
                 pub mThreshold: root::mozilla::dom::OwningDoubleOrDoubleSequence,
             }
             #[test]
             fn bindgen_test_layout_IntersectionObserverInit() {
@@ -6381,17 +6418,16 @@ pub mod root {
                 _unused: [u8; 0],
             }
             #[repr(C)]
             #[derive(Debug, Copy, Clone)]
             pub struct UnrestrictedDoubleOrKeyframeAnimationOptions {
                 _unused: [u8; 0],
             }
             #[repr(C)]
-            #[derive(Debug)]
             pub struct DestinationInsertionPointList {
                 pub _base: root::nsINodeList,
                 pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
                 pub _mOwningThread: root::nsAutoOwningThread,
                 pub mParent: root::RefPtr<root::mozilla::dom::Element>,
                 pub mDestinationPoints: root::nsCOMArray,
             }
             pub type DestinationInsertionPointList_HasThreadSafeRefCnt =
@@ -7541,16 +7577,19 @@ pub mod root {
                         "Alignment of field: " , stringify ! ( EventStates ) ,
                         "::" , 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,
@@ -7585,16 +7624,469 @@ pub mod root {
         pub type ParsingMode = u8;
         #[repr(i32)]
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum InheritTarget {
             Text = 0,
             FirstLetterContinuation = 1,
             PlaceholderFrame = 2,
         }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct ServoStyleContext {
+            pub _base: root::nsStyleContext,
+            pub mPresContext: *mut root::nsPresContext,
+            pub mSource: root::ServoComputedValues,
+        }
+        #[test]
+        fn bindgen_test_layout_ServoStyleContext() {
+            assert_eq!(::std::mem::size_of::<ServoStyleContext>() , 272usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( ServoStyleContext ) ));
+            assert_eq! (::std::mem::align_of::<ServoStyleContext>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( ServoStyleContext )
+                        ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleContext ) ) .
+                        mPresContext as * const _ as usize } , 32usize ,
+                        concat ! (
+                        "Alignment of field: " , stringify ! (
+                        ServoStyleContext ) , "::" , stringify ! (
+                        mPresContext ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleContext ) ) . mSource
+                        as * const _ as usize } , 40usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        ServoStyleContext ) , "::" , stringify ! ( mSource )
+                        ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoFont {
+            pub gecko: root::nsStyleFont,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoFont() {
+            assert_eq!(::std::mem::size_of::<GeckoFont>() , 120usize , concat
+                       ! ( "Size of: " , stringify ! ( GeckoFont ) ));
+            assert_eq! (::std::mem::align_of::<GeckoFont>() , 8usize , concat
+                        ! ( "Alignment of " , stringify ! ( GeckoFont ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoFont ) ) . gecko as * const
+                        _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoFont ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoColor {
+            pub gecko: root::nsStyleColor,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoColor() {
+            assert_eq!(::std::mem::size_of::<GeckoColor>() , 4usize , concat !
+                       ( "Size of: " , stringify ! ( GeckoColor ) ));
+            assert_eq! (::std::mem::align_of::<GeckoColor>() , 4usize , concat
+                        ! ( "Alignment of " , stringify ! ( GeckoColor ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoColor ) ) . gecko as * const
+                        _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoColor ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoList {
+            pub gecko: root::nsStyleList,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoList() {
+            assert_eq!(::std::mem::size_of::<GeckoList>() , 48usize , concat !
+                       ( "Size of: " , stringify ! ( GeckoList ) ));
+            assert_eq! (::std::mem::align_of::<GeckoList>() , 8usize , concat
+                        ! ( "Alignment of " , stringify ! ( GeckoList ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoList ) ) . gecko as * const
+                        _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoList ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoText {
+            pub gecko: root::nsStyleText,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoText() {
+            assert_eq!(::std::mem::size_of::<GeckoText>() , 160usize , concat
+                       ! ( "Size of: " , stringify ! ( GeckoText ) ));
+            assert_eq! (::std::mem::align_of::<GeckoText>() , 8usize , concat
+                        ! ( "Alignment of " , stringify ! ( GeckoText ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoText ) ) . gecko as * const
+                        _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoText ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoVisibility {
+            pub gecko: root::nsStyleVisibility,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoVisibility() {
+            assert_eq!(::std::mem::size_of::<GeckoVisibility>() , 7usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( GeckoVisibility ) ));
+            assert_eq! (::std::mem::align_of::<GeckoVisibility>() , 1usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoVisibility ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoVisibility ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoVisibility
+                        ) , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoUserInterface {
+            pub gecko: root::nsStyleUserInterface,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoUserInterface() {
+            assert_eq!(::std::mem::size_of::<GeckoUserInterface>() , 24usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( GeckoUserInterface ) ));
+            assert_eq! (::std::mem::align_of::<GeckoUserInterface>() , 8usize
+                        , concat ! (
+                        "Alignment of " , stringify ! ( GeckoUserInterface )
+                        ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoUserInterface ) ) . gecko as
+                        * const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        GeckoUserInterface ) , "::" , stringify ! ( gecko )
+                        ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoTableBorder {
+            pub gecko: root::nsStyleTableBorder,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoTableBorder() {
+            assert_eq!(::std::mem::size_of::<GeckoTableBorder>() , 12usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( GeckoTableBorder ) ));
+            assert_eq! (::std::mem::align_of::<GeckoTableBorder>() , 4usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoTableBorder ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoTableBorder ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        GeckoTableBorder ) , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoSVG {
+            pub gecko: root::nsStyleSVG,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoSVG() {
+            assert_eq!(::std::mem::size_of::<GeckoSVG>() , 128usize , concat !
+                       ( "Size of: " , stringify ! ( GeckoSVG ) ));
+            assert_eq! (::std::mem::align_of::<GeckoSVG>() , 8usize , concat !
+                        ( "Alignment of " , stringify ! ( GeckoSVG ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoSVG ) ) . gecko as * const _
+                        as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoSVG ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoBackground {
+            pub gecko: root::nsStyleBackground,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoBackground() {
+            assert_eq!(::std::mem::size_of::<GeckoBackground>() , 160usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( GeckoBackground ) ));
+            assert_eq! (::std::mem::align_of::<GeckoBackground>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoBackground ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoBackground ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoBackground
+                        ) , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoPosition {
+            pub gecko: root::nsStylePosition,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoPosition() {
+            assert_eq!(::std::mem::size_of::<GeckoPosition>() , 520usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoPosition )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoPosition>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoPosition ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoPosition ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoPosition )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoTextReset {
+            pub gecko: root::nsStyleTextReset,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoTextReset() {
+            assert_eq!(::std::mem::size_of::<GeckoTextReset>() , 80usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoTextReset )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoTextReset>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoTextReset ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoTextReset ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoTextReset
+                        ) , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoDisplay {
+            pub gecko: root::nsStyleDisplay,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoDisplay() {
+            assert_eq!(::std::mem::size_of::<GeckoDisplay>() , 416usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoDisplay )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoDisplay>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoDisplay ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoDisplay ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoDisplay )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoContent {
+            pub gecko: root::nsStyleContent,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoContent() {
+            assert_eq!(::std::mem::size_of::<GeckoContent>() , 24usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoContent )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoContent>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoContent ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoContent ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoContent )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoUIReset {
+            pub gecko: root::nsStyleUIReset,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoUIReset() {
+            assert_eq!(::std::mem::size_of::<GeckoUIReset>() , 56usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoUIReset )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoUIReset>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoUIReset ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoUIReset ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoUIReset )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoTable {
+            pub gecko: root::nsStyleTable,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoTable() {
+            assert_eq!(::std::mem::size_of::<GeckoTable>() , 8usize , concat !
+                       ( "Size of: " , stringify ! ( GeckoTable ) ));
+            assert_eq! (::std::mem::align_of::<GeckoTable>() , 4usize , concat
+                        ! ( "Alignment of " , stringify ! ( GeckoTable ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoTable ) ) . gecko as * const
+                        _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoTable ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoMargin {
+            pub gecko: root::nsStyleMargin,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoMargin() {
+            assert_eq!(::std::mem::size_of::<GeckoMargin>() , 40usize , concat
+                       ! ( "Size of: " , stringify ! ( GeckoMargin ) ));
+            assert_eq! (::std::mem::align_of::<GeckoMargin>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoMargin ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoMargin ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoMargin ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoPadding {
+            pub gecko: root::nsStylePadding,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoPadding() {
+            assert_eq!(::std::mem::size_of::<GeckoPadding>() , 40usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoPadding )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoPadding>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoPadding ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoPadding ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoPadding )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoBorder {
+            pub gecko: root::nsStyleBorder,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoBorder() {
+            assert_eq!(::std::mem::size_of::<GeckoBorder>() , 312usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoBorder )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoBorder>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoBorder ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoBorder ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoBorder ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoOutline {
+            pub gecko: root::nsStyleOutline,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoOutline() {
+            assert_eq!(::std::mem::size_of::<GeckoOutline>() , 104usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoOutline )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoOutline>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoOutline ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoOutline ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoOutline )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoXUL {
+            pub gecko: root::nsStyleXUL,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoXUL() {
+            assert_eq!(::std::mem::size_of::<GeckoXUL>() , 16usize , concat !
+                       ( "Size of: " , stringify ! ( GeckoXUL ) ));
+            assert_eq! (::std::mem::align_of::<GeckoXUL>() , 4usize , concat !
+                        ( "Alignment of " , stringify ! ( GeckoXUL ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoXUL ) ) . gecko as * const _
+                        as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoXUL ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoSVGReset {
+            pub gecko: root::nsStyleSVGReset,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoSVGReset() {
+            assert_eq!(::std::mem::size_of::<GeckoSVGReset>() , 192usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoSVGReset )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoSVGReset>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoSVGReset ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoSVGReset ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoSVGReset )
+                        , "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoColumn {
+            pub gecko: root::nsStyleColumn,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoColumn() {
+            assert_eq!(::std::mem::size_of::<GeckoColumn>() , 64usize , concat
+                       ! ( "Size of: " , stringify ! ( GeckoColumn ) ));
+            assert_eq! (::std::mem::align_of::<GeckoColumn>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoColumn ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoColumn ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoColumn ) ,
+                        "::" , stringify ! ( gecko ) ));
+        }
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct GeckoEffects {
+            pub gecko: root::nsStyleEffects,
+        }
+        #[test]
+        fn bindgen_test_layout_GeckoEffects() {
+            assert_eq!(::std::mem::size_of::<GeckoEffects>() , 40usize ,
+                       concat ! ( "Size of: " , stringify ! ( GeckoEffects )
+                       ));
+            assert_eq! (::std::mem::align_of::<GeckoEffects>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( GeckoEffects ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const GeckoEffects ) ) . gecko as *
+                        const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( GeckoEffects )
+                        , "::" , 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, }
         #[repr(C)]
         #[derive(Debug, Copy)]
@@ -7895,16 +8387,88 @@ pub mod root {
         #[repr(u8)]
         #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
         pub enum CORSMode {
             CORS_NONE = 0,
             CORS_ANONYMOUS = 1,
             CORS_USE_CREDENTIALS = 2,
         }
         #[repr(C)]
+        pub struct CSSStyleSheet {
+            pub _base: root::mozilla::StyleSheet,
+            pub mRuleCollection: root::RefPtr<root::CSSRuleListImpl>,
+            pub mInRuleProcessorCache: bool,
+            pub mScopeElement: root::RefPtr<root::mozilla::dom::Element>,
+            pub mRuleProcessors: *mut u8,
+        }
+        pub use self::super::super::root::mozilla::net::ReferrerPolicy as
+                CSSStyleSheet_ReferrerPolicy;
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct CSSStyleSheet_cycleCollection {
+            pub _base: root::mozilla::StyleSheet_cycleCollection,
+        }
+        #[test]
+        fn bindgen_test_layout_CSSStyleSheet_cycleCollection() {
+            assert_eq!(::std::mem::size_of::<CSSStyleSheet_cycleCollection>()
+                       , 16usize , concat ! (
+                       "Size of: " , stringify ! (
+                       CSSStyleSheet_cycleCollection ) ));
+            assert_eq! (::std::mem::align_of::<CSSStyleSheet_cycleCollection>()
+                        , 8usize , concat ! (
+                        "Alignment of " , stringify ! (
+                        CSSStyleSheet_cycleCollection ) ));
+        }
+        impl Clone for CSSStyleSheet_cycleCollection {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct CSSStyleSheet_COMTypeInfo {
+            pub _address: u8,
+        }
+        extern "C" {
+            #[link_name =
+                  "_ZN7mozilla13CSSStyleSheet21_cycleCollectorGlobalE"]
+            pub static mut CSSStyleSheet__cycleCollectorGlobal:
+                       root::mozilla::CSSStyleSheet_cycleCollection;
+        }
+        #[test]
+        fn bindgen_test_layout_CSSStyleSheet() {
+            assert_eq!(::std::mem::size_of::<CSSStyleSheet>() , 176usize ,
+                       concat ! ( "Size of: " , stringify ! ( CSSStyleSheet )
+                       ));
+            assert_eq! (::std::mem::align_of::<CSSStyleSheet>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( CSSStyleSheet ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const CSSStyleSheet ) ) .
+                        mRuleCollection as * const _ as usize } , 144usize ,
+                        concat ! (
+                        "Alignment of field: " , stringify ! ( CSSStyleSheet )
+                        , "::" , stringify ! ( mRuleCollection ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const CSSStyleSheet ) ) .
+                        mInRuleProcessorCache as * const _ as usize } ,
+                        152usize , concat ! (
+                        "Alignment of field: " , stringify ! ( CSSStyleSheet )
+                        , "::" , stringify ! ( mInRuleProcessorCache ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const CSSStyleSheet ) ) . mScopeElement
+                        as * const _ as usize } , 160usize , concat ! (
+                        "Alignment of field: " , stringify ! ( CSSStyleSheet )
+                        , "::" , stringify ! ( mScopeElement ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const CSSStyleSheet ) ) .
+                        mRuleProcessors as * const _ as usize } , 168usize ,
+                        concat ! (
+                        "Alignment of field: " , stringify ! ( CSSStyleSheet )
+                        , "::" , stringify ! ( mRuleProcessors ) ));
+        }
+        #[repr(C)]
         #[derive(Debug)]
         pub struct ServoStyleSheet {
             pub _base: root::mozilla::StyleSheet,
             pub mRuleList: root::RefPtr<root::mozilla::ServoCSSRuleList>,
         }
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct ServoStyleSheet_cycleCollection {
@@ -8136,20 +8700,145 @@ pub mod root {
             placeholder = 23,
             mozColorSwatch = 24,
             Count = 25,
             NonInheritingAnonBox = 26,
             XULTree = 27,
             NotPseudo = 28,
             MAX = 29,
         }
-        #[repr(C)]
-        #[derive(Debug, Copy, Clone)]
+        /**
+ * The set of style sheets that apply to a document, backed by a Servo
+ * Stylist.  A ServoStyleSet contains ServoStyleSheets.
+ */
+        #[repr(C)]
         pub struct ServoStyleSet {
-            _unused: [u8; 0],
+            pub mPresContext: *mut root::nsPresContext,
+            pub mRawSet: root::mozilla::UniquePtr<root::RawServoStyleSet>,
+            pub mSheets: [u64; 9usize],
+            pub mAuthorStyleDisabled: bool,
+            pub mStylistState: root::mozilla::StylistState,
+            pub mUserFontSetUpdateGeneration: u64,
+            pub mUserFontCacheUpdateGeneration: u32,
+            pub mNeedsRestyleAfterEnsureUniqueInner: bool,
+            pub mNonInheritingStyleContexts: [u64; 5usize],
+            pub mPostTraversalTasks: root::nsTArray<root::mozilla::PostTraversalTask>,
+            pub mStyleRuleMap: root::RefPtr<root::mozilla::ServoStyleRuleMap>,
+            pub mBindingManager: root::RefPtr<root::nsBindingManager>,
+        }
+        pub type ServoStyleSet_SnapshotTable =
+            root::mozilla::ServoElementSnapshotTable;
+        #[repr(C)]
+        #[derive(Debug)]
+        pub struct ServoStyleSet_AutoSetInServoTraversal {
+            pub mSet: *mut root::mozilla::ServoStyleSet,
+        }
+        #[test]
+        fn bindgen_test_layout_ServoStyleSet_AutoSetInServoTraversal() {
+            assert_eq!(::std::mem::size_of::<ServoStyleSet_AutoSetInServoTraversal>()
+                       , 8usize , concat ! (
+                       "Size of: " , stringify ! (
+                       ServoStyleSet_AutoSetInServoTraversal ) ));
+            assert_eq! (::std::mem::align_of::<ServoStyleSet_AutoSetInServoTraversal>()
+                        , 8usize , concat ! (
+                        "Alignment of " , stringify ! (
+                        ServoStyleSet_AutoSetInServoTraversal ) ));
+            assert_eq! (unsafe {
+                        & (
+                        * ( 0 as * const ServoStyleSet_AutoSetInServoTraversal
+                        ) ) . mSet as * const _ as usize } , 0usize , concat !
+                        (
+                        "Alignment of field: " , stringify ! (
+                        ServoStyleSet_AutoSetInServoTraversal ) , "::" ,
+                        stringify ! ( mSet ) ));
+        }
+        extern "C" {
+            #[link_name = "_ZN7mozilla13ServoStyleSet17sInServoTraversalE"]
+            pub static mut ServoStyleSet_sInServoTraversal:
+                       *mut root::mozilla::ServoStyleSet;
+        }
+        #[test]
+        fn bindgen_test_layout_ServoStyleSet() {
+            assert_eq!(::std::mem::size_of::<ServoStyleSet>() , 176usize ,
+                       concat ! ( "Size of: " , stringify ! ( ServoStyleSet )
+                       ));
+            assert_eq! (::std::mem::align_of::<ServoStyleSet>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( ServoStyleSet ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) . mPresContext
+                        as * const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mPresContext ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) . mRawSet as *
+                        const _ as usize } , 8usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mRawSet ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) . mSheets as *
+                        const _ as usize } , 16usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mSheets ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mAuthorStyleDisabled as * const _ as usize } , 88usize
+                        , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mAuthorStyleDisabled ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) . mStylistState
+                        as * const _ as usize } , 89usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mStylistState ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mUserFontSetUpdateGeneration as * const _ as usize } ,
+                        96usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mUserFontSetUpdateGeneration )
+                        ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mUserFontCacheUpdateGeneration as * const _ as usize }
+                        , 104usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mUserFontCacheUpdateGeneration
+                        ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mNeedsRestyleAfterEnsureUniqueInner as * const _ as
+                        usize } , 108usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! (
+                        mNeedsRestyleAfterEnsureUniqueInner ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mNonInheritingStyleContexts as * const _ as usize } ,
+                        112usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mNonInheritingStyleContexts )
+                        ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mPostTraversalTasks as * const _ as usize } , 152usize
+                        , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mPostTraversalTasks ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) . mStyleRuleMap
+                        as * const _ as usize } , 160usize , concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mStyleRuleMap ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const ServoStyleSet ) ) .
+                        mBindingManager as * const _ as usize } , 168usize ,
+                        concat ! (
+                        "Alignment of field: " , stringify ! ( ServoStyleSet )
+                        , "::" , stringify ! ( mBindingManager ) ));
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct EventChainVisitor {
             _unused: [u8; 0],
         }
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
@@ -8961,25 +9650,25 @@ pub mod root {
         #[derive(Debug)]
         pub struct OffTheBooksMutex {
             pub _base: root::mozilla::detail::MutexImpl,
             pub _base_1: root::mozilla::BlockingResourceBase,
             pub mOwningThread: *mut root::PRThread,
         }
         #[test]
         fn bindgen_test_layout_OffTheBooksMutex() {
-            assert_eq!(::std::mem::size_of::<OffTheBooksMutex>() , 72usize ,
+            assert_eq!(::std::mem::size_of::<OffTheBooksMutex>() , 96usize ,
                        concat ! (
                        "Size of: " , stringify ! ( OffTheBooksMutex ) ));
             assert_eq! (::std::mem::align_of::<OffTheBooksMutex>() , 8usize ,
                         concat ! (
                         "Alignment of " , stringify ! ( OffTheBooksMutex ) ));
             assert_eq! (unsafe {
                         & ( * ( 0 as * const OffTheBooksMutex ) ) .
-                        mOwningThread as * const _ as usize } , 64usize ,
+                        mOwningThread as * const _ as usize } , 88usize ,
                         concat ! (
                         "Alignment of field: " , stringify ! (
                         OffTheBooksMutex ) , "::" , stringify ! (
                         mOwningThread ) ));
         }
         /**
  * Mutex
  * When possible, use MutexAutoLock/MutexAutoUnlock to lock/unlock this
@@ -8987,17 +9676,17 @@ pub mod root {
  */
         #[repr(C)]
         #[derive(Debug)]
         pub struct Mutex {
             pub _base: root::mozilla::OffTheBooksMutex,
         }
         #[test]
         fn bindgen_test_layout_Mutex() {
-            assert_eq!(::std::mem::size_of::<Mutex>() , 72usize , concat ! (
+            assert_eq!(::std::mem::size_of::<Mutex>() , 96usize , concat ! (
                        "Size of: " , stringify ! ( Mutex ) ));
             assert_eq! (::std::mem::align_of::<Mutex>() , 8usize , concat ! (
                         "Alignment of " , stringify ! ( Mutex ) ));
         }
         pub mod image {
             #[allow(unused_imports)]
             use self::super::super::super::root;
             #[repr(C)]
@@ -10458,18 +11147,16 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const PropertyStyleAnimationValuePair )
                         ) . mValue as * const _ as usize } , 8usize , concat !
                         (
                         "Alignment of field: " , stringify ! (
                         PropertyStyleAnimationValuePair ) , "::" , stringify !
                         ( mValue ) ));
         }
-        pub type ComputedKeyframeValues =
-            root::nsTArray<root::mozilla::PropertyStyleAnimationValuePair>;
         #[test]
         fn __bindgen_test_layout_DefaultDelete_instantiation_3() {
             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 ! (
@@ -11456,17 +12143,16 @@ pub mod root {
             assert_eq! (::std::mem::align_of::<LookAndFeel>() , 1usize ,
                         concat ! (
                         "Alignment of " , stringify ! ( LookAndFeel ) ));
         }
         impl Clone for LookAndFeel {
             fn clone(&self) -> Self { *self }
         }
         #[repr(C)]
-        #[derive(Debug)]
         pub struct PseudoElementHashEntry {
             pub _base: root::PLDHashEntryHdr,
             pub mElement: root::RefPtr<root::mozilla::dom::Element>,
             pub mPseudoType: root::mozilla::CSSPseudoElementType,
         }
         pub type PseudoElementHashEntry_KeyType =
             root::mozilla::NonOwningAnimationTarget;
         pub type PseudoElementHashEntry_KeyTypePointer =
@@ -11620,16 +12306,86 @@ pub mod root {
                         concat ! (
                         "Alignment of " , stringify ! ( ServoMediaList ) ));
             assert_eq! (unsafe {
                         & ( * ( 0 as * const ServoMediaList ) ) . mRawList as
                         * const _ as usize } , 56usize , concat ! (
                         "Alignment of field: " , stringify ! ( ServoMediaList
                         ) , "::" , stringify ! ( mRawList ) ));
         }
+        /**
+ * A PostTraversalTask is a task to be performed immediately after a Servo
+ * traversal.  There are just a few tasks we need to perform, so we use this
+ * class rather than Runnables, to avoid virtual calls and some allocations.
+ *
+ * A PostTraversalTask is only safe to run immediately after the Servo
+ * traversal, since it can hold raw pointers to DOM objects.
+ */
+        #[repr(C)]
+        #[derive(Debug, Copy)]
+        pub struct PostTraversalTask {
+            pub mType: root::mozilla::PostTraversalTask_Type,
+            pub mTarget: *mut ::std::os::raw::c_void,
+            pub mResult: root::nsresult,
+        }
+        #[repr(i32)]
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+        pub enum PostTraversalTask_Type {
+            ResolveFontFaceLoadedPromise = 0,
+            RejectFontFaceLoadedPromise = 1,
+            DispatchLoadingEventAndReplaceReadyPromise = 2,
+            DispatchFontFaceSetCheckLoadingFinishedAfterDelay = 3,
+            LoadFontEntry = 4,
+        }
+        #[test]
+        fn bindgen_test_layout_PostTraversalTask() {
+            assert_eq!(::std::mem::size_of::<PostTraversalTask>() , 24usize ,
+                       concat ! (
+                       "Size of: " , stringify ! ( PostTraversalTask ) ));
+            assert_eq! (::std::mem::align_of::<PostTraversalTask>() , 8usize ,
+                        concat ! (
+                        "Alignment of " , stringify ! ( PostTraversalTask )
+                        ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const PostTraversalTask ) ) . mType as
+                        * const _ as usize } , 0usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        PostTraversalTask ) , "::" , stringify ! ( mType ) ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const PostTraversalTask ) ) . mTarget
+                        as * const _ as usize } , 8usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        PostTraversalTask ) , "::" , stringify ! ( mTarget )
+                        ));
+            assert_eq! (unsafe {
+                        & ( * ( 0 as * const PostTraversalTask ) ) . mResult
+                        as * const _ as usize } , 16usize , concat ! (
+                        "Alignment of field: " , stringify ! (
+                        PostTraversalTask ) , "::" , stringify ! ( mResult )
+                        ));
+        }
+        impl Clone for PostTraversalTask {
+            fn clone(&self) -> Self { *self }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone)]
+        pub struct ServoStyleRuleMap {
+            _unused: [u8; 0],
+        }
+        #[repr(u8)]
+        /**
+ * A few flags used to track which kind of stylist state we may need to
+ * update.
+ */
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+        pub enum StylistState {
+            NotDirty = 0,
+            StyleSheetsDirty = 1,
+            FullyDirty = 2,
+        }
         #[repr(C)]
         #[derive(Debug)]
         pub struct CSSFontFaceDescriptors {
             pub mFamily: root::nsCSSValue,
             pub mStyle: root::nsCSSValue,
             pub mWeight: root::nsCSSValue,
             pub mStretch: root::nsCSSValue,
             pub mSrc: root::nsCSSValue,
@@ -11721,206 +12477,204 @@ pub mod root {
  */
         #[repr(C)]
         #[derive(Debug, Copy, Clone)]
         pub struct UniquePtr<T> {
             pub mPtr: *mut T,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
         }
     }
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct _IO_FILE {
-        pub _flags: ::std::os::raw::c_int,
-        pub _IO_read_ptr: *mut ::std::os::raw::c_char,
-        pub _IO_read_end: *mut ::std::os::raw::c_char,
-        pub _IO_read_base: *mut ::std::os::raw::c_char,
-        pub _IO_write_base: *mut ::std::os::raw::c_char,
-        pub _IO_write_ptr: *mut ::std::os::raw::c_char,
-        pub _IO_write_end: *mut ::std::os::raw::c_char,
-        pub _IO_buf_base: *mut ::std::os::raw::c_char,
-        pub _IO_buf_end: *mut ::std::os::raw::c_char,
-        pub _IO_save_base: *mut ::std::os::raw::c_char,
-        pub _IO_backup_base: *mut ::std::os::raw::c_char,
-        pub _IO_save_end: *mut ::std::os::raw::c_char,
-        pub _markers: *mut root::_IO_marker,
-        pub _chain: *mut root::_IO_FILE,
-        pub _fileno: ::std::os::raw::c_int,
-        pub _flags2: ::std::os::raw::c_int,
-        pub _old_offset: root::__off_t,
-        pub _cur_column: ::std::os::raw::c_ushort,
-        pub _vtable_offset: ::std::os::raw::c_schar,
-        pub _shortbuf: [::std::os::raw::c_char; 1usize],
-        pub _lock: *mut root::_IO_lock_t,
-        pub _offset: root::__off64_t,
-        pub __pad1: *mut ::std::os::raw::c_void,
-        pub __pad2: *mut ::std::os::raw::c_void,
-        pub __pad3: *mut ::std::os::raw::c_void,
-        pub __pad4: *mut ::std::os::raw::c_void,
-        pub __pad5: usize,
-        pub _mode: ::std::os::raw::c_int,
-        pub _unused2: [::std::os::raw::c_char; 20usize],
-    }
-    #[test]
-    fn bindgen_test_layout__IO_FILE() {
-        assert_eq!(::std::mem::size_of::<_IO_FILE>() , 216usize , concat ! (
-                   "Size of: " , stringify ! ( _IO_FILE ) ));
-        assert_eq! (::std::mem::align_of::<_IO_FILE>() , 8usize , concat ! (
-                    "Alignment of " , stringify ! ( _IO_FILE ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _flags as * const _ as
+    pub type va_list = root::__builtin_va_list;
+    pub type fpos_t = root::__darwin_off_t;
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct __sbuf {
+        pub _base: *mut ::std::os::raw::c_uchar,
+        pub _size: ::std::os::raw::c_int,
+    }
+    #[test]
+    fn bindgen_test_layout___sbuf() {
+        assert_eq!(::std::mem::size_of::<__sbuf>() , 16usize , concat ! (
+                   "Size of: " , stringify ! ( __sbuf ) ));
+        assert_eq! (::std::mem::align_of::<__sbuf>() , 8usize , concat ! (
+                    "Alignment of " , stringify ! ( __sbuf ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sbuf ) ) . _base as * const _ as
                     usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
+                    "Alignment of field: " , stringify ! ( __sbuf ) , "::" ,
+                    stringify ! ( _base ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sbuf ) ) . _size as * const _ as
+                    usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sbuf ) , "::" ,
+                    stringify ! ( _size ) ));
+    }
+    impl Clone for __sbuf {
+        fn clone(&self) -> Self { *self }
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct __sFILEX {
+        _unused: [u8; 0],
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct __sFILE {
+        pub _p: *mut ::std::os::raw::c_uchar,
+        pub _r: ::std::os::raw::c_int,
+        pub _w: ::std::os::raw::c_int,
+        pub _flags: ::std::os::raw::c_short,
+        pub _file: ::std::os::raw::c_short,
+        pub _bf: root::__sbuf,
+        pub _lbfsize: ::std::os::raw::c_int,
+        pub _cookie: *mut ::std::os::raw::c_void,
+        pub _close: ::std::option::Option<unsafe extern "C" fn(arg1:
+                                                                   *mut ::std::os::raw::c_void)
+                                              -> ::std::os::raw::c_int>,
+        pub _read: ::std::option::Option<unsafe extern "C" fn(arg1:
+                                                                  *mut ::std::os::raw::c_void,
+                                                              arg2:
+                                                                  *mut ::std::os::raw::c_char,
+                                                              arg3:
+                                                                  ::std::os::raw::c_int)
+                                             -> ::std::os::raw::c_int>,
+        pub _seek: ::std::option::Option<unsafe extern "C" fn(arg1:
+                                                                  *mut ::std::os::raw::c_void,
+                                                              arg2:
+                                                                  root::fpos_t,
+                                                              arg3:
+                                                                  ::std::os::raw::c_int)
+                                             -> root::fpos_t>,
+        pub _write: ::std::option::Option<unsafe extern "C" fn(arg1:
+                                                                   *mut ::std::os::raw::c_void,
+                                                               arg2:
+                                                                   *const ::std::os::raw::c_char,
+                                                               arg3:
+                                                                   ::std::os::raw::c_int)
+                                              -> ::std::os::raw::c_int>,
+        pub _ub: root::__sbuf,
+        pub _extra: *mut root::__sFILEX,
+        pub _ur: ::std::os::raw::c_int,
+        pub _ubuf: [::std::os::raw::c_uchar; 3usize],
+        pub _nbuf: [::std::os::raw::c_uchar; 1usize],
+        pub _lb: root::__sbuf,
+        pub _blksize: ::std::os::raw::c_int,
+        pub _offset: root::fpos_t,
+    }
+    #[test]
+    fn bindgen_test_layout___sFILE() {
+        assert_eq!(::std::mem::size_of::<__sFILE>() , 152usize , concat ! (
+                   "Size of: " , stringify ! ( __sFILE ) ));
+        assert_eq! (::std::mem::align_of::<__sFILE>() , 8usize , concat ! (
+                    "Alignment of " , stringify ! ( __sFILE ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _p as * const _ as
+                    usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _p ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _r as * const _ as
+                    usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _r ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _w as * const _ as
+                    usize } , 12usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _w ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _flags as * const _ as
+                    usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
                     stringify ! ( _flags ) ));
         assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_read_ptr as *
-                    const _ as usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_read_ptr ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_read_end as *
-                    const _ as usize } , 16usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_read_end ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_read_base as *
-                    const _ as usize } , 24usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_read_base ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_write_base as *
-                    const _ as usize } , 32usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_write_base ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_write_ptr as *
-                    const _ as usize } , 40usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_write_ptr ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_write_end as *
-                    const _ as usize } , 48usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_write_end ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_buf_base as *
-                    const _ as usize } , 56usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_buf_base ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_buf_end as * const
-                    _ as usize } , 64usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_buf_end ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_save_base as *
-                    const _ as usize } , 72usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_save_base ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_backup_base as *
-                    const _ as usize } , 80usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_backup_base ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _IO_save_end as *
-                    const _ as usize } , 88usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _IO_save_end ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _markers as * const _
-                    as usize } , 96usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _markers ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _chain as * const _ as
+                    & ( * ( 0 as * const __sFILE ) ) . _file as * const _ as
+                    usize } , 18usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _file ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _bf as * const _ as
+                    usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _bf ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _lbfsize as * const _
+                    as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _lbfsize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _cookie as * const _ as
+                    usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _cookie ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _close as * const _ as
+                    usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _close ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _read as * const _ as
+                    usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _read ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _seek as * const _ as
+                    usize } , 72usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _seek ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _write as * const _ as
+                    usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _write ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _ub as * const _ as
+                    usize } , 88usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _ub ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _extra as * const _ as
                     usize } , 104usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _chain ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _fileno as * const _
-                    as usize } , 112usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _fileno ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _flags2 as * const _
-                    as usize } , 116usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _flags2 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _old_offset as * const
-                    _ as usize } , 120usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _old_offset ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _cur_column as * const
-                    _ as usize } , 128usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _cur_column ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _vtable_offset as *
-                    const _ as usize } , 130usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _vtable_offset ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _shortbuf as * const _
-                    as usize } , 131usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _shortbuf ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _lock as * const _ as
-                    usize } , 136usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _lock ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _offset as * const _
-                    as usize } , 144usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _extra ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _ur as * const _ as
+                    usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _ur ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _ubuf as * const _ as
+                    usize } , 116usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _ubuf ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _nbuf as * const _ as
+                    usize } , 119usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _nbuf ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _lb as * const _ as
+                    usize } , 120usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _lb ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _blksize as * const _
+                    as usize } , 136usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
+                    stringify ! ( _blksize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const __sFILE ) ) . _offset as * const _ as
+                    usize } , 144usize , concat ! (
+                    "Alignment of field: " , stringify ! ( __sFILE ) , "::" ,
                     stringify ! ( _offset ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . __pad1 as * const _ as
-                    usize } , 152usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( __pad1 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . __pad2 as * const _ as
-                    usize } , 160usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( __pad2 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . __pad3 as * const _ as
-                    usize } , 168usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( __pad3 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . __pad4 as * const _ as
-                    usize } , 176usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( __pad4 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . __pad5 as * const _ as
-                    usize } , 184usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( __pad5 ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _mode as * const _ as
-                    usize } , 192usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _mode ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_FILE ) ) . _unused2 as * const _
-                    as usize } , 196usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_FILE ) , "::" ,
-                    stringify ! ( _unused2 ) ));
-    }
-    impl Clone for _IO_FILE {
-        fn clone(&self) -> Self { *self }
-    }
-    pub type FILE = root::_IO_FILE;
-    pub type va_list = root::__builtin_va_list;
+    }
+    impl Clone for __sFILE {
+        fn clone(&self) -> Self { *self }
+    }
+    pub type FILE = root::__sFILE;
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct InfallibleAllocPolicy {
         pub _address: u8,
     }
     #[test]
     fn bindgen_test_layout_InfallibleAllocPolicy() {
         assert_eq!(::std::mem::size_of::<InfallibleAllocPolicy>() , 1usize ,
@@ -12467,49 +13221,16 @@ pub mod root {
         NS_ERROR_DOCUMENT_IS_PRINTMODE = 2155349969,
         NS_SUCCESS_DONT_FIXUP = 7864321,
         NS_SUCCESS_RESTART_APP_NOT_SAME_PROFILE = 7864323,
         NS_SUCCESS_UNORM_NOTFOUND = 7864337,
         NS_ERROR_NOT_IN_TREE = 2155348006,
         NS_OK_NO_NAME_CLAUSE_HANDLED = 7864354,
     }
     pub type nsrefcnt = root::MozRefCountType;
-    pub type _IO_lock_t = ::std::os::raw::c_void;
-    #[repr(C)]
-    #[derive(Debug, Copy)]
-    pub struct _IO_marker {
-        pub _next: *mut root::_IO_marker,
-        pub _sbuf: *mut root::_IO_FILE,
-        pub _pos: ::std::os::raw::c_int,
-    }
-    #[test]
-    fn bindgen_test_layout__IO_marker() {
-        assert_eq!(::std::mem::size_of::<_IO_marker>() , 24usize , concat ! (
-                   "Size of: " , stringify ! ( _IO_marker ) ));
-        assert_eq! (::std::mem::align_of::<_IO_marker>() , 8usize , concat ! (
-                    "Alignment of " , stringify ! ( _IO_marker ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_marker ) ) . _next as * const _
-                    as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_marker ) , "::"
-                    , stringify ! ( _next ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_marker ) ) . _sbuf as * const _
-                    as usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_marker ) , "::"
-                    , stringify ! ( _sbuf ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const _IO_marker ) ) . _pos as * const _ as
-                    usize } , 16usize , concat ! (
-                    "Alignment of field: " , stringify ! ( _IO_marker ) , "::"
-                    , stringify ! ( _pos ) ));
-    }
-    impl Clone for _IO_marker {
-        fn clone(&self) -> Self { *self }
-    }
     #[repr(C)]
     pub struct nsQueryFrame__bindgen_vtable(::std::os::raw::c_void);
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsQueryFrame {
         pub vtable_: *const nsQueryFrame__bindgen_vtable,
     }
     #[repr(u32)]
@@ -14865,21 +15586,16 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const AutoSetAsyncStackForNewCalls ) )
                         . oldAsyncCallIsExplicit as * const _ as usize } ,
                         40usize , concat ! (
                         "Alignment of field: " , stringify ! (
                         AutoSetAsyncStackForNewCalls ) , "::" , stringify ! (
                         oldAsyncCallIsExplicit ) ));
         }
-        pub type WarningReporter =
-            ::std::option::Option<unsafe extern "C" fn(cx:
-                                                           *mut root::JSContext,
-                                                       report:
-                                                           *mut root::JSErrorReport)>;
         #[repr(C)]
         #[derive(Debug)]
         pub struct AutoHideScriptedCaller {
             pub mContext: *mut root::JSContext,
             pub _mCheckNotUsedAsTemporary: root::mozilla::detail::GuardObjectNotificationReceiver,
         }
         #[test]
         fn bindgen_test_layout_AutoHideScriptedCaller() {
@@ -15031,151 +15747,16 @@ pub mod root {
                         ! ( "Alignment of " , stringify ! ( SourceHook ) ));
         }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct JSCompartment {
         _unused: [u8; 0],
     }
-    /**
- * Describes a single error or warning that occurs in the execution of script.
- */
-    #[repr(C)]
-    pub struct JSErrorReport {
-        pub _base: root::JSErrorBase,
-        pub linebuf_: *const u16,
-        pub linebufLength_: usize,
-        pub tokenOffset_: usize,
-        pub notes: root::mozilla::UniquePtr<root::JSErrorNotes>,
-        pub flags: ::std::os::raw::c_uint,
-        pub exnType: i16,
-        pub _bitfield_1: u8,
-        pub __bindgen_padding_0: u8,
-    }
-    #[test]
-    fn bindgen_test_layout_JSErrorReport() {
-        assert_eq!(::std::mem::size_of::<JSErrorReport>() , 72usize , concat !
-                   ( "Size of: " , stringify ! ( JSErrorReport ) ));
-        assert_eq! (::std::mem::align_of::<JSErrorReport>() , 8usize , concat
-                    ! ( "Alignment of " , stringify ! ( JSErrorReport ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const JSErrorReport ) ) . linebuf_ as *
-                    const _ as usize } , 32usize , concat ! (
-                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
-                    "::" , stringify ! ( linebuf_ ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const JSErrorReport ) ) . linebufLength_ as
-                    * const _ as usize } , 40usize , concat ! (
-                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
-                    "::" , stringify ! ( linebufLength_ ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const JSErrorReport ) ) . tokenOffset_ as *
-                    const _ as usize } , 48usize , concat ! (
-                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
-                    "::" , stringify ! ( tokenOffset_ ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const JSErrorReport ) ) . notes as * const
-                    _ as usize } , 56usize , concat ! (
-                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
-                    "::" , stringify ! ( notes ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const JSErrorReport ) ) . flags as * const
-                    _ as usize } , 64usize , concat ! (
-                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
-                    "::" , stringify ! ( flags ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const JSErrorReport ) ) . exnType as *
-                    const _ as usize } , 68usize , concat ! (
-                    "Alignment of field: " , stringify ! ( JSErrorReport ) ,
-                    "::" , stringify ! ( exnType ) ));
-    }
-    impl JSErrorReport {
-        #[inline]
-        pub fn isMuted(&self) -> bool {
-            let 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_isMuted(&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 ownsLinebuf_(&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_ownsLinebuf_(&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 new_bitfield_1(isMuted: bool, ownsLinebuf_: bool) -> u8 {
-            ({ ({ 0 } | ((isMuted as u8 as u8) << 0usize) & (1u64 as u8)) } |
-                 ((ownsLinebuf_ as u8 as u8) << 1usize) & (2u64 as u8))
-        }
-    }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct JSRuntime {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct JSTracer {
@@ -16070,17 +16651,17 @@ pub mod root {
         pub mFontFeatureValues: [u64; 6usize],
     }
     pub type gfxFontFeatureValueSet_HasThreadSafeRefCnt =
         root::mozilla::FalseType;
     #[repr(C)]
     #[derive(Debug)]
     pub struct gfxFontFeatureValueSet_ValueList {
         pub name: ::nsstring::nsStringRepr,
-        pub featureSelectors: root::nsTArray<u32>,
+        pub featureSelectors: root::nsTArray<::std::os::raw::c_uint>,
     }
     #[test]
     fn bindgen_test_layout_gfxFontFeatureValueSet_ValueList() {
         assert_eq!(::std::mem::size_of::<gfxFontFeatureValueSet_ValueList>() ,
                    24usize , concat ! (
                    "Size of: " , stringify ! (
                    gfxFontFeatureValueSet_ValueList ) ));
         assert_eq! (::std::mem::align_of::<gfxFontFeatureValueSet_ValueList>()
@@ -16175,17 +16756,17 @@ pub mod root {
                     gfxFontFeatureValueSet_FeatureValueHashKey ) , "::" ,
                     stringify ! ( mName ) ));
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct gfxFontFeatureValueSet_FeatureValueHashEntry {
         pub _base: root::PLDHashEntryHdr,
         pub mKey: root::gfxFontFeatureValueSet_FeatureValueHashKey,
-        pub mValues: root::nsTArray<u32>,
+        pub mValues: root::nsTArray<::std::os::raw::c_uint>,
     }
     pub type gfxFontFeatureValueSet_FeatureValueHashEntry_KeyType =
         *const root::gfxFontFeatureValueSet_FeatureValueHashKey;
     pub type gfxFontFeatureValueSet_FeatureValueHashEntry_KeyTypePointer =
         *const root::gfxFontFeatureValueSet_FeatureValueHashKey;
     pub const gfxFontFeatureValueSet_FeatureValueHashEntry_ALLOW_MEMMOVE:
               root::gfxFontFeatureValueSet_FeatureValueHashEntry__bindgen_ty_1
               =
@@ -16285,17 +16866,17 @@ pub mod root {
         pub stretch: i16,
         pub kerning: u8,
         pub synthesis: u8,
         pub size: root::nscoord,
         pub sizeAdjust: f32,
         pub alternateValues: root::nsTArray<root::gfxAlternateValue>,
         pub featureValueLookup: root::RefPtr<root::gfxFontFeatureValueSet>,
         pub fontFeatureSettings: root::nsTArray<root::gfxFontFeature>,
-        pub fontVariationSettings: root::nsTArray<root::gfxFontVariation>,
+        pub fontVariationSettings: root::nsTArray<root::mozilla::gfx::FontVariation>,
         pub languageOverride: u32,
     }
     #[test]
     fn bindgen_test_layout_nsFont() {
         assert_eq!(::std::mem::size_of::<nsFont>() , 88usize , concat ! (
                    "Size of: " , stringify ! ( nsFont ) ));
         assert_eq! (::std::mem::align_of::<nsFont>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsFont ) ));
@@ -17275,17 +17856,16 @@ pub mod root {
    */
     #[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)]
-    #[derive(Debug)]
     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 ! (
@@ -18264,16 +18844,2390 @@ pub mod root {
                   } |
                       ((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,
+        pub mMathDisplay: u8,
+        pub mMinFontSizeRatio: u8,
+        pub mExplicitLanguage: bool,
+        pub mAllowZoom: bool,
+        pub mScriptUnconstrainedSize: root::nscoord,
+        pub mScriptMinSize: root::nscoord,
+        pub mScriptSizeMultiplier: f32,
+        pub mLanguage: root::nsCOMPtr<root::nsIAtom>,
+    }
+    pub const nsStyleFont_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleFont() {
+        assert_eq!(::std::mem::size_of::<nsStyleFont>() , 120usize , concat !
+                   ( "Size of: " , stringify ! ( nsStyleFont ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleFont>() , 8usize , concat !
+                    ( "Alignment of " , stringify ! ( nsStyleFont ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mFont as * const _
+                    as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mFont ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mSize as * const _
+                    as usize } , 88usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mSize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mGenericID as *
+                    const _ as usize } , 92usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mGenericID ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mScriptLevel as *
+                    const _ as usize } , 93usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mScriptLevel ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mMathVariant as *
+                    const _ as usize } , 94usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mMathVariant ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mMathDisplay as *
+                    const _ as usize } , 95usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mMathDisplay ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mMinFontSizeRatio
+                    as * const _ as usize } , 96usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mMinFontSizeRatio ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mExplicitLanguage
+                    as * const _ as usize } , 97usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mExplicitLanguage ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mAllowZoom as *
+                    const _ as usize } , 98usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mAllowZoom ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) .
+                    mScriptUnconstrainedSize as * const _ as usize } ,
+                    100usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mScriptUnconstrainedSize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mScriptMinSize as *
+                    const _ as usize } , 104usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mScriptMinSize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) .
+                    mScriptSizeMultiplier as * const _ as usize } , 108usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mScriptSizeMultiplier ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleFont ) ) . mLanguage as *
+                    const _ as usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleFont ) ,
+                    "::" , stringify ! ( mLanguage ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleColor {
+        pub mColor: root::nscolor,
+    }
+    pub const nsStyleColor_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleColor() {
+        assert_eq!(::std::mem::size_of::<nsStyleColor>() , 4usize , concat ! (
+                   "Size of: " , stringify ! ( nsStyleColor ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleColor>() , 4usize , concat !
+                    ( "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_21() {
+        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_22() {
+        assert_eq!(::std::mem::size_of::<root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::mozilla::StaticRefPtr<root::nsStyleQuoteValues> ) ));
+        assert_eq!(::std::mem::align_of::<root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::mozilla::StaticRefPtr<root::nsStyleQuoteValues> ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleList {
+        pub mListStylePosition: u8,
+        pub mListStyleImage: root::RefPtr<root::nsStyleImageRequest>,
+        pub mCounterStyle: root::mozilla::CounterStylePtr,
+        pub mQuotes: root::RefPtr<root::nsStyleQuoteValues>,
+        pub mImageRegion: root::nsRect,
+    }
+    pub const nsStyleList_kHasFinishStyle: bool = true;
+    extern "C" {
+        #[link_name = "_ZN11nsStyleList14sInitialQuotesE"]
+        pub static mut nsStyleList_sInitialQuotes:
+                   root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>;
+    }
+    extern "C" {
+        #[link_name = "_ZN11nsStyleList11sNoneQuotesE"]
+        pub static mut nsStyleList_sNoneQuotes:
+                   root::mozilla::StaticRefPtr<root::nsStyleQuoteValues>;
+    }
+    #[test]
+    fn bindgen_test_layout_nsStyleList() {
+        assert_eq!(::std::mem::size_of::<nsStyleList>() , 48usize , concat ! (
+                   "Size of: " , stringify ! ( nsStyleList ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleList>() , 8usize , concat !
+                    ( "Alignment of " , stringify ! ( nsStyleList ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleList ) ) . mListStylePosition
+                    as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleList ) ,
+                    "::" , stringify ! ( mListStylePosition ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleList ) ) . mListStyleImage as
+                    * const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleList ) ,
+                    "::" , stringify ! ( mListStyleImage ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleList ) ) . mCounterStyle as *
+                    const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleList ) ,
+                    "::" , stringify ! ( mCounterStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleList ) ) . mQuotes as * const
+                    _ as usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleList ) ,
+                    "::" , stringify ! ( mQuotes ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleList ) ) . mImageRegion as *
+                    const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleList ) ,
+                    "::" , stringify ! ( mImageRegion ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleText {
+        pub mTextAlign: u8,
+        pub mTextAlignLast: u8,
+        pub _bitfield_1: u8,
+        pub mTextJustify: root::mozilla::StyleTextJustify,
+        pub mTextTransform: u8,
+        pub mWhiteSpace: root::mozilla::StyleWhiteSpace,
+        pub mWordBreak: u8,
+        pub mOverflowWrap: u8,
+        pub mHyphens: root::mozilla::StyleHyphens,
+        pub mRubyAlign: u8,
+        pub mRubyPosition: u8,
+        pub mTextSizeAdjust: u8,
+        pub mTextCombineUpright: u8,
+        pub mControlCharacterVisibility: u8,
+        pub mTextEmphasisPosition: u8,
+        pub mTextEmphasisStyle: u8,
+        pub mTextRendering: u8,
+        pub mTextEmphasisColor: root::mozilla::StyleComplexColor,
+        pub mWebkitTextFillColor: root::mozilla::StyleComplexColor,
+        pub mWebkitTextStrokeColor: root::mozilla::StyleComplexColor,
+        pub mTabSize: root::nsStyleCoord,
+        pub mWordSpacing: root::nsStyleCoord,
+        pub mLetterSpacing: root::nsStyleCoord,
+        pub mLineHeight: root::nsStyleCoord,
+        pub mTextIndent: root::nsStyleCoord,
+        pub mWebkitTextStrokeWidth: root::nscoord,
+        pub mTextShadow: root::RefPtr<root::nsCSSShadowArray>,
+        pub mTextEmphasisStyleString: ::nsstring::nsStringRepr,
+    }
+    pub const nsStyleText_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleText() {
+        assert_eq!(::std::mem::size_of::<nsStyleText>() , 160usize , concat !
+                   ( "Size of: " , stringify ! ( nsStyleText ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleText>() , 8usize , concat !
+                    ( "Alignment of " , stringify ! ( nsStyleText ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextAlign as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextAlign ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextAlignLast as *
+                    const _ as usize } , 1usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextAlignLast ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextJustify as *
+                    const _ as usize } , 3usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextJustify ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextTransform as *
+                    const _ as usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextTransform ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mWhiteSpace as *
+                    const _ as usize } , 5usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mWhiteSpace ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mWordBreak as *
+                    const _ as usize } , 6usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mWordBreak ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mOverflowWrap as *
+                    const _ as usize } , 7usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mOverflowWrap ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mHyphens as * const
+                    _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mHyphens ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mRubyAlign as *
+                    const _ as usize } , 9usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mRubyAlign ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mRubyPosition as *
+                    const _ as usize } , 10usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mRubyPosition ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextSizeAdjust as
+                    * const _ as usize } , 11usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextSizeAdjust ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextCombineUpright
+                    as * const _ as usize } , 12usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextCombineUpright ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) .
+                    mControlCharacterVisibility as * const _ as usize } ,
+                    13usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mControlCharacterVisibility ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) .
+                    mTextEmphasisPosition as * const _ as usize } , 14usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextEmphasisPosition ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextEmphasisStyle
+                    as * const _ as usize } , 15usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextEmphasisStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextRendering as *
+                    const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextRendering ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextEmphasisColor
+                    as * const _ as usize } , 20usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextEmphasisColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) .
+                    mWebkitTextFillColor as * const _ as usize } , 28usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mWebkitTextFillColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) .
+                    mWebkitTextStrokeColor as * const _ as usize } , 36usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mWebkitTextStrokeColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTabSize as * const
+                    _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTabSize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mWordSpacing as *
+                    const _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mWordSpacing ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mLetterSpacing as *
+                    const _ as usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mLetterSpacing ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mLineHeight as *
+                    const _ as usize } , 96usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mLineHeight ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextIndent as *
+                    const _ as usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextIndent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) .
+                    mWebkitTextStrokeWidth as * const _ as usize } , 128usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mWebkitTextStrokeWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) . mTextShadow as *
+                    const _ as usize } , 136usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextShadow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleText ) ) .
+                    mTextEmphasisStyleString as * const _ as usize } ,
+                    144usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleText ) ,
+                    "::" , stringify ! ( mTextEmphasisStyleString ) ));
+    }
+    impl nsStyleText {
+        #[inline]
+        pub fn mTextAlignTrue(&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_mTextAlignTrue(&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 mTextAlignLastTrue(&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_mTextAlignLastTrue(&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 new_bitfield_1(mTextAlignTrue: bool, mTextAlignLastTrue: bool)
+         -> u8 {
+            ({
+                 ({ 0 } |
+                      ((mTextAlignTrue as u8 as u8) << 0usize) & (1u64 as u8))
+             } | ((mTextAlignLastTrue as u8 as u8) << 1usize) & (2u64 as u8))
+        }
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleVisibility {
+        pub mImageOrientation: root::nsStyleImageOrientation,
+        pub mDirection: u8,
+        pub mVisible: u8,
+        pub mImageRendering: u8,
+        pub mWritingMode: u8,
+        pub mTextOrientation: u8,
+        pub mColorAdjust: u8,
+    }
+    pub const nsStyleVisibility_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleVisibility() {
+        assert_eq!(::std::mem::size_of::<nsStyleVisibility>() , 7usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStyleVisibility )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleVisibility>() , 1usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleVisibility ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) .
+                    mImageOrientation as * const _ as usize } , 0usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mImageOrientation ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) . mDirection as
+                    * const _ as usize } , 1usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mDirection ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) . mVisible as *
+                    const _ as usize } , 2usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mVisible ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) .
+                    mImageRendering as * const _ as usize } , 3usize , concat
+                    ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mImageRendering ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) . mWritingMode
+                    as * const _ as usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mWritingMode ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) .
+                    mTextOrientation as * const _ as usize } , 5usize , concat
+                    ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mTextOrientation ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVisibility ) ) . mColorAdjust
+                    as * const _ as usize } , 6usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
+                    , "::" , stringify ! ( mColorAdjust ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleUserInterface {
+        pub mUserInput: root::mozilla::StyleUserInput,
+        pub mUserModify: root::mozilla::StyleUserModify,
+        pub mUserFocus: root::mozilla::StyleUserFocus,
+        pub mPointerEvents: u8,
+        pub mCursor: u8,
+        pub mCursorImages: root::nsTArray<root::nsCursorImage>,
+        pub mCaretColor: root::mozilla::StyleComplexColor,
+    }
+    pub const nsStyleUserInterface_kHasFinishStyle: bool = true;
+    #[test]
+    fn bindgen_test_layout_nsStyleUserInterface() {
+        assert_eq!(::std::mem::size_of::<nsStyleUserInterface>() , 24usize ,
+                   concat ! (
+                   "Size of: " , stringify ! ( nsStyleUserInterface ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleUserInterface>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleUserInterface ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) . mUserInput
+                    as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! ( mUserInput )
+                    ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) .
+                    mUserModify as * const _ as usize } , 1usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! ( mUserModify
+                    ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) . mUserFocus
+                    as * const _ as usize } , 2usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! ( mUserFocus )
+                    ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) .
+                    mPointerEvents as * const _ as usize } , 3usize , concat !
+                    (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! (
+                    mPointerEvents ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) . mCursor as
+                    * const _ as usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! ( mCursor )
+                    ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) .
+                    mCursorImages as * const _ as usize } , 8usize , concat !
+                    (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! (
+                    mCursorImages ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUserInterface ) ) .
+                    mCaretColor as * const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleUserInterface ) , "::" , stringify ! ( mCaretColor
+                    ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleTableBorder {
+        pub mBorderSpacingCol: root::nscoord,
+        pub mBorderSpacingRow: root::nscoord,
+        pub mBorderCollapse: u8,
+        pub mCaptionSide: u8,
+        pub mEmptyCells: u8,
+    }
+    pub const nsStyleTableBorder_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleTableBorder() {
+        assert_eq!(::std::mem::size_of::<nsStyleTableBorder>() , 12usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStyleTableBorder )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleTableBorder>() , 4usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleTableBorder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTableBorder ) ) .
+                    mBorderSpacingCol as * const _ as usize } , 0usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTableBorder
+                    ) , "::" , stringify ! ( mBorderSpacingCol ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTableBorder ) ) .
+                    mBorderSpacingRow as * const _ as usize } , 4usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTableBorder
+                    ) , "::" , stringify ! ( mBorderSpacingRow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTableBorder ) ) .
+                    mBorderCollapse as * const _ as usize } , 8usize , concat
+                    ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTableBorder
+                    ) , "::" , stringify ! ( mBorderCollapse ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTableBorder ) ) . mCaptionSide
+                    as * const _ as usize } , 9usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTableBorder
+                    ) , "::" , stringify ! ( mCaptionSide ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTableBorder ) ) . mEmptyCells
+                    as * const _ as usize } , 10usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTableBorder
+                    ) , "::" , stringify ! ( mEmptyCells ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleSVG {
+        pub mFill: root::nsStyleSVGPaint,
+        pub mStroke: root::nsStyleSVGPaint,
+        pub mMarkerEnd: root::RefPtr<root::mozilla::css::URLValue>,
+        pub mMarkerMid: root::RefPtr<root::mozilla::css::URLValue>,
+        pub mMarkerStart: root::RefPtr<root::mozilla::css::URLValue>,
+        pub mStrokeDasharray: root::nsTArray<root::nsStyleCoord>,
+        pub mContextProps: root::nsTArray<root::nsCOMPtr<root::nsIAtom>>,
+        pub mStrokeDashoffset: root::nsStyleCoord,
+        pub mStrokeWidth: root::nsStyleCoord,
+        pub mFillOpacity: f32,
+        pub mStrokeMiterlimit: f32,
+        pub mStrokeOpacity: f32,
+        pub mClipRule: root::mozilla::StyleFillRule,
+        pub mColorInterpolation: u8,
+        pub mColorInterpolationFilters: u8,
+        pub mFillRule: root::mozilla::StyleFillRule,
+        pub mPaintOrder: u8,
+        pub mShapeRendering: u8,
+        pub mStrokeLinecap: u8,
+        pub mStrokeLinejoin: u8,
+        pub mTextAnchor: u8,
+        pub mContextPropsBits: u8,
+        pub mContextFlags: u8,
+    }
+    pub const nsStyleSVG_FILL_OPACITY_SOURCE_MASK:
+              root::nsStyleSVG__bindgen_ty_1 =
+        nsStyleSVG__bindgen_ty_1::FILL_OPACITY_SOURCE_MASK;
+    pub const nsStyleSVG_STROKE_OPACITY_SOURCE_MASK:
+              root::nsStyleSVG__bindgen_ty_1 =
+        nsStyleSVG__bindgen_ty_1::STROKE_OPACITY_SOURCE_MASK;
+    pub const nsStyleSVG_STROKE_DASHARRAY_CONTEXT:
+              root::nsStyleSVG__bindgen_ty_1 =
+        nsStyleSVG__bindgen_ty_1::STROKE_DASHARRAY_CONTEXT;
+    pub const nsStyleSVG_STROKE_DASHOFFSET_CONTEXT:
+              root::nsStyleSVG__bindgen_ty_1 =
+        nsStyleSVG__bindgen_ty_1::STROKE_DASHOFFSET_CONTEXT;
+    pub const nsStyleSVG_STROKE_WIDTH_CONTEXT: root::nsStyleSVG__bindgen_ty_1
+              =
+        nsStyleSVG__bindgen_ty_1::STROKE_WIDTH_CONTEXT;
+    pub const nsStyleSVG_FILL_OPACITY_SOURCE_SHIFT:
+              root::nsStyleSVG__bindgen_ty_1 =
+        nsStyleSVG__bindgen_ty_1::FILL_OPACITY_SOURCE_SHIFT;
+    pub const nsStyleSVG_STROKE_OPACITY_SOURCE_SHIFT:
+              root::nsStyleSVG__bindgen_ty_1 =
+        nsStyleSVG__bindgen_ty_1::STROKE_OPACITY_SOURCE_SHIFT;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsStyleSVG__bindgen_ty_1 {
+        FILL_OPACITY_SOURCE_MASK = 3,
+        STROKE_OPACITY_SOURCE_MASK = 12,
+        STROKE_DASHARRAY_CONTEXT = 16,
+        STROKE_DASHOFFSET_CONTEXT = 32,
+        STROKE_WIDTH_CONTEXT = 64,
+        FILL_OPACITY_SOURCE_SHIFT = 0,
+        STROKE_OPACITY_SOURCE_SHIFT = 2,
+    }
+    pub const nsStyleSVG_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleSVG() {
+        assert_eq!(::std::mem::size_of::<nsStyleSVG>() , 128usize , concat ! (
+                   "Size of: " , stringify ! ( nsStyleSVG ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleSVG>() , 8usize , concat ! (
+                    "Alignment of " , stringify ! ( nsStyleSVG ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mFill as * const _
+                    as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mFill ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStroke as * const _
+                    as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStroke ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mMarkerEnd as *
+                    const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mMarkerEnd ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mMarkerMid as *
+                    const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mMarkerMid ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mMarkerStart as *
+                    const _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mMarkerStart ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeDasharray as
+                    * const _ as usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeDasharray ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mContextProps as *
+                    const _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mContextProps ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeDashoffset as
+                    * const _ as usize } , 72usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeDashoffset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeWidth as *
+                    const _ as usize } , 88usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mFillOpacity as *
+                    const _ as usize } , 104usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mFillOpacity ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeMiterlimit as
+                    * const _ as usize } , 108usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeMiterlimit ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeOpacity as *
+                    const _ as usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeOpacity ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mClipRule as * const
+                    _ as usize } , 116usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mClipRule ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mColorInterpolation
+                    as * const _ as usize } , 117usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mColorInterpolation ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) .
+                    mColorInterpolationFilters as * const _ as usize } ,
+                    118usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mColorInterpolationFilters ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mFillRule as * const
+                    _ as usize } , 119usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mFillRule ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mPaintOrder as *
+                    const _ as usize } , 120usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mPaintOrder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mShapeRendering as *
+                    const _ as usize } , 121usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mShapeRendering ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeLinecap as *
+                    const _ as usize } , 122usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeLinecap ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mStrokeLinejoin as *
+                    const _ as usize } , 123usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mStrokeLinejoin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mTextAnchor as *
+                    const _ as usize } , 124usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mTextAnchor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mContextPropsBits as
+                    * const _ as usize } , 125usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mContextPropsBits ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVG ) ) . mContextFlags as *
+                    const _ as usize } , 126usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVG ) , "::"
+                    , stringify ! ( mContextFlags ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleVariables {
+        pub mVariables: root::mozilla::CSSVariableValues,
+    }
+    pub const nsStyleVariables_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleVariables() {
+        assert_eq!(::std::mem::size_of::<nsStyleVariables>() , 56usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStyleVariables )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleVariables>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleVariables ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleVariables ) ) . mVariables as
+                    * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleVariables )
+                    , "::" , stringify ! ( mVariables ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleBackground {
+        pub mImage: root::nsStyleImageLayers,
+        pub mBackgroundColor: root::mozilla::StyleComplexColor,
+    }
+    pub const nsStyleBackground_kHasFinishStyle: bool = true;
+    #[test]
+    fn bindgen_test_layout_nsStyleBackground() {
+        assert_eq!(::std::mem::size_of::<nsStyleBackground>() , 160usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStyleBackground )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleBackground>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleBackground ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBackground ) ) . mImage as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBackground )
+                    , "::" , stringify ! ( mImage ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBackground ) ) .
+                    mBackgroundColor as * const _ as usize } , 152usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBackground )
+                    , "::" , stringify ! ( mBackgroundColor ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStylePosition {
+        pub mObjectPosition: root::mozilla::Position,
+        pub mOffset: root::nsStyleSides,
+        pub mWidth: root::nsStyleCoord,
+        pub mMinWidth: root::nsStyleCoord,
+        pub mMaxWidth: root::nsStyleCoord,
+        pub mHeight: root::nsStyleCoord,
+        pub mMinHeight: root::nsStyleCoord,
+        pub mMaxHeight: root::nsStyleCoord,
+        pub mFlexBasis: root::nsStyleCoord,
+        pub mGridAutoColumnsMin: root::nsStyleCoord,
+        pub mGridAutoColumnsMax: root::nsStyleCoord,
+        pub mGridAutoRowsMin: root::nsStyleCoord,
+        pub mGridAutoRowsMax: root::nsStyleCoord,
+        pub mGridAutoFlow: u8,
+        pub mBoxSizing: root::mozilla::StyleBoxSizing,
+        pub mAlignContent: u16,
+        pub mAlignItems: u8,
+        pub mAlignSelf: u8,
+        pub mJustifyContent: u16,
+        pub mJustifyItems: u8,
+        pub mJustifySelf: u8,
+        pub mFlexDirection: u8,
+        pub mFlexWrap: u8,
+        pub mObjectFit: u8,
+        pub mOrder: i32,
+        pub mFlexGrow: f32,
+        pub mFlexShrink: f32,
+        pub mZIndex: root::nsStyleCoord,
+        pub mGridTemplateColumns: root::nsStyleGridTemplate,
+        pub mGridTemplateRows: root::nsStyleGridTemplate,
+        pub mGridTemplateAreas: root::RefPtr<root::mozilla::css::GridTemplateAreasValue>,
+        pub mGridColumnStart: root::nsStyleGridLine,
+        pub mGridColumnEnd: root::nsStyleGridLine,
+        pub mGridRowStart: root::nsStyleGridLine,
+        pub mGridRowEnd: root::nsStyleGridLine,
+        pub mGridColumnGap: root::nsStyleCoord,
+        pub mGridRowGap: root::nsStyleCoord,
+    }
+    pub const nsStylePosition_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStylePosition() {
+        assert_eq!(::std::mem::size_of::<nsStylePosition>() , 520usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStylePosition )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStylePosition>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStylePosition ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mObjectPosition
+                    as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mObjectPosition ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mOffset as *
+                    const _ as usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mOffset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mWidth as *
+                    const _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mMinWidth as *
+                    const _ as usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mMinWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mMaxWidth as *
+                    const _ as usize } , 96usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mMaxWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mHeight as *
+                    const _ as usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mHeight ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mMinHeight as *
+                    const _ as usize } , 128usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mMinHeight ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mMaxHeight as *
+                    const _ as usize } , 144usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mMaxHeight ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mFlexBasis as *
+                    const _ as usize } , 160usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mFlexBasis ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridAutoColumnsMin as * const _ as usize } , 176usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridAutoColumnsMin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridAutoColumnsMax as * const _ as usize } , 192usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridAutoColumnsMax ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridAutoRowsMin as * const _ as usize } , 208usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridAutoRowsMin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridAutoRowsMax as * const _ as usize } , 224usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridAutoRowsMax ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mGridAutoFlow
+                    as * const _ as usize } , 240usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridAutoFlow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mBoxSizing as *
+                    const _ as usize } , 241usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mBoxSizing ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mAlignContent
+                    as * const _ as usize } , 242usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mAlignContent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mAlignItems as
+                    * const _ as usize } , 244usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mAlignItems ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mAlignSelf as *
+                    const _ as usize } , 245usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mAlignSelf ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mJustifyContent
+                    as * const _ as usize } , 246usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mJustifyContent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mJustifyItems
+                    as * const _ as usize } , 248usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mJustifyItems ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mJustifySelf as
+                    * const _ as usize } , 249usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mJustifySelf ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mFlexDirection
+                    as * const _ as usize } , 250usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mFlexDirection ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mFlexWrap as *
+                    const _ as usize } , 251usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mFlexWrap ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mObjectFit as *
+                    const _ as usize } , 252usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mObjectFit ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mOrder as *
+                    const _ as usize } , 256usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mOrder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mFlexGrow as *
+                    const _ as usize } , 260usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mFlexGrow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mFlexShrink as
+                    * const _ as usize } , 264usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mFlexShrink ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mZIndex as *
+                    const _ as usize } , 272usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mZIndex ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridTemplateColumns as * const _ as usize } , 288usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridTemplateColumns ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridTemplateRows as * const _ as usize } , 336usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridTemplateRows ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridTemplateAreas as * const _ as usize } , 384usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridTemplateAreas ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) .
+                    mGridColumnStart as * const _ as usize } , 392usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridColumnStart ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mGridColumnEnd
+                    as * const _ as usize } , 416usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridColumnEnd ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mGridRowStart
+                    as * const _ as usize } , 440usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridRowStart ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mGridRowEnd as
+                    * const _ as usize } , 464usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridRowEnd ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mGridColumnGap
+                    as * const _ as usize } , 488usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridColumnGap ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePosition ) ) . mGridRowGap as
+                    * const _ as usize } , 504usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePosition ) ,
+                    "::" , stringify ! ( mGridRowGap ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleTextReset {
+        pub mTextOverflow: root::nsStyleTextOverflow,
+        pub mTextDecorationLine: u8,
+        pub mTextDecorationStyle: u8,
+        pub mUnicodeBidi: u8,
+        pub mInitialLetterSink: root::nscoord,
+        pub mInitialLetterSize: f32,
+        pub mTextDecorationColor: root::mozilla::StyleComplexColor,
+    }
+    pub const nsStyleTextReset_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleTextReset() {
+        assert_eq!(::std::mem::size_of::<nsStyleTextReset>() , 80usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStyleTextReset )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleTextReset>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleTextReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) . mTextOverflow
+                    as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mTextOverflow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) .
+                    mTextDecorationLine as * const _ as usize } , 56usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mTextDecorationLine ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) .
+                    mTextDecorationStyle as * const _ as usize } , 57usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mTextDecorationStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) . mUnicodeBidi
+                    as * const _ as usize } , 58usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mUnicodeBidi ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) .
+                    mInitialLetterSink as * const _ as usize } , 60usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mInitialLetterSink ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) .
+                    mInitialLetterSize as * const _ as usize } , 64usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mInitialLetterSize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTextReset ) ) .
+                    mTextDecorationColor as * const _ as usize } , 68usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTextReset )
+                    , "::" , stringify ! ( mTextDecorationColor ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleDisplay {
+        pub mBinding: root::BindingHolder,
+        pub mDisplay: root::mozilla::StyleDisplay,
+        pub mOriginalDisplay: root::mozilla::StyleDisplay,
+        pub mContain: u8,
+        pub mAppearance: u8,
+        pub mPosition: u8,
+        pub mFloat: root::mozilla::StyleFloat,
+        pub mOriginalFloat: root::mozilla::StyleFloat,
+        pub mBreakType: root::mozilla::StyleClear,
+        pub mBreakInside: u8,
+        pub mBreakBefore: bool,
+        pub mBreakAfter: bool,
+        pub mOverflowX: u8,
+        pub mOverflowY: u8,
+        pub mOverflowClipBox: u8,
+        pub mResize: u8,
+        pub mOrient: root::mozilla::StyleOrient,
+        pub mIsolation: u8,
+        pub mTopLayer: u8,
+        pub mWillChangeBitField: u8,
+        pub mWillChange: root::nsCOMArray,
+        pub mTouchAction: u8,
+        pub mScrollBehavior: u8,
+        pub mScrollSnapTypeX: u8,
+        pub mScrollSnapTypeY: u8,
+        pub mScrollSnapPointsX: root::nsStyleCoord,
+        pub mScrollSnapPointsY: root::nsStyleCoord,
+        pub mScrollSnapDestination: root::mozilla::Position,
+        pub mScrollSnapCoordinate: root::nsTArray<root::mozilla::Position>,
+        pub mBackfaceVisibility: u8,
+        pub mTransformStyle: u8,
+        pub mTransformBox: root::nsStyleDisplay_StyleGeometryBox,
+        pub mSpecifiedTransform: root::RefPtr<root::nsCSSValueSharedList>,
+        pub mTransformOrigin: [root::nsStyleCoord; 3usize],
+        pub mChildPerspective: root::nsStyleCoord,
+        pub mPerspectiveOrigin: [root::nsStyleCoord; 2usize],
+        pub mVerticalAlign: root::nsStyleCoord,
+        pub mTransitions: root::nsStyleAutoArray<root::mozilla::StyleTransition>,
+        pub mTransitionTimingFunctionCount: u32,
+        pub mTransitionDurationCount: u32,
+        pub mTransitionDelayCount: u32,
+        pub mTransitionPropertyCount: u32,
+        pub mAnimations: root::nsStyleAutoArray<root::mozilla::StyleAnimation>,
+        pub mAnimationTimingFunctionCount: u32,
+        pub mAnimationDurationCount: u32,
+        pub mAnimationDelayCount: u32,
+        pub mAnimationNameCount: u32,
+        pub mAnimationDirectionCount: u32,
+        pub mAnimationFillModeCount: u32,
+        pub mAnimationPlayStateCount: u32,
+        pub mAnimationIterationCountCount: u32,
+        pub mShapeOutside: root::mozilla::StyleShapeSource,
+    }
+    pub use self::super::root::mozilla::StyleGeometryBox as
+            nsStyleDisplay_StyleGeometryBox;
+    pub const nsStyleDisplay_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleDisplay() {
+        assert_eq!(::std::mem::size_of::<nsStyleDisplay>() , 416usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStyleDisplay ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleDisplay>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleDisplay ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBinding as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mBinding ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mDisplay as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mDisplay ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOriginalDisplay
+                    as * const _ as usize } , 9usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mOriginalDisplay ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mContain as *
+                    const _ as usize } , 10usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mContain ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mAppearance as *
+                    const _ as usize } , 11usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAppearance ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mPosition as *
+                    const _ as usize } , 12usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mPosition ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mFloat as *
+                    const _ as usize } , 13usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mFloat ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOriginalFloat
+                    as * const _ as usize } , 14usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mOriginalFloat ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakType as *
+                    const _ as usize } , 15usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mBreakType ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakInside as
+                    * const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mBreakInside ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakBefore as
+                    * const _ as usize } , 17usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mBreakBefore ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakAfter as *
+                    const _ as usize } , 18usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mBreakAfter ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOverflowX as *
+                    const _ as usize } , 19usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mOverflowX ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOverflowY as *
+                    const _ as usize } , 20usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mOverflowY ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOverflowClipBox
+                    as * const _ as usize } , 21usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mOverflowClipBox ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mResize as *
+                    const _ as usize } , 22usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mResize ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOrient as *
+                    const _ as usize } , 23usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mOrient ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mIsolation as *
+                    const _ as usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mIsolation ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTopLayer as *
+                    const _ as usize } , 25usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTopLayer ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mWillChangeBitField as * const _ as usize } , 26usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mWillChangeBitField ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mWillChange as *
+                    const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mWillChange ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTouchAction as
+                    * const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTouchAction ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mScrollBehavior
+                    as * const _ as usize } , 41usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollBehavior ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mScrollSnapTypeX
+                    as * const _ as usize } , 42usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollSnapTypeX ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mScrollSnapTypeY
+                    as * const _ as usize } , 43usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollSnapTypeY ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mScrollSnapPointsX as * const _ as usize } , 48usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollSnapPointsX ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mScrollSnapPointsY as * const _ as usize } , 64usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollSnapPointsY ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mScrollSnapDestination as * const _ as usize } , 80usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollSnapDestination ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mScrollSnapCoordinate as * const _ as usize } , 104usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mScrollSnapCoordinate ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mBackfaceVisibility as * const _ as usize } , 112usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mBackfaceVisibility ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransformStyle
+                    as * const _ as usize } , 113usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransformStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransformBox as
+                    * const _ as usize } , 114usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransformBox ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mSpecifiedTransform as * const _ as usize } , 120usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mSpecifiedTransform ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransformOrigin
+                    as * const _ as usize } , 128usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransformOrigin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mChildPerspective as * const _ as usize } , 176usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mChildPerspective ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mPerspectiveOrigin as * const _ as usize } , 192usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mPerspectiveOrigin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mVerticalAlign
+                    as * const _ as usize } , 224usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mVerticalAlign ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransitions as
+                    * const _ as usize } , 240usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransitions ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mTransitionTimingFunctionCount as * const _ as usize } ,
+                    288usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransitionTimingFunctionCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mTransitionDurationCount as * const _ as usize } ,
+                    292usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransitionDurationCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mTransitionDelayCount as * const _ as usize } , 296usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransitionDelayCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mTransitionPropertyCount as * const _ as usize } ,
+                    300usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mTransitionPropertyCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mAnimations as *
+                    const _ as usize } , 304usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimations ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationTimingFunctionCount as * const _ as usize } ,
+                    368usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationTimingFunctionCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationDurationCount as * const _ as usize } , 372usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationDurationCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationDelayCount as * const _ as usize } , 376usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationDelayCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationNameCount as * const _ as usize } , 380usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationNameCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationDirectionCount as * const _ as usize } ,
+                    384usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationDirectionCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationFillModeCount as * const _ as usize } , 388usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationFillModeCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationPlayStateCount as * const _ as usize } ,
+                    392usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationPlayStateCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) .
+                    mAnimationIterationCountCount as * const _ as usize } ,
+                    396usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mAnimationIterationCountCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleDisplay ) ) . mShapeOutside as
+                    * const _ as usize } , 400usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
+                    "::" , stringify ! ( mShapeOutside ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleContent {
+        pub mContents: root::nsTArray<root::nsStyleContentData>,
+        pub mIncrements: root::nsTArray<root::nsStyleCounterData>,
+        pub mResets: root::nsTArray<root::nsStyleCounterData>,
+    }
+    pub const nsStyleContent_kHasFinishStyle: bool = true;
+    #[test]
+    fn bindgen_test_layout_nsStyleContent() {
+        assert_eq!(::std::mem::size_of::<nsStyleContent>() , 24usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStyleContent ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleContent>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleContent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleContent ) ) . mContents as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleContent ) ,
+                    "::" , stringify ! ( mContents ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleContent ) ) . mIncrements as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleContent ) ,
+                    "::" , stringify ! ( mIncrements ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleContent ) ) . mResets as *
+                    const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleContent ) ,
+                    "::" , stringify ! ( mResets ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleUIReset {
+        pub mUserSelect: root::mozilla::StyleUserSelect,
+        pub mForceBrokenImageIcon: u8,
+        pub mIMEMode: u8,
+        pub mWindowDragging: root::mozilla::StyleWindowDragging,
+        pub mWindowShadow: u8,
+        pub mWindowOpacity: f32,
+        pub mSpecifiedWindowTransform: root::RefPtr<root::nsCSSValueSharedList>,
+        pub mWindowTransformOrigin: [root::nsStyleCoord; 2usize],
+    }
+    pub const nsStyleUIReset_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleUIReset() {
+        assert_eq!(::std::mem::size_of::<nsStyleUIReset>() , 56usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStyleUIReset ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleUIReset>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleUIReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) . mUserSelect as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mUserSelect ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) .
+                    mForceBrokenImageIcon as * const _ as usize } , 1usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mForceBrokenImageIcon ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) . mIMEMode as *
+                    const _ as usize } , 2usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mIMEMode ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) . mWindowDragging
+                    as * const _ as usize } , 3usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mWindowDragging ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) . mWindowShadow as
+                    * const _ as usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mWindowShadow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) . mWindowOpacity
+                    as * const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mWindowOpacity ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) .
+                    mSpecifiedWindowTransform as * const _ as usize } ,
+                    16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mSpecifiedWindowTransform ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleUIReset ) ) .
+                    mWindowTransformOrigin as * const _ as usize } , 24usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleUIReset ) ,
+                    "::" , stringify ! ( mWindowTransformOrigin ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleTable {
+        pub mLayoutStrategy: u8,
+        pub mSpan: i32,
+    }
+    pub const nsStyleTable_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleTable() {
+        assert_eq!(::std::mem::size_of::<nsStyleTable>() , 8usize , concat ! (
+                   "Size of: " , stringify ! ( nsStyleTable ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleTable>() , 4usize , concat !
+                    ( "Alignment of " , stringify ! ( nsStyleTable ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTable ) ) . mLayoutStrategy as
+                    * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTable ) ,
+                    "::" , stringify ! ( mLayoutStrategy ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleTable ) ) . mSpan as * const _
+                    as usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleTable ) ,
+                    "::" , stringify ! ( mSpan ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleMargin {
+        pub mMargin: root::nsStyleSides,
+    }
+    pub const nsStyleMargin_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleMargin() {
+        assert_eq!(::std::mem::size_of::<nsStyleMargin>() , 40usize , concat !
+                   ( "Size of: " , stringify ! ( nsStyleMargin ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleMargin>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleMargin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleMargin ) ) . mMargin as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleMargin ) ,
+                    "::" , stringify ! ( mMargin ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStylePadding {
+        pub mPadding: root::nsStyleSides,
+    }
+    pub const nsStylePadding_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStylePadding() {
+        assert_eq!(::std::mem::size_of::<nsStylePadding>() , 40usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStylePadding ) ));
+        assert_eq! (::std::mem::align_of::<nsStylePadding>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStylePadding ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStylePadding ) ) . mPadding as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStylePadding ) ,
+                    "::" , stringify ! ( mPadding ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleBorder {
+        pub mBorderColors: *mut *mut root::nsBorderColors,
+        pub mBorderRadius: root::nsStyleCorners,
+        pub mBorderImageSource: root::nsStyleImage,
+        pub mBorderImageSlice: root::nsStyleSides,
+        pub mBorderImageWidth: root::nsStyleSides,
+        pub mBorderImageOutset: root::nsStyleSides,
+        pub mBorderImageFill: u8,
+        pub mBorderImageRepeatH: u8,
+        pub mBorderImageRepeatV: u8,
+        pub mFloatEdge: root::mozilla::StyleFloatEdge,
+        pub mBoxDecorationBreak: root::mozilla::StyleBoxDecorationBreak,
+        pub mBorderStyle: [u8; 4usize],
+        pub __bindgen_anon_1: root::nsStyleBorder__bindgen_ty_1,
+        pub mComputedBorder: root::nsMargin,
+        pub mBorder: root::nsMargin,
+        pub mTwipsPerPixel: root::nscoord,
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsStyleBorder__bindgen_ty_1 {
+        pub __bindgen_anon_1: root::__BindgenUnionField<root::nsStyleBorder__bindgen_ty_1__bindgen_ty_1>,
+        pub mBorderColor: root::__BindgenUnionField<[root::mozilla::StyleComplexColor; 4usize]>,
+        pub bindgen_union_field: [u32; 8usize],
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsStyleBorder__bindgen_ty_1__bindgen_ty_1 {
+        pub mBorderTopColor: root::mozilla::StyleComplexColor,
+        pub mBorderRightColor: root::mozilla::StyleComplexColor,
+        pub mBorderBottomColor: root::mozilla::StyleComplexColor,
+        pub mBorderLeftColor: root::mozilla::StyleComplexColor,
+    }
+    #[test]
+    fn bindgen_test_layout_nsStyleBorder__bindgen_ty_1__bindgen_ty_1() {
+        assert_eq!(::std::mem::size_of::<nsStyleBorder__bindgen_ty_1__bindgen_ty_1>()
+                   , 32usize , concat ! (
+                   "Size of: " , stringify ! (
+                   nsStyleBorder__bindgen_ty_1__bindgen_ty_1 ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleBorder__bindgen_ty_1__bindgen_ty_1>()
+                    , 4usize , concat ! (
+                    "Alignment of " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1__bindgen_ty_1 ) ));
+        assert_eq! (unsafe {
+                    & (
+                    * ( 0 as * const nsStyleBorder__bindgen_ty_1__bindgen_ty_1
+                    ) ) . mBorderTopColor as * const _ as usize } , 0usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1__bindgen_ty_1 ) , "::" ,
+                    stringify ! ( mBorderTopColor ) ));
+        assert_eq! (unsafe {
+                    & (
+                    * ( 0 as * const nsStyleBorder__bindgen_ty_1__bindgen_ty_1
+                    ) ) . mBorderRightColor as * const _ as usize } , 8usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1__bindgen_ty_1 ) , "::" ,
+                    stringify ! ( mBorderRightColor ) ));
+        assert_eq! (unsafe {
+                    & (
+                    * ( 0 as * const nsStyleBorder__bindgen_ty_1__bindgen_ty_1
+                    ) ) . mBorderBottomColor as * const _ as usize } , 16usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1__bindgen_ty_1 ) , "::" ,
+                    stringify ! ( mBorderBottomColor ) ));
+        assert_eq! (unsafe {
+                    & (
+                    * ( 0 as * const nsStyleBorder__bindgen_ty_1__bindgen_ty_1
+                    ) ) . mBorderLeftColor as * const _ as usize } , 24usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1__bindgen_ty_1 ) , "::" ,
+                    stringify ! ( mBorderLeftColor ) ));
+    }
+    impl Clone for nsStyleBorder__bindgen_ty_1__bindgen_ty_1 {
+        fn clone(&self) -> Self { *self }
+    }
+    #[test]
+    fn bindgen_test_layout_nsStyleBorder__bindgen_ty_1() {
+        assert_eq!(::std::mem::size_of::<nsStyleBorder__bindgen_ty_1>() ,
+                   32usize , concat ! (
+                   "Size of: " , stringify ! ( nsStyleBorder__bindgen_ty_1 )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleBorder__bindgen_ty_1>() ,
+                    4usize , concat ! (
+                    "Alignment of " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1 ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder__bindgen_ty_1 ) ) .
+                    mBorderColor as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    nsStyleBorder__bindgen_ty_1 ) , "::" , stringify ! (
+                    mBorderColor ) ));
+    }
+    impl Clone for nsStyleBorder__bindgen_ty_1 {
+        fn clone(&self) -> Self { *self }
+    }
+    pub const nsStyleBorder_kHasFinishStyle: bool = true;
+    #[test]
+    fn bindgen_test_layout_nsStyleBorder() {
+        assert_eq!(::std::mem::size_of::<nsStyleBorder>() , 312usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStyleBorder ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleBorder>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleBorder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorderColors as
+                    * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderColors ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorderRadius as
+                    * const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderRadius ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) .
+                    mBorderImageSource as * const _ as usize } , 80usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageSource ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorderImageSlice
+                    as * const _ as usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageSlice ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorderImageWidth
+                    as * const _ as usize } , 152usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) .
+                    mBorderImageOutset as * const _ as usize } , 192usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageOutset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorderImageFill
+                    as * const _ as usize } , 232usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageFill ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) .
+                    mBorderImageRepeatH as * const _ as usize } , 233usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageRepeatH ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) .
+                    mBorderImageRepeatV as * const _ as usize } , 234usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderImageRepeatV ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mFloatEdge as *
+                    const _ as usize } , 235usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mFloatEdge ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) .
+                    mBoxDecorationBreak as * const _ as usize } , 236usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBoxDecorationBreak ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorderStyle as *
+                    const _ as usize } , 237usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorderStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mComputedBorder
+                    as * const _ as usize } , 276usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mComputedBorder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mBorder as *
+                    const _ as usize } , 292usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mBorder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleBorder ) ) . mTwipsPerPixel as
+                    * const _ as usize } , 308usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleBorder ) ,
+                    "::" , stringify ! ( mTwipsPerPixel ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleOutline {
+        pub mOutlineRadius: root::nsStyleCorners,
+        pub mOutlineWidth: root::nscoord,
+        pub mOutlineOffset: root::nscoord,
+        pub mOutlineColor: root::mozilla::StyleComplexColor,
+        pub mOutlineStyle: u8,
+        pub mActualOutlineWidth: root::nscoord,
+        pub mTwipsPerPixel: root::nscoord,
+    }
+    pub const nsStyleOutline_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleOutline() {
+        assert_eq!(::std::mem::size_of::<nsStyleOutline>() , 104usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStyleOutline ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleOutline>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleOutline ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) . mOutlineRadius
+                    as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mOutlineRadius ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) . mOutlineWidth as
+                    * const _ as usize } , 72usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mOutlineWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) . mOutlineOffset
+                    as * const _ as usize } , 76usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mOutlineOffset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) . mOutlineColor as
+                    * const _ as usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mOutlineColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) . mOutlineStyle as
+                    * const _ as usize } , 88usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mOutlineStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) .
+                    mActualOutlineWidth as * const _ as usize } , 92usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mActualOutlineWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleOutline ) ) . mTwipsPerPixel
+                    as * const _ as usize } , 96usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleOutline ) ,
+                    "::" , stringify ! ( mTwipsPerPixel ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleXUL {
+        pub mBoxFlex: f32,
+        pub mBoxOrdinal: u32,
+        pub mBoxAlign: root::mozilla::StyleBoxAlign,
+        pub mBoxDirection: root::mozilla::StyleBoxDirection,
+        pub mBoxOrient: root::mozilla::StyleBoxOrient,
+        pub mBoxPack: root::mozilla::StyleBoxPack,
+        pub mStackSizing: root::mozilla::StyleStackSizing,
+    }
+    pub const nsStyleXUL_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleXUL() {
+        assert_eq!(::std::mem::size_of::<nsStyleXUL>() , 16usize , concat ! (
+                   "Size of: " , stringify ! ( nsStyleXUL ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleXUL>() , 4usize , concat ! (
+                    "Alignment of " , stringify ! ( nsStyleXUL ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mBoxFlex as * const
+                    _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mBoxFlex ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mBoxOrdinal as *
+                    const _ as usize } , 4usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mBoxOrdinal ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mBoxAlign as * const
+                    _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mBoxAlign ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mBoxDirection as *
+                    const _ as usize } , 9usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mBoxDirection ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mBoxOrient as *
+                    const _ as usize } , 10usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mBoxOrient ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mBoxPack as * const
+                    _ as usize } , 11usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mBoxPack ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleXUL ) ) . mStackSizing as *
+                    const _ as usize } , 12usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleXUL ) , "::"
+                    , stringify ! ( mStackSizing ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleSVGReset {
+        pub mMask: root::nsStyleImageLayers,
+        pub mClipPath: root::mozilla::StyleShapeSource,
+        pub mStopColor: root::nscolor,
+        pub mFloodColor: root::nscolor,
+        pub mLightingColor: root::nscolor,
+        pub mStopOpacity: f32,
+        pub mFloodOpacity: f32,
+        pub mDominantBaseline: u8,
+        pub mVectorEffect: u8,
+        pub mMaskType: u8,
+    }
+    pub const nsStyleSVGReset_kHasFinishStyle: bool = true;
+    #[test]
+    fn bindgen_test_layout_nsStyleSVGReset() {
+        assert_eq!(::std::mem::size_of::<nsStyleSVGReset>() , 192usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsStyleSVGReset )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsStyleSVGReset>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsStyleSVGReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mMask as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mMask ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mClipPath as *
+                    const _ as usize } , 152usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mClipPath ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mStopColor as *
+                    const _ as usize } , 168usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mStopColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mFloodColor as
+                    * const _ as usize } , 172usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mFloodColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mLightingColor
+                    as * const _ as usize } , 176usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mLightingColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mStopOpacity as
+                    * const _ as usize } , 180usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mStopOpacity ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mFloodOpacity
+                    as * const _ as usize } , 184usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mFloodOpacity ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) .
+                    mDominantBaseline as * const _ as usize } , 188usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mDominantBaseline ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mVectorEffect
+                    as * const _ as usize } , 189usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mVectorEffect ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleSVGReset ) ) . mMaskType as *
+                    const _ as usize } , 190usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleSVGReset ) ,
+                    "::" , stringify ! ( mMaskType ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleColumn {
+        pub mColumnCount: u32,
+        pub mColumnWidth: root::nsStyleCoord,
+        pub mColumnGap: root::nsStyleCoord,
+        pub mColumnRuleColor: root::mozilla::StyleComplexColor,
+        pub mColumnRuleStyle: u8,
+        pub mColumnFill: u8,
+        pub mColumnSpan: u8,
+        pub mColumnRuleWidth: root::nscoord,
+        pub mTwipsPerPixel: root::nscoord,
+    }
+    pub const nsStyleColumn_kHasFinishStyle: bool = false;
+    pub const nsStyleColumn_kMaxColumnCount: u32 = 1000;
+    #[test]
+    fn bindgen_test_layout_nsStyleColumn() {
+        assert_eq!(::std::mem::size_of::<nsStyleColumn>() , 64usize , concat !
+                   ( "Size of: " , stringify ! ( nsStyleColumn ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleColumn>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleColumn ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnCount as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnCount ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnWidth as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnGap as *
+                    const _ as usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnGap ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnRuleColor
+                    as * const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnRuleColor ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnRuleStyle
+                    as * const _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnRuleStyle ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnFill as *
+                    const _ as usize } , 49usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnFill ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnSpan as *
+                    const _ as usize } , 50usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnSpan ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mColumnRuleWidth
+                    as * const _ as usize } , 52usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mColumnRuleWidth ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleColumn ) ) . mTwipsPerPixel as
+                    * const _ as usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleColumn ) ,
+                    "::" , stringify ! ( mTwipsPerPixel ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct nsStyleEffects {
+        pub mFilters: root::nsTArray<root::nsStyleFilter>,
+        pub mBoxShadow: root::RefPtr<root::nsCSSShadowArray>,
+        pub mClip: root::nsRect,
+        pub mOpacity: f32,
+        pub mClipFlags: u8,
+        pub mMixBlendMode: u8,
+    }
+    pub const nsStyleEffects_kHasFinishStyle: bool = false;
+    #[test]
+    fn bindgen_test_layout_nsStyleEffects() {
+        assert_eq!(::std::mem::size_of::<nsStyleEffects>() , 40usize , concat
+                   ! ( "Size of: " , stringify ! ( nsStyleEffects ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleEffects>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleEffects ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleEffects ) ) . mFilters as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleEffects ) ,
+                    "::" , stringify ! ( mFilters ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleEffects ) ) . mBoxShadow as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleEffects ) ,
+                    "::" , stringify ! ( mBoxShadow ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleEffects ) ) . mClip as * const
+                    _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleEffects ) ,
+                    "::" , stringify ! ( mClip ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleEffects ) ) . mOpacity as *
+                    const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleEffects ) ,
+                    "::" , stringify ! ( mOpacity ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleEffects ) ) . mClipFlags as *
+                    const _ as usize } , 36usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleEffects ) ,
+                    "::" , 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
+ * so we define this type on the C++ side and use the bindgenned version
+ * on the Rust side.
+ *
+ */
+    #[repr(C)]
+    #[derive(Debug)]
+    pub struct ServoComputedValues {
+        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>,
+        pub Visibility: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoVisibility>,
+        pub UserInterface: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoUserInterface>,
+        pub TableBorder: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoTableBorder>,
+        pub SVG: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoSVG>,
+        pub Background: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoBackground>,
+        pub Position: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoPosition>,
+        pub TextReset: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoTextReset>,
+        pub Display: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoDisplay>,
+        pub Content: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoContent>,
+        pub UIReset: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoUIReset>,
+        pub Table: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoTable>,
+        pub Margin: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoMargin>,
+        pub Padding: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoPadding>,
+        pub Border: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoBorder>,
+        pub Outline: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoOutline>,
+        pub XUL: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoXUL>,
+        pub SVGReset: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoSVGReset>,
+        pub Column: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoColumn>,
+        pub Effects: ::gecko_bindings::structs::ServoRawOffsetArc<root::mozilla::GeckoEffects>,
+        pub custom_properties: ::gecko_bindings::structs::ServoCustomPropertiesMap,
+        pub writing_mode: ::gecko_bindings::structs::ServoWritingMode,
+        pub font_computation_data: ::gecko_bindings::structs::ServoFontComputationData,
+        /// The rule node representing the ordered list of rules matched for this
+  /// node.  Can be None for default values and text nodes.  This is
+  /// essentially an optimization to avoid referencing the root rule node.
+        pub rules: ::gecko_bindings::structs::ServoRuleNode,
+        /// The element's computed values if visited, only computed if there's a
+  /// 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 flags: ::gecko_bindings::structs::ServoComputedValueFlags,
+    }
+    #[test]
+    fn bindgen_test_layout_ServoComputedValues() {
+        assert_eq!(::std::mem::size_of::<ServoComputedValues>() , 232usize ,
+                   concat ! (
+                   "Size of: " , stringify ! ( ServoComputedValues ) ));
+        assert_eq! (::std::mem::align_of::<ServoComputedValues>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( ServoComputedValues ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Font as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Font ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Color as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Color ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . List as *
+                    const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( List ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Text as *
+                    const _ as usize } , 24usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Text ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Visibility
+                    as * const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Visibility ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) .
+                    UserInterface as * const _ as usize } , 40usize , concat !
+                    (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( UserInterface ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . TableBorder
+                    as * const _ as usize } , 48usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( TableBorder ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . SVG as *
+                    const _ as usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( SVG ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Background
+                    as * const _ as usize } , 64usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Background ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Position as
+                    * const _ as usize } , 72usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Position ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . TextReset
+                    as * const _ as usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( TextReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Display as
+                    * const _ as usize } , 88usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Display ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Content as
+                    * const _ as usize } , 96usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Content ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . UIReset as
+                    * const _ as usize } , 104usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( UIReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Table as *
+                    const _ as usize } , 112usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Table ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Margin as *
+                    const _ as usize } , 120usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Margin ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Padding as
+                    * const _ as usize } , 128usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Padding ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Border as *
+                    const _ as usize } , 136usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Border ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Outline as
+                    * const _ as usize } , 144usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Outline ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . XUL as *
+                    const _ as usize } , 152usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( XUL ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . SVGReset as
+                    * const _ as usize } , 160usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( SVGReset ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Column as *
+                    const _ as usize } , 168usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Column ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . Effects as
+                    * const _ as usize } , 176usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( Effects ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) .
+                    custom_properties as * const _ as usize } , 184usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( custom_properties ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) .
+                    writing_mode as * const _ as usize } , 192usize , concat !
+                    (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( writing_mode ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) .
+                    font_computation_data as * const _ as usize } , 196usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( font_computation_data ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . rules as *
+                    const _ as usize } , 208usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( rules ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) .
+                    visited_style as * const _ as usize } , 216usize , concat
+                    ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( visited_style ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValues ) ) . flags as *
+                    const _ as usize } , 224usize , concat ! (
+                    "Alignment of field: " , stringify ! ( ServoComputedValues
+                    ) , "::" , stringify ! ( flags ) ));
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct ServoComputedValuesForgotten {
+        pub mPtr: *const root::ServoComputedValues,
+    }
+    #[test]
+    fn bindgen_test_layout_ServoComputedValuesForgotten() {
+        assert_eq!(::std::mem::size_of::<ServoComputedValuesForgotten>() ,
+                   8usize , concat ! (
+                   "Size of: " , stringify ! ( ServoComputedValuesForgotten )
+                   ));
+        assert_eq! (::std::mem::align_of::<ServoComputedValuesForgotten>() ,
+                    8usize , concat ! (
+                    "Alignment of " , stringify ! (
+                    ServoComputedValuesForgotten ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const ServoComputedValuesForgotten ) ) .
+                    mPtr as * const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! (
+                    ServoComputedValuesForgotten ) , "::" , stringify ! ( mPtr
+                    ) ));
+    }
+    impl Clone for ServoComputedValuesForgotten {
+        fn clone(&self) -> Self { *self }
+    }
     #[repr(u32)]
     #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
     pub enum WeakMapTraceKind {
         DoNotTraceWeakMaps = 0,
         ExpandWeakMaps = 1,
         TraceWeakMapValues = 2,
         TraceWeakMapKeysValues = 3,
     }
@@ -18318,17 +21272,17 @@ pub mod root {
  * case that nsTAString::mData does not point to one of these special
  * buffers.  The mDataFlags member variable distinguishes the buffer type.
  *
  * When this header is in use, it enables reference counting, and capacity
  * tracking.  NOTE: A string buffer can be modified only if its reference
  * count is 1.
  */
     #[repr(C)]
-    #[derive(Debug)]
+    #[derive(Debug, Copy)]
     pub struct nsStringBuffer {
         pub mRefCount: u32,
         pub mStorageSize: u32,
     }
     #[test]
     fn bindgen_test_layout_nsStringBuffer() {
         assert_eq!(::std::mem::size_of::<nsStringBuffer>() , 8usize , concat !
                    ( "Size of: " , stringify ! ( nsStringBuffer ) ));
@@ -18340,16 +21294,19 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( nsStringBuffer ) ,
                     "::" , stringify ! ( mRefCount ) ));
         assert_eq! (unsafe {
                     & ( * ( 0 as * const nsStringBuffer ) ) . mStorageSize as
                     * const _ as usize } , 4usize , concat ! (
                     "Alignment of field: " , stringify ! ( nsStringBuffer ) ,
                     "::" , stringify ! ( mStorageSize ) ));
     }
+    impl Clone for nsStringBuffer {
+        fn clone(&self) -> Self { *self }
+    }
     #[repr(C)]
     #[derive(Debug, Copy)]
     pub struct nsIAtom {
         pub _base: root::nsISupports,
         pub _bitfield_1: u32,
         pub mHash: u32,
         /**
    * WARNING! There is an invisible constraint on |mString|: the chars it
@@ -18804,17 +21761,16 @@ pub mod root {
         _unused: [u8; 0],
     }
     /**
  * An internal interface that abstracts some DOMNode-related parts that both
  * nsIContent and nsIDocument share.  An instance of this interface has a list
  * of nsIContent children and provides access to them.
  */
     #[repr(C)]
-    #[derive(Debug)]
     pub struct nsINode {
         pub _base: root::mozilla::dom::EventTarget,
         pub mNodeInfo: root::RefPtr<root::mozilla::dom::NodeInfo>,
         pub mParent: *mut root::nsINode,
         pub mNextSibling: *mut root::nsIContent,
         pub mPreviousSibling: *mut root::nsIContent,
         pub mFirstChild: *mut root::nsIContent,
         pub __bindgen_anon_1: root::nsINode__bindgen_ty_1,
@@ -20107,17 +23063,17 @@ pub mod root {
         pub mReferrerPolicySet: bool,
         pub mReferrerPolicy: root::nsIDocument_ReferrerPolicyEnum,
         pub mBlockAllMixedContent: bool,
         pub mBlockAllMixedContentPreloads: bool,
         pub mUpgradeInsecureRequests: bool,
         pub mUpgradeInsecurePreloads: bool,
         pub mHSTSPrimingURIList: [u64; 6usize],
         pub mDocumentContainer: u64,
-        pub mCharacterSet: root::mozilla::NotNull<*const root::nsIDocument_Encoding>,
+        pub mCharacterSet: root::mozilla::NotNull<*const root::mozilla::Encoding>,
         pub mCharacterSetSource: i32,
         pub mParentDocument: *mut root::nsIDocument,
         pub mCachedRootElement: *mut root::mozilla::dom::Element,
         pub mNodeInfoManager: *mut root::nsNodeInfoManager,
         pub mCSSLoader: root::RefPtr<root::mozilla::css::Loader>,
         pub mStyleImageLoader: root::RefPtr<root::mozilla::css::ImageLoader>,
         pub mAttrStyleSheet: root::RefPtr<root::nsHTMLStyleSheet>,
         pub mStyleAttrStyleSheet: root::RefPtr<root::nsHTMLCSSStyleSheet>,
@@ -20165,17 +23121,17 @@ pub mod root {
    * have this document as their owner and that are being evaluated right now.
    */
         pub mExternalScriptsBeingEvaluated: u32,
         /**
    * The current frame request callback handle
    */
         pub mFrameRequestCallbackCounter: i32,
         pub mStaticCloneCount: u32,
-        pub mBlockedTrackingNodes: root::nsTArray<root::nsWeakPtr>,
+        pub mBlockedTrackingNodes: root::nsTArray<root::nsCOMPtr<root::nsIWeakReference>>,
         pub mWindow: *mut root::nsPIDOMWindowInner,
         pub mCachedEncoder: root::nsCOMPtr<root::nsIDocumentEncoder>,
         pub mFrameRequestCallbacks: root::nsTArray<root::nsIDocument_FrameRequest>,
         pub mBFCacheEntry: *mut root::nsIBFCacheEntry,
         pub mBaseTarget: ::nsstring::nsStringRepr,
         pub mStateObjectContainer: root::nsCOMPtr<root::nsIStructuredCloneContainer>,
         pub mStateObjectCached: root::nsCOMPtr<root::nsIVariant>,
         pub mInSyncOperationCount: u32,
@@ -22946,18 +25902,152 @@ pub mod root {
                           (70368744177664u64 as u64))
              } |
                  ((mIsScopedStyleEnabled as u32 as u64) << 47usize) &
                      (422212465065984u64 as u64))
         }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
+    pub struct nsCSSRuleProcessor {
+        _unused: [u8; 0],
+    }
+    #[repr(C)]
     pub struct nsBindingManager {
-        _unused: [u8; 0],
+        pub _base: root::nsStubMutationObserver,
+        pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
+        pub _mOwningThread: root::nsAutoOwningThread,
+        pub mBoundContentSet: u64,
+        pub mWrapperTable: u64,
+        pub mDocumentTable: u64,
+        pub mLoadingDocTable: u64,
+        pub mAttachedStack: root::nsBindingList,
+        pub mProcessingAttachedStack: bool,
+        pub mDestroyed: bool,
+        pub mAttachedStackSizeOnOutermost: u32,
+        pub mProcessAttachedQueueEvent: u64,
+        pub mDocument: *mut root::nsIDocument,
+    }
+    pub type nsBindingManager_HasThreadSafeRefCnt = root::mozilla::FalseType;
+    #[repr(u32)]
+    /**
+   * Notify the binding manager that an element
+   * has been removed from its document,
+   * so that it can update any bindings or
+   * nsIAnonymousContentCreator-created anonymous
+   * content that may depend on the document.
+   * @param aContent the element that's being moved
+   * @param aOldDocument the old document in which the
+   *   content resided.
+   * @param aDestructorHandling whether or not to run the possible XBL
+   *        destructor.
+   */
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum nsBindingManager_DestructorHandling {
+        eRunDtor = 0,
+        eDoNotRunDtor = 1,
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsBindingManager_cycleCollection {
+        pub _base: root::nsXPCOMCycleCollectionParticipant,
+    }
+    #[test]
+    fn bindgen_test_layout_nsBindingManager_cycleCollection() {
+        assert_eq!(::std::mem::size_of::<nsBindingManager_cycleCollection>() ,
+                   16usize , concat ! (
+                   "Size of: " , stringify ! (
+                   nsBindingManager_cycleCollection ) ));
+        assert_eq! (::std::mem::align_of::<nsBindingManager_cycleCollection>()
+                    , 8usize , concat ! (
+                    "Alignment of " , stringify ! (
+                    nsBindingManager_cycleCollection ) ));
+    }
+    impl Clone for nsBindingManager_cycleCollection {
+        fn clone(&self) -> Self { *self }
+    }
+    pub type nsBindingManager_WrapperHashtable = u8;
+    extern "C" {
+        #[link_name = "_ZN16nsBindingManager21_cycleCollectorGlobalE"]
+        pub static mut nsBindingManager__cycleCollectorGlobal:
+                   root::nsBindingManager_cycleCollection;
+    }
+    #[test]
+    fn bindgen_test_layout_nsBindingManager() {
+        assert_eq!(::std::mem::size_of::<nsBindingManager>() , 88usize ,
+                   concat ! ( "Size of: " , stringify ! ( nsBindingManager )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsBindingManager>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsBindingManager ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . mRefCnt as *
+                    const _ as usize } , 8usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mRefCnt ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . _mOwningThread
+                    as * const _ as usize } , 16usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( _mOwningThread ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) .
+                    mBoundContentSet as * const _ as usize } , 24usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mBoundContentSet ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . mWrapperTable
+                    as * const _ as usize } , 32usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mWrapperTable ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . mDocumentTable
+                    as * const _ as usize } , 40usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mDocumentTable ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) .
+                    mLoadingDocTable as * const _ as usize } , 48usize ,
+                    concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mLoadingDocTable ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . mAttachedStack
+                    as * const _ as usize } , 56usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mAttachedStack ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) .
+                    mProcessingAttachedStack as * const _ as usize } , 64usize
+                    , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mProcessingAttachedStack ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . mDestroyed as
+                    * const _ as usize } , 65usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mDestroyed ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) .
+                    mAttachedStackSizeOnOutermost as * const _ as usize } ,
+                    68usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mAttachedStackSizeOnOutermost ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) .
+                    mProcessAttachedQueueEvent as * const _ as usize } ,
+                    72usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mProcessAttachedQueueEvent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsBindingManager ) ) . mDocument as *
+                    const _ as usize } , 80usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsBindingManager )
+                    , "::" , stringify ! ( mDocument ) ));
     }
     #[repr(C)]
     #[derive(Debug)]
     pub struct nsCSSCounterStyleRule {
         pub _base: root::mozilla::css::Rule,
         pub _base_1: root::nsIDOMCSSCounterStyleRule,
         pub mName: root::nsCOMPtr<root::nsIAtom>,
         pub mValues: [root::nsCSSValue; 10usize],
@@ -23008,17 +26098,16 @@ pub mod root {
                     nsFontFaceRuleContainer ) , "::" , stringify ! (
                     mSheetType ) ));
     }
     /**
  * A node of content in a document's content model. This interface
  * is supported by all content objects.
  */
     #[repr(C)]
-    #[derive(Debug)]
     pub struct nsIContent {
         pub _base: root::nsINode,
     }
     pub type nsIContent_IMEState = root::mozilla::widget::IMEState;
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIContent_COMTypeInfo {
         pub _address: u8,
@@ -23093,20 +26182,79 @@ pub mod root {
     }
     #[test]
     fn bindgen_test_layout_nsIContent() {
         assert_eq!(::std::mem::size_of::<nsIContent>() , 88usize , concat ! (
                    "Size of: " , stringify ! ( nsIContent ) ));
         assert_eq! (::std::mem::align_of::<nsIContent>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsIContent ) ));
     }
-    #[repr(C)]
-    #[derive(Debug, Copy, Clone)]
+    /**
+ * An nsStyleContext represents the computed style data for an element.
+ * The computed style data are stored in a set of structs (see
+ * nsStyleStruct.h) that are cached either on the style context or in
+ * the rule tree (see nsRuleNode.h for a description of this caching and
+ * how the cached structs are shared).
+ *
+ * Since the data in |nsIStyleRule|s and |nsRuleNode|s are immutable
+ * (with a few exceptions, like system color changes), the data in an
+ * nsStyleContext are also immutable (with the additional exception of
+ * GetUniqueStyleData).  When style data change,
+ * ElementRestyler::Restyle creates a new style context.
+ *
+ * Style contexts are reference counted.  References are generally held
+ * by:
+ *  1. the |nsIFrame|s that are using the style context and
+ *  2. any *child* style contexts (this might be the reverse of
+ *     expectation, but it makes sense in this case)
+ */
+    #[repr(C)]
+    #[derive(Debug)]
     pub struct nsStyleContext {
-        _unused: [u8; 0],
+        pub mParent: root::RefPtr<root::nsStyleContext>,
+        pub mPseudoTag: root::nsCOMPtr<root::nsIAtom>,
+        pub mBits: u64,
+        pub mRefCnt: u32,
+        pub mFrameRefCnt: u32,
+    }
+    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 ) ));
+        assert_eq! (::std::mem::align_of::<nsStyleContext>() , 8usize , concat
+                    ! ( "Alignment of " , stringify ! ( nsStyleContext ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleContext ) ) . mParent as *
+                    const _ as usize } , 0usize , concat ! (
+                    "Alignment of field: " , stringify ! ( nsStyleContext ) ,
+                    "::" , stringify ! ( mParent ) ));
+        assert_eq! (unsafe {
+                    & ( * ( 0 as * const nsStyleContext ) ) . mPseudoTag as *
+                    const _ as usize } , 8usize , concat ! (
+                    "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 ! (
+                    "Alignment of field: " , stringify ! ( nsStyleContext ) ,
+                    "::" , stringify ! ( mFrameRefCnt ) ));
     }
     #[repr(C)]
     pub struct nsPresContext {
         pub _base: root::nsIObserver,
         pub _base_1: u64,
         pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mType: root::nsPresContext_nsPresContextType,
@@ -26311,17 +29459,16 @@ pub mod root {
         assert_eq! (::std::mem::align_of::<nsIVariant>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsIVariant ) ));
     }
     impl Clone for nsIVariant {
         fn clone(&self) -> Self { *self }
     }
     pub const kNameSpaceID_None: i32 = 0;
     #[repr(C)]
-    #[derive(Debug)]
     pub struct nsNodeInfoManager {
         pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mNodeInfoHash: *mut root::PLHashTable,
         pub mDocument: *mut root::nsIDocument,
         pub mNonDocumentNodeInfos: u32,
         pub mPrincipal: root::nsCOMPtr<root::nsIPrincipal>,
         pub mDefaultPrincipal: root::nsCOMPtr<root::nsIPrincipal>,
@@ -26737,23 +29884,22 @@ pub mod root {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsCSSSelectorList {
         _unused: [u8; 0],
     }
     #[repr(C)]
-    #[derive(Debug)]
     pub struct nsDOMAttributeMap {
         pub _base: root::nsIDOMMozNamedAttrMap,
         pub _base_1: root::nsWrapperCache,
         pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
-        pub mContent: root::nsCOMPtr<root::nsDOMAttributeMap_Element>,
+        pub mContent: root::nsCOMPtr<root::mozilla::dom::Element>,
         /**
    * Cache of Attrs.
    */
         pub mAttributeCache: root::nsDOMAttributeMap_AttrCache,
     }
     pub type nsDOMAttributeMap_Attr = root::mozilla::dom::Attr;
     pub type nsDOMAttributeMap_Element = root::mozilla::dom::Element;
     pub type nsDOMAttributeMap_ErrorResult = root::mozilla::ErrorResult;
@@ -26892,67 +30038,67 @@ pub mod root {
                     "Alignment of field: " , stringify ! ( nsNodeWeakReference
                     ) , "::" , stringify ! ( mNode ) ));
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsDOMMutationObserver {
         _unused: [u8; 0],
     }
-    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_LISTENERMANAGER;
-    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_PROPERTIES;
-    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_ANONYMOUS_ROOT;
-    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
-    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_NATIVE_ANONYMOUS_ROOT;
-    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_FORCE_XBL_BINDINGS;
-    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_MAY_BE_IN_BINDING_MNGR;
-    pub const NODE_IS_EDITABLE: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_EDITABLE;
-    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_NATIVE_ANONYMOUS;
-    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_IN_SHADOW_TREE;
-    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_EMPTY_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_SLOW_SELECTOR;
-    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_EDGE_CHILD_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
-    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_ALL_SELECTOR_FLAGS;
-    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_NEEDS_FRAME;
-    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_DESCENDANTS_NEED_FRAMES;
-    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_ACCESSKEY;
-    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_DIRECTION_RTL;
-    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_HAS_DIRECTION_LTR;
-    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_ALL_DIRECTION_FLAGS;
-    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_CHROME_ONLY_ACCESS;
-    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
-    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_83 =
-        _bindgen_ty_83::NODE_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_83 {
+    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_LISTENERMANAGER;
+    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_PROPERTIES;
+    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_ANONYMOUS_ROOT;
+    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
+    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_NATIVE_ANONYMOUS_ROOT;
+    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_FORCE_XBL_BINDINGS;
+    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_MAY_BE_IN_BINDING_MNGR;
+    pub const NODE_IS_EDITABLE: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_EDITABLE;
+    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_NATIVE_ANONYMOUS;
+    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_IN_SHADOW_TREE;
+    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_EMPTY_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_SLOW_SELECTOR;
+    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_EDGE_CHILD_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
+    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_ALL_SELECTOR_FLAGS;
+    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_NEEDS_FRAME;
+    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_DESCENDANTS_NEED_FRAMES;
+    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_ACCESSKEY;
+    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_DIRECTION_RTL;
+    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_HAS_DIRECTION_LTR;
+    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_ALL_DIRECTION_FLAGS;
+    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_CHROME_ONLY_ACCESS;
+    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
+    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_18 =
+        _bindgen_ty_18::NODE_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_18 {
         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,
@@ -27011,17 +30157,16 @@ pub mod root {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsTextFragment {
         _unused: [u8; 0],
     }
     #[repr(C)]
-    #[derive(Debug)]
     pub struct nsXBLBinding {
         pub mRefCnt: root::nsCycleCollectingAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mMarkedForDeath: bool,
         pub mUsingContentXBLScope: bool,
         pub mIsShadowRootBinding: bool,
         pub mPrototypeBinding: *mut root::nsXBLPrototypeBinding,
         pub mContent: root::nsCOMPtr<root::nsIContent>,
@@ -28136,17 +31281,16 @@ pub mod root {
                    "Size of: " , stringify ! ( nsITimer ) ));
         assert_eq! (::std::mem::align_of::<nsITimer>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( nsITimer ) ));
     }
     impl Clone for nsITimer {
         fn clone(&self) -> Self { *self }
     }
     #[repr(C)]
-    #[derive(Debug)]
     pub struct CapturingContentInfo {
         pub mAllowed: bool,
         pub mPointerLock: bool,
         pub mRetargetToElement: bool,
         pub mPreventDrag: bool,
         pub mContent: root::mozilla::StaticRefPtr<root::nsIContent>,
     }
     #[test]
@@ -28490,16 +31634,68 @@ pub mod root {
                    "Size of: " , stringify ! ( nsIScriptGlobalObject ) ));
         assert_eq! (::std::mem::align_of::<nsIScriptGlobalObject>() , 8usize ,
                     concat ! (
                     "Alignment of " , stringify ! ( nsIScriptGlobalObject )
                     ));
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
+    pub struct nsIInterfaceInfo {
+        _unused: [u8; 0],
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsIXPConnectJSObjectHolder {
+        pub _base: root::nsISupports,
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct nsIXPConnectJSObjectHolder_COMTypeInfo {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_nsIXPConnectJSObjectHolder() {
+        assert_eq!(::std::mem::size_of::<nsIXPConnectJSObjectHolder>() ,
+                   8usize , concat ! (
+                   "Size of: " , stringify ! ( nsIXPConnectJSObjectHolder )
+                   ));
+        assert_eq! (::std::mem::align_of::<nsIXPConnectJSObjectHolder>() ,
+                    8usize , concat ! (
+                    "Alignment of " , stringify ! ( nsIXPConnectJSObjectHolder
+                    ) ));
+    }
+    impl Clone for nsIXPConnectJSObjectHolder {
+        fn clone(&self) -> Self { *self }
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy)]
+    pub struct nsIXPConnectWrappedJS {
+        pub _base: root::nsIXPConnectJSObjectHolder,
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
+    pub struct nsIXPConnectWrappedJS_COMTypeInfo {
+        pub _address: u8,
+    }
+    #[test]
+    fn bindgen_test_layout_nsIXPConnectWrappedJS() {
+        assert_eq!(::std::mem::size_of::<nsIXPConnectWrappedJS>() , 8usize ,
+                   concat ! (
+                   "Size of: " , stringify ! ( nsIXPConnectWrappedJS ) ));
+        assert_eq! (::std::mem::align_of::<nsIXPConnectWrappedJS>() , 8usize ,
+                    concat ! (
+                    "Alignment of " , stringify ! ( nsIXPConnectWrappedJS )
+                    ));
+    }
+    impl Clone for nsIXPConnectWrappedJS {
+        fn clone(&self) -> Self { *self }
+    }
+    #[repr(C)]
+    #[derive(Debug, Copy, Clone)]
     pub struct nsISimpleEnumerator {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIControllers {
         _unused: [u8; 0],
     }
@@ -29237,363 +32433,16 @@ pub mod root {
                     1usize , concat ! (
                     "Alignment of " , stringify ! (
                     ProfilerBacktraceDestructor ) ));
     }
     impl Clone for ProfilerBacktraceDestructor {
         fn clone(&self) -> Self { *self }
     }
     #[repr(C)]
-    #[derive(Debug)]
-    pub struct nsStyleDisplay {
-        pub mBinding: root::BindingHolder,
-        pub mDisplay: root::mozilla::StyleDisplay,
-        pub mOriginalDisplay: root::mozilla::StyleDisplay,
-        pub mContain: u8,
-        pub mAppearance: u8,
-        pub mPosition: u8,
-        pub mFloat: root::mozilla::StyleFloat,
-        pub mOriginalFloat: root::mozilla::StyleFloat,
-        pub mBreakType: root::mozilla::StyleClear,
-        pub mBreakInside: u8,
-        pub mBreakBefore: bool,
-        pub mBreakAfter: bool,
-        pub mOverflowX: u8,
-        pub mOverflowY: u8,
-        pub mOverflowClipBox: u8,
-        pub mResize: u8,
-        pub mOrient: root::mozilla::StyleOrient,
-        pub mIsolation: u8,
-        pub mTopLayer: u8,
-        pub mWillChangeBitField: u8,
-        pub mWillChange: root::nsCOMArray,
-        pub mTouchAction: u8,
-        pub mScrollBehavior: u8,
-        pub mScrollSnapTypeX: u8,
-        pub mScrollSnapTypeY: u8,
-        pub mScrollSnapPointsX: root::nsStyleCoord,
-        pub mScrollSnapPointsY: root::nsStyleCoord,
-        pub mScrollSnapDestination: root::mozilla::Position,
-        pub mScrollSnapCoordinate: root::nsTArray<root::mozilla::Position>,
-        pub mBackfaceVisibility: u8,
-        pub mTransformStyle: u8,
-        pub mTransformBox: root::nsStyleDisplay_StyleGeometryBox,
-        pub mSpecifiedTransform: root::RefPtr<root::nsCSSValueSharedList>,
-        pub mTransformOrigin: [root::nsStyleCoord; 3usize],
-        pub mChildPerspective: root::nsStyleCoord,
-        pub mPerspectiveOrigin: [root::nsStyleCoord; 2usize],
-        pub mVerticalAlign: root::nsStyleCoord,
-        pub mTransitions: root::nsStyleAutoArray<root::mozilla::StyleTransition>,
-        pub mTransitionTimingFunctionCount: u32,
-        pub mTransitionDurationCount: u32,
-        pub mTransitionDelayCount: u32,
-        pub mTransitionPropertyCount: u32,
-        pub mAnimations: root::nsStyleAutoArray<root::mozilla::StyleAnimation>,
-        pub mAnimationTimingFunctionCount: u32,
-        pub mAnimationDurationCount: u32,
-        pub mAnimationDelayCount: u32,
-        pub mAnimationNameCount: u32,
-        pub mAnimationDirectionCount: u32,
-        pub mAnimationFillModeCount: u32,
-        pub mAnimationPlayStateCount: u32,
-        pub mAnimationIterationCountCount: u32,
-        pub mShapeOutside: root::mozilla::StyleShapeSource,
-    }
-    pub use self::super::root::mozilla::StyleGeometryBox as
-            nsStyleDisplay_StyleGeometryBox;
-    pub const nsStyleDisplay_kHasFinishStyle: bool = false;
-    #[test]
-    fn bindgen_test_layout_nsStyleDisplay() {
-        assert_eq!(::std::mem::size_of::<nsStyleDisplay>() , 416usize , concat
-                   ! ( "Size of: " , stringify ! ( nsStyleDisplay ) ));
-        assert_eq! (::std::mem::align_of::<nsStyleDisplay>() , 8usize , concat
-                    ! ( "Alignment of " , stringify ! ( nsStyleDisplay ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBinding as *
-                    const _ as usize } , 0usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mBinding ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mDisplay as *
-                    const _ as usize } , 8usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mDisplay ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOriginalDisplay
-                    as * const _ as usize } , 9usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mOriginalDisplay ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mContain as *
-                    const _ as usize } , 10usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mContain ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mAppearance as *
-                    const _ as usize } , 11usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAppearance ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mPosition as *
-                    const _ as usize } , 12usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mPosition ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mFloat as *
-                    const _ as usize } , 13usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mFloat ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOriginalFloat
-                    as * const _ as usize } , 14usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mOriginalFloat ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakType as *
-                    const _ as usize } , 15usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mBreakType ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakInside as
-                    * const _ as usize } , 16usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mBreakInside ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakBefore as
-                    * const _ as usize } , 17usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mBreakBefore ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mBreakAfter as *
-                    const _ as usize } , 18usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mBreakAfter ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOverflowX as *
-                    const _ as usize } , 19usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mOverflowX ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOverflowY as *
-                    const _ as usize } , 20usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mOverflowY ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOverflowClipBox
-                    as * const _ as usize } , 21usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mOverflowClipBox ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mResize as *
-                    const _ as usize } , 22usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mResize ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mOrient as *
-                    const _ as usize } , 23usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mOrient ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mIsolation as *
-                    const _ as usize } , 24usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mIsolation ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTopLayer as *
-                    const _ as usize } , 25usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTopLayer ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mWillChangeBitField as * const _ as usize } , 26usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mWillChangeBitField ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mWillChange as *
-                    const _ as usize } , 32usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mWillChange ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTouchAction as
-                    * const _ as usize } , 40usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTouchAction ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mScrollBehavior
-                    as * const _ as usize } , 41usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollBehavior ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mScrollSnapTypeX
-                    as * const _ as usize } , 42usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollSnapTypeX ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mScrollSnapTypeY
-                    as * const _ as usize } , 43usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollSnapTypeY ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mScrollSnapPointsX as * const _ as usize } , 48usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollSnapPointsX ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mScrollSnapPointsY as * const _ as usize } , 64usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollSnapPointsY ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mScrollSnapDestination as * const _ as usize } , 80usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollSnapDestination ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mScrollSnapCoordinate as * const _ as usize } , 104usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mScrollSnapCoordinate ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mBackfaceVisibility as * const _ as usize } , 112usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mBackfaceVisibility ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransformStyle
-                    as * const _ as usize } , 113usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransformStyle ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransformBox as
-                    * const _ as usize } , 114usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransformBox ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mSpecifiedTransform as * const _ as usize } , 120usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mSpecifiedTransform ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransformOrigin
-                    as * const _ as usize } , 128usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransformOrigin ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mChildPerspective as * const _ as usize } , 176usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mChildPerspective ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mPerspectiveOrigin as * const _ as usize } , 192usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mPerspectiveOrigin ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mVerticalAlign
-                    as * const _ as usize } , 224usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mVerticalAlign ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mTransitions as
-                    * const _ as usize } , 240usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransitions ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mTransitionTimingFunctionCount as * const _ as usize } ,
-                    288usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransitionTimingFunctionCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mTransitionDurationCount as * const _ as usize } ,
-                    292usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransitionDurationCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mTransitionDelayCount as * const _ as usize } , 296usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransitionDelayCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mTransitionPropertyCount as * const _ as usize } ,
-                    300usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mTransitionPropertyCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mAnimations as *
-                    const _ as usize } , 304usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimations ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationTimingFunctionCount as * const _ as usize } ,
-                    368usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationTimingFunctionCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationDurationCount as * const _ as usize } , 372usize
-                    , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationDurationCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationDelayCount as * const _ as usize } , 376usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationDelayCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationNameCount as * const _ as usize } , 380usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationNameCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationDirectionCount as * const _ as usize } ,
-                    384usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationDirectionCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationFillModeCount as * const _ as usize } , 388usize
-                    , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationFillModeCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationPlayStateCount as * const _ as usize } ,
-                    392usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationPlayStateCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) .
-                    mAnimationIterationCountCount as * const _ as usize } ,
-                    396usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mAnimationIterationCountCount ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleDisplay ) ) . mShapeOutside as
-                    * const _ as usize } , 400usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleDisplay ) ,
-                    "::" , stringify ! ( mShapeOutside ) ));
-    }
-    #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsBidi {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIPrintSettings {
         _unused: [u8; 0],
@@ -32228,17 +35077,17 @@ pub mod root {
         pub _base: root::imgIRequest,
         pub _base_1: root::mozilla::image::IProgressObserver,
         pub _base_2: root::nsISupportsPriority,
         pub _base_3: root::nsISecurityInfoProvider,
         pub _base_4: root::nsITimedChannel,
         pub mRefCnt: root::nsAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mBehaviour: root::mozilla::UniquePtr<root::ProxyBehaviour>,
-        pub mURI: root::RefPtr<root::imgRequestProxy_ImageURL>,
+        pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
         pub mListener: *mut root::imgINotificationObserver,
         pub mLoadGroup: root::nsCOMPtr<root::nsILoadGroup>,
         pub mLoadFlags: root::nsLoadFlags,
         pub mLockCount: u32,
         pub mAnimationConsumers: u32,
         pub mCanceled: bool,
         pub mIsInLoadGroup: bool,
         pub mListenerIsStrongRef: bool,
@@ -33460,17 +36309,17 @@ pub mod root {
         pub _base_1: root::nsIThreadRetargetableStreamListener,
         pub _base_2: root::nsIChannelEventSink,
         pub _base_3: root::nsIInterfaceRequestor,
         pub _base_4: root::nsIAsyncVerifyRedirectCallback,
         pub mRefCnt: root::mozilla::ThreadSafeAutoRefCnt,
         pub _mOwningThread: root::nsAutoOwningThread,
         pub mLoader: *mut root::imgLoader,
         pub mRequest: root::nsCOMPtr<root::nsIRequest>,
-        pub mURI: root::RefPtr<root::imgRequest_ImageURL>,
+        pub mURI: root::RefPtr<root::mozilla::image::ImageURL>,
         pub mCurrentURI: root::nsCOMPtr<root::nsIURI>,
         pub mLoadingPrincipal: root::nsCOMPtr<root::nsIPrincipal>,
         pub mPrincipal: root::nsCOMPtr<root::nsIPrincipal>,
         pub mProperties: root::nsCOMPtr<root::nsIProperties>,
         pub mSecurityInfo: root::nsCOMPtr<root::nsISupports>,
         pub mChannel: root::nsCOMPtr<root::nsIChannel>,
         pub mPrevChannelSink: root::nsCOMPtr<root::nsIInterfaceRequestor>,
         pub mApplicationCache: root::nsCOMPtr<root::nsIApplicationCache>,
@@ -33487,32 +36336,32 @@ pub mod root {
         pub mRedirectCallback: root::nsCOMPtr<root::nsIAsyncVerifyRedirectCallback>,
         pub mNewRedirectChannel: root::nsCOMPtr<root::nsIChannel>,
         pub mInnerWindowId: u64,
         pub mCORSMode: i32,
         pub mReferrerPolicy: root::imgRequest_ReferrerPolicy,
         pub mImageErrorCode: root::nsresult,
         pub mBoostCategoriesRequested: u32,
         pub mMutex: root::mozilla::Mutex,
-        pub mProgressTracker: root::RefPtr<root::imgRequest_ProgressTracker>,
-        pub mImage: root::RefPtr<root::imgRequest_Image>,
+        pub mProgressTracker: root::RefPtr<root::mozilla::image::ProgressTracker>,
+        pub mImage: root::RefPtr<root::mozilla::image::Image>,
         pub _bitfield_1: u8,
         pub __bindgen_padding_0: [u8; 7usize],
     }
     pub type imgRequest_Image = root::mozilla::image::Image;
     pub type imgRequest_ImageCacheKey = root::mozilla::image::ImageCacheKey;
     pub type imgRequest_ImageURL = root::mozilla::image::ImageURL;
     pub type imgRequest_ProgressTracker =
         root::mozilla::image::ProgressTracker;
     pub use self::super::root::mozilla::net::ReferrerPolicy as
             imgRequest_ReferrerPolicy;
     pub type imgRequest_HasThreadSafeRefCnt = root::mozilla::TrueType;
     #[test]
     fn bindgen_test_layout_imgRequest() {
-        assert_eq!(::std::mem::size_of::<imgRequest>() , 424usize , concat ! (
+        assert_eq!(::std::mem::size_of::<imgRequest>() , 448usize , concat ! (
                    "Size of: " , stringify ! ( imgRequest ) ));
         assert_eq! (::std::mem::align_of::<imgRequest>() , 8usize , concat ! (
                     "Alignment of " , stringify ! ( imgRequest ) ));
     }
     impl imgRequest {
         #[inline]
         pub fn mIsMultiPartChannel(&self) -> bool {
             let mut unit_field_val: u8 =
@@ -33773,167 +36622,16 @@ pub mod root {
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct ProxyBehaviour {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug)]
-    pub struct nsStyleVisibility {
-        pub mImageOrientation: root::nsStyleImageOrientation,
-        pub mDirection: u8,
-        pub mVisible: u8,
-        pub mImageRendering: u8,
-        pub mWritingMode: u8,
-        pub mTextOrientation: u8,
-        pub mColorAdjust: u8,
-    }
-    pub const nsStyleVisibility_kHasFinishStyle: bool = false;
-    #[test]
-    fn bindgen_test_layout_nsStyleVisibility() {
-        assert_eq!(::std::mem::size_of::<nsStyleVisibility>() , 7usize ,
-                   concat ! ( "Size of: " , stringify ! ( nsStyleVisibility )
-                   ));
-        assert_eq! (::std::mem::align_of::<nsStyleVisibility>() , 1usize ,
-                    concat ! (
-                    "Alignment of " , stringify ! ( nsStyleVisibility ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) .
-                    mImageOrientation as * const _ as usize } , 0usize ,
-                    concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mImageOrientation ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) . mDirection as
-                    * const _ as usize } , 1usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mDirection ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) . mVisible as *
-                    const _ as usize } , 2usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mVisible ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) .
-                    mImageRendering as * const _ as usize } , 3usize , concat
-                    ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mImageRendering ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) . mWritingMode
-                    as * const _ as usize } , 4usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mWritingMode ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) .
-                    mTextOrientation as * const _ as usize } , 5usize , concat
-                    ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mTextOrientation ) ));
-        assert_eq! (unsafe {
-                    & ( * ( 0 as * const nsStyleVisibility ) ) . mColorAdjust
-                    as * const _ as usize } , 6usize , concat ! (
-                    "Alignment of field: " , stringify ! ( nsStyleVisibility )
-                    , "::" , stringify ! ( mColorAdjust ) )