servo: Merge #10293 - Tweak gecko bindings (from bholley:tweak_bindings); r=emilio
authorBobby Holley <bobbyholley@gmail.com>
Fri, 01 Apr 2016 16:23:00 +0500
changeset 338377 fd9cb158d8f0a27f40fd621eeb102a4c2f84fc17
parent 338376 cb1f6bb1f801d7243fae36e01bca72886b8ca375
child 338378 8e11990e3ad1ccd414d3d74dc2e2ef6dc00b86f9
push id31307
push usergszorc@mozilla.com
push dateSat, 04 Feb 2017 00:59:06 +0000
treeherdermozilla-central@94079d43835f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersemilio
servo: Merge #10293 - Tweak gecko bindings (from bholley:tweak_bindings); r=emilio A few changes as discussed. Source-Repo: https://github.com/servo/servo Source-Revision: 95819a4334526751168de0b9868dbd76e27b0d57
servo/ports/geckolib/bindings.rs
servo/ports/geckolib/gecko_style_structs.rs
servo/ports/geckolib/glue.rs
servo/ports/geckolib/tools/regen_bindings.sh
servo/ports/geckolib/tools/regen_style_structs.sh
--- a/servo/ports/geckolib/bindings.rs
+++ b/servo/ports/geckolib/bindings.rs
@@ -1,51 +1,23 @@
 /* automatically generated by rust-bindgen */
 
-pub type int64_t = i64;
-pub type uint64_t = u64;
-pub type int_least64_t = int64_t;
-pub type uint_least64_t = uint64_t;
-pub type int_fast64_t = int64_t;
-pub type uint_fast64_t = uint64_t;
-pub type int32_t = i32;
-pub type uint32_t = u32;
-pub type int_least32_t = int32_t;
-pub type uint_least32_t = uint32_t;
-pub type int_fast32_t = int32_t;
-pub type uint_fast32_t = uint32_t;
-pub type int16_t = i16;
-pub type uint16_t = u16;
-pub type int_least16_t = int16_t;
-pub type uint_least16_t = uint16_t;
-pub type int_fast16_t = int16_t;
-pub type uint_fast16_t = uint16_t;
-pub type int8_t = ::libc::c_char;
-pub type uint8_t = u8;
-pub type int_least8_t = int8_t;
-pub type uint_least8_t = uint8_t;
-pub type int_fast8_t = int8_t;
-pub type uint_fast8_t = uint8_t;
-pub type intptr_t = int64_t;
-pub type uintptr_t = uint64_t;
-pub type intmax_t = ::libc::c_long;
-pub type uintmax_t = ::libc::c_ulong;
 pub enum nsIAtom { }
 pub enum nsINode { }
 pub type RawGeckoNode = nsINode;
 pub enum Element { }
 pub type RawGeckoElement = Element;
 pub enum nsIDocument { }
 pub type RawGeckoDocument = nsIDocument;
 pub enum ServoNodeData { }
 pub enum ServoComputedValues { }
 pub enum RawServoStyleSheet { }
 pub enum RawServoStyleSet { }
 extern "C" {
-    pub fn Gecko_ChildrenCount(node: *mut RawGeckoNode) -> uint32_t;
+    pub fn Gecko_ChildrenCount(node: *mut RawGeckoNode) -> u32;
     pub fn Gecko_NodeIsElement(node: *mut RawGeckoNode) -> bool;
     pub fn Gecko_GetParentNode(node: *mut RawGeckoNode) -> *mut RawGeckoNode;
     pub fn Gecko_GetFirstChild(node: *mut RawGeckoNode) -> *mut RawGeckoNode;
     pub fn Gecko_GetLastChild(node: *mut RawGeckoNode) -> *mut RawGeckoNode;
     pub fn Gecko_GetPrevSibling(node: *mut RawGeckoNode) -> *mut RawGeckoNode;
     pub fn Gecko_GetNextSibling(node: *mut RawGeckoNode) -> *mut RawGeckoNode;
     pub fn Gecko_GetParentElement(element: *mut RawGeckoElement)
      -> *mut RawGeckoElement;
@@ -54,51 +26,51 @@ extern "C" {
     pub fn Gecko_GetLastChildElement(element: *mut RawGeckoElement)
      -> *mut RawGeckoElement;
     pub fn Gecko_GetPrevSiblingElement(element: *mut RawGeckoElement)
      -> *mut RawGeckoElement;
     pub fn Gecko_GetNextSiblingElement(element: *mut RawGeckoElement)
      -> *mut RawGeckoElement;
     pub fn Gecko_GetDocumentElement(document: *mut RawGeckoDocument)
      -> *mut RawGeckoElement;
-    pub fn Gecko_ElementState(element: *mut RawGeckoElement) -> uint8_t;
+    pub fn Gecko_ElementState(element: *mut RawGeckoElement) -> u8;
     pub fn Gecko_IsHTMLElementInHTMLDocument(element: *mut RawGeckoElement)
      -> bool;
     pub fn Gecko_IsLink(element: *mut RawGeckoElement) -> bool;
     pub fn Gecko_IsTextNode(node: *mut RawGeckoNode) -> bool;
     pub fn Gecko_IsVisitedLink(element: *mut RawGeckoElement) -> bool;
     pub fn Gecko_IsUnvisitedLink(element: *mut RawGeckoElement) -> bool;
     pub fn Gecko_IsRootElement(element: *mut RawGeckoElement) -> bool;
     pub fn Gecko_GetNodeData(node: *mut RawGeckoNode) -> *mut ServoNodeData;
     pub fn Gecko_SetNodeData(node: *mut RawGeckoNode,
                              data: *mut ServoNodeData);
     pub fn Servo_DropNodeData(data: *mut ServoNodeData);
-    pub fn Servo_StylesheetFromUTF8Bytes(bytes: *const uint8_t,
-                                         length: uint32_t)
+    pub fn Servo_StylesheetFromUTF8Bytes(bytes: *const u8, length: u32)
      -> *mut RawServoStyleSheet;
     pub fn Servo_AddRefStyleSheet(sheet: *mut RawServoStyleSheet);
     pub fn Servo_ReleaseStyleSheet(sheet: *mut RawServoStyleSheet);
     pub fn Servo_AppendStyleSheet(sheet: *mut RawServoStyleSheet,
                                   set: *mut RawServoStyleSet);
     pub fn Servo_PrependStyleSheet(sheet: *mut RawServoStyleSheet,
                                    set: *mut RawServoStyleSet);
     pub fn Servo_RemoveStyleSheet(sheet: *mut RawServoStyleSheet,
                                   set: *mut RawServoStyleSet);
     pub fn Servo_StyleSheetHasRules(sheet: *mut RawServoStyleSheet) -> bool;
     pub fn Servo_InitStyleSet() -> *mut RawServoStyleSet;
     pub fn Servo_DropStyleSet(set: *mut RawServoStyleSet);
+    pub fn Gecko_GetAttrAsUTF8(element: *mut RawGeckoElement, ns: *const u8,
+                               name: *const u8, length: *mut u32)
+     -> *const ::std::os::raw::c_char;
+    pub fn Gecko_LocalName(element: *mut RawGeckoElement, length: *mut u32)
+     -> *const u16;
+    pub fn Gecko_Namespace(element: *mut RawGeckoElement, length: *mut u32)
+     -> *const u16;
     pub fn Servo_GetComputedValues(element: *mut RawGeckoElement)
      -> *mut ServoComputedValues;
-    pub fn Servo_GetComputedValuesForAnonymousBox(pseudoTag: *mut nsIAtom)
+    pub fn Servo_GetComputedValuesForAnonymousBox(parentStyleOrNull:
+                                                      *mut ServoComputedValues,
+                                                  pseudoTag: *mut nsIAtom)
      -> *mut ServoComputedValues;
     pub fn Servo_AddRefComputedValues(arg1: *mut ServoComputedValues);
     pub fn Servo_ReleaseComputedValues(arg1: *mut ServoComputedValues);
-    pub fn Gecko_GetAttrAsUTF8(element: *mut RawGeckoElement,
-                               ns: *const uint8_t, name: *const uint8_t,
-                               length: *mut uint32_t)
-     -> *const ::libc::c_char;
-    pub fn Gecko_LocalName(element: *mut RawGeckoElement,
-                           length: *mut uint32_t) -> *const uint16_t;
-    pub fn Gecko_Namespace(element: *mut RawGeckoElement,
-                           length: *mut uint32_t) -> *const uint16_t;
     pub fn Servo_RestyleDocument(doc: *mut RawGeckoDocument,
                                  set: *mut RawServoStyleSet);
 }
--- a/servo/ports/geckolib/gecko_style_structs.rs
+++ b/servo/ports/geckolib/gecko_style_structs.rs
@@ -812,17 +812,16 @@ pub const NS_STYLE_IN_DISPLAY_NONE_SUBTR
     4294967296;
 pub const NS_STYLE_INELIGIBLE_FOR_SHARING: ::std::os::raw::c_ulonglong =
     8589934592;
 pub const NS_STYLE_HAS_CHILD_THAT_USES_RESET_STYLE:
           ::std::os::raw::c_ulonglong =
     17179869184;
 pub const NS_STYLE_CONTEXT_TYPE_SHIFT: ::std::os::raw::c_uint = 35;
 pub const NS_RULE_NODE_IS_ANIMATION_RULE: ::std::os::raw::c_uint = 16777216;
-pub const NS_RULE_NODE_GC_MARK: ::std::os::raw::c_uint = 33554432;
 pub const NS_RULE_NODE_USED_DIRECTLY: ::std::os::raw::c_uint = 67108864;
 pub const NS_RULE_NODE_IS_IMPORTANT: ::std::os::raw::c_uint = 134217728;
 pub const NS_RULE_NODE_LEVEL_MASK: ::std::os::raw::c_uint = 4026531840;
 pub const NS_RULE_NODE_LEVEL_SHIFT: ::std::os::raw::c_uint = 28;
 pub const NS_RULE_NODE_HAS_ANIMATION_DATA: ::std::os::raw::c_uint =
     2147483648;
 pub const BORDER_COLOR_FOREGROUND: ::std::os::raw::c_uint = 32;
 pub const OUTLINE_COLOR_INITIAL: ::std::os::raw::c_uint = 128;
@@ -1367,18 +1366,18 @@ pub enum nsAString_internal_nsTSubstring
     F_SHARED = 4,
     F_OWNED = 8,
     F_FIXED = 16,
     F_LITERAL = 32,
     F_CLASS_FIXED = 65536,
 }
 #[test]
 fn bindgen_test_layout_nsAString_internal() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAString_internal > (  ) ,
-               16usize);
+    assert_eq!(::std::mem::size_of::<nsAString_internal>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsAString_internal>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCStringComparator;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsDefaultCStringComparator {
     pub _base: nsCStringComparator,
@@ -1398,18 +1397,18 @@ pub enum nsACString_internal_nsTSubstrin
     F_SHARED = 4,
     F_OWNED = 8,
     F_FIXED = 16,
     F_LITERAL = 32,
     F_CLASS_FIXED = 65536,
 }
 #[test]
 fn bindgen_test_layout_nsACString_internal() {
-    assert_eq!(:: std:: mem:: size_of:: < nsACString_internal > (  ) ,
-               16usize);
+    assert_eq!(::std::mem::size_of::<nsACString_internal>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsACString_internal>() , 8usize);
 }
 /**
  * ASCII case-insensitive comparator.  (for Unicode case-insensitive
  * comparision, see nsUnicharUtils.h)
  */
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCaseInsensitiveCStringComparator {
@@ -1422,205 +1421,223 @@ pub struct nsCaseInsensitiveCStringArray
 #[derive(Copy, Clone)]
 pub struct nsSubstringTuple {
     pub mHead: *const nsSubstringTuple,
     pub mFragA: *const nsAString_internal,
     pub mFragB: *const nsAString_internal,
 }
 #[test]
 fn bindgen_test_layout_nsSubstringTuple() {
-    assert_eq!(:: std:: mem:: size_of:: < nsSubstringTuple > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsSubstringTuple>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsSubstringTuple>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCSubstringTuple {
     pub mHead: *const nsCSubstringTuple,
     pub mFragA: *const nsACString_internal,
     pub mFragB: *const nsACString_internal,
 }
 #[test]
 fn bindgen_test_layout_nsCSubstringTuple() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSubstringTuple > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsCSubstringTuple>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsCSubstringTuple>() , 8usize);
 }
 #[repr(C)]
 pub struct nsString {
     pub _base: nsAString_internal,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsString_Segment {
     pub mBegin: u32,
     pub mLength: u32,
 }
 #[test]
 fn bindgen_test_layout_nsString_Segment() {
-    assert_eq!(:: std:: mem:: size_of:: < nsString_Segment > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsString_Segment>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsString_Segment>() , 4usize);
 }
 #[test]
 fn bindgen_test_layout_nsString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsFixedString {
     pub _base: nsString,
     pub mFixedCapacity: ::std::os::raw::c_uint,
     pub mFixedBuf: *mut ::std::os::raw::c_ushort,
 }
 #[test]
 fn bindgen_test_layout_nsFixedString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsFixedString > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<nsFixedString>() , 32usize);
+    assert_eq!(::std::mem::align_of::<nsFixedString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsAutoString {
     pub _base: nsFixedString,
     pub mStorage: [::std::os::raw::c_ushort; 64usize],
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsAutoString_nsTString_h_unnamed_3 { kDefaultStorageSize = 64, }
 #[test]
 fn bindgen_test_layout_nsAutoString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAutoString > (  ) , 160usize);
+    assert_eq!(::std::mem::size_of::<nsAutoString>() , 160usize);
+    assert_eq!(::std::mem::align_of::<nsAutoString>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsTArrayElementTraits<> {
     pub _phantom0: ::std::marker::PhantomData<nsAutoString>,
 }
 #[repr(C)]
 pub struct nsXPIDLString {
     pub _base: nsString,
 }
 #[test]
 fn bindgen_test_layout_nsXPIDLString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsXPIDLString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsXPIDLString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsXPIDLString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsGetterCopies {
     pub mString: *mut nsAString_internal,
     pub mData: *mut ::std::os::raw::c_ushort,
 }
 #[test]
 fn bindgen_test_layout_nsGetterCopies() {
-    assert_eq!(:: std:: mem:: size_of:: < nsGetterCopies > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsGetterCopies>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsGetterCopies>() , 8usize);
 }
 #[repr(C)]
 pub struct nsAdoptingString {
     pub _base: nsXPIDLString,
 }
 #[test]
 fn bindgen_test_layout_nsAdoptingString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAdoptingString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsAdoptingString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsAdoptingString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCString {
     pub _base: nsACString_internal,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCString_Segment {
     pub mBegin: u32,
     pub mLength: u32,
 }
 #[test]
 fn bindgen_test_layout_nsCString_Segment() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCString_Segment > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsCString_Segment>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsCString_Segment>() , 4usize);
 }
 #[test]
 fn bindgen_test_layout_nsCString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsCString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsCString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsFixedCString {
     pub _base: nsCString,
     pub mFixedCapacity: ::std::os::raw::c_uint,
     pub mFixedBuf: *mut ::std::os::raw::c_char,
 }
 #[test]
 fn bindgen_test_layout_nsFixedCString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsFixedCString > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<nsFixedCString>() , 32usize);
+    assert_eq!(::std::mem::align_of::<nsFixedCString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsAutoCString {
     pub _base: nsFixedCString,
     pub mStorage: [::std::os::raw::c_char; 64usize],
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsAutoCString_nsTString_h_unnamed_4 { kDefaultStorageSize = 64, }
 #[test]
 fn bindgen_test_layout_nsAutoCString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAutoCString > (  ) , 96usize);
+    assert_eq!(::std::mem::size_of::<nsAutoCString>() , 96usize);
+    assert_eq!(::std::mem::align_of::<nsAutoCString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsXPIDLCString {
     pub _base: nsCString,
 }
 #[test]
 fn bindgen_test_layout_nsXPIDLCString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsXPIDLCString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsXPIDLCString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsXPIDLCString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCGetterCopies {
     pub mString: *mut nsACString_internal,
     pub mData: *mut ::std::os::raw::c_char,
 }
 #[test]
 fn bindgen_test_layout_nsCGetterCopies() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCGetterCopies > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsCGetterCopies>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsCGetterCopies>() , 8usize);
 }
 #[repr(C)]
 pub struct nsAdoptingCString {
     pub _base: nsXPIDLCString,
 }
 #[test]
 fn bindgen_test_layout_nsAdoptingCString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAdoptingCString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsAdoptingCString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsAdoptingCString>() , 8usize);
 }
 /**
  * A helper class that converts a UTF-16 string to ASCII in a lossy manner
  */
 #[repr(C)]
 pub struct NS_LossyConvertUTF16toASCII {
     pub _base: nsAutoCString,
 }
 #[test]
 fn bindgen_test_layout_NS_LossyConvertUTF16toASCII() {
-    assert_eq!(:: std:: mem:: size_of:: < NS_LossyConvertUTF16toASCII > (  ) ,
+    assert_eq!(::std::mem::size_of::<NS_LossyConvertUTF16toASCII>() ,
                96usize);
+    assert_eq!(::std::mem::align_of::<NS_LossyConvertUTF16toASCII>() ,
+               8usize);
 }
 #[repr(C)]
 pub struct NS_ConvertASCIItoUTF16 {
     pub _base: nsAutoString,
 }
 #[test]
 fn bindgen_test_layout_NS_ConvertASCIItoUTF16() {
-    assert_eq!(:: std:: mem:: size_of:: < NS_ConvertASCIItoUTF16 > (  ) ,
-               160usize);
+    assert_eq!(::std::mem::size_of::<NS_ConvertASCIItoUTF16>() , 160usize);
+    assert_eq!(::std::mem::align_of::<NS_ConvertASCIItoUTF16>() , 8usize);
 }
 /**
  * A helper class that converts a UTF-16 string to UTF-8
  */
 #[repr(C)]
 pub struct NS_ConvertUTF16toUTF8 {
     pub _base: nsAutoCString,
 }
 #[test]
 fn bindgen_test_layout_NS_ConvertUTF16toUTF8() {
-    assert_eq!(:: std:: mem:: size_of:: < NS_ConvertUTF16toUTF8 > (  ) ,
-               96usize);
+    assert_eq!(::std::mem::size_of::<NS_ConvertUTF16toUTF8>() , 96usize);
+    assert_eq!(::std::mem::align_of::<NS_ConvertUTF16toUTF8>() , 8usize);
 }
 #[repr(C)]
 pub struct NS_ConvertUTF8toUTF16 {
     pub _base: nsAutoString,
 }
 #[test]
 fn bindgen_test_layout_NS_ConvertUTF8toUTF16() {
-    assert_eq!(:: std:: mem:: size_of:: < NS_ConvertUTF8toUTF16 > (  ) ,
-               160usize);
+    assert_eq!(::std::mem::size_of::<NS_ConvertUTF8toUTF16>() , 160usize);
+    assert_eq!(::std::mem::align_of::<NS_ConvertUTF8toUTF16>() , 8usize);
 }
 pub type nsVoidableString = nsAutoString;
 pub enum ErrorReporter { }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsCSSTokenType {
     eCSSToken_Whitespace = 0,
     eCSSToken_Comment = 1,
@@ -1682,33 +1699,34 @@ pub struct nsCSSToken {
     pub mInteger2: i32,
     pub mType: nsCSSTokenType,
     pub mSymbol: ::std::os::raw::c_ushort,
     pub mIntegerValid: bool,
     pub mHasSign: bool,
 }
 #[test]
 fn bindgen_test_layout_nsCSSToken() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSToken > (  ) , 184usize);
+    assert_eq!(::std::mem::size_of::<nsCSSToken>() , 184usize);
+    assert_eq!(::std::mem::align_of::<nsCSSToken>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCSSScannerPosition {
     pub mOffset: u32,
     pub mLineNumber: u32,
     pub mLineOffset: u32,
     pub mTokenLineNumber: u32,
     pub mTokenLineOffset: u32,
     pub mTokenOffset: u32,
     pub mInitialized: bool,
 }
 #[test]
 fn bindgen_test_layout_nsCSSScannerPosition() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSScannerPosition > (  ) ,
-               28usize);
+    assert_eq!(::std::mem::size_of::<nsCSSScannerPosition>() , 28usize);
+    assert_eq!(::std::mem::align_of::<nsCSSScannerPosition>() , 4usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsCSSScannerExclude {
     eCSSScannerExclude_None = 0,
     eCSSScannerExclude_Comments = 1,
     eCSSScannerExclude_WhitespaceAndComments = 2,
 }
@@ -1739,55 +1757,79 @@ pub enum nsCSSScanner_EOFCharacters {
     eEOFCharacters_Asterisk = 4,
     eEOFCharacters_Slash = 8,
     eEOFCharacters_DoubleQuote = 16,
     eEOFCharacters_SingleQuote = 32,
     eEOFCharacters_CloseParen = 64,
 }
 #[test]
 fn bindgen_test_layout_nsCSSScanner() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSScanner > (  ) , 64usize);
+    assert_eq!(::std::mem::size_of::<nsCSSScanner>() , 64usize);
+    assert_eq!(::std::mem::align_of::<nsCSSScanner>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSGridTemplateAreaToken {
     pub mName: nsAutoString,
     pub isTrash: bool,
 }
 #[test]
 fn bindgen_test_layout_nsCSSGridTemplateAreaToken() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSGridTemplateAreaToken > (  ) ,
+    assert_eq!(::std::mem::size_of::<nsCSSGridTemplateAreaToken>() ,
                168usize);
+    assert_eq!(::std::mem::align_of::<nsCSSGridTemplateAreaToken>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCSSGridTemplateAreaScanner {
     pub mBuffer: *const ::std::os::raw::c_ushort,
     pub mOffset: u32,
     pub mCount: u32,
 }
 #[test]
 fn bindgen_test_layout_nsCSSGridTemplateAreaScanner() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSGridTemplateAreaScanner > (  )
-               , 16usize);
+    assert_eq!(::std::mem::size_of::<nsCSSGridTemplateAreaScanner>() ,
+               16usize);
+    assert_eq!(::std::mem::align_of::<nsCSSGridTemplateAreaScanner>() ,
+               8usize);
 }
 /**
  * A "unique identifier". This is modeled after OSF DCE UUIDs.
  */
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsID {
     pub m0: u32,
     pub m1: u16,
     pub m2: u16,
     pub m3: [u8; 8usize],
 }
 #[test]
 fn bindgen_test_layout_nsID() {
-    assert_eq!(:: std:: mem:: size_of:: < nsID > (  ) , 16usize);
-}
+    assert_eq!(::std::mem::size_of::<nsID>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsID>() , 4usize);
+}
+/**
+ * A stack helper class to convert a nsID to a string.  Useful
+ * for printing nsIDs.  For example:
+ *   nsID aID = ...;
+ *   printf("%s", nsIDToCString(aID).get());
+ */
+/*
+ * Rust chokes on generating Clone for arrays wider than 32. Keep
+ * this commented out until we have a fix in bindgen.
+ * #[repr(C)]
+#[derive(Copy, Clone)]
+pub struct nsIDToCString {
+    pub mStringBytes: [::std::os::raw::c_char; 39usize],
+}
+#[test]
+fn bindgen_test_layout_nsIDToCString() {
+    assert_eq!(::std::mem::size_of::<nsIDToCString>() , 39usize);
+    assert_eq!(::std::mem::align_of::<nsIDToCString>() , 1usize);
+} */
 pub type nsCID = nsID;
 /**
  * An "interface id" which can be used to uniquely identify a given
  * interface.
  */
 pub type nsIID = nsID;
 /**
  * Basic component object model interface. Objects which implement
@@ -1800,54 +1842,58 @@ pub type nsIID = nsID;
 pub struct nsISupports {
     pub _vftable: *const _vftable_nsISupports,
 }
 #[repr(C)]
 pub struct _vftable_nsISupports {
 }
 #[test]
 fn bindgen_test_layout_nsISupports() {
-    assert_eq!(:: std:: mem:: size_of:: < nsISupports > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsISupports>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsISupports>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsAutoOwningThread {
     pub mThread: *mut ::std::os::raw::c_void,
 }
 #[test]
 fn bindgen_test_layout_nsAutoOwningThread() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAutoOwningThread > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsAutoOwningThread>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsAutoOwningThread>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsCycleCollectingAutoRefCnt {
     pub mRefCntAndFlags: usize,
 }
 #[test]
 fn bindgen_test_layout_nsCycleCollectingAutoRefCnt() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCycleCollectingAutoRefCnt > (  ) ,
+    assert_eq!(::std::mem::size_of::<nsCycleCollectingAutoRefCnt>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsCycleCollectingAutoRefCnt>() ,
                8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsAutoRefCnt {
     pub mValue: nsrefcnt,
 }
 #[test]
 fn bindgen_test_layout_nsAutoRefCnt() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAutoRefCnt > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsAutoRefCnt>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsAutoRefCnt>() , 8usize);
 }
 #[repr(C)]
 pub struct ThreadSafeAutoRefCnt {
     pub mValue: u64,
 }
 #[test]
 fn bindgen_test_layout_ThreadSafeAutoRefCnt() {
-    assert_eq!(:: std:: mem:: size_of:: < ThreadSafeAutoRefCnt > (  ) ,
-               8usize);
+    assert_eq!(::std::mem::size_of::<ThreadSafeAutoRefCnt>() , 8usize);
+    assert_eq!(::std::mem::align_of::<ThreadSafeAutoRefCnt>() , 8usize);
 }
 /**
  * There are two ways of implementing QueryInterface, and we use both:
  *
  * Table-driven QueryInterface uses a static table of IID->offset mappings
  * and a shared helper function. Using it tends to reduce codesize and improve
  * runtime performance (due to processor cache hits).
  *
@@ -1861,17 +1907,18 @@ fn bindgen_test_layout_ThreadSafeAutoRef
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct QITableEntry {
     pub iid: *const nsIID,
     pub offset: i32,
 }
 #[test]
 fn bindgen_test_layout_QITableEntry() {
-    assert_eq!(:: std:: mem:: size_of:: < QITableEntry > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<QITableEntry>() , 16usize);
+    assert_eq!(::std::mem::align_of::<QITableEntry>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct RefPtrTraits<U> {
     pub _phantom0: ::std::marker::PhantomData<U>,
 }
 #[repr(C)]
 pub struct RefPtr<T> {
@@ -1888,87 +1935,92 @@ pub struct RefPtrGetterAddRefs<T> {
 pub struct nsCOMPtr_helper;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsQueryInterface {
     pub mRawPtr: *mut nsISupports,
 }
 #[test]
 fn bindgen_test_layout_nsQueryInterface() {
-    assert_eq!(:: std:: mem:: size_of:: < nsQueryInterface > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsQueryInterface>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsQueryInterface>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsQueryInterfaceWithError {
     pub mRawPtr: *mut nsISupports,
     pub mErrorPtr: *mut nsresult,
 }
 #[test]
 fn bindgen_test_layout_nsQueryInterfaceWithError() {
-    assert_eq!(:: std:: mem:: size_of:: < nsQueryInterfaceWithError > (  ) ,
-               16usize);
+    assert_eq!(::std::mem::size_of::<nsQueryInterfaceWithError>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsQueryInterfaceWithError>() , 8usize);
 }
 ////////////////////////////////////////////////////////////////////////////
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsGetServiceByCID {
     pub mCID: *const nsCID,
 }
 #[test]
 fn bindgen_test_layout_nsGetServiceByCID() {
-    assert_eq!(:: std:: mem:: size_of:: < nsGetServiceByCID > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsGetServiceByCID>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsGetServiceByCID>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsGetServiceByCIDWithError {
     pub mCID: *const nsCID,
     pub mErrorPtr: *mut nsresult,
 }
 #[test]
 fn bindgen_test_layout_nsGetServiceByCIDWithError() {
-    assert_eq!(:: std:: mem:: size_of:: < nsGetServiceByCIDWithError > (  ) ,
-               16usize);
+    assert_eq!(::std::mem::size_of::<nsGetServiceByCIDWithError>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsGetServiceByCIDWithError>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsGetServiceByContractID {
     pub mContractID: *const ::std::os::raw::c_char,
 }
 #[test]
 fn bindgen_test_layout_nsGetServiceByContractID() {
-    assert_eq!(:: std:: mem:: size_of:: < nsGetServiceByContractID > (  ) ,
-               8usize);
+    assert_eq!(::std::mem::size_of::<nsGetServiceByContractID>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsGetServiceByContractID>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsGetServiceByContractIDWithError {
     pub mContractID: *const ::std::os::raw::c_char,
     pub mErrorPtr: *mut nsresult,
 }
 #[test]
 fn bindgen_test_layout_nsGetServiceByContractIDWithError() {
-    assert_eq!(:: std:: mem:: size_of:: < nsGetServiceByContractIDWithError >
-               (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsGetServiceByContractIDWithError>() ,
+               16usize);
+    assert_eq!(::std::mem::align_of::<nsGetServiceByContractIDWithError>() ,
+               8usize);
 }
 /**
  * Factors implementation for all template versions of nsCOMPtr.
  *
  * Here's the way people normally do things like this:
  *
  *   template<class T> class Foo { ... };
  *   template<> class Foo<void*> { ... };
  *   template<class T> class Foo<T*> : private Foo<void*> { ... };
  */
 #[repr(C)]
 pub struct nsCOMPtr_base {
     pub mRawPtr: *mut nsISupports,
 }
 #[test]
 fn bindgen_test_layout_nsCOMPtr_base() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCOMPtr_base > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsCOMPtr_base>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsCOMPtr_base>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCOMPtr<T> {
     pub mRawPtr: *mut T,
 }
 /**
  * This class is designed to be used for anonymous temporary objects in the
  * argument list of calls that return COM interface pointers, e.g.,
@@ -2002,43 +2054,46 @@ pub struct nsAutoPtrGetterTransfers<T> {
 pub type PLDHashNumber = u32;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PLDHashEntryHdr {
     pub mKeyHash: PLDHashNumber,
 }
 #[test]
 fn bindgen_test_layout_PLDHashEntryHdr() {
-    assert_eq!(:: std:: mem:: size_of:: < PLDHashEntryHdr > (  ) , 4usize);
+    assert_eq!(::std::mem::size_of::<PLDHashEntryHdr>() , 4usize);
+    assert_eq!(::std::mem::align_of::<PLDHashEntryHdr>() , 4usize);
 }
 #[repr(C)]
 pub struct Checker {
     pub mState: u32,
     pub mIsWritable: u32,
 }
 #[test]
 fn bindgen_test_layout_Checker() {
-    assert_eq!(:: std:: mem:: size_of:: < Checker > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<Checker>() , 8usize);
+    assert_eq!(::std::mem::align_of::<Checker>() , 4usize);
 }
 #[repr(C)]
 pub struct PLDHashTable {
     pub mOps: *const PLDHashTableOps,
     pub mHashShift: i16,
     pub mEntrySize: u32,
     pub mEntryCount: u32,
     pub mRemovedCount: u32,
     pub mEntryStore: [u64; 2usize],
     pub mChecker: Checker,
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum PLDHashTable_SearchReason { ForSearchOrRemove = 0, ForAdd = 1, }
 #[test]
 fn bindgen_test_layout_PLDHashTable() {
-    assert_eq!(:: std:: mem:: size_of:: < PLDHashTable > (  ) , 48usize);
+    assert_eq!(::std::mem::size_of::<PLDHashTable>() , 48usize);
+    assert_eq!(::std::mem::align_of::<PLDHashTable>() , 8usize);
 }
 pub type PLDHashHashKey =
     ::std::option::Option<unsafe extern "C" fn(aKey:
                                                    *const ::std::os::raw::c_void)
                               -> PLDHashNumber>;
 pub type PLDHashMatchEntry =
     ::std::option::Option<unsafe extern "C" fn(aEntry: *const PLDHashEntryHdr,
                                                aKey:
@@ -2061,27 +2116,29 @@ pub struct PLDHashTableOps {
     pub hashKey: PLDHashHashKey,
     pub matchEntry: PLDHashMatchEntry,
     pub moveEntry: PLDHashMoveEntry,
     pub clearEntry: PLDHashClearEntry,
     pub initEntry: PLDHashInitEntry,
 }
 #[test]
 fn bindgen_test_layout_PLDHashTableOps() {
-    assert_eq!(:: std:: mem:: size_of:: < PLDHashTableOps > (  ) , 40usize);
+    assert_eq!(::std::mem::size_of::<PLDHashTableOps>() , 40usize);
+    assert_eq!(::std::mem::align_of::<PLDHashTableOps>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PLDHashEntryStub {
     pub _base: PLDHashEntryHdr,
     pub key: *const ::std::os::raw::c_void,
 }
 #[test]
 fn bindgen_test_layout_PLDHashEntryStub() {
-    assert_eq!(:: std:: mem:: size_of:: < PLDHashEntryStub > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<PLDHashEntryStub>() , 16usize);
+    assert_eq!(::std::mem::align_of::<PLDHashEntryStub>() , 8usize);
 }
 /**
  * a base class for templated hashtables.
  *
  * Clients will rarely need to use this class directly. Check the derived
  * classes first, to see if they will meet your needs.
  *
  * @param EntryType  the templated entry-type class that is managed by the
@@ -2129,46 +2186,44 @@ fn bindgen_test_layout_PLDHashEntryStub(
  * @see nsClassHashtable
  * @author "Benjamin Smedberg <bsmedberg@covad.net>"
  */
 #[repr(C)]
 pub struct nsTHashtable<EntryType> {
     pub mTable: PLDHashTable,
     pub _phantom0: ::std::marker::PhantomData<EntryType>,
 }
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct nsDataHashtable {
-    _bindgen_opaque_blob: [u64; 0usize],
-}
+pub struct nsDataHashtable;
 #[test]
 fn bindgen_test_layout_nsDataHashtable() {
-    assert_eq!(:: std:: mem:: size_of:: < nsDataHashtable > (  ) , 0usize);
+    assert_eq!(::std::mem::size_of::<nsDataHashtable>() , 0usize);
+    assert_eq!(::std::mem::align_of::<nsDataHashtable>() , 0usize);
 }
 pub enum CSSVariableResolver { }
 #[repr(C)]
 pub struct CSSVariableValues {
     pub mVariableIDs: [u64; 6usize],
     pub mVariables: u64,
 }
 #[repr(C)]
 pub struct CSSVariableValues_Variable {
     pub mVariableName: nsString,
     pub mValue: nsString,
     pub mFirstToken: nsCSSTokenSerializationType,
     pub mLastToken: nsCSSTokenSerializationType,
 }
 #[test]
 fn bindgen_test_layout_CSSVariableValues_Variable() {
-    assert_eq!(:: std:: mem:: size_of:: < CSSVariableValues_Variable > (  ) ,
-               40usize);
+    assert_eq!(::std::mem::size_of::<CSSVariableValues_Variable>() , 40usize);
+    assert_eq!(::std::mem::align_of::<CSSVariableValues_Variable>() , 8usize);
 }
 #[test]
 fn bindgen_test_layout_CSSVariableValues() {
-    assert_eq!(:: std:: mem:: size_of:: < CSSVariableValues > (  ) , 56usize);
+    assert_eq!(::std::mem::size_of::<CSSVariableValues>() , 56usize);
+    assert_eq!(::std::mem::align_of::<CSSVariableValues>() , 8usize);
 }
 #[repr(i8)]
 #[derive(Copy, Clone, Debug)]
 pub enum SheetType {
     Agent = 0,
     User = 1,
     PresHint = 2,
     SVGAttrAnimation = 3,
@@ -2178,24 +2233,23 @@ pub enum SheetType {
     Override = 7,
     Animation = 8,
     Transition = 9,
     Count = 10,
     Unknown = -1,
 }
 pub type nscolor = u32;
 pub type nscoord = i32;
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
 pub struct nsIntPoint {
-    _bindgen_opaque_blob: [u64; 1usize],
+    pub _bindgen_opaque_blob: [u32; 2usize],
 }
 #[test]
 fn bindgen_test_layout_nsIntPoint() {
-    assert_eq!(:: std:: mem:: size_of:: < nsIntPoint > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsIntPoint>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsIntPoint>() , 4usize);
 }
 /**
  * These *_Simple types are used to map Gecko types to layout-equivalent but
  * simpler Rust types, to aid Rust binding generation.
  *
  * If something in this types or the assertions below needs to change, ask
  * bholley, heycam or emilio before!
  *
@@ -2204,41 +2258,42 @@ fn bindgen_test_layout_nsIntPoint() {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsPoint {
     pub x: nscoord,
     pub y: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsPoint() {
-    assert_eq!(:: std:: mem:: size_of:: < nsPoint > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsPoint>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsPoint>() , 4usize);
 }
 /**
  * <div rustbindgen="true" replaces="nsMargin">
  */
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsMargin {
     pub top: nscoord,
     pub right: nscoord,
     pub bottom: nscoord,
     pub left: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsMargin() {
-    assert_eq!(:: std:: mem:: size_of:: < nsMargin > (  ) , 16usize);
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
+    assert_eq!(::std::mem::size_of::<nsMargin>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsMargin>() , 4usize);
+}
 pub struct nsIntMargin {
-    _bindgen_opaque_blob: [u64; 2usize],
+    pub _bindgen_opaque_blob: [u32; 4usize],
 }
 #[test]
 fn bindgen_test_layout_nsIntMargin() {
-    assert_eq!(:: std:: mem:: size_of:: < nsIntMargin > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsIntMargin>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsIntMargin>() , 4usize);
 }
 pub const eFamily_generic_first: FontFamilyType =
     FontFamilyType::eFamily_serif;
 pub const eFamily_generic_last: FontFamilyType =
     FontFamilyType::eFamily_fantasy;
 pub const eFamily_generic_count: FontFamilyType =
     FontFamilyType::eFamily_monospace;
 /**
@@ -2269,60 +2324,62 @@ pub enum QuotedName { eQuotedName = 0, e
  */
 #[repr(C)]
 pub struct FontFamilyName {
     pub mType: FontFamilyType,
     pub mName: nsString,
 }
 #[test]
 fn bindgen_test_layout_FontFamilyName() {
-    assert_eq!(:: std:: mem:: size_of:: < FontFamilyName > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<FontFamilyName>() , 24usize);
+    assert_eq!(::std::mem::align_of::<FontFamilyName>() , 8usize);
 }
 /**
  * font family list, array of font families and a default font type.
  * font family names are either named strings or generics. the default
  * font type is used to preserve the variable font fallback behavior
  */
 #[repr(C)]
 pub struct FontFamilyList {
     pub mFontlist: u64,
     pub mDefaultFontType: FontFamilyType,
 }
 #[test]
 fn bindgen_test_layout_FontFamilyList() {
-    assert_eq!(:: std:: mem:: size_of:: < FontFamilyList > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<FontFamilyList>() , 16usize);
+    assert_eq!(::std::mem::align_of::<FontFamilyList>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct gfxFontFeature {
     pub mTag: u32,
     pub mValue: u32,
 }
 #[test]
 fn bindgen_test_layout_gfxFontFeature() {
-    assert_eq!(:: std:: mem:: size_of:: < gfxFontFeature > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<gfxFontFeature>() , 8usize);
+    assert_eq!(::std::mem::align_of::<gfxFontFeature>() , 4usize);
 }
 #[repr(C)]
 pub struct gfxAlternateValue {
     pub alternate: u32,
     pub value: nsString,
 }
 #[test]
 fn bindgen_test_layout_gfxAlternateValue() {
-    assert_eq!(:: std:: mem:: size_of:: < gfxAlternateValue > (  ) , 24usize);
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
+    assert_eq!(::std::mem::size_of::<gfxAlternateValue>() , 24usize);
+    assert_eq!(::std::mem::align_of::<gfxAlternateValue>() , 8usize);
+}
 pub struct gfxFontFeatureValueSet {
-    _bindgen_opaque_blob: [u64; 8usize],
+    pub _bindgen_opaque_blob: [u64; 8usize],
 }
 #[test]
 fn bindgen_test_layout_gfxFontFeatureValueSet() {
-    assert_eq!(:: std:: mem:: size_of:: < gfxFontFeatureValueSet > (  ) ,
-               64usize);
+    assert_eq!(::std::mem::size_of::<gfxFontFeatureValueSet>() , 64usize);
+    assert_eq!(::std::mem::align_of::<gfxFontFeatureValueSet>() , 8usize);
 }
 pub enum gfxFontStyle { }
 pub type nsFontFamilyEnumFunc =
     ::std::option::Option<unsafe extern "C" fn(aFamily: *const nsString,
                                                aGeneric: bool,
                                                aData:
                                                    *mut ::std::os::raw::c_void)
                               -> bool>;
@@ -2346,41 +2403,42 @@ pub struct nsFont {
     pub sizeAdjust: f32,
     pub alternateValues: u64,
     pub featureValueLookup: RefPtr<gfxFontFeatureValueSet>,
     pub fontFeatureSettings: u64,
     pub languageOverride: nsString,
 }
 #[test]
 fn bindgen_test_layout_nsFont() {
-    assert_eq!(:: std:: mem:: size_of:: < nsFont > (  ) , 88usize);
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
+    assert_eq!(::std::mem::size_of::<nsFont>() , 88usize);
+    assert_eq!(::std::mem::align_of::<nsFont>() , 8usize);
+}
 pub struct nsIntRect {
-    _bindgen_opaque_blob: [u64; 2usize],
+    pub _bindgen_opaque_blob: [u32; 4usize],
 }
 #[test]
 fn bindgen_test_layout_nsIntRect() {
-    assert_eq!(:: std:: mem:: size_of:: < nsIntRect > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsIntRect>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsIntRect>() , 4usize);
 }
 /**
  * <div rustbindgen="true" replaces="nsRect">
  */
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsRect {
     pub x: nscoord,
     pub y: nscoord,
     pub width: nscoord,
     pub height: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsRect() {
-    assert_eq!(:: std:: mem:: size_of:: < nsRect > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsRect>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsRect>() , 4usize);
 }
 #[repr(i8)]
 #[derive(Copy, Clone, Debug)]
 pub enum StyleBoxSizing { Content = 0, Padding = 1, Border = 2, }
 pub enum PlaybackDirection { }
 pub enum FillMode { }
 pub enum WritingMode { }
 #[repr(u32)]
@@ -2441,63 +2499,67 @@ pub struct nsStyleCoord {
 #[derive(Copy, Clone)]
 pub struct nsStyleCoord_CalcValue {
     pub mLength: nscoord,
     pub mPercent: f32,
     pub mHasPercent: bool,
 }
 #[test]
 fn bindgen_test_layout_nsStyleCoord_CalcValue() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleCoord_CalcValue > (  ) ,
-               12usize);
+    assert_eq!(::std::mem::size_of::<nsStyleCoord_CalcValue>() , 12usize);
+    assert_eq!(::std::mem::align_of::<nsStyleCoord_CalcValue>() , 4usize);
 }
 #[repr(C)]
 pub struct nsStyleCoord_Calc {
     pub _base: nsStyleCoord_CalcValue,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsStyleCoord_Calc() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleCoord_Calc > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<nsStyleCoord_Calc>() , 32usize);
+    assert_eq!(::std::mem::align_of::<nsStyleCoord_Calc>() , 8usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsStyleCoord_CoordConstructorType { CoordConstructor = 0, }
 #[test]
 fn bindgen_test_layout_nsStyleCoord() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleCoord > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsStyleCoord>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsStyleCoord>() , 8usize);
 }
 /**
  * Class that represents a set of top/right/bottom/left nsStyleCoords.
  * This is commonly used to hold the widths of the borders, margins,
  * or paddings of a box.
  */
 #[repr(C)]
 pub struct nsStyleSides {
     pub mUnits: [nsStyleUnit; 4usize],
     pub mValues: [nsStyleUnion; 4usize],
 }
 #[test]
 fn bindgen_test_layout_nsStyleSides() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleSides > (  ) , 40usize);
+    assert_eq!(::std::mem::size_of::<nsStyleSides>() , 40usize);
+    assert_eq!(::std::mem::align_of::<nsStyleSides>() , 8usize);
 }
 /**
  * Class that represents a set of top-left/top-right/bottom-left/bottom-right
  * nsStyleCoord pairs.  This is used to hold the dimensions of the
  * corners of a box (for, e.g., border-radius and outline-radius).
  */
 #[repr(C)]
 pub struct nsStyleCorners {
     pub mUnits: [nsStyleUnit; 8usize],
     pub mValues: [nsStyleUnion; 8usize],
 }
 #[test]
 fn bindgen_test_layout_nsStyleCorners() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleCorners > (  ) , 72usize);
+    assert_eq!(::std::mem::size_of::<nsStyleCorners>() , 72usize);
+    assert_eq!(::std::mem::align_of::<nsStyleCorners>() , 8usize);
 }
 pub type nsLoadFlags = u32;
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsIRequest {
     pub _base: nsISupports,
 }
 #[repr(C)]
@@ -2518,24 +2580,23 @@ pub enum nsIRequest_nsIRequest_h_unnamed
     VALIDATE_ALWAYS = 2048,
     VALIDATE_NEVER = 4096,
     VALIDATE_ONCE_PER_SESSION = 8192,
     LOAD_ANONYMOUS = 16384,
     LOAD_FRESH_CONNECTION = 32768,
 }
 pub enum nsIContentSecurityPolicy { }
 pub enum nsIDOMDocument { }
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
 pub struct nsIPrincipal {
-    _bindgen_opaque_blob: [u64; 1usize],
+    pub _bindgen_opaque_blob: u64,
 }
 #[test]
 fn bindgen_test_layout_nsIPrincipal() {
-    assert_eq!(:: std:: mem:: size_of:: < nsIPrincipal > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsIPrincipal>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsIPrincipal>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsIExpandedPrincipal {
     pub _base: nsISupports,
 }
 #[repr(C)]
 pub struct _vftable_nsIExpandedPrincipal {
@@ -2552,17 +2613,18 @@ pub struct _vftable_nsIExpandedPrincipal
  */
 #[repr(C)]
 pub struct nsStringBuffer {
     pub mRefCount: u32,
     pub mStorageSize: u32,
 }
 #[test]
 fn bindgen_test_layout_nsStringBuffer() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStringBuffer > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsStringBuffer>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsStringBuffer>() , 4usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsIAtom {
     pub _base: nsISupports,
     pub mLength: u32,
     pub mHash: u32,
     /**
@@ -2573,33 +2635,36 @@ pub struct nsIAtom {
     pub mString: *mut ::std::os::raw::c_ushort,
 }
 #[repr(C)]
 pub struct _vftable_nsIAtom {
     pub _base: _vftable_nsISupports,
 }
 #[test]
 fn bindgen_test_layout_nsIAtom() {
-    assert_eq!(:: std:: mem:: size_of:: < nsIAtom > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsIAtom>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsIAtom>() , 8usize);
 }
 #[repr(C)]
 pub struct nsAtomString {
     pub _base: nsString,
 }
 #[test]
 fn bindgen_test_layout_nsAtomString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAtomString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsAtomString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsAtomString>() , 8usize);
 }
 #[repr(C)]
 pub struct nsAtomCString {
     pub _base: nsCString,
 }
 #[test]
 fn bindgen_test_layout_nsAtomCString() {
-    assert_eq!(:: std:: mem:: size_of:: < nsAtomCString > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsAtomCString>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsAtomCString>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsDependentAtomString {
     pub _base: [u64; 2usize],
 }
 /**
  * A class for holding strong references to handle-managed objects.
@@ -2879,220 +2944,221 @@ pub enum nsCSSProperty {
     eCSSProperty_text_align_last = 208,
     eCSSProperty_text_combine_upright = 209,
     eCSSProperty_text_decoration_color = 210,
     eCSSProperty_text_decoration_line = 211,
     eCSSProperty_text_decoration_style = 212,
     eCSSProperty_text_emphasis_color = 213,
     eCSSProperty_text_emphasis_position = 214,
     eCSSProperty_text_emphasis_style = 215,
-    eCSSProperty_text_indent = 216,
-    eCSSProperty_text_orientation = 217,
-    eCSSProperty_text_overflow = 218,
-    eCSSProperty_text_shadow = 219,
-    eCSSProperty_text_size_adjust = 220,
-    eCSSProperty_text_transform = 221,
-    eCSSProperty_transform = 222,
-    eCSSProperty_transform_box = 223,
-    eCSSProperty_transform_origin = 224,
-    eCSSProperty_perspective_origin = 225,
-    eCSSProperty_perspective = 226,
-    eCSSProperty_transform_style = 227,
-    eCSSProperty_backface_visibility = 228,
-    eCSSProperty_top = 229,
-    eCSSProperty__moz_top_layer = 230,
-    eCSSProperty_touch_action = 231,
-    eCSSProperty_transition_delay = 232,
-    eCSSProperty_transition_duration = 233,
-    eCSSProperty_transition_property = 234,
-    eCSSProperty_transition_timing_function = 235,
-    eCSSProperty_unicode_bidi = 236,
-    eCSSProperty_user_focus = 237,
-    eCSSProperty_user_input = 238,
-    eCSSProperty_user_modify = 239,
-    eCSSProperty_user_select = 240,
-    eCSSProperty_vertical_align = 241,
-    eCSSProperty_visibility = 242,
-    eCSSProperty_white_space = 243,
-    eCSSProperty_width = 244,
-    eCSSProperty__moz_window_dragging = 245,
-    eCSSProperty__moz_window_shadow = 246,
-    eCSSProperty_word_break = 247,
-    eCSSProperty_word_spacing = 248,
-    eCSSProperty_word_wrap = 249,
-    eCSSProperty_hyphens = 250,
-    eCSSProperty_writing_mode = 251,
-    eCSSProperty_z_index = 252,
-    eCSSProperty_box_align = 253,
-    eCSSProperty_box_direction = 254,
-    eCSSProperty_box_flex = 255,
-    eCSSProperty_box_orient = 256,
-    eCSSProperty_box_pack = 257,
-    eCSSProperty_box_ordinal_group = 258,
-    eCSSProperty_stack_sizing = 259,
-    eCSSProperty_script_level = 260,
-    eCSSProperty_script_size_multiplier = 261,
-    eCSSProperty_script_min_size = 262,
-    eCSSProperty_math_variant = 263,
-    eCSSProperty_math_display = 264,
-    eCSSProperty_clip_path = 265,
-    eCSSProperty_clip_rule = 266,
-    eCSSProperty_color_interpolation = 267,
-    eCSSProperty_color_interpolation_filters = 268,
-    eCSSProperty_dominant_baseline = 269,
-    eCSSProperty_fill = 270,
-    eCSSProperty_fill_opacity = 271,
-    eCSSProperty_fill_rule = 272,
-    eCSSProperty_filter = 273,
-    eCSSProperty_flood_color = 274,
-    eCSSProperty_flood_opacity = 275,
-    eCSSProperty_image_rendering = 276,
-    eCSSProperty_lighting_color = 277,
-    eCSSProperty_marker_end = 278,
-    eCSSProperty_marker_mid = 279,
-    eCSSProperty_marker_start = 280,
-    eCSSProperty_mask = 281,
-    eCSSProperty_mask_type = 282,
-    eCSSProperty_shape_rendering = 283,
-    eCSSProperty_stop_color = 284,
-    eCSSProperty_stop_opacity = 285,
-    eCSSProperty_stroke = 286,
-    eCSSProperty_stroke_dasharray = 287,
-    eCSSProperty_stroke_dashoffset = 288,
-    eCSSProperty_stroke_linecap = 289,
-    eCSSProperty_stroke_linejoin = 290,
-    eCSSProperty_stroke_miterlimit = 291,
-    eCSSProperty_stroke_opacity = 292,
-    eCSSProperty_stroke_width = 293,
-    eCSSProperty_text_anchor = 294,
-    eCSSProperty_text_rendering = 295,
-    eCSSProperty_vector_effect = 296,
-    eCSSProperty_will_change = 297,
-    eCSSProperty__x_lang = 298,
-    eCSSProperty__x_span = 299,
-    eCSSProperty__x_text_zoom = 300,
-    eCSSProperty_COUNT_no_shorthands = 301,
-    eCSSProperty_all = 302,
-    eCSSProperty_animation = 303,
-    eCSSProperty_background = 304,
-    eCSSProperty_border = 305,
-    eCSSProperty_border_block_end = 306,
-    eCSSProperty_border_block_start = 307,
-    eCSSProperty_border_bottom = 308,
-    eCSSProperty_border_color = 309,
-    eCSSProperty_border_image = 310,
-    eCSSProperty_border_inline_end = 311,
-    eCSSProperty_border_inline_start = 312,
-    eCSSProperty_border_left = 313,
-    eCSSProperty_border_right = 314,
-    eCSSProperty_border_style = 315,
-    eCSSProperty_border_top = 316,
-    eCSSProperty_border_width = 317,
-    eCSSProperty_border_radius = 318,
-    eCSSProperty__moz_columns = 319,
-    eCSSProperty__moz_column_rule = 320,
-    eCSSProperty_flex = 321,
-    eCSSProperty_flex_flow = 322,
-    eCSSProperty_font = 323,
-    eCSSProperty_font_variant = 324,
-    eCSSProperty_grid = 325,
-    eCSSProperty_grid_column = 326,
-    eCSSProperty_grid_row = 327,
-    eCSSProperty_grid_area = 328,
-    eCSSProperty_grid_gap = 329,
-    eCSSProperty_list_style = 330,
-    eCSSProperty_margin = 331,
-    eCSSProperty_outline = 332,
-    eCSSProperty_overflow = 333,
-    eCSSProperty_padding = 334,
-    eCSSProperty_scroll_snap_type = 335,
-    eCSSProperty_text_decoration = 336,
-    eCSSProperty_text_emphasis = 337,
-    eCSSProperty_transition = 338,
-    eCSSProperty_marker = 339,
-    eCSSProperty__moz_transform = 340,
-    eCSSProperty_COUNT = 341,
-    eCSSPropertyAlias_MozPerspectiveOrigin = 342,
-    eCSSPropertyAlias_MozPerspective = 343,
-    eCSSPropertyAlias_MozTransformStyle = 344,
-    eCSSPropertyAlias_MozBackfaceVisibility = 345,
-    eCSSPropertyAlias_MozBorderImage = 346,
-    eCSSPropertyAlias_MozTransition = 347,
-    eCSSPropertyAlias_MozTransitionDelay = 348,
-    eCSSPropertyAlias_MozTransitionDuration = 349,
-    eCSSPropertyAlias_MozTransitionProperty = 350,
-    eCSSPropertyAlias_MozTransitionTimingFunction = 351,
-    eCSSPropertyAlias_MozAnimation = 352,
-    eCSSPropertyAlias_MozAnimationDelay = 353,
-    eCSSPropertyAlias_MozAnimationDirection = 354,
-    eCSSPropertyAlias_MozAnimationDuration = 355,
-    eCSSPropertyAlias_MozAnimationFillMode = 356,
-    eCSSPropertyAlias_MozAnimationIterationCount = 357,
-    eCSSPropertyAlias_MozAnimationName = 358,
-    eCSSPropertyAlias_MozAnimationPlayState = 359,
-    eCSSPropertyAlias_MozAnimationTimingFunction = 360,
-    eCSSPropertyAlias_MozBoxSizing = 361,
-    eCSSPropertyAlias_MozFontFeatureSettings = 362,
-    eCSSPropertyAlias_MozFontLanguageOverride = 363,
-    eCSSPropertyAlias_MozPaddingEnd = 364,
-    eCSSPropertyAlias_MozPaddingStart = 365,
-    eCSSPropertyAlias_MozMarginEnd = 366,
-    eCSSPropertyAlias_MozMarginStart = 367,
-    eCSSPropertyAlias_MozBorderEnd = 368,
-    eCSSPropertyAlias_MozBorderEndColor = 369,
-    eCSSPropertyAlias_MozBorderEndStyle = 370,
-    eCSSPropertyAlias_MozBorderEndWidth = 371,
-    eCSSPropertyAlias_MozBorderStart = 372,
-    eCSSPropertyAlias_MozBorderStartColor = 373,
-    eCSSPropertyAlias_MozBorderStartStyle = 374,
-    eCSSPropertyAlias_MozBorderStartWidth = 375,
-    eCSSPropertyAlias_MozHyphens = 376,
-    eCSSPropertyAlias_WebkitAnimation = 377,
-    eCSSPropertyAlias_WebkitAnimationDelay = 378,
-    eCSSPropertyAlias_WebkitAnimationDirection = 379,
-    eCSSPropertyAlias_WebkitAnimationDuration = 380,
-    eCSSPropertyAlias_WebkitAnimationFillMode = 381,
-    eCSSPropertyAlias_WebkitAnimationIterationCount = 382,
-    eCSSPropertyAlias_WebkitAnimationName = 383,
-    eCSSPropertyAlias_WebkitAnimationPlayState = 384,
-    eCSSPropertyAlias_WebkitAnimationTimingFunction = 385,
-    eCSSPropertyAlias_WebkitFilter = 386,
-    eCSSPropertyAlias_WebkitTextSizeAdjust = 387,
-    eCSSPropertyAlias_WebkitTransform = 388,
-    eCSSPropertyAlias_WebkitTransformOrigin = 389,
-    eCSSPropertyAlias_WebkitTransformStyle = 390,
-    eCSSPropertyAlias_WebkitBackfaceVisibility = 391,
-    eCSSPropertyAlias_WebkitPerspective = 392,
-    eCSSPropertyAlias_WebkitPerspectiveOrigin = 393,
-    eCSSPropertyAlias_WebkitTransition = 394,
-    eCSSPropertyAlias_WebkitTransitionDelay = 395,
-    eCSSPropertyAlias_WebkitTransitionDuration = 396,
-    eCSSPropertyAlias_WebkitTransitionProperty = 397,
-    eCSSPropertyAlias_WebkitTransitionTimingFunction = 398,
-    eCSSPropertyAlias_WebkitBorderRadius = 399,
-    eCSSPropertyAlias_WebkitBorderTopLeftRadius = 400,
-    eCSSPropertyAlias_WebkitBorderTopRightRadius = 401,
-    eCSSPropertyAlias_WebkitBorderBottomLeftRadius = 402,
-    eCSSPropertyAlias_WebkitBorderBottomRightRadius = 403,
-    eCSSPropertyAlias_WebkitBackgroundClip = 404,
-    eCSSPropertyAlias_WebkitBackgroundOrigin = 405,
-    eCSSPropertyAlias_WebkitBackgroundSize = 406,
-    eCSSPropertyAlias_WebkitBorderImage = 407,
-    eCSSPropertyAlias_WebkitBoxShadow = 408,
-    eCSSPropertyAlias_WebkitBoxSizing = 409,
-    eCSSPropertyAlias_WebkitBoxFlex = 410,
-    eCSSPropertyAlias_WebkitBoxOrdinalGroup = 411,
-    eCSSPropertyAlias_WebkitBoxAlign = 412,
-    eCSSPropertyAlias_WebkitBoxPack = 413,
-    eCSSPropertyAlias_WebkitUserSelect = 414,
-    eCSSProperty_COUNT_with_aliases = 415,
-    eCSSPropertyExtra_all_properties = 416,
-    eCSSPropertyExtra_x_none_value = 417,
-    eCSSPropertyExtra_x_auto_value = 418,
-    eCSSPropertyExtra_variable = 419,
+    eCSSProperty__webkit_text_fill_color = 216,
+    eCSSProperty_text_indent = 217,
+    eCSSProperty_text_orientation = 218,
+    eCSSProperty_text_overflow = 219,
+    eCSSProperty_text_shadow = 220,
+    eCSSProperty_text_size_adjust = 221,
+    eCSSProperty_text_transform = 222,
+    eCSSProperty_transform = 223,
+    eCSSProperty_transform_box = 224,
+    eCSSProperty_transform_origin = 225,
+    eCSSProperty_perspective_origin = 226,
+    eCSSProperty_perspective = 227,
+    eCSSProperty_transform_style = 228,
+    eCSSProperty_backface_visibility = 229,
+    eCSSProperty_top = 230,
+    eCSSProperty__moz_top_layer = 231,
+    eCSSProperty_touch_action = 232,
+    eCSSProperty_transition_delay = 233,
+    eCSSProperty_transition_duration = 234,
+    eCSSProperty_transition_property = 235,
+    eCSSProperty_transition_timing_function = 236,
+    eCSSProperty_unicode_bidi = 237,
+    eCSSProperty_user_focus = 238,
+    eCSSProperty_user_input = 239,
+    eCSSProperty_user_modify = 240,
+    eCSSProperty_user_select = 241,
+    eCSSProperty_vertical_align = 242,
+    eCSSProperty_visibility = 243,
+    eCSSProperty_white_space = 244,
+    eCSSProperty_width = 245,
+    eCSSProperty__moz_window_dragging = 246,
+    eCSSProperty__moz_window_shadow = 247,
+    eCSSProperty_word_break = 248,
+    eCSSProperty_word_spacing = 249,
+    eCSSProperty_word_wrap = 250,
+    eCSSProperty_hyphens = 251,
+    eCSSProperty_writing_mode = 252,
+    eCSSProperty_z_index = 253,
+    eCSSProperty_box_align = 254,
+    eCSSProperty_box_direction = 255,
+    eCSSProperty_box_flex = 256,
+    eCSSProperty_box_orient = 257,
+    eCSSProperty_box_pack = 258,
+    eCSSProperty_box_ordinal_group = 259,
+    eCSSProperty_stack_sizing = 260,
+    eCSSProperty_script_level = 261,
+    eCSSProperty_script_size_multiplier = 262,
+    eCSSProperty_script_min_size = 263,
+    eCSSProperty_math_variant = 264,
+    eCSSProperty_math_display = 265,
+    eCSSProperty_clip_path = 266,
+    eCSSProperty_clip_rule = 267,
+    eCSSProperty_color_interpolation = 268,
+    eCSSProperty_color_interpolation_filters = 269,
+    eCSSProperty_dominant_baseline = 270,
+    eCSSProperty_fill = 271,
+    eCSSProperty_fill_opacity = 272,
+    eCSSProperty_fill_rule = 273,
+    eCSSProperty_filter = 274,
+    eCSSProperty_flood_color = 275,
+    eCSSProperty_flood_opacity = 276,
+    eCSSProperty_image_rendering = 277,
+    eCSSProperty_lighting_color = 278,
+    eCSSProperty_marker_end = 279,
+    eCSSProperty_marker_mid = 280,
+    eCSSProperty_marker_start = 281,
+    eCSSProperty_mask = 282,
+    eCSSProperty_mask_type = 283,
+    eCSSProperty_shape_rendering = 284,
+    eCSSProperty_stop_color = 285,
+    eCSSProperty_stop_opacity = 286,
+    eCSSProperty_stroke = 287,
+    eCSSProperty_stroke_dasharray = 288,
+    eCSSProperty_stroke_dashoffset = 289,
+    eCSSProperty_stroke_linecap = 290,
+    eCSSProperty_stroke_linejoin = 291,
+    eCSSProperty_stroke_miterlimit = 292,
+    eCSSProperty_stroke_opacity = 293,
+    eCSSProperty_stroke_width = 294,
+    eCSSProperty_text_anchor = 295,
+    eCSSProperty_text_rendering = 296,
+    eCSSProperty_vector_effect = 297,
+    eCSSProperty_will_change = 298,
+    eCSSProperty__x_lang = 299,
+    eCSSProperty__x_span = 300,
+    eCSSProperty__x_text_zoom = 301,
+    eCSSProperty_COUNT_no_shorthands = 302,
+    eCSSProperty_all = 303,
+    eCSSProperty_animation = 304,
+    eCSSProperty_background = 305,
+    eCSSProperty_border = 306,
+    eCSSProperty_border_block_end = 307,
+    eCSSProperty_border_block_start = 308,
+    eCSSProperty_border_bottom = 309,
+    eCSSProperty_border_color = 310,
+    eCSSProperty_border_image = 311,
+    eCSSProperty_border_inline_end = 312,
+    eCSSProperty_border_inline_start = 313,
+    eCSSProperty_border_left = 314,
+    eCSSProperty_border_right = 315,
+    eCSSProperty_border_style = 316,
+    eCSSProperty_border_top = 317,
+    eCSSProperty_border_width = 318,
+    eCSSProperty_border_radius = 319,
+    eCSSProperty__moz_columns = 320,
+    eCSSProperty__moz_column_rule = 321,
+    eCSSProperty_flex = 322,
+    eCSSProperty_flex_flow = 323,
+    eCSSProperty_font = 324,
+    eCSSProperty_font_variant = 325,
+    eCSSProperty_grid = 326,
+    eCSSProperty_grid_column = 327,
+    eCSSProperty_grid_row = 328,
+    eCSSProperty_grid_area = 329,
+    eCSSProperty_grid_gap = 330,
+    eCSSProperty_list_style = 331,
+    eCSSProperty_margin = 332,
+    eCSSProperty_outline = 333,
+    eCSSProperty_overflow = 334,
+    eCSSProperty_padding = 335,
+    eCSSProperty_scroll_snap_type = 336,
+    eCSSProperty_text_decoration = 337,
+    eCSSProperty_text_emphasis = 338,
+    eCSSProperty_transition = 339,
+    eCSSProperty_marker = 340,
+    eCSSProperty__moz_transform = 341,
+    eCSSProperty_COUNT = 342,
+    eCSSPropertyAlias_MozPerspectiveOrigin = 343,
+    eCSSPropertyAlias_MozPerspective = 344,
+    eCSSPropertyAlias_MozTransformStyle = 345,
+    eCSSPropertyAlias_MozBackfaceVisibility = 346,
+    eCSSPropertyAlias_MozBorderImage = 347,
+    eCSSPropertyAlias_MozTransition = 348,
+    eCSSPropertyAlias_MozTransitionDelay = 349,
+    eCSSPropertyAlias_MozTransitionDuration = 350,
+    eCSSPropertyAlias_MozTransitionProperty = 351,
+    eCSSPropertyAlias_MozTransitionTimingFunction = 352,
+    eCSSPropertyAlias_MozAnimation = 353,
+    eCSSPropertyAlias_MozAnimationDelay = 354,
+    eCSSPropertyAlias_MozAnimationDirection = 355,
+    eCSSPropertyAlias_MozAnimationDuration = 356,
+    eCSSPropertyAlias_MozAnimationFillMode = 357,
+    eCSSPropertyAlias_MozAnimationIterationCount = 358,
+    eCSSPropertyAlias_MozAnimationName = 359,
+    eCSSPropertyAlias_MozAnimationPlayState = 360,
+    eCSSPropertyAlias_MozAnimationTimingFunction = 361,
+    eCSSPropertyAlias_MozBoxSizing = 362,
+    eCSSPropertyAlias_MozFontFeatureSettings = 363,
+    eCSSPropertyAlias_MozFontLanguageOverride = 364,
+    eCSSPropertyAlias_MozPaddingEnd = 365,
+    eCSSPropertyAlias_MozPaddingStart = 366,
+    eCSSPropertyAlias_MozMarginEnd = 367,
+    eCSSPropertyAlias_MozMarginStart = 368,
+    eCSSPropertyAlias_MozBorderEnd = 369,
+    eCSSPropertyAlias_MozBorderEndColor = 370,
+    eCSSPropertyAlias_MozBorderEndStyle = 371,
+    eCSSPropertyAlias_MozBorderEndWidth = 372,
+    eCSSPropertyAlias_MozBorderStart = 373,
+    eCSSPropertyAlias_MozBorderStartColor = 374,
+    eCSSPropertyAlias_MozBorderStartStyle = 375,
+    eCSSPropertyAlias_MozBorderStartWidth = 376,
+    eCSSPropertyAlias_MozHyphens = 377,
+    eCSSPropertyAlias_WebkitAnimation = 378,
+    eCSSPropertyAlias_WebkitAnimationDelay = 379,
+    eCSSPropertyAlias_WebkitAnimationDirection = 380,
+    eCSSPropertyAlias_WebkitAnimationDuration = 381,
+    eCSSPropertyAlias_WebkitAnimationFillMode = 382,
+    eCSSPropertyAlias_WebkitAnimationIterationCount = 383,
+    eCSSPropertyAlias_WebkitAnimationName = 384,
+    eCSSPropertyAlias_WebkitAnimationPlayState = 385,
+    eCSSPropertyAlias_WebkitAnimationTimingFunction = 386,
+    eCSSPropertyAlias_WebkitFilter = 387,
+    eCSSPropertyAlias_WebkitTextSizeAdjust = 388,
+    eCSSPropertyAlias_WebkitTransform = 389,
+    eCSSPropertyAlias_WebkitTransformOrigin = 390,
+    eCSSPropertyAlias_WebkitTransformStyle = 391,
+    eCSSPropertyAlias_WebkitBackfaceVisibility = 392,
+    eCSSPropertyAlias_WebkitPerspective = 393,
+    eCSSPropertyAlias_WebkitPerspectiveOrigin = 394,
+    eCSSPropertyAlias_WebkitTransition = 395,
+    eCSSPropertyAlias_WebkitTransitionDelay = 396,
+    eCSSPropertyAlias_WebkitTransitionDuration = 397,
+    eCSSPropertyAlias_WebkitTransitionProperty = 398,
+    eCSSPropertyAlias_WebkitTransitionTimingFunction = 399,
+    eCSSPropertyAlias_WebkitBorderRadius = 400,
+    eCSSPropertyAlias_WebkitBorderTopLeftRadius = 401,
+    eCSSPropertyAlias_WebkitBorderTopRightRadius = 402,
+    eCSSPropertyAlias_WebkitBorderBottomLeftRadius = 403,
+    eCSSPropertyAlias_WebkitBorderBottomRightRadius = 404,
+    eCSSPropertyAlias_WebkitBackgroundClip = 405,
+    eCSSPropertyAlias_WebkitBackgroundOrigin = 406,
+    eCSSPropertyAlias_WebkitBackgroundSize = 407,
+    eCSSPropertyAlias_WebkitBorderImage = 408,
+    eCSSPropertyAlias_WebkitBoxShadow = 409,
+    eCSSPropertyAlias_WebkitBoxSizing = 410,
+    eCSSPropertyAlias_WebkitBoxFlex = 411,
+    eCSSPropertyAlias_WebkitBoxOrdinalGroup = 412,
+    eCSSPropertyAlias_WebkitBoxAlign = 413,
+    eCSSPropertyAlias_WebkitBoxPack = 414,
+    eCSSPropertyAlias_WebkitUserSelect = 415,
+    eCSSProperty_COUNT_with_aliases = 416,
+    eCSSPropertyExtra_all_properties = 417,
+    eCSSPropertyExtra_x_none_value = 418,
+    eCSSPropertyExtra_x_auto_value = 419,
+    eCSSPropertyExtra_variable = 420,
 }
 #[repr(i32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsCSSFontDesc {
     eCSSFontDesc_UNKNOWN = -1,
     eCSSFontDesc_Family = 0,
     eCSSFontDesc_Style = 1,
     eCSSFontDesc_Weight = 2,
@@ -3132,69 +3198,68 @@ pub enum nsCSSPropertyLogicalGroup {
     eCSSPropertyLogicalGroup_Offset = 5,
     eCSSPropertyLogicalGroup_Padding = 6,
     eCSSPropertyLogicalGroup_MinSize = 7,
     eCSSPropertyLogicalGroup_Size = 8,
     eCSSPropertyLogicalGroup_WebkitBoxOrient = 9,
     eCSSPropertyLogicalGroup_COUNT = 10,
 }
 pub enum CSSStyleSheet { }
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
 pub struct URLValue {
-    _bindgen_opaque_blob: [u64; 7usize],
+    pub _bindgen_opaque_blob: [u64; 7usize],
 }
 #[test]
 fn bindgen_test_layout_URLValue() {
-    assert_eq!(:: std:: mem:: size_of:: < URLValue > (  ) , 56usize);
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
+    assert_eq!(::std::mem::size_of::<URLValue>() , 56usize);
+    assert_eq!(::std::mem::align_of::<URLValue>() , 8usize);
+}
 pub struct ImageValue {
-    _bindgen_opaque_blob: [u64; 13usize],
+    pub _bindgen_opaque_blob: [u64; 13usize],
 }
 #[test]
 fn bindgen_test_layout_ImageValue() {
-    assert_eq!(:: std:: mem:: size_of:: < ImageValue > (  ) , 104usize);
+    assert_eq!(::std::mem::size_of::<ImageValue>() , 104usize);
+    assert_eq!(::std::mem::align_of::<ImageValue>() , 8usize);
 }
 #[repr(C)]
 pub struct GridNamedArea {
     pub mName: nsString,
     pub mColumnStart: u32,
     pub mColumnEnd: u32,
     pub mRowStart: u32,
     pub mRowEnd: u32,
 }
 #[test]
 fn bindgen_test_layout_GridNamedArea() {
-    assert_eq!(:: std:: mem:: size_of:: < GridNamedArea > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<GridNamedArea>() , 32usize);
+    assert_eq!(::std::mem::align_of::<GridNamedArea>() , 8usize);
 }
 #[repr(C)]
 pub struct GridTemplateAreasValue {
     pub mNamedAreas: u64,
     pub mTemplates: u64,
     pub mNColumns: u32,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_GridTemplateAreasValue() {
-    assert_eq!(:: std:: mem:: size_of:: < GridTemplateAreasValue > (  ) ,
-               40usize);
+    assert_eq!(::std::mem::size_of::<GridTemplateAreasValue>() , 40usize);
+    assert_eq!(::std::mem::align_of::<GridTemplateAreasValue>() , 8usize);
 }
 #[repr(C)]
 pub struct FontFamilyListRefCnt {
     pub _base: FontFamilyList,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_FontFamilyListRefCnt() {
-    assert_eq!(:: std:: mem:: size_of:: < FontFamilyListRefCnt > (  ) ,
-               32usize);
+    assert_eq!(::std::mem::size_of::<FontFamilyListRefCnt>() , 32usize);
+    assert_eq!(::std::mem::align_of::<FontFamilyListRefCnt>() , 8usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsCSSUnit {
     eCSSUnit_Null = 0,
     eCSSUnit_Auto = 1,
     eCSSUnit_Inherit = 2,
     eCSSUnit_Initial = 3,
@@ -3287,171 +3352,178 @@ pub enum nsCSSValue_Serialization { eNor
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsCSSValue_nsCSSValue_h_unnamed_8 {
     pub _bindgen_data_: u64,
 }
 impl nsCSSValue_nsCSSValue_h_unnamed_8 { }
 #[test]
 fn bindgen_test_layout_nsCSSValue() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValue > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValue>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValue>() , 8usize);
 }
 #[repr(C)]
 pub struct Array {
     pub mRefCnt: usize,
     pub mCount: usize,
     pub mArray: [nsCSSValue; 1usize],
 }
 #[test]
 fn bindgen_test_layout_Array() {
-    assert_eq!(:: std:: mem:: size_of:: < Array > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<Array>() , 32usize);
+    assert_eq!(::std::mem::align_of::<Array>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueList {
     pub mValue: nsCSSValue,
     pub mNext: *mut nsCSSValueList,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueList() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueList > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueList>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueList>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueList_heap {
     pub _base: nsCSSValueList,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueList_heap() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueList_heap > (  ) ,
-               40usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueList_heap>() , 40usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueList_heap>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueSharedList {
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
     pub mHead: *mut nsCSSValueList,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueSharedList() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueSharedList > (  ) ,
-               24usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueSharedList>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueSharedList>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSRect {
     pub mTop: nsCSSValue,
     pub mRight: nsCSSValue,
     pub mBottom: nsCSSValue,
     pub mLeft: nsCSSValue,
 }
 #[test]
 fn bindgen_test_layout_nsCSSRect() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSRect > (  ) , 64usize);
+    assert_eq!(::std::mem::size_of::<nsCSSRect>() , 64usize);
+    assert_eq!(::std::mem::align_of::<nsCSSRect>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSRect_heap {
     pub _base: nsCSSRect,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsCSSRect_heap() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSRect_heap > (  ) , 80usize);
+    assert_eq!(::std::mem::size_of::<nsCSSRect_heap>() , 80usize);
+    assert_eq!(::std::mem::align_of::<nsCSSRect_heap>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValuePair {
     pub mXValue: nsCSSValue,
     pub mYValue: nsCSSValue,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValuePair() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValuePair > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValuePair>() , 32usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValuePair>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValuePair_heap {
     pub _base: nsCSSValuePair,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValuePair_heap() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValuePair_heap > (  ) ,
-               48usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValuePair_heap>() , 48usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValuePair_heap>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueTriplet {
     pub mXValue: nsCSSValue,
     pub mYValue: nsCSSValue,
     pub mZValue: nsCSSValue,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueTriplet() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueTriplet > (  ) , 48usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueTriplet>() , 48usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueTriplet>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueTriplet_heap {
     pub _base: nsCSSValueTriplet,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueTriplet_heap() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueTriplet_heap > (  ) ,
-               64usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueTriplet_heap>() , 64usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueTriplet_heap>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValuePairList {
     pub mXValue: nsCSSValue,
     pub mYValue: nsCSSValue,
     pub mNext: *mut nsCSSValuePairList,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValuePairList() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValuePairList > (  ) ,
-               40usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValuePairList>() , 40usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValuePairList>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValuePairList_heap {
     pub _base: nsCSSValuePairList,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValuePairList_heap() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValuePairList_heap > (  ) ,
-               56usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValuePairList_heap>() , 56usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValuePairList_heap>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueGradientStop {
     pub mLocation: nsCSSValue,
     pub mColor: nsCSSValue,
     pub mIsInterpolationHint: bool,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueGradientStop() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueGradientStop > (  ) ,
-               40usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueGradientStop>() , 40usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueGradientStop>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueGradient {
     pub mIsRadial: bool,
     pub mIsRepeating: bool,
     pub mIsLegacySyntax: bool,
     pub mIsExplicitSize: bool,
     pub mBgPos: nsCSSValuePair,
     pub mAngle: nsCSSValue,
     pub mRadialValues: [nsCSSValue; 2usize],
     pub mStops: u64,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueGradient() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueGradient > (  ) ,
-               112usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueGradient>() , 112usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueGradient>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueTokenStream {
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
     pub mPropertyID: nsCSSProperty,
     pub mShorthandPropertyID: nsCSSProperty,
     pub mTokenStream: nsString,
@@ -3459,121 +3531,117 @@ pub struct nsCSSValueTokenStream {
     pub mSheetURI: nsCOMPtr<nsIURI>,
     pub mSheetPrincipal: nsCOMPtr<nsIPrincipal>,
     pub mLineNumber: u32,
     pub mLineOffset: u32,
     pub mLevel: SheetType,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueTokenStream() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueTokenStream > (  ) ,
-               80usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueTokenStream>() , 80usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueTokenStream>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSValueFloatColor {
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
     pub mComponent1: f32,
     pub mComponent2: f32,
     pub mComponent3: f32,
     pub mAlpha: f32,
 }
 #[test]
 fn bindgen_test_layout_nsCSSValueFloatColor() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSValueFloatColor > (  ) ,
-               32usize);
+    assert_eq!(::std::mem::size_of::<nsCSSValueFloatColor>() , 32usize);
+    assert_eq!(::std::mem::align_of::<nsCSSValueFloatColor>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSCornerSizes {
     pub mTopLeft: nsCSSValue,
     pub mTopRight: nsCSSValue,
     pub mBottomRight: nsCSSValue,
     pub mBottomLeft: nsCSSValue,
 }
 #[test]
 fn bindgen_test_layout_nsCSSCornerSizes() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSCornerSizes > (  ) , 64usize);
+    assert_eq!(::std::mem::size_of::<nsCSSCornerSizes>() , 64usize);
+    assert_eq!(::std::mem::align_of::<nsCSSCornerSizes>() , 8usize);
 }
 pub enum imgIContainer { }
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
 pub struct imgIRequest {
-    _bindgen_opaque_blob: [u64; 1usize],
+    pub _bindgen_opaque_blob: u64,
 }
 #[test]
 fn bindgen_test_layout_imgIRequest() {
-    assert_eq!(:: std:: mem:: size_of:: < imgIRequest > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<imgIRequest>() , 8usize);
+    assert_eq!(::std::mem::align_of::<imgIRequest>() , 8usize);
 }
 pub enum imgStatusNotifyRunnable { }
 pub enum ProxyBehaviour { }
 pub enum Image { }
 pub enum ImageURL { }
 pub enum ProgressTracker { }
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
 pub struct imgRequestProxy {
-    _bindgen_opaque_blob: [u64; 15usize],
+    pub _bindgen_opaque_blob: [u64; 15usize],
 }
 #[test]
 fn bindgen_test_layout_imgRequestProxy() {
-    assert_eq!(:: std:: mem:: size_of:: < imgRequestProxy > (  ) , 120usize);
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
+    assert_eq!(::std::mem::size_of::<imgRequestProxy>() , 120usize);
+    assert_eq!(::std::mem::align_of::<imgRequestProxy>() , 8usize);
+}
 pub struct imgRequestProxyStatic {
-    _bindgen_opaque_blob: [u64; 16usize],
+    pub _bindgen_opaque_blob: [u64; 16usize],
 }
 #[test]
 fn bindgen_test_layout_imgRequestProxyStatic() {
-    assert_eq!(:: std:: mem:: size_of:: < imgRequestProxyStatic > (  ) ,
-               128usize);
+    assert_eq!(::std::mem::size_of::<imgRequestProxyStatic>() , 128usize);
+    assert_eq!(::std::mem::align_of::<imgRequestProxyStatic>() , 8usize);
 }
 pub type CounterValue = i32;
 pub enum NegativeType { }
 pub enum PadType { }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct CounterStyle {
     pub _vftable: *const _vftable_CounterStyle,
     pub mStyle: i32,
 }
 #[repr(C)]
 pub struct _vftable_CounterStyle {
 }
 #[test]
 fn bindgen_test_layout_CounterStyle() {
-    assert_eq!(:: std:: mem:: size_of:: < CounterStyle > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<CounterStyle>() , 16usize);
+    assert_eq!(::std::mem::align_of::<CounterStyle>() , 8usize);
 }
 #[repr(C)]
 pub struct AnonymousCounterStyle {
     pub _base: CounterStyle,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
     pub mSingleString: bool,
     pub mSystem: u8,
     pub mSymbols: u64,
 }
 #[repr(C)]
 pub struct _vftable_AnonymousCounterStyle {
     pub _base: _vftable_CounterStyle,
 }
 #[test]
 fn bindgen_test_layout_AnonymousCounterStyle() {
-    assert_eq!(:: std:: mem:: size_of:: < AnonymousCounterStyle > (  ) ,
-               48usize);
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
+    assert_eq!(::std::mem::size_of::<AnonymousCounterStyle>() , 48usize);
+    assert_eq!(::std::mem::align_of::<AnonymousCounterStyle>() , 8usize);
+}
 pub struct CounterStyleManager {
-    _bindgen_opaque_blob: [u64; 9usize],
+    pub _bindgen_opaque_blob: [u64; 9usize],
 }
 #[test]
 fn bindgen_test_layout_CounterStyleManager() {
-    assert_eq!(:: std:: mem:: size_of:: < CounterStyleManager > (  ) ,
-               72usize);
+    assert_eq!(::std::mem::size_of::<CounterStyleManager>() , 72usize);
+    assert_eq!(::std::mem::align_of::<CounterStyleManager>() , 8usize);
 }
 pub enum nsIFrame { }
 pub enum nsStyleContext { }
 pub enum nsTextFrame { }
 #[repr(C)]
 pub struct nsStyleFont {
     pub mFont: nsFont,
     pub mSize: nscoord,
@@ -3586,28 +3654,29 @@ pub struct nsStyleFont {
     pub mAllowZoom: bool,
     pub mScriptUnconstrainedSize: nscoord,
     pub mScriptMinSize: nscoord,
     pub mScriptSizeMultiplier: f32,
     pub mLanguage: nsCOMPtr<nsIAtom>,
 }
 #[test]
 fn bindgen_test_layout_nsStyleFont() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleFont > (  ) , 120usize);
+    assert_eq!(::std::mem::size_of::<nsStyleFont>() , 120usize);
+    assert_eq!(::std::mem::align_of::<nsStyleFont>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleGradientStop {
     pub mLocation: nsStyleCoord,
     pub mColor: nscolor,
     pub mIsInterpolationHint: bool,
 }
 #[test]
 fn bindgen_test_layout_nsStyleGradientStop() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleGradientStop > (  ) ,
-               24usize);
+    assert_eq!(::std::mem::size_of::<nsStyleGradientStop>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleGradientStop>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleGradient {
     pub mShape: u8,
     pub mSize: u8,
     pub mRepeating: bool,
     pub mLegacySyntax: bool,
     pub mBgPosX: nsStyleCoord,
@@ -3616,17 +3685,18 @@ pub struct nsStyleGradient {
     pub mRadiusX: nsStyleCoord,
     pub mRadiusY: nsStyleCoord,
     pub mStops: u64,
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
 }
 #[test]
 fn bindgen_test_layout_nsStyleGradient() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleGradient > (  ) , 112usize);
+    assert_eq!(::std::mem::size_of::<nsStyleGradient>() , 112usize);
+    assert_eq!(::std::mem::align_of::<nsStyleGradient>() , 8usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsStyleImageType {
     eStyleImageType_Null = 0,
     eStyleImageType_Image = 1,
     eStyleImageType_Gradient = 2,
     eStyleImageType_Element = 3,
@@ -3652,25 +3722,27 @@ pub struct nsStyleImage {
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsStyleImage_nsStyleStruct_h_unnamed_11 {
     pub _bindgen_data_: u64,
 }
 impl nsStyleImage_nsStyleStruct_h_unnamed_11 { }
 #[test]
 fn bindgen_test_layout_nsStyleImage() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImage > (  ) , 40usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImage>() , 40usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImage>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleColor {
     pub mColor: nscolor,
 }
 #[test]
 fn bindgen_test_layout_nsStyleColor() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleColor > (  ) , 4usize);
+    assert_eq!(::std::mem::size_of::<nsStyleColor>() , 4usize);
+    assert_eq!(::std::mem::align_of::<nsStyleColor>() , 4usize);
 }
 #[repr(C)]
 pub struct nsStyleImageLayers {
     pub mAttachmentCount: u32,
     pub mClipCount: u32,
     pub mOriginCount: u32,
     pub mRepeatCount: u32,
     pub mPositionCount: u32,
@@ -3699,61 +3771,65 @@ pub enum nsStyleImageLayers_nsStyleStruc
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsStyleImageLayers_Position {
     pub mXPosition: nsStyleCoord_CalcValue,
     pub mYPosition: nsStyleCoord_CalcValue,
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageLayers_Position() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageLayers_Position > (  ) ,
+    assert_eq!(::std::mem::size_of::<nsStyleImageLayers_Position>() ,
                24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageLayers_Position>() ,
+               4usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsStyleImageLayers_Size {
     pub mWidth: nsStyleImageLayers_Size_Dimension,
     pub mHeight: nsStyleImageLayers_Size_Dimension,
     pub mWidthType: u8,
     pub mHeightType: u8,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsStyleImageLayers_Size_Dimension {
     pub _base: nsStyleCoord_CalcValue,
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageLayers_Size_Dimension() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageLayers_Size_Dimension >
-               (  ) , 12usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImageLayers_Size_Dimension>() ,
+               12usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageLayers_Size_Dimension>() ,
+               4usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsStyleImageLayers_Size_DimensionType {
     eContain = 0,
     eCover = 1,
     eAuto = 2,
     eLengthPercentage = 3,
     eDimensionType_COUNT = 4,
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageLayers_Size() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageLayers_Size > (  ) ,
-               28usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImageLayers_Size>() , 28usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageLayers_Size>() , 4usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsStyleImageLayers_Repeat {
     pub mXRepeat: u8,
     pub mYRepeat: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageLayers_Repeat() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageLayers_Repeat > (  ) ,
-               2usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImageLayers_Repeat>() , 2usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageLayers_Repeat>() , 1usize);
 }
 #[repr(C)]
 pub struct nsStyleImageLayers_Layer {
     pub mImage: nsStyleImage,
     pub mSourceURI: nsCOMPtr<nsIURI>,
     pub mPosition: nsStyleImageLayers_Position,
     pub mSize: nsStyleImageLayers_Size,
     pub mClip: u8,
@@ -3761,87 +3837,92 @@ pub struct nsStyleImageLayers_Layer {
     pub mAttachment: u8,
     pub mBlendMode: u8,
     pub mComposite: u8,
     pub mMaskMode: u8,
     pub mRepeat: nsStyleImageLayers_Repeat,
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageLayers_Layer() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageLayers_Layer > (  ) ,
-               112usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImageLayers_Layer>() , 112usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageLayers_Layer>() , 8usize);
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageLayers() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageLayers > (  ) ,
-               168usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImageLayers>() , 168usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageLayers>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleBackground {
     pub mImage: nsStyleImageLayers,
     pub mBackgroundColor: nscolor,
 }
 #[test]
 fn bindgen_test_layout_nsStyleBackground() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleBackground > (  ) ,
-               176usize);
+    assert_eq!(::std::mem::size_of::<nsStyleBackground>() , 176usize);
+    assert_eq!(::std::mem::align_of::<nsStyleBackground>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleMargin {
     pub mMargin: nsStyleSides,
     pub mHasCachedMargin: bool,
     pub mCachedMargin: nsMargin,
 }
 #[test]
 fn bindgen_test_layout_nsStyleMargin() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleMargin > (  ) , 64usize);
+    assert_eq!(::std::mem::size_of::<nsStyleMargin>() , 64usize);
+    assert_eq!(::std::mem::align_of::<nsStyleMargin>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStylePadding {
     pub mPadding: nsStyleSides,
     pub mHasCachedPadding: bool,
     pub mCachedPadding: nsMargin,
 }
 #[test]
 fn bindgen_test_layout_nsStylePadding() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStylePadding > (  ) , 64usize);
+    assert_eq!(::std::mem::size_of::<nsStylePadding>() , 64usize);
+    assert_eq!(::std::mem::align_of::<nsStylePadding>() , 8usize);
 }
 #[repr(C)]
 pub struct nsBorderColors {
     pub mNext: *mut nsBorderColors,
     pub mColor: nscolor,
 }
 #[test]
 fn bindgen_test_layout_nsBorderColors() {
-    assert_eq!(:: std:: mem:: size_of:: < nsBorderColors > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsBorderColors>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsBorderColors>() , 8usize);
 }
 #[repr(C)]
 pub struct nsCSSShadowItem {
     pub mXOffset: nscoord,
     pub mYOffset: nscoord,
     pub mRadius: nscoord,
     pub mSpread: nscoord,
     pub mColor: nscolor,
     pub mHasColor: bool,
     pub mInset: bool,
 }
 #[test]
 fn bindgen_test_layout_nsCSSShadowItem() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSShadowItem > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsCSSShadowItem>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsCSSShadowItem>() , 4usize);
 }
 #[repr(C)]
 pub struct nsCSSShadowArray {
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
     pub mLength: u32,
     pub mArray: [nsCSSShadowItem; 1usize],
 }
 #[test]
 fn bindgen_test_layout_nsCSSShadowArray() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCSSShadowArray > (  ) , 48usize);
+    assert_eq!(::std::mem::size_of::<nsCSSShadowArray>() , 48usize);
+    assert_eq!(::std::mem::align_of::<nsCSSShadowArray>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleBorder {
     pub mBorderColors: *mut *mut nsBorderColors,
     pub mBoxShadow: RefPtr<nsCSSShadowArray>,
     pub mBorderRadius: nsStyleCorners,
     pub mBorderImageSource: nsStyleImage,
     pub mBorderImageSlice: nsStyleSides,
@@ -3855,69 +3936,73 @@ pub struct nsStyleBorder {
     pub mComputedBorder: nsMargin,
     pub mBorder: nsMargin,
     pub mBorderStyle: [u8; 4usize],
     pub mBorderColor: [nscolor; 4usize],
     pub mTwipsPerPixel: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsStyleBorder() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleBorder > (  ) , 312usize);
+    assert_eq!(::std::mem::size_of::<nsStyleBorder>() , 312usize);
+    assert_eq!(::std::mem::align_of::<nsStyleBorder>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleOutline {
     pub mOutlineRadius: nsStyleCorners,
     pub mOutlineWidth: nsStyleCoord,
     pub mOutlineOffset: nscoord,
     pub mCachedOutlineWidth: nscoord,
     pub mOutlineColor: nscolor,
     pub mHasCachedOutline: bool,
     pub mOutlineStyle: u8,
     pub mTwipsPerPixel: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsStyleOutline() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleOutline > (  ) , 112usize);
+    assert_eq!(::std::mem::size_of::<nsStyleOutline>() , 112usize);
+    assert_eq!(::std::mem::align_of::<nsStyleOutline>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleList {
     pub mListStylePosition: u8,
     pub mListStyleType: nsString,
     pub mCounterStyle: RefPtr<CounterStyle>,
     pub mListStyleImage: RefPtr<imgRequestProxy>,
     pub mImageRegion: nsRect,
 }
 #[test]
 fn bindgen_test_layout_nsStyleList() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleList > (  ) , 56usize);
+    assert_eq!(::std::mem::size_of::<nsStyleList>() , 56usize);
+    assert_eq!(::std::mem::align_of::<nsStyleList>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleGridLine {
     pub mHasSpan: bool,
     pub mInteger: i32,
     pub mLineName: nsString,
 }
 #[test]
 fn bindgen_test_layout_nsStyleGridLine() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleGridLine > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsStyleGridLine>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleGridLine>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleGridTemplate {
     pub mLineNameLists: u64,
     pub mMinTrackSizingFunctions: u64,
     pub mMaxTrackSizingFunctions: u64,
     pub mRepeatAutoLineNameListBefore: u64,
     pub mRepeatAutoLineNameListAfter: u64,
     pub mRepeatAutoIndex: i16,
     pub _bitfield_1: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleGridTemplate() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleGridTemplate > (  ) ,
-               48usize);
+    assert_eq!(::std::mem::size_of::<nsStyleGridTemplate>() , 48usize);
+    assert_eq!(::std::mem::align_of::<nsStyleGridTemplate>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStylePosition {
     pub mObjectPosition: nsStyleImageLayers_Position,
     pub mOffset: nsStyleSides,
     pub mWidth: nsStyleCoord,
     pub mMinWidth: nsStyleCoord,
     pub mMaxWidth: nsStyleCoord,
@@ -3951,51 +4036,53 @@ pub struct nsStylePosition {
     pub mGridColumnEnd: nsStyleGridLine,
     pub mGridRowStart: nsStyleGridLine,
     pub mGridRowEnd: nsStyleGridLine,
     pub mGridColumnGap: nscoord,
     pub mGridRowGap: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsStylePosition() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStylePosition > (  ) , 496usize);
+    assert_eq!(::std::mem::size_of::<nsStylePosition>() , 496usize);
+    assert_eq!(::std::mem::align_of::<nsStylePosition>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleTextOverflowSide {
     pub mString: nsString,
     pub mType: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleTextOverflowSide() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleTextOverflowSide > (  ) ,
-               24usize);
+    assert_eq!(::std::mem::size_of::<nsStyleTextOverflowSide>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleTextOverflowSide>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleTextOverflow {
     pub mLeft: nsStyleTextOverflowSide,
     pub mRight: nsStyleTextOverflowSide,
     pub mLogicalDirections: bool,
 }
 #[test]
 fn bindgen_test_layout_nsStyleTextOverflow() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleTextOverflow > (  ) ,
-               56usize);
+    assert_eq!(::std::mem::size_of::<nsStyleTextOverflow>() , 56usize);
+    assert_eq!(::std::mem::align_of::<nsStyleTextOverflow>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleTextReset {
     pub mVerticalAlign: nsStyleCoord,
     pub mTextOverflow: nsStyleTextOverflow,
     pub mTextDecorationLine: u8,
     pub mUnicodeBidi: u8,
     pub mTextDecorationStyle: u8,
     pub mTextDecorationColor: nscolor,
 }
 #[test]
 fn bindgen_test_layout_nsStyleTextReset() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleTextReset > (  ) , 80usize);
+    assert_eq!(::std::mem::size_of::<nsStyleTextReset>() , 80usize);
+    assert_eq!(::std::mem::align_of::<nsStyleTextReset>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleText {
     pub mTextAlign: u8,
     pub mTextAlignLast: u8,
     pub _bitfield_1: u8,
     pub mTextTransform: u8,
     pub mWhiteSpace: u8,
@@ -4006,26 +4093,28 @@ pub struct nsStyleText {
     pub mRubyPosition: u8,
     pub mTextSizeAdjust: u8,
     pub mTextCombineUpright: u8,
     pub mControlCharacterVisibility: u8,
     pub mTextEmphasisPosition: u8,
     pub mTextEmphasisStyle: u8,
     pub mTabSize: i32,
     pub mTextEmphasisColor: nscolor,
+    pub mWebkitTextFillColor: nscolor,
     pub mWordSpacing: nsStyleCoord,
     pub mLetterSpacing: nsStyleCoord,
     pub mLineHeight: nsStyleCoord,
     pub mTextIndent: nsStyleCoord,
     pub mTextShadow: RefPtr<nsCSSShadowArray>,
     pub mTextEmphasisStyleString: nsString,
 }
 #[test]
 fn bindgen_test_layout_nsStyleText() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleText > (  ) , 112usize);
+    assert_eq!(::std::mem::size_of::<nsStyleText>() , 120usize);
+    assert_eq!(::std::mem::align_of::<nsStyleText>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsStyleImageOrientation {
     pub mOrientation: u8,
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
@@ -4039,31 +4128,32 @@ pub enum nsStyleImageOrientation_Bits {
 pub enum nsStyleImageOrientation_Angles {
     ANGLE_0 = 0,
     ANGLE_90 = 1,
     ANGLE_180 = 2,
     ANGLE_270 = 3,
 }
 #[test]
 fn bindgen_test_layout_nsStyleImageOrientation() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleImageOrientation > (  ) ,
-               1usize);
+    assert_eq!(::std::mem::size_of::<nsStyleImageOrientation>() , 1usize);
+    assert_eq!(::std::mem::align_of::<nsStyleImageOrientation>() , 1usize);
 }
 #[repr(C)]
 pub struct nsStyleVisibility {
     pub mImageOrientation: nsStyleImageOrientation,
     pub mDirection: u8,
     pub mVisible: u8,
     pub mPointerEvents: u8,
     pub mWritingMode: u8,
     pub mTextOrientation: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleVisibility() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleVisibility > (  ) , 6usize);
+    assert_eq!(::std::mem::size_of::<nsStyleVisibility>() , 6usize);
+    assert_eq!(::std::mem::align_of::<nsStyleVisibility>() , 1usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsTimingFunction {
     pub mType: nsTimingFunction_Type,
     pub nsStyleStruct_h_unnamed_13: nsTimingFunction_nsStyleStruct_h_unnamed_13,
 }
 #[repr(i32)]
@@ -4092,44 +4182,47 @@ pub enum nsTimingFunction_Keyword { Impl
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsTimingFunction_nsStyleStruct_h_unnamed_13 {
     pub _bindgen_data_: [u32; 4usize],
 }
 impl nsTimingFunction_nsStyleStruct_h_unnamed_13 { }
 #[test]
 fn bindgen_test_layout_nsTimingFunction() {
-    assert_eq!(:: std:: mem:: size_of:: < nsTimingFunction > (  ) , 20usize);
+    assert_eq!(::std::mem::size_of::<nsTimingFunction>() , 20usize);
+    assert_eq!(::std::mem::align_of::<nsTimingFunction>() , 4usize);
 }
 #[repr(C)]
 pub struct StyleTransition {
     pub mTimingFunction: nsTimingFunction,
     pub mDuration: f32,
     pub mDelay: f32,
     pub mProperty: nsCSSProperty,
     pub mUnknownProperty: nsCOMPtr<nsIAtom>,
 }
 #[test]
 fn bindgen_test_layout_StyleTransition() {
-    assert_eq!(:: std:: mem:: size_of:: < StyleTransition > (  ) , 40usize);
+    assert_eq!(::std::mem::size_of::<StyleTransition>() , 40usize);
+    assert_eq!(::std::mem::align_of::<StyleTransition>() , 8usize);
 }
 #[repr(C)]
 pub struct StyleAnimation {
     pub mTimingFunction: nsTimingFunction,
     pub mDuration: f32,
     pub mDelay: f32,
     pub mName: nsString,
     pub mDirection: PlaybackDirection,
     pub mFillMode: FillMode,
     pub mPlayState: u8,
     pub mIterationCount: f32,
 }
 #[test]
 fn bindgen_test_layout_StyleAnimation() {
-    assert_eq!(:: std:: mem:: size_of:: < StyleAnimation > (  ) , 64usize);
+    assert_eq!(::std::mem::size_of::<StyleAnimation>() , 64usize);
+    assert_eq!(::std::mem::align_of::<StyleAnimation>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleDisplay {
     pub mBinding: RefPtr<URLValue>,
     pub mClip: nsRect,
     pub mOpacity: f32,
     pub mDisplay: u8,
     pub mOriginalDisplay: u8,
@@ -4180,39 +4273,41 @@ pub struct nsStyleDisplay {
     pub mAnimationNameCount: u32,
     pub mAnimationDirectionCount: u32,
     pub mAnimationFillModeCount: u32,
     pub mAnimationPlayStateCount: u32,
     pub mAnimationIterationCountCount: u32,
 }
 #[test]
 fn bindgen_test_layout_nsStyleDisplay() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleDisplay > (  ) , 456usize);
+    assert_eq!(::std::mem::size_of::<nsStyleDisplay>() , 456usize);
+    assert_eq!(::std::mem::align_of::<nsStyleDisplay>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleTable {
     pub mLayoutStrategy: u8,
     pub mSpan: i32,
 }
 #[test]
 fn bindgen_test_layout_nsStyleTable() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleTable > (  ) , 8usize);
+    assert_eq!(::std::mem::size_of::<nsStyleTable>() , 8usize);
+    assert_eq!(::std::mem::align_of::<nsStyleTable>() , 4usize);
 }
 #[repr(C)]
 pub struct nsStyleTableBorder {
     pub mBorderSpacingCol: nscoord,
     pub mBorderSpacingRow: nscoord,
     pub mBorderCollapse: u8,
     pub mCaptionSide: u8,
     pub mEmptyCells: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleTableBorder() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleTableBorder > (  ) ,
-               12usize);
+    assert_eq!(::std::mem::size_of::<nsStyleTableBorder>() , 12usize);
+    assert_eq!(::std::mem::align_of::<nsStyleTableBorder>() , 4usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsStyleContentType {
     eStyleContentType_String = 1,
     eStyleContentType_Image = 10,
     eStyleContentType_Attr = 20,
     eStyleContentType_Counter = 30,
@@ -4233,118 +4328,124 @@ pub struct nsStyleContentData {
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsStyleContentData_nsStyleStruct_h_unnamed_16 {
     pub _bindgen_data_: u64,
 }
 impl nsStyleContentData_nsStyleStruct_h_unnamed_16 { }
 #[test]
 fn bindgen_test_layout_nsStyleContentData() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleContentData > (  ) ,
-               24usize);
+    assert_eq!(::std::mem::size_of::<nsStyleContentData>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleContentData>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleCounterData {
     pub mCounter: nsString,
     pub mValue: i32,
 }
 #[test]
 fn bindgen_test_layout_nsStyleCounterData() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleCounterData > (  ) ,
-               24usize);
+    assert_eq!(::std::mem::size_of::<nsStyleCounterData>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleCounterData>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleQuotes {
     pub mQuotesCount: u32,
     pub mQuotes: *mut nsString,
 }
 #[test]
 fn bindgen_test_layout_nsStyleQuotes() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleQuotes > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsStyleQuotes>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsStyleQuotes>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleContent {
     pub mMarkerOffset: nsStyleCoord,
     pub mContents: *mut nsStyleContentData,
     pub mIncrements: *mut nsStyleCounterData,
     pub mResets: *mut nsStyleCounterData,
     pub mContentCount: u32,
     pub mIncrementCount: u32,
     pub mResetCount: u32,
 }
 #[test]
 fn bindgen_test_layout_nsStyleContent() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleContent > (  ) , 56usize);
+    assert_eq!(::std::mem::size_of::<nsStyleContent>() , 56usize);
+    assert_eq!(::std::mem::align_of::<nsStyleContent>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleUIReset {
     pub mUserSelect: u8,
     pub mForceBrokenImageIcon: u8,
     pub mIMEMode: u8,
     pub mWindowDragging: u8,
     pub mWindowShadow: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleUIReset() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleUIReset > (  ) , 5usize);
+    assert_eq!(::std::mem::size_of::<nsStyleUIReset>() , 5usize);
+    assert_eq!(::std::mem::align_of::<nsStyleUIReset>() , 1usize);
 }
 #[repr(C)]
 pub struct nsCursorImage {
     pub mHaveHotspot: bool,
     pub mHotspotX: f32,
     pub mHotspotY: f32,
     pub mImage: nsCOMPtr<imgIRequest>,
 }
 #[test]
 fn bindgen_test_layout_nsCursorImage() {
-    assert_eq!(:: std:: mem:: size_of:: < nsCursorImage > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsCursorImage>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsCursorImage>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleUserInterface {
     pub mUserInput: u8,
     pub mUserModify: u8,
     pub mUserFocus: u8,
     pub mCursor: u8,
     pub mCursorArrayLength: u32,
     pub mCursorArray: *mut nsCursorImage,
 }
 #[test]
 fn bindgen_test_layout_nsStyleUserInterface() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleUserInterface > (  ) ,
-               16usize);
+    assert_eq!(::std::mem::size_of::<nsStyleUserInterface>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsStyleUserInterface>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleXUL {
     pub mBoxFlex: f32,
     pub mBoxOrdinal: u32,
     pub mBoxAlign: u8,
     pub mBoxDirection: u8,
     pub mBoxOrient: u8,
     pub mBoxPack: u8,
     pub mStretchStack: bool,
 }
 #[test]
 fn bindgen_test_layout_nsStyleXUL() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleXUL > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsStyleXUL>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsStyleXUL>() , 4usize);
 }
 #[repr(C)]
 pub struct nsStyleColumn {
     pub mColumnCount: u32,
     pub mColumnWidth: nsStyleCoord,
     pub mColumnGap: nsStyleCoord,
     pub mColumnRuleColor: nscolor,
     pub mColumnRuleStyle: u8,
     pub mColumnFill: u8,
     pub mColumnRuleColorIsForeground: bool,
     pub mColumnRuleWidth: nscoord,
     pub mTwipsPerPixel: nscoord,
 }
 #[test]
 fn bindgen_test_layout_nsStyleColumn() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleColumn > (  ) , 56usize);
+    assert_eq!(::std::mem::size_of::<nsStyleColumn>() , 56usize);
+    assert_eq!(::std::mem::align_of::<nsStyleColumn>() , 8usize);
 }
 #[repr(u32)]
 #[derive(Copy, Clone, Debug)]
 pub enum nsStyleSVGPaintType {
     eStyleSVGPaintType_None = 1,
     eStyleSVGPaintType_Color = 2,
     eStyleSVGPaintType_Server = 3,
     eStyleSVGPaintType_ContextFill = 4,
@@ -4366,17 +4467,18 @@ pub struct nsStyleSVGPaint {
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsStyleSVGPaint_nsStyleStruct_h_unnamed_17 {
     pub _bindgen_data_: u64,
 }
 impl nsStyleSVGPaint_nsStyleStruct_h_unnamed_17 { }
 #[test]
 fn bindgen_test_layout_nsStyleSVGPaint() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleSVGPaint > (  ) , 16usize);
+    assert_eq!(::std::mem::size_of::<nsStyleSVGPaint>() , 16usize);
+    assert_eq!(::std::mem::align_of::<nsStyleSVGPaint>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleSVG {
     pub mFill: nsStyleSVGPaint,
     pub mStroke: nsStyleSVGPaint,
     pub mMarkerEnd: nsCOMPtr<nsIURI>,
     pub mMarkerMid: nsCOMPtr<nsIURI>,
     pub mMarkerStart: nsCOMPtr<nsIURI>,
@@ -4399,17 +4501,18 @@ pub struct nsStyleSVG {
     pub mTextAnchor: u8,
     pub mTextRendering: u8,
     pub _bitfield_1: nsStyleSVGOpacitySource,
     pub _bitfield_2: nsStyleSVGOpacitySource,
     pub _bitfield_3: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleSVG() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleSVG > (  ) , 128usize);
+    assert_eq!(::std::mem::size_of::<nsStyleSVG>() , 128usize);
+    assert_eq!(::std::mem::align_of::<nsStyleSVG>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleBasicShape {
     pub mRefCnt: nsAutoRefCnt,
     pub _mOwningThread: nsAutoOwningThread,
     pub mType: nsStyleBasicShape_Type,
     pub mFillRule: i32,
     pub mCoordinates: u64,
@@ -4421,50 +4524,52 @@ pub struct nsStyleBasicShape {
 pub enum nsStyleBasicShape_Type {
     eInset = 0,
     eCircle = 1,
     eEllipse = 2,
     ePolygon = 3,
 }
 #[test]
 fn bindgen_test_layout_nsStyleBasicShape() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleBasicShape > (  ) ,
-               128usize);
+    assert_eq!(::std::mem::size_of::<nsStyleBasicShape>() , 128usize);
+    assert_eq!(::std::mem::align_of::<nsStyleBasicShape>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleClipPath {
     pub mType: i32,
     pub nsStyleStruct_h_unnamed_18: nsStyleClipPath_nsStyleStruct_h_unnamed_18,
     pub mSizingBox: u8,
 }
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsStyleClipPath_nsStyleStruct_h_unnamed_18 {
     pub _bindgen_data_: u64,
 }
 impl nsStyleClipPath_nsStyleStruct_h_unnamed_18 { }
 #[test]
 fn bindgen_test_layout_nsStyleClipPath() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleClipPath > (  ) , 24usize);
+    assert_eq!(::std::mem::size_of::<nsStyleClipPath>() , 24usize);
+    assert_eq!(::std::mem::align_of::<nsStyleClipPath>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleFilter {
     pub mType: i32,
     pub mFilterParameter: nsStyleCoord,
     pub nsStyleStruct_h_unnamed_19: nsStyleFilter_nsStyleStruct_h_unnamed_19,
 }
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct nsStyleFilter_nsStyleStruct_h_unnamed_19 {
     pub _bindgen_data_: u64,
 }
 impl nsStyleFilter_nsStyleStruct_h_unnamed_19 { }
 #[test]
 fn bindgen_test_layout_nsStyleFilter() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleFilter > (  ) , 32usize);
+    assert_eq!(::std::mem::size_of::<nsStyleFilter>() , 32usize);
+    assert_eq!(::std::mem::align_of::<nsStyleFilter>() , 8usize);
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct nsTArray_CopyChooser;
 #[repr(C)]
 pub struct nsStyleSVGReset {
     pub mMask: nsStyleImageLayers,
     pub mClipPath: nsStyleClipPath,
@@ -4475,18 +4580,20 @@ pub struct nsStyleSVGReset {
     pub mStopOpacity: f32,
     pub mFloodOpacity: f32,
     pub mDominantBaseline: u8,
     pub mVectorEffect: u8,
     pub mMaskType: u8,
 }
 #[test]
 fn bindgen_test_layout_nsStyleSVGReset() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleSVGReset > (  ) , 224usize);
+    assert_eq!(::std::mem::size_of::<nsStyleSVGReset>() , 224usize);
+    assert_eq!(::std::mem::align_of::<nsStyleSVGReset>() , 8usize);
 }
 #[repr(C)]
 pub struct nsStyleVariables {
     pub mVariables: CSSVariableValues,
 }
 #[test]
 fn bindgen_test_layout_nsStyleVariables() {
-    assert_eq!(:: std:: mem:: size_of:: < nsStyleVariables > (  ) , 56usize);
-}
+    assert_eq!(::std::mem::size_of::<nsStyleVariables>() , 56usize);
+    assert_eq!(::std::mem::align_of::<nsStyleVariables>() , 8usize);
+}
--- a/servo/ports/geckolib/glue.rs
+++ b/servo/ports/geckolib/glue.rs
@@ -2,17 +2,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #![allow(unsafe_code)]
 
 use app_units::Au;
 use bindings::{RawGeckoDocument, RawGeckoElement};
 use bindings::{RawServoStyleSet, RawServoStyleSheet, ServoComputedValues, ServoNodeData};
-use bindings::{nsIAtom, uint8_t, uint32_t};
+use bindings::{nsIAtom};
 use data::PerDocumentStyleData;
 use euclid::Size2D;
 use properties::GeckoComputedValues;
 use selector_impl::{SharedStyleContext, Stylesheet};
 use std::marker::PhantomData;
 use std::mem::{forget, transmute};
 use std::ptr;
 use std::slice;
@@ -68,18 +68,18 @@ pub extern "C" fn Servo_RestyleDocument(
 #[no_mangle]
 pub extern "C" fn Servo_DropNodeData(data: *mut ServoNodeData) -> () {
     unsafe {
         let _ = Box::<NonOpaqueStyleData>::from_raw(data as *mut NonOpaqueStyleData);
     }
 }
 
 #[no_mangle]
-pub extern "C" fn Servo_StylesheetFromUTF8Bytes(bytes: *const uint8_t,
-                                                length: uint32_t) -> *mut RawServoStyleSheet {
+pub extern "C" fn Servo_StylesheetFromUTF8Bytes(bytes: *const u8,
+                                                length: u32) -> *mut RawServoStyleSheet {
 
     let input = unsafe { from_utf8_unchecked(slice::from_raw_parts(bytes, length as usize)) };
 
     // FIXME(heycam): Pass in the real base URL and sheet origin to use.
     let url = Url::parse("about:none").unwrap();
     let sheet = Arc::new(Stylesheet::from_str(input, url, Origin::Author, Box::new(StdoutErrorReporter)));
     unsafe {
         transmute(sheet)
@@ -170,17 +170,18 @@ pub extern "C" fn Servo_ReleaseStyleShee
 pub extern "C" fn Servo_GetComputedValues(element: *mut RawGeckoElement)
      -> *mut ServoComputedValues {
     let node = unsafe { GeckoElement::from_raw(element).as_node() };
     let arc_cv = node.borrow_data().map(|data| data.style.clone());
     arc_cv.map_or(ptr::null_mut(), |arc| unsafe { transmute(arc) })
 }
 
 #[no_mangle]
-pub extern "C" fn Servo_GetComputedValuesForAnonymousBox(_: *mut nsIAtom)
+pub extern "C" fn Servo_GetComputedValuesForAnonymousBox(_parentStyleOrNull: *mut ServoComputedValues,
+                                                         _pseudoTag: *mut nsIAtom)
      -> *mut ServoComputedValues {
     unimplemented!();
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_AddRefComputedValues(ptr: *mut ServoComputedValues) -> () {
     type Helpers = ArcHelpers<ServoComputedValues, GeckoComputedValues>;
     unsafe { Helpers::addref(ptr) };
--- a/servo/ports/geckolib/tools/regen_bindings.sh
+++ b/servo/ports/geckolib/tools/regen_bindings.sh
@@ -30,9 +30,11 @@ fi
 # The absolute path is required to allow launching lldb with an untrusted
 # library in DYLD_LIBRARY_PATH.
 #
 # /Applications/Xcode.app/Contents/Developer/usr/bin/lldb --
 ./rust-bindgen/target/debug/bindgen                \
   -x c++ -std=gnu++0x                              \
   "-I$DIST_INCLUDE"                                \
   -o ../bindings.rs                                \
-  "$DIST_INCLUDE/mozilla/ServoBindings.h"
+  -no-type-renaming                                \
+  "$DIST_INCLUDE/mozilla/ServoBindings.h"          \
+  -match "ServoBindings.h"                         \
--- a/servo/ports/geckolib/tools/regen_style_structs.sh
+++ b/servo/ports/geckolib/tools/regen_style_structs.sh
@@ -23,17 +23,17 @@ export DIST_INCLUDE="$1/dist/include"
 CLANG_SEARCH_DIRS=$(clang++ -E -x c++ - -v < /dev/null 2>&1 | awk '{ \
   if ($0 == "#include <...> search starts here:")                    \
     in_headers = 1;                                                  \
   else if ($0 == "End of search list.")                              \
     in_headers = 0;                                                  \
   else if (in_headers == 1) {                                        \
     gsub(/^[ \t]+/, "", $0);                                         \
     gsub(/[ \t].+$/, "", $0);                                        \
-    printf " -isystem \"%s\"", $0;                                   \
+    printf " -isystem %s", $0;                                       \
   }
 }' | sed -e s/:$//g)
 
 # Check for the include directory.
 if [ ! -d "$DIST_INCLUDE" ]; then
   echo "$DIST_INCLUDE: directory not found"
   exit 1
 fi