merge autoland to mozilla-central. r=merge a=merge
authorSebastian Hengst <archaeopteryx@coole-files.de>
Mon, 14 Aug 2017 01:28:24 +0200
changeset 645673 e594b178728bc6a51fc81bffcb1d6f0a7071cd33
parent 645649 e928c65095ed32151bbe6e462eda3e8c79edca9f (current diff)
parent 645672 946e48295eb0d4553c983d086420c8da20bd63be (diff)
child 645674 3bfcbdf5c6c381d5a8febb5c209e27a69fb89f9b
push id73826
push userbmo:gasolin@mozilla.com
push dateMon, 14 Aug 2017 01:51:50 +0000
reviewersmerge, merge
milestone57.0a1
merge autoland to mozilla-central. r=merge a=merge MozReview-Commit-ID: GUnN9pacyFH
testing/web-platform/meta/selection/addRange-08.html.ini
testing/web-platform/meta/selection/addRange-40.html.ini
testing/web-platform/meta/selection/addRange-44.html.ini
testing/web-platform/meta/selection/addRange-48.html.ini
testing/web-platform/meta/selection/addRange-52.html.ini
testing/web-platform/meta/selection/addRange-56.html.ini
testing/web-platform/meta/selection/collapse-00.html.ini
testing/web-platform/meta/selection/collapse-15.html.ini
testing/web-platform/meta/selection/collapse-30.html.ini
testing/web-platform/meta/selection/collapse-45.html.ini
testing/web-platform/meta/selection/collapseToStartEnd.html.ini
testing/web-platform/meta/selection/extend-00.html.ini
testing/web-platform/meta/selection/extend-20.html.ini
testing/web-platform/meta/selection/extend-40.html.ini
testing/web-platform/meta/selection/isCollapsed.html.ini
testing/web-platform/meta/selection/removeAllRanges.html.ini
testing/web-platform/meta/selection/selectAllChildren.html.ini
toolkit/mozapps/extensions/test/xpcshell/test_seen_newprofile.js
--- a/browser/base/content/aboutNetError.xhtml
+++ b/browser/base/content/aboutNetError.xhtml
@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <!DOCTYPE html [
   <!ENTITY % htmlDTD
     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
     "DTD/xhtml1-strict.dtd">
   %htmlDTD;
   <!ENTITY % netErrorDTD
-    SYSTEM "chrome://global/locale/netError.dtd">
+    SYSTEM "chrome://browser/locale/netError.dtd">
   %netErrorDTD;
   <!ENTITY % globalDTD
     SYSTEM "chrome://global/locale/global.dtd">
   %globalDTD;
 ]>
 
 <!-- This Source Code Form is subject to the terms of the Mozilla Public
    - License, v. 2.0. If a copy of the MPL was not distributed with this
--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -4197,42 +4197,42 @@ BitIsPropagated(const Element* aElement)
                   parentNode == parentNode->OwnerDoc()->GetRootElement());
   }
   return true;
 }
 #endif
 
 template<typename Traits>
 void
-NoteDirtyContent(nsIContent* aContent)
+NoteDirtyElement(Element* aElement)
 {
-  MOZ_ASSERT(aContent->IsInComposedDoc());
-  nsIDocument* doc = aContent->GetComposedDoc();
+  MOZ_ASSERT(aElement->IsInComposedDoc());
+  nsIDocument* doc = aElement->GetComposedDoc();
   nsIPresShell* shell = doc->GetShell();
   NS_ENSURE_TRUE_VOID(shell);
   shell->EnsureStyleFlush();
 
-  Element* parent = aContent->GetFlattenedTreeParentElementForStyle();
+  Element* parent = aElement->GetFlattenedTreeParentElementForStyle();
   if (!parent || !parent->HasServoData()) {
     // The bits only apply to styled elements.
     return;
   }
 
   Element* curr = parent;
   while (curr && !Traits::HasBit(curr)) {
     Traits::SetBit(curr);
     curr = curr->GetFlattenedTreeParentElementForStyle();
   }
 
   MOZ_ASSERT(BitIsPropagated<Traits>(parent));
 }
 
 void
-nsIContent::NoteDirtyForServo()
+Element::NoteDirtyForServo()
 {
-  NoteDirtyContent<DirtyDescendantsBit>(this);
+  NoteDirtyElement<DirtyDescendantsBit>(this);
 }
 
 void
-nsIContent::NoteAnimationOnlyDirtyForServo()
+Element::NoteAnimationOnlyDirtyForServo()
 {
-  NoteDirtyContent<AnimationOnlyDirtyDescendantsBit>(this);
+  NoteDirtyElement<AnimationOnlyDirtyDescendantsBit>(this);
 }
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -463,16 +463,19 @@ public:
       UpdateState(true);
     }
   }
 
   bool GetBindingURL(nsIDocument* aDocument, css::URLValue **aResult);
 
   Directionality GetComputedDirectionality() const;
 
+  void NoteDirtyForServo();
+  void NoteAnimationOnlyDirtyForServo();
+
   bool HasDirtyDescendantsForServo() const
   {
     MOZ_ASSERT(IsStyledByServo());
     return HasFlag(ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO);
   }
 
   void SetHasDirtyDescendantsForServo() {
     MOZ_ASSERT(IsStyledByServo());
--- a/dom/base/Selection.cpp
+++ b/dom/base/Selection.cpp
@@ -2476,16 +2476,31 @@ Selection::Collapse(nsINode* aContainer,
 void
 Selection::Collapse(nsINode& aContainer, uint32_t aOffset, ErrorResult& aRv)
 {
   if (!mFrameSelection) {
     aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection
     return;
   }
 
+  if (aContainer.NodeType() == nsIDOMNode::DOCUMENT_TYPE_NODE) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
+    return;
+  }
+
+  if (aOffset > aContainer.Length()) {
+    aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+    return;
+  }
+
+  if (!HasSameRoot(aContainer)) {
+    // Return with no error
+    return;
+  }
+
   nsCOMPtr<nsINode> container = &aContainer;
 
   RefPtr<nsFrameSelection> frameSelection = mFrameSelection;
   frameSelection->InvalidateDesiredPos();
   if (!IsValidSelectionPoint(frameSelection, container)) {
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
@@ -2875,16 +2890,21 @@ Selection::Extend(nsINode& aContainer, u
     return;
   }
 
   if (!mFrameSelection) {
     aRv.Throw(NS_ERROR_NOT_INITIALIZED); // Can't do selection
     return;
   }
 
+  if (!HasSameRoot(aContainer)) {
+    // Return with no error
+    return;
+  }
+
   nsresult res;
   if (!IsValidSelectionPoint(mFrameSelection, &aContainer)) {
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
 
   RefPtr<nsPresContext> presContext = GetPresContext();
   if (!presContext || presContext->Document() != aContainer.OwnerDoc()) {
@@ -3164,16 +3184,26 @@ Selection::SelectAllChildrenJS(nsINode& 
   AutoRestore<bool> calledFromJSRestorer(mCalledByJS);
   mCalledByJS = true;
   SelectAllChildren(aNode, aRv);
 }
 
 void
 Selection::SelectAllChildren(nsINode& aNode, ErrorResult& aRv)
 {
+  if (aNode.NodeType() == nsIDOMNode::DOCUMENT_TYPE_NODE) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
+    return;
+  }
+
+  if (!HasSameRoot(aNode)) {
+    // Return with no error
+    return;
+  }
+
   if (mFrameSelection) {
     mFrameSelection->PostReason(nsISelectionListener::SELECTALL_REASON);
   }
   SelectionBatcher batch(this);
 
   Collapse(aNode, 0, aRv);
   if (aRv.Failed()) {
     return;
@@ -3966,16 +3996,22 @@ void
 Selection::SetBaseAndExtent(nsINode& aAnchorNode, uint32_t aAnchorOffset,
                             nsINode& aFocusNode, uint32_t aFocusOffset,
                             ErrorResult& aRv)
 {
   if (!mFrameSelection) {
     return;
   }
 
+  if (!HasSameRoot(aAnchorNode) ||
+      !HasSameRoot(aFocusNode)) {
+    // Return with no error
+    return;
+  }
+
   SelectionBatcher batch(this);
 
   int32_t relativePosition =
     nsContentUtils::ComparePoints(&aAnchorNode, aAnchorOffset,
                                   &aFocusNode, aFocusOffset);
   nsINode* start = &aAnchorNode;
   nsINode* end = &aFocusNode;
   uint32_t startOffset = aAnchorOffset;
@@ -4206,8 +4242,16 @@ Selection::WrapObject(JSContext* aCx, JS
   return mozilla::dom::SelectionBinding::Wrap(aCx, this, aGivenProto);
 }
 
 // AutoHideSelectionChanges
 AutoHideSelectionChanges::AutoHideSelectionChanges(const nsFrameSelection* aFrame)
   : AutoHideSelectionChanges(
       aFrame ? aFrame->GetSelection(SelectionType::eNormal) : nullptr)
 {}
+
+bool
+Selection::HasSameRoot(nsINode& aNode)
+{
+  nsINode* root = aNode.SubtreeRoot();
+  nsIDocument* doc = GetParentObject();
+  return doc == root || (root && doc == root->GetComposedDoc());
+}
--- a/dom/base/Selection.h
+++ b/dom/base/Selection.h
@@ -277,16 +277,19 @@ public:
   void RemoveSelectionChangeBlocker();
   bool IsBlockingSelectionChangeEvents() const;
 private:
   friend class ::nsAutoScrollTimer;
 
   // Note: DoAutoScroll might destroy arbitrary frames etc.
   nsresult DoAutoScroll(nsIFrame *aFrame, nsPoint& aPoint);
 
+  // We are not allowed to be in nodes whose root is not our document
+  bool HasSameRoot(nsINode& aNode);
+
   // XXX Please don't add additional uses of this method, it's only for
   // XXX supporting broken code (bug 1245883) in the following classes:
   friend class ::nsCopySupport;
   friend class ::nsHTMLCopyEncoder;
   void AddRangeInternal(nsRange& aRange, nsIDocument* aDocument, ErrorResult&);
 
 public:
   SelectionType GetType() const { return mSelectionType; }
--- a/dom/base/UseCounter.h
+++ b/dom/base/UseCounter.h
@@ -13,20 +13,23 @@ enum UseCounter : int16_t {
   eUseCounter_UNKNOWN = -1,
 #define USE_COUNTER_DOM_METHOD(interface_, name_) \
     eUseCounter_##interface_##_##name_,
 #define USE_COUNTER_DOM_ATTRIBUTE(interface_, name_) \
     eUseCounter_##interface_##_##name_##_getter, \
     eUseCounter_##interface_##_##name_##_setter,
 #define USE_COUNTER_CSS_PROPERTY(name_, id_) \
     eUseCounter_property_##id_,
+#define USE_COUNTER_CUSTOM(name_, desc_) \
+    eUseCounter_custom_##name_,
 #include "mozilla/dom/UseCounterList.h"
 #undef USE_COUNTER_DOM_METHOD
 #undef USE_COUNTER_DOM_ATTRIBUTE
 #undef USE_COUNTER_CSS_PROPERTY
+#undef USE_COUNTER_CUSTOM
 
 #define DEPRECATED_OPERATION(op_) \
   eUseCounter_##op_,
 #include "nsDeprecatedOperationList.h"
 #undef DEPRECATED_OPERATION
 
   eUseCounter_Count
 };
--- a/dom/base/UseCounters.conf
+++ b/dom/base/UseCounters.conf
@@ -7,32 +7,40 @@
 // through Telemetry.
 //
 // The format of this file is very strict.  Each line can be:
 //
 //   (a) a blank line
 //
 //   (b) a comment, which is a line that begins with "//"
 //
-//   (c) one of three possible use counter declarations:
+//   (c) one of four possible use counter declarations:
 //
 //         method <IDL interface name>.<IDL operation name>
 //         attribute <IDL interface name>.<IDL attribute name>
 //         property <CSS property method name>
+//         custom <any valid identifier> <description>
 //
 // The |CSS property method name| should be identical to the |method|
 // argument to CSS_PROP and related macros.  The method name is
 // identical to the name of the property, except that all hyphens are
 // removed and CamelCase naming is used.  See nsCSSPropList.h for
 // further details.
 //
+// The <description> for custom counters will be appended to "When a document "
+// or "When a page ", so phrase it appropriately.  For instance, "constructs a
+// Foo object" or "calls Document.bar('some value')".  It may contain any
+// character.
+//
 // To actually cause use counters to be incremented, DOM methods
 // and attributes must have a [UseCounter] extended attribute in
 // the Web IDL file.  CSS properties require no special treatment
-// beyond being listed below.
+// beyond being listed below.  Custom counters are incremented when
+// SetDocumentAndPageUseCounter(eUseCounter_custom_MyName) is called on an
+// ns(I)Document object.
 //
 // You might reasonably ask why we have this file and we require
 // annotating things with [UseCounter] in the relevant WebIDL file as
 // well.  Generating things from bindings codegen and ensuring all the
 // dependencies were correct would have been rather difficult, and
 // annotating the WebIDL files does nothing for identifying CSS
 // property usage, which we would also like to track.
 
--- a/dom/base/gen-usecounters.py
+++ b/dom/base/gen-usecounters.py
@@ -32,29 +32,34 @@ def generate_list(f, counters):
 #endif
 ''' % { 'name': name }, file=f)
 
     print(AUTOGENERATED_WARNING_COMMENT, file=f)
 
     print_optional_macro_declare('USE_COUNTER_DOM_METHOD')
     print_optional_macro_declare('USE_COUNTER_DOM_ATTRIBUTE')
     print_optional_macro_declare('USE_COUNTER_CSS_PROPERTY')
+    print_optional_macro_declare('USE_COUNTER_CUSTOM')
 
     for counter in counters:
         if counter['type'] == 'method':
             print('USE_COUNTER_DOM_METHOD(%s, %s)' % (counter['interface_name'], counter['method_name']), file=f)
         elif counter['type'] == 'attribute':
             print('USE_COUNTER_DOM_ATTRIBUTE(%s, %s)' % (counter['interface_name'], counter['attribute_name']), file=f)
         elif counter['type'] == 'property':
             prop = counter['property_name']
             print('USE_COUNTER_CSS_PROPERTY(%s, %s)' % (prop, prop), file=f)
+        elif counter['type'] == 'custom':
+            desc = counter['desc'].replace('\\', r'\\').replace('"', r'\"')
+            print('USE_COUNTER_CUSTOM(%s, "%s")' % (counter['name'], desc), file=f)
 
     print_optional_macro_undeclare('USE_COUNTER_DOM_METHOD')
     print_optional_macro_undeclare('USE_COUNTER_DOM_ATTRIBUTE')
     print_optional_macro_undeclare('USE_COUNTER_CSS_PROPERTY')
+    print_optional_macro_undeclare('USE_COUNTER_CUSTOM')
 
 def generate_property_map(f, counters):
     print(AUTOGENERATED_WARNING_COMMENT, file=f)
     print('''
 enum {
   #define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) privatename_
   #define CSS_PROP_LIST_INCLUDE_LOGICAL
   #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_,     \\
--- a/dom/base/nsIContent.h
+++ b/dom/base/nsIContent.h
@@ -975,19 +975,16 @@ public:
   virtual nsresult GetEventTargetParent(
                      mozilla::EventChainPreVisitor& aVisitor) override;
 
   virtual bool IsPurple() = 0;
   virtual void RemovePurple() = 0;
 
   virtual bool OwnedOnlyByTheDOMTree() { return false; }
 
-  void NoteDirtyForServo();
-  void NoteAnimationOnlyDirtyForServo();
-
 protected:
   /**
    * Hook for implementing GetID.  This is guaranteed to only be
    * called if HasID() is true.
    */
   nsIAtom* DoGetID() const;
 
   // Returns base URI without considering xml:base.
--- a/dom/base/usecounters.py
+++ b/dom/base/usecounters.py
@@ -33,16 +33,23 @@ def read_conf(conf_filename):
                         'attribute_name': attribute_name }
                 continue
             m = re.match(r'property ([A-Za-z0-9]+)$', line)
             if m:
                 property_name = m.group(1)
                 yield { 'type': 'property',
                         'property_name': property_name }
                 continue
+            m = re.match(r'custom ([A-Za-z0-9_]+) (.*)$', line)
+            if m:
+                name, desc = m.groups()
+                yield { 'type': 'custom',
+                        'name': name,
+                        'desc': desc }
+                continue
             raise ValueError('error parsing %s at line %d' % (conf_filename, line_num))
 
     return parse_counters(stream)
 
 def generate_histograms(filename):
     # The mapping for use counters to telemetry histograms depends on the
     # ordering of items in the dictionary.
     items = collections.OrderedDict()
@@ -62,10 +69,12 @@ def generate_histograms(filename):
         elif counter['type'] == 'attribute':
             attr = '%s.%s' % (counter['interface_name'], counter['attribute_name'])
             counter_name = attr.replace('.', '_').upper()
             append_counters('%s_getter' % counter_name, 'got %s' % attr)
             append_counters('%s_setter' % counter_name, 'set %s' % attr)
         elif counter['type'] == 'property':
             prop = counter['property_name']
             append_counters('PROPERTY_%s' % prop.replace('-', '_').upper(), "used the '%s' property" % prop)
+        elif counter['type'] == 'custom':
+            append_counters(counter['name'].upper(), counter['desc'])
 
     return items
--- a/editor/libeditor/tests/test_bug537046.html
+++ b/editor/libeditor/tests/test_bug537046.html
@@ -18,18 +18,16 @@ https://bugzilla.mozilla.org/show_bug.cg
   </div>
   <div id="source" contenteditable="true">
 </div>
 <pre id="test">
 <script type="application/javascript">
 
 /** Test for Bug 537046 **/
 
-SimpleTest.expectAssertions(1);
-
 SimpleTest.waitForExplicitFinish();
 addLoadEvent(function() {
   var ed = document.getElementById("editor");
   var src = document.getElementById("source");
   ed.addEventListener("DOMSubtreeModified", function() {
     src.textContent = ed.innerHTML;
   });
   src.addEventListener("DOMSubtreeModified", function() {
--- a/layout/base/ServoRestyleManager.cpp
+++ b/layout/base/ServoRestyleManager.cpp
@@ -786,44 +786,48 @@ ServoRestyleManager::ProcessPostTraversa
     thisFrameRestyleState.emplace(*styleFrame, aRestyleState, changeHint, type);
   }
 
   // We can't really assume as used changes from display: contents elements (or
   // other elements without frames).
   ServoRestyleState& childrenRestyleState =
     thisFrameRestyleState ? *thisFrameRestyleState : aRestyleState;
 
-  RefPtr<ServoStyleContext> newContext = nullptr;
+  RefPtr<ServoStyleContext> upToDateContext =
+    (wasRestyled || !oldStyleContext)
+      ? aRestyleState.StyleSet().ResolveServoStyle(aElement)
+      : oldStyleContext;
+
+  MOZ_ASSERT(upToDateContext);
+
   if (wasRestyled && oldStyleContext) {
     MOZ_ASSERT(styleFrame || displayContentsStyle);
-    newContext =
-      aRestyleState.StyleSet().ResolveServoStyle(aElement);
-    MOZ_ASSERT(oldStyleContext->ComputedData() != newContext->ComputedData());
+    MOZ_ASSERT(oldStyleContext->ComputedData() != upToDateContext->ComputedData());
 
-    newContext->ResolveSameStructsAs(oldStyleContext);
+    upToDateContext->ResolveSameStructsAs(oldStyleContext);
 
     // We want to walk all the continuations here, even the ones with different
     // styles.  In practice, the only reason we get continuations with different
     // styles here is ::first-line (::first-letter never affects element
     // styles).  But in that case, newContext is the right context for the
     // _later_ continuations anyway (the ones not affected by ::first-line), not
     // the earlier ones, so there is no point stopping right at the point when
     // we'd actually be setting the right style context.
     //
     // This does mean that we may be setting the wrong style context on our
     // initial continuations; ::first-line fixes that up after the fact.
     for (nsIFrame* f = styleFrame; f; f = f->GetNextContinuation()) {
       MOZ_ASSERT_IF(f != styleFrame, !f->GetAdditionalStyleContext(0));
-      f->SetStyleContext(newContext);
+      f->SetStyleContext(upToDateContext);
     }
 
     if (MOZ_UNLIKELY(displayContentsStyle)) {
       MOZ_ASSERT(!styleFrame);
       PresContext()->FrameConstructor()->
-        ChangeRegisteredDisplayContentsStyleFor(aElement, newContext);
+        ChangeRegisteredDisplayContentsStyleFor(aElement, upToDateContext);
     }
 
     if (styleFrame) {
       UpdateAdditionalStyleContexts(styleFrame, aRestyleState);
       styleFrame->UpdateStyleOfOwnedAnonBoxes(childrenRestyleState);
     }
 
     if (!aElement->GetParent()) {
@@ -851,19 +855,16 @@ ServoRestyleManager::ProcessPostTraversa
 
   const bool traverseElementChildren =
     NeedsToTraverseElementChildren(*aElement);
   const bool descendantsNeedFrames =
     aElement->HasFlag(NODE_DESCENDANTS_NEED_FRAMES);
   const bool traverseTextChildren = wasRestyled || descendantsNeedFrames;
   bool recreatedAnyContext = wasRestyled;
   if (traverseElementChildren || traverseTextChildren) {
-    ServoStyleContext* upToDateContext =
-      wasRestyled ? newContext : oldStyleContext;
-
     StyleChildrenIterator it(aElement);
     TextPostTraversalState textState(*upToDateContext,
                                      displayContentsStyle && wasRestyled,
                                      childrenRestyleState);
     for (nsIContent* n = it.GetNextChild(); n; n = it.GetNextChild()) {
       if (traverseElementChildren && n->IsElement()) {
         recreatedAnyContext |= ProcessPostTraversal(n->AsElement(),
                                                     upToDateContext,
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -7546,18 +7546,25 @@ nsCSSFrameConstructor::MaybeRecreateForF
 }
 
 void
 nsCSSFrameConstructor::LazilyStyleNewChildRange(nsIContent* aStartChild,
                                                 nsIContent* aEndChild)
 {
   for (nsIContent* child = aStartChild; child != aEndChild;
        child = child->GetNextSibling()) {
-    child->NoteDirtyForServo();
-  }
+    if (child->IsElement()) {
+      child->AsElement()->NoteDirtyForServo();
+    }
+  }
+
+  // NoteDirtyForServo() will ensure a style flush, but we don't invoke it for
+  // text nodes. So since this range might include no elements, we still need
+  // to manually ensure a style flush.
+  mPresShell->EnsureStyleFlush();
 }
 
 void
 nsCSSFrameConstructor::StyleNewChildRange(nsIContent* aStartChild,
                                           nsIContent* aEndChild)
 {
   ServoStyleSet* styleSet = mPresShell->StyleSet()->AsServo();
 
--- a/layout/painting/ActiveLayerTracker.cpp
+++ b/layout/painting/ActiveLayerTracker.cpp
@@ -40,20 +40,16 @@ class LayerActivity {
 public:
   enum ActivityIndex {
     ACTIVITY_OPACITY,
     ACTIVITY_TRANSFORM,
     ACTIVITY_LEFT,
     ACTIVITY_TOP,
     ACTIVITY_RIGHT,
     ACTIVITY_BOTTOM,
-    ACTIVITY_MARGIN_LEFT,
-    ACTIVITY_MARGIN_TOP,
-    ACTIVITY_MARGIN_RIGHT,
-    ACTIVITY_MARGIN_BOTTOM,
     ACTIVITY_BACKGROUND_POSITION,
 
     ACTIVITY_SCALE,
 
     // keep as last item
     ACTIVITY_COUNT
   };
 
@@ -75,20 +71,16 @@ public:
   {
     switch (aProperty) {
     case eCSSProperty_opacity: return ACTIVITY_OPACITY;
     case eCSSProperty_transform: return ACTIVITY_TRANSFORM;
     case eCSSProperty_left: return ACTIVITY_LEFT;
     case eCSSProperty_top: return ACTIVITY_TOP;
     case eCSSProperty_right: return ACTIVITY_RIGHT;
     case eCSSProperty_bottom: return ACTIVITY_BOTTOM;
-    case eCSSProperty_margin_left: return ACTIVITY_MARGIN_LEFT;
-    case eCSSProperty_margin_top: return ACTIVITY_MARGIN_TOP;
-    case eCSSProperty_margin_right: return ACTIVITY_MARGIN_RIGHT;
-    case eCSSProperty_margin_bottom: return ACTIVITY_MARGIN_BOTTOM;
     case eCSSProperty_background_position: return ACTIVITY_BACKGROUND_POSITION;
     case eCSSProperty_background_position_x: return ACTIVITY_BACKGROUND_POSITION;
     case eCSSProperty_background_position_y: return ACTIVITY_BACKGROUND_POSITION;
     default: MOZ_ASSERT(false); return ACTIVITY_OPACITY;
     }
   }
 
   // While tracked, exactly one of mFrame or mContent is non-null, depending
@@ -444,28 +436,24 @@ ActiveLayerTracker::IsStyleAnimated(nsDi
   }
   if (aProperty == eCSSProperty_transform && aFrame->Combines3DTransformWithAncestors()) {
     return IsStyleAnimated(aBuilder, aFrame->GetParent(), aProperty);
   }
   return nsLayoutUtils::HasEffectiveAnimation(aFrame, aProperty);
 }
 
 /* static */ bool
-ActiveLayerTracker::IsOffsetOrMarginStyleAnimated(nsIFrame* aFrame)
+ActiveLayerTracker::IsOffsetStyleAnimated(nsIFrame* aFrame)
 {
   LayerActivity* layerActivity = GetLayerActivity(aFrame);
   if (layerActivity) {
     if (layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_LEFT] >= 2 ||
         layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_TOP] >= 2 ||
         layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_RIGHT] >= 2 ||
-        layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_BOTTOM] >= 2 ||
-        layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_MARGIN_LEFT] >= 2 ||
-        layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_MARGIN_TOP] >= 2 ||
-        layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_MARGIN_RIGHT] >= 2 ||
-        layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_MARGIN_BOTTOM] >= 2) {
+        layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_BOTTOM] >= 2) {
       return true;
     }
   }
   // We should also check for running CSS animations of these properties once
   // bug 1009693 is fixed. Until that happens, layerization isn't useful for
   // animations of these properties because we'll invalidate the layer contents
   // on every change anyway.
   // See bug 1151346 for a patch that adds a check for CSS animations.
--- a/layout/painting/ActiveLayerTracker.h
+++ b/layout/painting/ActiveLayerTracker.h
@@ -81,17 +81,17 @@ public:
    * for constructing active layers.
    */
   static bool IsStyleAnimated(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
                               nsCSSPropertyID aProperty);
   /**
    * Return true if any of aFrame's offset property styles should be considered
    * as being animated for constructing active layers.
    */
-  static bool IsOffsetOrMarginStyleAnimated(nsIFrame* aFrame);
+  static bool IsOffsetStyleAnimated(nsIFrame* aFrame);
   /**
    * Return true if aFrame's background-position-x or background-position-y
    * property is animated.
    */
   static bool IsBackgroundPositionAnimated(nsDisplayListBuilder* aBuilder,
                                            nsIFrame* aFrame);
   /**
    * Return true if aFrame either has an animated scale now, or is likely to
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -1496,17 +1496,17 @@ nsDisplayListBuilder::IsAnimatedGeometry
     if (aParent) {
       *aParent = nsLayoutUtils::GetCrossDocParentFrame(aFrame);
     }
     return AGR_NO;
   }
 
   if (nsLayoutUtils::IsPopup(aFrame))
     return AGR_YES;
-  if (ActiveLayerTracker::IsOffsetOrMarginStyleAnimated(aFrame)) {
+  if (ActiveLayerTracker::IsOffsetStyleAnimated(aFrame)) {
     const bool inBudget = AddToAGRBudget(aFrame);
     if (inBudget) {
       return AGR_YES;
     }
   }
   if (!aFrame->GetParent() &&
       nsLayoutUtils::ViewportHasDisplayPort(aFrame->PresContext())) {
     // Viewport frames in a display port need to be animated geometry roots
--- a/layout/style/ServoBindingList.h
+++ b/layout/style/ServoBindingList.h
@@ -39,16 +39,19 @@ SERVO_BINDING_FUNC(Servo_StyleSheet_HasR
 SERVO_BINDING_FUNC(Servo_StyleSheet_GetRules, ServoCssRulesStrong,
                    RawServoStyleSheetContentsBorrowed sheet)
 SERVO_BINDING_FUNC(Servo_StyleSheet_Clone, RawServoStyleSheetContentsStrong,
                    RawServoStyleSheetContentsBorrowed sheet,
                    const mozilla::ServoStyleSheet* reference_sheet);
 SERVO_BINDING_FUNC(Servo_StyleSheet_SizeOfIncludingThis, size_t,
                    mozilla::MallocSizeOf malloc_size_of,
                    RawServoStyleSheetContentsBorrowed sheet)
+SERVO_BINDING_FUNC(Servo_StyleSheet_GetOrigin,
+                   mozilla::OriginFlags,
+                   RawServoStyleSheetContentsBorrowed sheet)
 SERVO_BINDING_FUNC(Servo_StyleSet_Init, RawServoStyleSetOwned, RawGeckoPresContextOwned pres_context)
 SERVO_BINDING_FUNC(Servo_StyleSet_Clear, void,
                    RawServoStyleSetBorrowed set)
 SERVO_BINDING_FUNC(Servo_StyleSet_RebuildCachedData, void,
                    RawServoStyleSetBorrowed set)
 SERVO_BINDING_FUNC(Servo_StyleSet_MediumFeaturesChanged, bool,
                    RawServoStyleSetBorrowed set, bool* viewport_units_used)
 SERVO_BINDING_FUNC(Servo_StyleSet_Drop, void, RawServoStyleSetOwned set)
@@ -65,17 +68,19 @@ SERVO_BINDING_FUNC(Servo_StyleSet_Remove
                    const mozilla::ServoStyleSheet* gecko_sheet)
 SERVO_BINDING_FUNC(Servo_StyleSet_InsertStyleSheetBefore, void,
                    RawServoStyleSetBorrowed set,
                    const mozilla::ServoStyleSheet* gecko_sheet,
                    const mozilla::ServoStyleSheet* before)
 SERVO_BINDING_FUNC(Servo_StyleSet_FlushStyleSheets, void, RawServoStyleSetBorrowed set,
                    RawGeckoElementBorrowedOrNull doc_elem)
 SERVO_BINDING_FUNC(Servo_StyleSet_NoteStyleSheetsChanged, void,
-                   RawServoStyleSetBorrowed set, bool author_style_disabled)
+                   RawServoStyleSetBorrowed set,
+                   bool author_style_disabled,
+                   mozilla::OriginFlags changed_origins)
 SERVO_BINDING_FUNC(Servo_StyleSet_GetKeyframesForName, bool,
                    RawServoStyleSetBorrowed set,
                    const nsACString* property,
                    nsTimingFunctionBorrowed timing_function,
                    RawGeckoKeyframeListBorrowedMut keyframe_list)
 SERVO_BINDING_FUNC(Servo_StyleSet_GetFontFaceRules, void,
                    RawServoStyleSetBorrowed set,
                    RawGeckoFontFaceRuleListBorrowedMut list)
--- a/layout/style/ServoBindingTypes.h
+++ b/layout/style/ServoBindingTypes.h
@@ -31,16 +31,17 @@ namespace dom {
 class Element;
 class StyleChildrenIterator;
 } // namespace dom
 struct AnimationPropertySegment;
 struct ComputedTiming;
 struct Keyframe;
 struct PropertyValuePair;
 struct PropertyStyleAnimationValuePair;
+enum class OriginFlags : uint8_t;
 using ComputedKeyframeValues = nsTArray<PropertyStyleAnimationValuePair>;
 } // namespace mozilla
 namespace nsStyleTransformMatrix {
 enum class MatrixTransformOperator: uint8_t;
 }
 
 class nsCSSPropertyIDSet;
 class nsCSSValue;
--- a/layout/style/ServoBindings.toml
+++ b/layout/style/ServoBindings.toml
@@ -85,16 +85,17 @@ raw-lines = [
 hide-types = [
     "nsString",
     ".*char_traits",
     ".*incompatible_char_type",
 ]
 bitfield-enums = [
     "nsChangeHint",
     "nsRestyleHint",
+    "OriginFlags",
 ]
 constified-enums = [
     "UpdateAnimationsTasks",
     "ParsingMode",
     "ThemeWidgetType",
     "ServoTraversalFlags",
 ]
 constified-enum-variants = [
@@ -132,16 +133,17 @@ whitelist-types = [
     "mozilla::css::ErrorReporter",
     "mozilla::css::LoaderReusableStyleSheets",
     "mozilla::css::SheetParsingMode",
     "mozilla::css::URLMatchingFunction",
     "mozilla::dom::IterationCompositeOperation",
     "mozilla::dom::StyleChildrenIterator",
     "mozilla::HalfCorner",
     "mozilla::MallocSizeOf",
+    "mozilla::OriginFlags",
     "mozilla::PropertyStyleAnimationValuePair",
     "mozilla::ServoTraversalFlags",
     "mozilla::StylePrefs",
     "mozilla::StyleShapeRadius",
     "mozilla::StyleGrid.*",
     "mozilla::UpdateAnimationsTasks",
     "mozilla::LookAndFeel",
     "mozilla::gfx::Float",
@@ -362,16 +364,17 @@ raw-lines = [
 whitelist-functions = ["Servo_.*", "Gecko_.*"]
 structs-types = [
     "mozilla::css::GridTemplateAreasValue",
     "mozilla::css::ErrorReporter",
     "mozilla::css::ImageValue",
     "mozilla::css::URLValue",
     "mozilla::css::URLValueData",
     "mozilla::MallocSizeOf",
+    "mozilla::OriginFlags",
     "mozilla::Side",
     "mozilla::UniquePtr",
     "nsIContent",
     "nsIDocument",
     "nsIDocument_DocumentTheme",
     "RawGeckoAnimationPropertySegment",
     "RawGeckoComputedTiming",
     "RawGeckoCSSPropertyIDList",
--- a/layout/style/ServoStyleSet.cpp
+++ b/layout/style/ServoStyleSet.cpp
@@ -166,17 +166,19 @@ ServoStyleSet::InvalidateStyleForCSSRule
 nsRestyleHint
 ServoStyleSet::MediumFeaturesChanged(bool aViewportChanged)
 {
   bool viewportUnitsUsed = false;
   const bool rulesChanged =
     Servo_StyleSet_MediumFeaturesChanged(mRawSet.get(), &viewportUnitsUsed);
 
   if (rulesChanged) {
-    ForceAllStyleDirty();
+    // XXXheycam Should be able to tell which origin to pass in here
+    // (bug 1389871).
+    MarkOriginsDirty(OriginFlags::All);
     return eRestyle_Subtree;
   }
 
   if (viewportUnitsUsed && aViewportChanged) {
     return eRestyle_ForceDescendants;
   }
 
   return nsRestyleHint(0);
@@ -212,17 +214,17 @@ ServoStyleSet::GetAuthorStyleDisabled() 
 nsresult
 ServoStyleSet::SetAuthorStyleDisabled(bool aStyleDisabled)
 {
   if (mAuthorStyleDisabled == aStyleDisabled) {
     return NS_OK;
   }
 
   mAuthorStyleDisabled = aStyleDisabled;
-  ForceAllStyleDirty();
+  MarkOriginsDirty(OriginFlags::Author);
 
   return NS_OK;
 }
 
 void
 ServoStyleSet::BeginUpdate()
 {
 }
@@ -866,16 +868,20 @@ ServoStyleSet::StyleDocument(ServoTraver
   DocumentStyleRootIterator iter(mPresContext->Document());
   while (Element* root = iter.GetNextStyleRoot()) {
     MOZ_ASSERT(MayTraverseFrom(const_cast<Element*>(root)));
     AutoPrepareTraversal guard(this);
     const SnapshotTable& snapshots = Snapshots();
     bool isInitial = !root->HasServoData();
     auto flags = aBaseFlags;
 
+    // If there were text nodes inserted into the document (but not elements),
+    // there may be lazy frame construction to do even if no styling is required.
+    postTraversalRequired |= root->HasFlag(NODE_DESCENDANTS_NEED_FRAMES);
+
     // Allow the parallel traversal, unless we're traversing traversing one of
     // the native anonymous document style roots, which are tiny and not worth
     // parallelizing over.
     if (!root->IsInNativeAnonymousSubtree()) {
       flags |= ServoTraversalFlags::ParallelTraversal;
     }
 
     // Do the first traversal.
@@ -1028,34 +1034,35 @@ ServoStyleSet::StyleSubtreeForReconstruc
   if (mPresContext->EffectCompositor()->PreTraverseInSubtree(flags, aRoot)) {
     postTraversalRequired =
       Servo_TraverseSubtree(aRoot, mRawSet.get(), &snapshots, flags);
     MOZ_ASSERT(!postTraversalRequired);
   }
 }
 
 void
-ServoStyleSet::ForceAllStyleDirty()
+ServoStyleSet::MarkOriginsDirty(OriginFlags aChangedOrigins)
 {
   SetStylistStyleSheetsDirty();
-  Servo_StyleSet_NoteStyleSheetsChanged(mRawSet.get(), mAuthorStyleDisabled);
+  Servo_StyleSet_NoteStyleSheetsChanged(mRawSet.get(),
+                                        mAuthorStyleDisabled,
+                                        aChangedOrigins);
 }
 
 void
 ServoStyleSet::RecordStyleSheetChange(
     ServoStyleSheet* aSheet,
     StyleSheet::ChangeType aChangeType)
 {
-  SetStylistStyleSheetsDirty();
   switch (aChangeType) {
     case StyleSheet::ChangeType::RuleAdded:
     case StyleSheet::ChangeType::RuleRemoved:
     case StyleSheet::ChangeType::RuleChanged:
       // FIXME(emilio): We can presumably do better in a bunch of these.
-      return ForceAllStyleDirty();
+      return MarkOriginsDirty(aSheet->GetOrigin());
     case StyleSheet::ChangeType::ApplicableStateChanged:
     case StyleSheet::ChangeType::Added:
     case StyleSheet::ChangeType::Removed:
       // Do nothing, we've already recorded the change in the
       // Append/Remove/Replace methods, etc, and will act consequently.
       return;
   }
 }
--- a/layout/style/ServoStyleSet.h
+++ b/layout/style/ServoStyleSet.h
@@ -53,16 +53,26 @@ namespace mozilla {
 enum class StylistState : uint8_t {
   /** The stylist is not dirty, we should do nothing */
   NotDirty = 0,
 
   /** The style sheets have changed, so we need to update the style data. */
   StyleSheetsDirty,
 };
 
+// Bitfield type to represent Servo stylesheet origins.
+enum class OriginFlags : uint8_t {
+  UserAgent = 0x01,
+  User      = 0x02,
+  Author    = 0x04,
+  All       = 0x07,
+};
+
+MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(OriginFlags)
+
 /**
  * The set of style sheets that apply to a document, backed by a Servo
  * Stylist.  A ServoStyleSet contains ServoStyleSheets.
  */
 class ServoStyleSet
 {
   friend class ServoRestyleManager;
   typedef ServoElementSnapshotTable SnapshotTable;
@@ -94,17 +104,17 @@ public:
   void BeginShutdown();
   void Shutdown();
 
   void RecordStyleSheetChange(mozilla::ServoStyleSheet*, StyleSheet::ChangeType);
 
   void RecordShadowStyleChange(mozilla::dom::ShadowRoot* aShadowRoot) {
     // FIXME(emilio): When we properly support shadow dom we'll need to do
     // better.
-    ForceAllStyleDirty();
+    MarkOriginsDirty(OriginFlags::All);
   }
 
   bool StyleSheetsHaveChanged() const
   {
     return StylistNeedsUpdate();
   }
 
   nsRestyleHint MediumFeaturesChanged(bool aViewportChanged);
@@ -284,23 +294,16 @@ public:
    * styles.  This will leave the subtree in a state just like after an initial
    * styling, i.e. with new styles, no change hints, and with the dirty
    * descendants bits cleared.  No comparison of old and new styles is done,
    * so no change hints will be processed.
    */
   void StyleSubtreeForReconstruct(dom::Element* aRoot);
 
   /**
-   * Records that the contents of style sheets have changed since the last
-   * restyle.  Calling this will ensure that the Stylist rebuilds its
-   * selector maps.
-   */
-  void ForceAllStyleDirty();
-
-  /**
    * Helper for correctly calling UpdateStylist without paying the cost of an
    * extra function call in the common no-rebuild-needed case.
    */
   void UpdateStylistIfNeeded()
   {
     if (StylistNeedsUpdate()) {
       UpdateStylist();
     }
@@ -489,16 +492,23 @@ private:
    */
   void PreTraverse(ServoTraversalFlags aFlags,
                    dom::Element* aRoot = nullptr);
 
   // Subset of the pre-traverse steps that involve syncing up data
   void PreTraverseSync();
 
   /**
+   * Records that the contents of style sheets at the specified origin have
+   * changed since the last.  Calling this will ensure that the Stylist
+   * rebuilds its selector maps.
+   */
+  void MarkOriginsDirty(OriginFlags aChangedOrigins);
+
+  /**
    * Note that the stylist needs a style flush due to style sheet changes.
    */
   void SetStylistStyleSheetsDirty()
   {
     mStylistState = StylistState::StyleSheetsDirty;
   }
 
   bool StylistNeedsUpdate() const
--- a/layout/style/ServoStyleSheet.cpp
+++ b/layout/style/ServoStyleSheet.cpp
@@ -458,9 +458,15 @@ ServoStyleSheet::SizeOfIncludingThis(Mal
     // is worthwhile:
     // - s->mRuleList
 
     s = s->mNext ? s->mNext->AsServo() : nullptr;
   }
   return n;
 }
 
+OriginFlags
+ServoStyleSheet::GetOrigin()
+{
+  return Servo_StyleSheet_GetOrigin(Inner()->mContents);
+}
+
 } // namespace mozilla
--- a/layout/style/ServoStyleSheet.h
+++ b/layout/style/ServoStyleSheet.h
@@ -116,16 +116,19 @@ public:
   // nsICSSLoaderObserver interface
   NS_IMETHOD StyleSheetLoaded(StyleSheet* aSheet, bool aWasAlternate,
                               nsresult aStatus) final;
 
   // Internal GetCssRules method which do not have security check and
   // completelness check.
   ServoCSSRuleList* GetCssRulesInternal();
 
+  // Returns the stylesheet's Servo origin as an OriginFlags value.
+  OriginFlags GetOrigin();
+
 protected:
   virtual ~ServoStyleSheet();
 
   void LastRelease();
 
   ServoStyleSheetInner* Inner() const
   {
     return static_cast<ServoStyleSheetInner*>(mInner);
--- a/layout/style/nsDOMCSSAttrDeclaration.cpp
+++ b/layout/style/nsDOMCSSAttrDeclaration.cpp
@@ -206,18 +206,16 @@ nsDOMCSSAttributeDeclaration::SetPropert
   // Scripted modifications to style.opacity or style.transform
   // could immediately force us into the animated state if heuristics suggest
   // this is scripted animation.
   // FIXME: This is missing the margin shorthand and the logical versions of
   // the margin properties, see bug 1266287.
   if (aPropID == eCSSProperty_opacity || aPropID == eCSSProperty_transform ||
       aPropID == eCSSProperty_left || aPropID == eCSSProperty_top ||
       aPropID == eCSSProperty_right || aPropID == eCSSProperty_bottom ||
-      aPropID == eCSSProperty_margin_left || aPropID == eCSSProperty_margin_top ||
-      aPropID == eCSSProperty_margin_right || aPropID == eCSSProperty_margin_bottom ||
       aPropID == eCSSProperty_background_position_x ||
       aPropID == eCSSProperty_background_position_y ||
       aPropID == eCSSProperty_background_position) {
     nsIFrame* frame = mElement->GetPrimaryFrame();
     if (frame) {
       ActiveLayerTracker::NotifyInlineStyleRuleModified(frame, aPropID, aValue, this);
     }
   }
--- a/layout/style/test/mochitest.ini
+++ b/layout/style/test/mochitest.ini
@@ -203,16 +203,18 @@ skip-if = toolkit == 'android' #bug 5366
 [test_flexbox_flex_shorthand.html]
 [test_flexbox_focus_order.html]
 [test_flexbox_layout.html]
 support-files = flexbox_layout_testcases.js
 [test_flexbox_order.html]
 [test_flexbox_order_abspos.html]
 [test_flexbox_order_table.html]
 [test_flexbox_reflow_counts.html]
+[test_font_face_cascade.html]
+fail-if = !stylo # bug 1389937
 [test_font_face_parser.html]
 [test_font_family_parsing.html]
 [test_font_loading_api.html]
 support-files =
   BitPattern.woff
   file_font_loading_api_vframe.html
 [test_garbage_at_end_of_declarations.html]
 [test_grid_container_shorthands.html]
new file mode 100644
--- /dev/null
+++ b/layout/style/test/test_font_face_cascade.html
@@ -0,0 +1,37 @@
+<!DOCTYPE HTML>
+<title>Test that @font-face rules from different origins cascade correctly</title>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css">
+<script>
+let io = SpecialPowers.Cc["@mozilla.org/network/io-service;1"]
+  .getService(SpecialPowers.Ci.nsIIOService);
+
+let utils = SpecialPowers.wrap(window)
+  .QueryInterface(SpecialPowers.Ci.nsIInterfaceRequestor)
+  .getInterface(SpecialPowers.Ci.nsIDOMWindowUtils);
+
+function load_sheet(sheet_text, level) {
+  if (level != "AGENT_SHEET" && level != "USER_SHEET" && level != "AUTHOR_SHEET") {
+    throw "unknown level";
+  }
+
+  let uri = io.newURI("data:text/css," + encodeURI(sheet_text));
+  utils.loadSheet(uri, utils[level]);
+}
+
+load_sheet(
+  "@font-face { font-family: TestAgent; src: url(about:invalid); }",
+  "AGENT_SHEET");
+
+load_sheet(
+  "@font-face { font-family: TestAuthor; src: url(about:invalid); }",
+  "AUTHOR_SHEET");
+
+load_sheet(
+  "@font-face { font-family: TestUser; src: url(about:invalid); }",
+  "USER_SHEET");
+
+is([...document.fonts].map(f => f.family).join(" "),
+   '"TestAuthor" "TestUser" "TestAgent"',
+   "@font-face rules are returned in correct cascade order");
+</script>
--- a/servo/components/layout_thread/lib.rs
+++ b/servo/components/layout_thread/lib.rs
@@ -132,17 +132,17 @@ use style::error_reporting::{NullReporte
 use style::invalidation::element::restyle_hints::RestyleHint;
 use style::logical_geometry::LogicalPoint;
 use style::media_queries::{Device, MediaList, MediaType};
 use style::properties::PropertyId;
 use style::selector_parser::SnapshotMap;
 use style::servo::restyle_damage::{REFLOW, REFLOW_OUT_OF_FLOW, REPAINT, REPOSITION, STORE_OVERFLOW};
 use style::shared_lock::{SharedRwLock, SharedRwLockReadGuard, StylesheetGuards};
 use style::stylesheets::{Origin, Stylesheet, StylesheetInDocument, UserAgentStylesheets};
-use style::stylist::{ExtraStyleData, Stylist};
+use style::stylist::Stylist;
 use style::thread_state;
 use style::timer::Timer;
 use style::traversal::{DomTraversal, TraversalDriver};
 use style::traversal_flags::TraversalFlags;
 use style_traits::CSSPixel;
 use style_traits::DevicePixel;
 use style_traits::SpeculativePainter;
 
@@ -1201,17 +1201,17 @@ impl LayoutThread {
 
         // If the entire flow tree is invalid, then it will be reflowed anyhow.
         let ua_stylesheets = &*UA_STYLESHEETS;
         let ua_or_user_guard = ua_stylesheets.shared_lock.read();
         let guards = StylesheetGuards {
             author: &author_guard,
             ua_or_user: &ua_or_user_guard,
         };
-        let mut extra_data = ExtraStyleData;
+        let mut extra_data = Default::default();
         let needs_dirtying = self.stylist.update(
             StylesheetIterator(data.document_stylesheets.iter()),
             &guards,
             Some(ua_stylesheets),
             data.stylesheets_changed,
             /* author_styles_disabled = */ false,
             &mut extra_data);
         let needs_reflow = viewport_size_changed && !needs_dirtying;
--- a/servo/components/style/gecko/data.rs
+++ b/servo/components/style/gecko/data.rs
@@ -12,17 +12,17 @@ use gecko_bindings::structs::RawGeckoPre
 use gecko_bindings::structs::nsIDocument;
 use gecko_bindings::sugar::ownership::{HasArcFFI, HasBoxFFI, HasFFI, HasSimpleFFI};
 use invalidation::media_queries::{MediaListKey, ToMediaListKey};
 use media_queries::{Device, MediaList};
 use properties::ComputedValues;
 use servo_arc::Arc;
 use shared_lock::{Locked, StylesheetGuards, SharedRwLockReadGuard};
 use stylesheet_set::StylesheetSet;
-use stylesheets::{StylesheetContents, StylesheetInDocument};
+use stylesheets::{Origin, PerOrigin, StylesheetContents, StylesheetInDocument};
 use stylist::{ExtraStyleData, Stylist};
 
 /// Little wrapper to a Gecko style sheet.
 #[derive(PartialEq, Eq, Debug)]
 pub struct GeckoStyleSheet(*const ServoStyleSheet);
 
 impl ToMediaListKey for ::gecko::data::GeckoStyleSheet {
     fn to_media_list_key(&self) -> MediaListKey {
@@ -113,17 +113,17 @@ impl StylesheetInDocument for GeckoStyle
 pub struct PerDocumentStyleDataImpl {
     /// Rule processor.
     pub stylist: Stylist,
 
     /// List of stylesheets, mirrored from Gecko.
     pub stylesheets: StylesheetSet<GeckoStyleSheet>,
 
     /// List of effective @font-face and @counter-style rules.
-    pub extra_style_data: ExtraStyleData,
+    pub extra_style_data: PerOrigin<ExtraStyleData>,
 }
 
 /// The data itself is an `AtomicRefCell`, which guarantees the proper semantics
 /// and unexpected races while trying to mutate it.
 pub struct PerDocumentStyleData(AtomicRefCell<PerDocumentStyleDataImpl>);
 
 impl PerDocumentStyleData {
     /// Create a dummy `PerDocumentStyleData`.
@@ -158,17 +158,17 @@ impl PerDocumentStyleDataImpl {
                                 document_element: Option<E>)
         where E: TElement,
     {
         if !self.stylesheets.has_changed() {
             return;
         }
 
         let author_style_disabled = self.stylesheets.author_style_disabled();
-        self.stylist.clear();
+
         let iter = self.stylesheets.flush(document_element);
         self.stylist.rebuild(
             iter,
             &StylesheetGuards::same(guard),
             /* ua_sheets = */ None,
             /* stylesheets_changed = */ true,
             author_style_disabled,
             &mut self.extra_style_data,
@@ -188,16 +188,21 @@ impl PerDocumentStyleDataImpl {
     }
 
     /// Clear the stylist.  This will be a no-op if the stylist is
     /// already cleared; the stylist handles that.
     pub fn clear_stylist(&mut self) {
         self.stylist.clear();
     }
 
+    /// Clear the stylist's data for the specified origin.
+    pub fn clear_stylist_origin(&mut self, origin: &Origin) {
+        self.stylist.clear_origin(origin);
+    }
+
     /// Returns whether visited links are enabled.
     fn visited_links_enabled(&self) -> bool {
         unsafe { bindings::Gecko_AreVisitedLinksEnabled() }
     }
     /// Returns whether visited styles are enabled.
     pub fn visited_styles_enabled(&self) -> bool {
         self.visited_links_enabled() && !self.is_private_browsing_enabled()
     }
--- a/servo/components/style/gecko/generated/bindings.rs
+++ b/servo/components/style/gecko/generated/bindings.rs
@@ -10,16 +10,17 @@ pub type ServoStyleContextBorrowedOrNull
 pub type ServoComputedDataBorrowed<'a> = &'a ServoComputedData;
 pub type RawServoAnimationValueTableBorrowed<'a> = &'a ();
 use gecko_bindings::structs::mozilla::css::GridTemplateAreasValue;
 use gecko_bindings::structs::mozilla::css::ErrorReporter;
 use gecko_bindings::structs::mozilla::css::ImageValue;
 use gecko_bindings::structs::mozilla::css::URLValue;
 use gecko_bindings::structs::mozilla::css::URLValueData;
 use gecko_bindings::structs::mozilla::MallocSizeOf;
+use gecko_bindings::structs::mozilla::OriginFlags;
 use gecko_bindings::structs::mozilla::Side;
 use gecko_bindings::structs::mozilla::UniquePtr;
 use gecko_bindings::structs::nsIContent;
 use gecko_bindings::structs::nsIDocument;
 use gecko_bindings::structs::nsIDocument_DocumentTheme;
 use gecko_bindings::structs::RawGeckoAnimationPropertySegment;
 use gecko_bindings::structs::RawGeckoComputedTiming;
 use gecko_bindings::structs::RawGeckoCSSPropertyIDList;
@@ -1952,16 +1953,21 @@ extern "C" {
 }
 extern "C" {
     pub fn Servo_StyleSheet_SizeOfIncludingThis(malloc_size_of: MallocSizeOf,
                                                 sheet:
                                                     RawServoStyleSheetContentsBorrowed)
      -> usize;
 }
 extern "C" {
+    pub fn Servo_StyleSheet_GetOrigin(sheet:
+                                          RawServoStyleSheetContentsBorrowed)
+     -> OriginFlags;
+}
+extern "C" {
     pub fn Servo_StyleSet_Init(pres_context: RawGeckoPresContextOwned)
      -> RawServoStyleSetOwned;
 }
 extern "C" {
     pub fn Servo_StyleSet_Clear(set: RawServoStyleSetBorrowed);
 }
 extern "C" {
     pub fn Servo_StyleSet_RebuildCachedData(set: RawServoStyleSetBorrowed);
@@ -2001,17 +2007,19 @@ extern "C" {
 extern "C" {
     pub fn Servo_StyleSet_FlushStyleSheets(set: RawServoStyleSetBorrowed,
                                            doc_elem:
                                                RawGeckoElementBorrowedOrNull);
 }
 extern "C" {
     pub fn Servo_StyleSet_NoteStyleSheetsChanged(set:
                                                      RawServoStyleSetBorrowed,
-                                                 author_style_disabled: bool);
+                                                 author_style_disabled: bool,
+                                                 changed_origins:
+                                                     OriginFlags);
 }
 extern "C" {
     pub fn Servo_StyleSet_GetKeyframesForName(set: RawServoStyleSetBorrowed,
                                               property: *const nsACString,
                                               timing_function:
                                                   nsTimingFunctionBorrowed,
                                               keyframe_list:
                                                   RawGeckoKeyframeListBorrowedMut)
--- a/servo/components/style/gecko/generated/structs_debug.rs
+++ b/servo/components/style/gecko/generated/structs_debug.rs
@@ -1047,18 +1047,16 @@ pub mod root {
         pub struct pair<_T1, _T2> {
             pub first: _T1,
             pub second: _T2,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T1>>,
             pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T2>>,
         }
         pub type pair_first_type<_T1> = _T1;
         pub type pair_second_type<_T2> = _T2;
-        pub type pair__PCCP = u8;
-        pub type pair__PCCFP = u8;
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct input_iterator_tag {
             pub _address: u8,
         }
         #[test]
         fn bindgen_test_layout_input_iterator_tag() {
             assert_eq!(::std::mem::size_of::<input_iterator_tag>() , 1usize ,
@@ -8280,16 +8278,61 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const PropertyStyleAnimationValuePair )
                         ) . mValue as * const _ as usize } , 8usize , concat !
                         (
                         "Alignment of field: " , stringify ! (
                         PropertyStyleAnimationValuePair ) , "::" , stringify !
                         ( mValue ) ));
         }
+        pub const OriginFlags_UserAgent: root::mozilla::OriginFlags =
+            OriginFlags(1);
+        pub const OriginFlags_User: root::mozilla::OriginFlags =
+            OriginFlags(2);
+        pub const OriginFlags_Author: root::mozilla::OriginFlags =
+            OriginFlags(4);
+        pub const OriginFlags_All: root::mozilla::OriginFlags =
+            OriginFlags(7);
+        impl ::std::ops::BitOr<root::mozilla::OriginFlags> for
+         root::mozilla::OriginFlags {
+            type
+            Output
+            =
+            Self;
+            #[inline]
+            fn bitor(self, other: Self) -> Self {
+                OriginFlags(self.0 | other.0)
+            }
+        }
+        impl ::std::ops::BitOrAssign for root::mozilla::OriginFlags {
+            #[inline]
+            fn bitor_assign(&mut self, rhs: root::mozilla::OriginFlags) {
+                self.0 |= rhs.0;
+            }
+        }
+        impl ::std::ops::BitAnd<root::mozilla::OriginFlags> for
+         root::mozilla::OriginFlags {
+            type
+            Output
+            =
+            Self;
+            #[inline]
+            fn bitand(self, other: Self) -> Self {
+                OriginFlags(self.0 & other.0)
+            }
+        }
+        impl ::std::ops::BitAndAssign for root::mozilla::OriginFlags {
+            #[inline]
+            fn bitand_assign(&mut self, rhs: root::mozilla::OriginFlags) {
+                self.0 &= rhs.0;
+            }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+        pub struct OriginFlags(pub u8);
         #[test]
         fn __bindgen_test_layout_DefaultDelete_open0_RawServoStyleSet_close0_instantiation() {
             assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
                        1usize , concat ! (
                        "Size of template specialization: " , stringify ! (
                        root::mozilla::DefaultDelete ) ));
             assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>()
                        , 1usize , concat ! (
@@ -16914,16 +16957,17 @@ pub mod root {
         pub mUseCounters: [u64; 2usize],
         pub mChildDocumentUseCounters: [u64; 2usize],
         pub mNotifiedPageForUseCounter: [u64; 2usize],
         pub mIncCounters: u16,
         pub mUserHasInteracted: bool,
         pub mPageUnloadingEventTimeStamp: root::mozilla::TimeStamp,
         pub mDocGroup: root::RefPtr<root::mozilla::dom::DocGroup>,
         pub mTrackingScripts: [u64; 6usize],
+        pub mBufferedCSPViolations: root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>,
     }
     pub type nsIDocument_GlobalObject = root::mozilla::dom::GlobalObject;
     pub type nsIDocument_Encoding = root::mozilla::Encoding;
     pub type nsIDocument_NotNull<T> = root::mozilla::NotNull<T>;
     pub use self::super::root::mozilla::net::ReferrerPolicy as
             nsIDocument_ReferrerPolicyEnum;
     pub type nsIDocument_Element = root::mozilla::dom::Element;
     pub type nsIDocument_FullscreenRequest =
@@ -17208,17 +17252,17 @@ pub mod root {
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIDocument_FrameRequest {
         _unused: [u8; 0],
     }
     pub const nsIDocument_kSegmentSize: usize = 128;
     #[test]
     fn bindgen_test_layout_nsIDocument() {
-        assert_eq!(::std::mem::size_of::<nsIDocument>() , 880usize , concat !
+        assert_eq!(::std::mem::size_of::<nsIDocument>() , 888usize , concat !
                    ( "Size of: " , stringify ! ( nsIDocument ) ));
         assert_eq! (::std::mem::align_of::<nsIDocument>() , 8usize , concat !
                     ( "Alignment of " , stringify ! ( nsIDocument ) ));
     }
     impl nsIDocument {
         #[inline]
         pub fn mBidiEnabled(&self) -> bool {
             let mut unit_field_val: u64 =
@@ -19077,35 +19121,34 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mIsScopedStyleEnabled(&self) -> ::std::os::raw::c_uint {
-            let mut unit_field_val: u64 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u64 as *mut u8,
-                                                ::std::mem::size_of::<u64>())
-            };
-            let mask = 1688849860263936u64 as u64;
+        pub fn mBufferingCSPViolations(&self) -> bool {
+            let mut unit_field_val: u64 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u64 as *mut u8,
+                                                ::std::mem::size_of::<u64>())
+            };
+            let mask = 562949953421312u64 as u64;
             let val = (unit_field_val & mask) >> 49usize;
-            unsafe { ::std::mem::transmute(val as u32) }
-        }
-        #[inline]
-        pub fn set_mIsScopedStyleEnabled(&mut self,
-                                         val: ::std::os::raw::c_uint) {
-            let mask = 1688849860263936u64 as u64;
-            let val = val as u32 as u64;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mBufferingCSPViolations(&mut self, val: bool) {
+            let mask = 562949953421312u64 as u64;
+            let val = val as u8 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
@@ -19116,16 +19159,55 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
+        pub fn mIsScopedStyleEnabled(&self) -> ::std::os::raw::c_uint {
+            let mut unit_field_val: u64 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u64 as *mut u8,
+                                                ::std::mem::size_of::<u64>())
+            };
+            let mask = 3377699720527872u64 as u64;
+            let val = (unit_field_val & mask) >> 50usize;
+            unsafe { ::std::mem::transmute(val as u32) }
+        }
+        #[inline]
+        pub fn set_mIsScopedStyleEnabled(&mut self,
+                                         val: ::std::os::raw::c_uint) {
+            let mask = 3377699720527872u64 as u64;
+            let val = val as u32 as u64;
+            let mut unit_field_val: u64 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u64 as *mut u8,
+                                                ::std::mem::size_of::<u64>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 50usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u64>());
+            }
+        }
+        #[inline]
         pub fn new_bitfield_1(mBidiEnabled: bool, mMathMLEnabled: bool,
                               mIsInitialDocumentInWindow: bool,
                               mIgnoreDocGroupMismatches: bool,
                               mLoadedAsData: bool,
                               mLoadedAsInteractiveData: bool,
                               mMayStartLayout: bool,
                               mHaveFiredTitleChange: bool, mIsShowing: bool,
                               mVisible: bool, mHasReferrerPolicyCSP: bool,
@@ -19160,16 +19242,17 @@ pub mod root {
                               mPostedFlushUserFontSet: bool,
                               mDidFireDOMContentLoaded: bool,
                               mHasScrollLinkedEffect: bool,
                               mFrameRequestCallbacksScheduled: bool,
                               mIsTopLevelContentDocument: bool,
                               mIsContentDocument: bool,
                               mMightHaveStaleServoData: bool,
                               mDidCallBeginLoad: bool,
+                              mBufferingCSPViolations: bool,
                               mIsScopedStyleEnabled: ::std::os::raw::c_uint)
          -> u64 {
             ({
                  ({
                       ({
                            ({
                                 ({
                                      ({
@@ -19212,577 +19295,592 @@ pub mod root {
                                                                                                                                                                                                                               ({
                                                                                                                                                                                                                                    ({
                                                                                                                                                                                                                                         ({
                                                                                                                                                                                                                                              ({
                                                                                                                                                                                                                                                   ({
                                                                                                                                                                                                                                                        ({
                                                                                                                                                                                                                                                             ({
                                                                                                                                                                                                                                                                  ({
-                                                                                                                                                                                                                                                                      0
+                                                                                                                                                                                                                                                                      ({
+                                                                                                                                                                                                                                                                           0
+                                                                                                                                                                                                                                                                       }
+                                                                                                                                                                                                                                                                           |
+                                                                                                                                                                                                                                                                           ((mBidiEnabled
+                                                                                                                                                                                                                                                                                 as
+                                                                                                                                                                                                                                                                                 u8
+                                                                                                                                                                                                                                                                                 as
+                                                                                                                                                                                                                                                                                 u64)
+                                                                                                                                                                                                                                                                                <<
+                                                                                                                                                                                                                                                                                0usize)
+                                                                                                                                                                                                                                                                               &
+                                                                                                                                                                                                                                                                               (1u64
+                                                                                                                                                                                                                                                                                    as
+                                                                                                                                                                                                                                                                                    u64))
                                                                                                                                                                                                                                                                   }
                                                                                                                                                                                                                                                                       |
-                                                                                                                                                                                                                                                                      ((mBidiEnabled
+                                                                                                                                                                                                                                                                      ((mMathMLEnabled
                                                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                                                             u8
                                                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                                                             u64)
                                                                                                                                                                                                                                                                            <<
-                                                                                                                                                                                                                                                                           0usize)
+                                                                                                                                                                                                                                                                           1usize)
                                                                                                                                                                                                                                                                           &
-                                                                                                                                                                                                                                                                          (1u64
+                                                                                                                                                                                                                                                                          (2u64
                                                                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                                                                u64))
                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                  |
-                                                                                                                                                                                                                                                                 ((mMathMLEnabled
+                                                                                                                                                                                                                                                                 ((mIsInitialDocumentInWindow
                                                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                                                        u8
                                                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                                                        u64)
                                                                                                                                                                                                                                                                       <<
-                                                                                                                                                                                                                                                                      1usize)
+                                                                                                                                                                                                                                                                      2usize)
                                                                                                                                                                                                                                                                      &
-                                                                                                                                                                                                                                                                     (2u64
+                                                                                                                                                                                                                                                                     (4u64
                                                                                                                                                                                                                                                                           as
                                                                                                                                                                                                                                                                           u64))
                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                             |
-                                                                                                                                                                                                                                                            ((mIsInitialDocumentInWindow
+                                                                                                                                                                                                                                                            ((mIgnoreDocGroupMismatches
                                                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                                                   u8
                                                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                                                   u64)
                                                                                                                                                                                                                                                                  <<
-                                                                                                                                                                                                                                                                 2usize)
+                                                                                                                                                                                                                                                                 3usize)
                                                                                                                                                                                                                                                                 &
-                                                                                                                                                                                                                                                                (4u64
+                                                                                                                                                                                                                                                                (8u64
                                                                                                                                                                                                                                                                      as
                                                                                                                                                                                                                                                                      u64))
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                        |
-                                                                                                                                                                                                                                                       ((mIgnoreDocGroupMismatches
+                                                                                                                                                                                                                                                       ((mLoadedAsData
                                                                                                                                                                                                                                                              as
                                                                                                                                                                                                                                                              u8
                                                                                                                                                                                                                                                              as
                                                                                                                                                                                                                                                              u64)
                                                                                                                                                                                                                                                             <<
-                                                                                                                                                                                                                                                            3usize)
+                                                                                                                                                                                                                                                            4usize)
                                                                                                                                                                                                                                                            &
-                                                                                                                                                                                                                                                           (8u64
+                                                                                                                                                                                                                                                           (16u64
                                                                                                                                                                                                                                                                 as
                                                                                                                                                                                                                                                                 u64))
                                                                                                                                                                                                                                               }
                                                                                                                                                                                                                                                   |
-                                                                                                                                                                                                                                                  ((mLoadedAsData
+                                                                                                                                                                                                                                                  ((mLoadedAsInteractiveData
                                                                                                                                                                                                                                                         as
                                                                                                                                                                                                                                                         u8
                                                                                                                                                                                                                                                         as
                                                                                                                                                                                                                                                         u64)
                                                                                                                                                                                                                                                        <<
-                                                                                                                                                                                                                                                       4usize)
+                                                                                                                                                                                                                                                       5usize)
                                                                                                                                                                                                                                                       &
-                                                                                                                                                                                                                                                      (16u64
+                                                                                                                                                                                                                                                      (32u64
                                                                                                                                                                                                                                                            as
                                                                                                                                                                                                                                                            u64))
                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                              |
-                                                                                                                                                                                                                                             ((mLoadedAsInteractiveData
+                                                                                                                                                                                                                                             ((mMayStartLayout
                                                                                                                                                                                                                                                    as
                                                                                                                                                                                                                                                    u8
                                                                                                                                                                                                                                                    as
                                                                                                                                                                                                                                                    u64)
                                                                                                                                                                                                                                                   <<
-                                                                                                                                                                                                                                                  5usize)
+                                                                                                                                                                                                                                                  6usize)
                                                                                                                                                                                                                                                  &
-                                                                                                                                                                                                                                                 (32u64
+                                                                                                                                                                                                                                                 (64u64
                                                                                                                                                                                                                                                       as
                                                                                                                                                                                                                                                       u64))
                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                         |
-                                                                                                                                                                                                                                        ((mMayStartLayout
+                                                                                                                                                                                                                                        ((mHaveFiredTitleChange
                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                               u8
                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                               u64)
                                                                                                                                                                                                                                              <<
-                                                                                                                                                                                                                                             6usize)
+                                                                                                                                                                                                                                             7usize)
                                                                                                                                                                                                                                             &
-                                                                                                                                                                                                                                            (64u64
+                                                                                                                                                                                                                                            (128u64
                                                                                                                                                                                                                                                  as
                                                                                                                                                                                                                                                  u64))
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                    |
-                                                                                                                                                                                                                                   ((mHaveFiredTitleChange
+                                                                                                                                                                                                                                   ((mIsShowing
                                                                                                                                                                                                                                          as
                                                                                                                                                                                                                                          u8
                                                                                                                                                                                                                                          as
                                                                                                                                                                                                                                          u64)
                                                                                                                                                                                                                                         <<
-                                                                                                                                                                                                                                        7usize)
+                                                                                                                                                                                                                                        8usize)
                                                                                                                                                                                                                                        &
-                                                                                                                                                                                                                                       (128u64
+                                                                                                                                                                                                                                       (256u64
                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                             u64))
                                                                                                                                                                                                                           }
                                                                                                                                                                                                                               |
-                                                                                                                                                                                                                              ((mIsShowing
+                                                                                                                                                                                                                              ((mVisible
                                                                                                                                                                                                                                     as
                                                                                                                                                                                                                                     u8
                                                                                                                                                                                                                                     as
                                                                                                                                                                                                                                     u64)
                                                                                                                                                                                                                                    <<
-                                                                                                                                                                                                                                   8usize)
+                                                                                                                                                                                                                                   9usize)
                                                                                                                                                                                                                                   &
-                                                                                                                                                                                                                                  (256u64
+                                                                                                                                                                                                                                  (512u64
                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                        u64))
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                          |
-                                                                                                                                                                                                                         ((mVisible
+                                                                                                                                                                                                                         ((mHasReferrerPolicyCSP
                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                u8
                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                u64)
                                                                                                                                                                                                                               <<
-                                                                                                                                                                                                                              9usize)
+                                                                                                                                                                                                                              10usize)
                                                                                                                                                                                                                              &
-                                                                                                                                                                                                                             (512u64
+                                                                                                                                                                                                                             (1024u64
                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                   u64))
                                                                                                                                                                                                                 }
                                                                                                                                                                                                                     |
-                                                                                                                                                                                                                    ((mHasReferrerPolicyCSP
+                                                                                                                                                                                                                    ((mRemovedFromDocShell
                                                                                                                                                                                                                           as
                                                                                                                                                                                                                           u8
                                                                                                                                                                                                                           as
                                                                                                                                                                                                                           u64)
                                                                                                                                                                                                                          <<
-                                                                                                                                                                                                                         10usize)
+                                                                                                                                                                                                                         11usize)
                                                                                                                                                                                                                         &
-                                                                                                                                                                                                                        (1024u64
+                                                                                                                                                                                                                        (2048u64
                                                                                                                                                                                                                              as
                                                                                                                                                                                                                              u64))
                                                                                                                                                                                                            }
                                                                                                                                                                                                                |
-                                                                                                                                                                                                               ((mRemovedFromDocShell
+                                                                                                                                                                                                               ((mAllowDNSPrefetch
                                                                                                                                                                                                                      as
                                                                                                                                                                                                                      u8
                                                                                                                                                                                                                      as
                                                                                                                                                                                                                      u64)
                                                                                                                                                                                                                     <<
-                                                                                                                                                                                                                    11usize)
+                                                                                                                                                                                                                    12usize)
                                                                                                                                                                                                                    &
-                                                                                                                                                                                                                   (2048u64
+                                                                                                                                                                                                                   (4096u64
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         u64))
                                                                                                                                                                                                       }
                                                                                                                                                                                                           |
-                                                                                                                                                                                                          ((mAllowDNSPrefetch
+                                                                                                                                                                                                          ((mIsStaticDocument
                                                                                                                                                                                                                 as
                                                                                                                                                                                                                 u8
                                                                                                                                                                                                                 as
                                                                                                                                                                                                                 u64)
                                                                                                                                                                                                                <<
-                                                                                                                                                                                                               12usize)
+                                                                                                                                                                                                               13usize)
                                                                                                                                                                                                               &
-                                                                                                                                                                                                              (4096u64
+                                                                                                                                                                                                              (8192u64
                                                                                                                                                                                                                    as
                                                                                                                                                                                                                    u64))
                                                                                                                                                                                                  }
                                                                                                                                                                                                      |
-                                                                                                                                                                                                     ((mIsStaticDocument
+                                                                                                                                                                                                     ((mCreatingStaticClone
                                                                                                                                                                                                            as
                                                                                                                                                                                                            u8
                                                                                                                                                                                                            as
                                                                                                                                                                                                            u64)
                                                                                                                                                                                                           <<
-                                                                                                                                                                                                          13usize)
+                                                                                                                                                                                                          14usize)
                                                                                                                                                                                                          &
-                                                                                                                                                                                                         (8192u64
+                                                                                                                                                                                                         (16384u64
                                                                                                                                                                                                               as
                                                                                                                                                                                                               u64))
                                                                                                                                                                                             }
                                                                                                                                                                                                 |
-                                                                                                                                                                                                ((mCreatingStaticClone
+                                                                                                                                                                                                ((mInUnlinkOrDeletion
                                                                                                                                                                                                       as
                                                                                                                                                                                                       u8
                                                                                                                                                                                                       as
                                                                                                                                                                                                       u64)
                                                                                                                                                                                                      <<
-                                                                                                                                                                                                     14usize)
+                                                                                                                                                                                                     15usize)
                                                                                                                                                                                                     &
-                                                                                                                                                                                                    (16384u64
+                                                                                                                                                                                                    (32768u64
                                                                                                                                                                                                          as
                                                                                                                                                                                                          u64))
                                                                                                                                                                                        }
                                                                                                                                                                                            |
-                                                                                                                                                                                           ((mInUnlinkOrDeletion
+                                                                                                                                                                                           ((mHasHadScriptHandlingObject
                                                                                                                                                                                                  as
                                                                                                                                                                                                  u8
                                                                                                                                                                                                  as
                                                                                                                                                                                                  u64)
                                                                                                                                                                                                 <<
-                                                                                                                                                                                                15usize)
+                                                                                                                                                                                                16usize)
                                                                                                                                                                                                &
-                                                                                                                                                                                               (32768u64
+                                                                                                                                                                                               (65536u64
                                                                                                                                                                                                     as
                                                                                                                                                                                                     u64))
                                                                                                                                                                                   }
                                                                                                                                                                                       |
-                                                                                                                                                                                      ((mHasHadScriptHandlingObject
+                                                                                                                                                                                      ((mIsBeingUsedAsImage
                                                                                                                                                                                             as
                                                                                                                                                                                             u8
                                                                                                                                                                                             as
                                                                                                                                                                                             u64)
                                                                                                                                                                                            <<
-                                                                                                                                                                                           16usize)
+                                                                                                                                                                                           17usize)
                                                                                                                                                                                           &
-                                                                                                                                                                                          (65536u64
+                                                                                                                                                                                          (131072u64
                                                                                                                                                                                                as
                                                                                                                                                                                                u64))
                                                                                                                                                                              }
                                                                                                                                                                                  |
-                                                                                                                                                                                 ((mIsBeingUsedAsImage
+                                                                                                                                                                                 ((mIsSyntheticDocument
                                                                                                                                                                                        as
                                                                                                                                                                                        u8
                                                                                                                                                                                        as
                                                                                                                                                                                        u64)
                                                                                                                                                                                       <<
-                                                                                                                                                                                      17usize)
+                                                                                                                                                                                      18usize)
                                                                                                                                                                                      &
-                                                                                                                                                                                     (131072u64
+                                                                                                                                                                                     (262144u64
                                                                                                                                                                                           as
                                                                                                                                                                                           u64))
                                                                                                                                                                         }
                                                                                                                                                                             |
-                                                                                                                                                                            ((mIsSyntheticDocument
+                                                                                                                                                                            ((mHasLinksToUpdate
                                                                                                                                                                                   as
                                                                                                                                                                                   u8
                                                                                                                                                                                   as
                                                                                                                                                                                   u64)
                                                                                                                                                                                  <<
-                                                                                                                                                                                 18usize)
+                                                                                                                                                                                 19usize)
                                                                                                                                                                                 &
-                                                                                                                                                                                (262144u64
+                                                                                                                                                                                (524288u64
                                                                                                                                                                                      as
                                                                                                                                                                                      u64))
                                                                                                                                                                    }
                                                                                                                                                                        |
-                                                                                                                                                                       ((mHasLinksToUpdate
+                                                                                                                                                                       ((mHasLinksToUpdateRunnable
                                                                                                                                                                              as
                                                                                                                                                                              u8
                                                                                                                                                                              as
                                                                                                                                                                              u64)
                                                                                                                                                                             <<
-                                                                                                                                                                            19usize)
+                                                                                                                                                                            20usize)
                                                                                                                                                                            &
-                                                                                                                                                                           (524288u64
+                                                                                                                                                                           (1048576u64
                                                                                                                                                                                 as
                                                                                                                                                                                 u64))
                                                                                                                                                               }
                                                                                                                                                                   |
-                                                                                                                                                                  ((mHasLinksToUpdateRunnable
+                                                                                                                                                                  ((mMayHaveDOMMutationObservers
                                                                                                                                                                         as
                                                                                                                                                                         u8
                                                                                                                                                                         as
                                                                                                                                                                         u64)
                                                                                                                                                                        <<
-                                                                                                                                                                       20usize)
+                                                                                                                                                                       21usize)
                                                                                                                                                                       &
-                                                                                                                                                                      (1048576u64
+                                                                                                                                                                      (2097152u64
                                                                                                                                                                            as
                                                                                                                                                                            u64))
                                                                                                                                                          }
                                                                                                                                                              |
-                                                                                                                                                             ((mMayHaveDOMMutationObservers
+                                                                                                                                                             ((mMayHaveAnimationObservers
                                                                                                                                                                    as
                                                                                                                                                                    u8
                                                                                                                                                                    as
                                                                                                                                                                    u64)
                                                                                                                                                                   <<
-                                                                                                                                                                  21usize)
+                                                                                                                                                                  22usize)
                                                                                                                                                                  &
-                                                                                                                                                                 (2097152u64
+                                                                                                                                                                 (4194304u64
                                                                                                                                                                       as
                                                                                                                                                                       u64))
                                                                                                                                                     }
                                                                                                                                                         |
-                                                                                                                                                        ((mMayHaveAnimationObservers
+                                                                                                                                                        ((mHasMixedActiveContentLoaded
                                                                                                                                                               as
                                                                                                                                                               u8
                                                                                                                                                               as
                                                                                                                                                               u64)
                                                                                                                                                              <<
-                                                                                                                                                             22usize)
+                                                                                                                                                             23usize)
                                                                                                                                                             &
-                                                                                                                                                            (4194304u64
+                                                                                                                                                            (8388608u64
                                                                                                                                                                  as
                                                                                                                                                                  u64))
                                                                                                                                                }
                                                                                                                                                    |
-                                                                                                                                                   ((mHasMixedActiveContentLoaded
+                                                                                                                                                   ((mHasMixedActiveContentBlocked
                                                                                                                                                          as
                                                                                                                                                          u8
                                                                                                                                                          as
                                                                                                                                                          u64)
                                                                                                                                                         <<
-                                                                                                                                                        23usize)
+                                                                                                                                                        24usize)
                                                                                                                                                        &
-                                                                                                                                                       (8388608u64
+                                                                                                                                                       (16777216u64
                                                                                                                                                             as
                                                                                                                                                             u64))
                                                                                                                                           }
                                                                                                                                               |
-                                                                                                                                              ((mHasMixedActiveContentBlocked
+                                                                                                                                              ((mHasMixedDisplayContentLoaded
                                                                                                                                                     as
                                                                                                                                                     u8
                                                                                                                                                     as
                                                                                                                                                     u64)
                                                                                                                                                    <<
-                                                                                                                                                   24usize)
+                                                                                                                                                   25usize)
                                                                                                                                                   &
-                                                                                                                                                  (16777216u64
+                                                                                                                                                  (33554432u64
                                                                                                                                                        as
                                                                                                                                                        u64))
                                                                                                                                      }
                                                                                                                                          |
-                                                                                                                                         ((mHasMixedDisplayContentLoaded
+                                                                                                                                         ((mHasMixedDisplayContentBlocked
                                                                                                                                                as
                                                                                                                                                u8
                                                                                                                                                as
                                                                                                                                                u64)
                                                                                                                                               <<
-                                                                                                                                              25usize)
+                                                                                                                                              26usize)
                                                                                                                                              &
-                                                                                                                                             (33554432u64
+                                                                                                                                             (67108864u64
                                                                                                                                                   as
                                                                                                                                                   u64))
                                                                                                                                 }
                                                                                                                                     |
-                                                                                                                                    ((mHasMixedDisplayContentBlocked
+                                                                                                                                    ((mHasMixedContentObjectSubrequest
                                                                                                                                           as
                                                                                                                                           u8
                                                                                                                                           as
                                                                                                                                           u64)
                                                                                                                                          <<
-                                                                                                                                         26usize)
+                                                                                                                                         27usize)
                                                                                                                                         &
-                                                                                                                                        (67108864u64
+                                                                                                                                        (134217728u64
                                                                                                                                              as
                                                                                                                                              u64))
                                                                                                                            }
                                                                                                                                |
-                                                                                                                               ((mHasMixedContentObjectSubrequest
+                                                                                                                               ((mHasCSP
                                                                                                                                      as
                                                                                                                                      u8
                                                                                                                                      as
                                                                                                                                      u64)
                                                                                                                                     <<
-                                                                                                                                    27usize)
+                                                                                                                                    28usize)
                                                                                                                                    &
-                                                                                                                                   (134217728u64
+                                                                                                                                   (268435456u64
                                                                                                                                         as
                                                                                                                                         u64))
                                                                                                                       }
                                                                                                                           |
-                                                                                                                          ((mHasCSP
+                                                                                                                          ((mHasUnsafeEvalCSP
                                                                                                                                 as
                                                                                                                                 u8
                                                                                                                                 as
                                                                                                                                 u64)
                                                                                                                                <<
-                                                                                                                               28usize)
+                                                                                                                               29usize)
                                                                                                                               &
-                                                                                                                              (268435456u64
+                                                                                                                              (536870912u64
                                                                                                                                    as
                                                                                                                                    u64))
                                                                                                                  }
                                                                                                                      |
-                                                                                                                     ((mHasUnsafeEvalCSP
+                                                                                                                     ((mHasUnsafeInlineCSP
                                                                                                                            as
                                                                                                                            u8
                                                                                                                            as
                                                                                                                            u64)
                                                                                                                           <<
-                                                                                                                          29usize)
+                                                                                                                          30usize)
                                                                                                                          &
-                                                                                                                         (536870912u64
+                                                                                                                         (1073741824u64
                                                                                                                               as
                                                                                                                               u64))
                                                                                                             }
                                                                                                                 |
-                                                                                                                ((mHasUnsafeInlineCSP
+                                                                                                                ((mHasTrackingContentBlocked
                                                                                                                       as
                                                                                                                       u8
                                                                                                                       as
                                                                                                                       u64)
                                                                                                                      <<
-                                                                                                                     30usize)
+                                                                                                                     31usize)
                                                                                                                     &
-                                                                                                                    (1073741824u64
+                                                                                                                    (2147483648u64
                                                                                                                          as
                                                                                                                          u64))
                                                                                                        }
                                                                                                            |
-                                                                                                           ((mHasTrackingContentBlocked
+                                                                                                           ((mHasTrackingContentLoaded
                                                                                                                  as
                                                                                                                  u8
                                                                                                                  as
                                                                                                                  u64)
                                                                                                                 <<
-                                                                                                                31usize)
+                                                                                                                32usize)
                                                                                                                &
-                                                                                                               (2147483648u64
+                                                                                                               (4294967296u64
                                                                                                                     as
                                                                                                                     u64))
                                                                                                   }
                                                                                                       |
-                                                                                                      ((mHasTrackingContentLoaded
+                                                                                                      ((mBFCacheDisallowed
                                                                                                             as
                                                                                                             u8
                                                                                                             as
                                                                                                             u64)
                                                                                                            <<
-                                                                                                           32usize)
+                                                                                                           33usize)
                                                                                                           &
-                                                                                                          (4294967296u64
+                                                                                                          (8589934592u64
                                                                                                                as
                                                                                                                u64))
                                                                                              }
                                                                                                  |
-                                                                                                 ((mBFCacheDisallowed
+                                                                                                 ((mHasHadDefaultView
                                                                                                        as
                                                                                                        u8
                                                                                                        as
                                                                                                        u64)
                                                                                                       <<
-                                                                                                      33usize)
+                                                                                                      34usize)
                                                                                                      &
-                                                                                                     (8589934592u64
+                                                                                                     (17179869184u64
                                                                                                           as
                                                                                                           u64))
                                                                                         }
                                                                                             |
-                                                                                            ((mHasHadDefaultView
+                                                                                            ((mStyleSheetChangeEventsEnabled
                                                                                                   as
                                                                                                   u8
                                                                                                   as
                                                                                                   u64)
                                                                                                  <<
-                                                                                                 34usize)
+                                                                                                 35usize)
                                                                                                 &
-                                                                                                (17179869184u64
+                                                                                                (34359738368u64
                                                                                                      as
                                                                                                      u64))
                                                                                    }
                                                                                        |
-                                                                                       ((mStyleSheetChangeEventsEnabled
+                                                                                       ((mIsSrcdocDocument
                                                                                              as
                                                                                              u8
                                                                                              as
                                                                                              u64)
                                                                                             <<
-                                                                                            35usize)
+                                                                                            36usize)
                                                                                            &
-                                                                                           (34359738368u64
+                                                                                           (68719476736u64
                                                                                                 as
                                                                                                 u64))
                                                                               }
                                                                                   |
-                                                                                  ((mIsSrcdocDocument
+                                                                                  ((mDidDocumentOpen
                                                                                         as
                                                                                         u8
                                                                                         as
                                                                                         u64)
                                                                                        <<
-                                                                                       36usize)
+                                                                                       37usize)
                                                                                       &
-                                                                                      (68719476736u64
+                                                                                      (137438953472u64
                                                                                            as
                                                                                            u64))
                                                                          } |
-                                                                             ((mDidDocumentOpen
+                                                                             ((mHasDisplayDocument
                                                                                    as
                                                                                    u8
                                                                                    as
                                                                                    u64)
                                                                                   <<
-                                                                                  37usize)
+                                                                                  38usize)
                                                                                  &
-                                                                                 (137438953472u64
+                                                                                 (274877906944u64
                                                                                       as
                                                                                       u64))
                                                                     } |
-                                                                        ((mHasDisplayDocument
+                                                                        ((mFontFaceSetDirty
                                                                               as
                                                                               u8
                                                                               as
                                                                               u64)
                                                                              <<
-                                                                             38usize)
+                                                                             39usize)
                                                                             &
-                                                                            (274877906944u64
+                                                                            (549755813888u64
                                                                                  as
                                                                                  u64))
                                                                } |
-                                                                   ((mFontFaceSetDirty
+                                                                   ((mGetUserFontSetCalled
                                                                          as u8
                                                                          as
                                                                          u64)
                                                                         <<
-                                                                        39usize)
+                                                                        40usize)
                                                                        &
-                                                                       (549755813888u64
+                                                                       (1099511627776u64
                                                                             as
                                                                             u64))
                                                           } |
-                                                              ((mGetUserFontSetCalled
+                                                              ((mPostedFlushUserFontSet
                                                                     as u8 as
                                                                     u64) <<
-                                                                   40usize) &
-                                                                  (1099511627776u64
+                                                                   41usize) &
+                                                                  (2199023255552u64
                                                                        as
                                                                        u64))
                                                      } |
-                                                         ((mPostedFlushUserFontSet
+                                                         ((mDidFireDOMContentLoaded
                                                                as u8 as u64)
-                                                              << 41usize) &
-                                                             (2199023255552u64
+                                                              << 42usize) &
+                                                             (4398046511104u64
                                                                   as u64))
                                                 } |
-                                                    ((mDidFireDOMContentLoaded
+                                                    ((mHasScrollLinkedEffect
                                                           as u8 as u64) <<
-                                                         42usize) &
-                                                        (4398046511104u64 as
+                                                         43usize) &
+                                                        (8796093022208u64 as
                                                              u64))
                                            } |
-                                               ((mHasScrollLinkedEffect as u8
-                                                     as u64) << 43usize) &
-                                                   (8796093022208u64 as u64))
+                                               ((mFrameRequestCallbacksScheduled
+                                                     as u8 as u64) << 44usize)
+                                                   &
+                                                   (17592186044416u64 as u64))
                                       } |
-                                          ((mFrameRequestCallbacksScheduled as
-                                                u8 as u64) << 44usize) &
-                                              (17592186044416u64 as u64))
+                                          ((mIsTopLevelContentDocument as u8
+                                                as u64) << 45usize) &
+                                              (35184372088832u64 as u64))
                                  } |
-                                     ((mIsTopLevelContentDocument as u8 as
-                                           u64) << 45usize) &
-                                         (35184372088832u64 as u64))
+                                     ((mIsContentDocument as u8 as u64) <<
+                                          46usize) &
+                                         (70368744177664u64 as u64))
                             } |
-                                ((mIsContentDocument as u8 as u64) << 46usize)
-                                    & (70368744177664u64 as u64))
+                                ((mMightHaveStaleServoData as u8 as u64) <<
+                                     47usize) & (140737488355328u64 as u64))
                        } |
-                           ((mMightHaveStaleServoData as u8 as u64) <<
-                                47usize) & (140737488355328u64 as u64))
+                           ((mDidCallBeginLoad as u8 as u64) << 48usize) &
+                               (281474976710656u64 as u64))
                   } |
-                      ((mDidCallBeginLoad as u8 as u64) << 48usize) &
-                          (281474976710656u64 as u64))
+                      ((mBufferingCSPViolations as u8 as u64) << 49usize) &
+                          (562949953421312u64 as u64))
              } |
-                 ((mIsScopedStyleEnabled as u32 as u64) << 49usize) &
-                     (1688849860263936u64 as u64))
+                 ((mIsScopedStyleEnabled as u32 as u64) << 50usize) &
+                     (3377699720527872u64 as u64))
         }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsCSSRuleProcessor {
         _unused: [u8; 0],
     }
     #[repr(C)]
@@ -25009,67 +25107,67 @@ pub mod root {
     pub struct nsDOMMutationObserver {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsRange {
         _unused: [u8; 0],
     }
-    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_LISTENERMANAGER;
-    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_PROPERTIES;
-    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_ANONYMOUS_ROOT;
-    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
-    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_NATIVE_ANONYMOUS_ROOT;
-    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_FORCE_XBL_BINDINGS;
-    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_MAY_BE_IN_BINDING_MNGR;
-    pub const NODE_IS_EDITABLE: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_EDITABLE;
-    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_NATIVE_ANONYMOUS;
-    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_IN_SHADOW_TREE;
-    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_EMPTY_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_SLOW_SELECTOR;
-    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_EDGE_CHILD_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
-    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_ALL_SELECTOR_FLAGS;
-    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_NEEDS_FRAME;
-    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_DESCENDANTS_NEED_FRAMES;
-    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_ACCESSKEY;
-    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_DIRECTION_RTL;
-    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_DIRECTION_LTR;
-    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_ALL_DIRECTION_FLAGS;
-    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_CHROME_ONLY_ACCESS;
-    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
-    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_72 {
+    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_LISTENERMANAGER;
+    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_PROPERTIES;
+    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_ANONYMOUS_ROOT;
+    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
+    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_NATIVE_ANONYMOUS_ROOT;
+    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_FORCE_XBL_BINDINGS;
+    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_MAY_BE_IN_BINDING_MNGR;
+    pub const NODE_IS_EDITABLE: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_EDITABLE;
+    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_NATIVE_ANONYMOUS;
+    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_IN_SHADOW_TREE;
+    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_EMPTY_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_SLOW_SELECTOR;
+    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_EDGE_CHILD_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
+    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_ALL_SELECTOR_FLAGS;
+    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_NEEDS_FRAME;
+    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_DESCENDANTS_NEED_FRAMES;
+    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_ACCESSKEY;
+    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_DIRECTION_RTL;
+    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_DIRECTION_LTR;
+    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_ALL_DIRECTION_FLAGS;
+    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_CHROME_ONLY_ACCESS;
+    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
+    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_84 {
         NODE_HAS_LISTENERMANAGER = 4,
         NODE_HAS_PROPERTIES = 8,
         NODE_IS_ANONYMOUS_ROOT = 16,
         NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = 32,
         NODE_IS_NATIVE_ANONYMOUS_ROOT = 64,
         NODE_FORCE_XBL_BINDINGS = 128,
         NODE_MAY_BE_IN_BINDING_MNGR = 256,
         NODE_IS_EDITABLE = 512,
@@ -32637,56 +32735,56 @@ pub mod root {
     }
     #[test]
     fn bindgen_test_layout_nsISMILAttr() {
         assert_eq!(::std::mem::size_of::<nsISMILAttr>() , 8usize , concat ! (
                    "Size of: " , stringify ! ( nsISMILAttr ) ));
         assert_eq! (::std::mem::align_of::<nsISMILAttr>() , 8usize , concat !
                     ( "Alignment of " , stringify ! ( nsISMILAttr ) ));
     }
-    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
     pub const ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO:
-              root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_74
-              =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
+              root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_86
+              =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
     pub const ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT:
-              root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
-    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_PENDING_RESTYLE_FLAGS;
-    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
-    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_ALL_RESTYLE_FLAGS;
-    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_74 {
+              root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
+    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_PENDING_RESTYLE_FLAGS;
+    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
+    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_ALL_RESTYLE_FLAGS;
+    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_86 {
         ELEMENT_SHARED_RESTYLE_BIT_1 = 8388608,
         ELEMENT_SHARED_RESTYLE_BIT_2 = 16777216,
         ELEMENT_SHARED_RESTYLE_BIT_3 = 33554432,
         ELEMENT_SHARED_RESTYLE_BIT_4 = 67108864,
         ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR = 134217728,
         ELEMENT_PENDING_RESTYLE_FLAGS = 41943040,
         ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS = 83886080,
         ELEMENT_ALL_RESTYLE_FLAGS = 260046848,
@@ -33552,17 +33650,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::gfx::FontVariation>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_200542_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_226841_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsCSSSelector>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsCSSSelector> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsCSSSelector>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsCSSSelector> ) ));
@@ -33908,17 +34006,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_202359_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_228658_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -34069,17 +34167,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::JS::DeletePolicy ) ));
         assert_eq!(::std::mem::align_of::<root::JS::DeletePolicy>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::DeletePolicy ) ));
     }
     #[test]
-    fn __bindgen_test_layout_iterator_open0_input_iterator_tag_UniquePtr_open1_JSErrorNotes_Note_DeletePolicy_open2_JSErrorNotes_Note_close2_close1_long__bindgen_ty_id_207978__bindgen_ty_id_207985_close0_instantiation() {
+    fn __bindgen_test_layout_iterator_open0_input_iterator_tag_UniquePtr_open1_JSErrorNotes_Note_DeletePolicy_open2_JSErrorNotes_Note_close2_close1_long__bindgen_ty_id_234269__bindgen_ty_id_234276_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::std::iterator ) ));
         assert_eq!(::std::mem::align_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::std::iterator ) ));
@@ -34234,16 +34332,38 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIDocument> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIDocument>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIDocument> ) ));
     }
     #[test]
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIRunnable>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIRunnable> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIRunnable>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIRunnable> ) ));
+    }
+    #[test]
     fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_AnonymousContent_close1_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
@@ -34295,17 +34415,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_210463_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_236754_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
@@ -34363,17 +34483,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIObserver> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIObserver>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIObserver> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_210765_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_237056_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
@@ -34475,17 +34595,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::URLExtraData> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::URLExtraData>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::URLExtraData> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_NotNull_open0__bindgen_ty_id_211307_close0_instantiation() {
+    fn __bindgen_test_layout_NotNull_open0__bindgen_ty_id_237598_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::mozilla::NotNull<*const root::mozilla::Encoding>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::NotNull<*const root::mozilla::Encoding> )
                    ));
         assert_eq!(::std::mem::align_of::<root::mozilla::NotNull<*const root::mozilla::Encoding>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
@@ -34800,16 +34920,38 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DocGroup> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::DocGroup>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DocGroup> ) ));
     }
     #[test]
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_1() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_1() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIRunnable>>()
+                   , 8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIRunnable> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIRunnable>>()
+                   , 8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr<root::nsIRunnable> ) ));
+    }
+    #[test]
     fn __bindgen_test_layout_RefPtr_open0_CSSRuleListImpl_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::CSSRuleListImpl>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::CSSRuleListImpl> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::CSSRuleListImpl>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
@@ -34857,17 +34999,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_211722_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_238019_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -34947,17 +35089,17 @@ pub mod root {
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::ServoStyleSheet>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::ServoStyleSheet>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_212121_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_238418_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -35048,17 +35190,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<::nsstring::nsStringRepr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_213085_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_239383_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -35137,28 +35279,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::nsCSSFontFaceRule> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::nsCSSFontFaceRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::nsCSSFontFaceRule> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_213390_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_239688_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_213395_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_239693_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -35205,17 +35347,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::CSSStyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::CSSStyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::CSSStyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_213886_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_240184_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -35853,17 +35995,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIWeakReference> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIWeakReference>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIWeakReference> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_216747_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_243035_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut ::std::os::raw::c_void>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut ::std::os::raw::c_void> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut ::std::os::raw::c_void>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut ::std::os::raw::c_void> ) ));
@@ -35932,17 +36074,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::DefaultDelete ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
                    1usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::DefaultDelete ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_223009_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_249305_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::AudioContext>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::AudioContext> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::AudioContext>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::AudioContext> ) ));
@@ -35965,28 +36107,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::CallbackObject> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::CallbackObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::CallbackObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_224170_close0_instantiation() {
+    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_250466_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_224174_close0_instantiation() {
+    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_250470_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
@@ -35998,17 +36140,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIGlobalObject> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIGlobalObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIGlobalObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_TenuredHeap_open0__bindgen_ty_id_224181_close0_instantiation() {
+    fn __bindgen_test_layout_TenuredHeap_open0__bindgen_ty_id_250477_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
         assert_eq!(::std::mem::align_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
@@ -36031,39 +36173,39 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsISupports> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation() {
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_2() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_2() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_1() {
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_3() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
@@ -36077,17 +36219,17 @@ pub mod root {
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::CycleCollectedJSContext_RunInMetastableStateData>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::CycleCollectedJSContext_RunInMetastableStateData>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_225354_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_251547_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
@@ -36272,17 +36414,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<f64>>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_226802_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_252995_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
@@ -36377,39 +36519,39 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_229225_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_255418_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::CounterStyle>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::CounterStyle> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::CounterStyle>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::CounterStyle> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_1() {
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_3() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr<root::nsIRunnable>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr<root::nsIRunnable>> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_2() {
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_4() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIRunnable>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIRunnable> ) ));
@@ -37078,17 +37220,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::nsStyleImageRequest> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::nsStyleImageRequest>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::nsStyleImageRequest> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_231778_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_257971_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
@@ -37315,28 +37457,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIURI> ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr<root::nsIURI>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr<root::nsIURI> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_239586_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_265779_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_239591_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_265784_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37414,17 +37556,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::ShadowRoot> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::ShadowRoot>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::ShadowRoot> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_239704_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_265897_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37701,17 +37843,17 @@ pub mod root {
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsAutoPtr<root::mozilla::dom::ExplicitChildIterator>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsAutoPtr<root::mozilla::dom::ExplicitChildIterator>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_241290_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_267483_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37723,28 +37865,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_241452_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_267645_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_241457_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_267650_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37866,28 +38008,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::gfx::FontVariation>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_243541_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_269734_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_243549_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_269742_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
--- a/servo/components/style/gecko/generated/structs_release.rs
+++ b/servo/components/style/gecko/generated/structs_release.rs
@@ -1047,18 +1047,16 @@ pub mod root {
         pub struct pair<_T1, _T2> {
             pub first: _T1,
             pub second: _T2,
             pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T1>>,
             pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<_T2>>,
         }
         pub type pair_first_type<_T1> = _T1;
         pub type pair_second_type<_T2> = _T2;
-        pub type pair__PCCP = u8;
-        pub type pair__PCCFP = u8;
         #[repr(C)]
         #[derive(Debug, Copy)]
         pub struct input_iterator_tag {
             pub _address: u8,
         }
         #[test]
         fn bindgen_test_layout_input_iterator_tag() {
             assert_eq!(::std::mem::size_of::<input_iterator_tag>() , 1usize ,
@@ -8126,16 +8124,61 @@ pub mod root {
             assert_eq! (unsafe {
                         & ( * ( 0 as * const PropertyStyleAnimationValuePair )
                         ) . mValue as * const _ as usize } , 8usize , concat !
                         (
                         "Alignment of field: " , stringify ! (
                         PropertyStyleAnimationValuePair ) , "::" , stringify !
                         ( mValue ) ));
         }
+        pub const OriginFlags_UserAgent: root::mozilla::OriginFlags =
+            OriginFlags(1);
+        pub const OriginFlags_User: root::mozilla::OriginFlags =
+            OriginFlags(2);
+        pub const OriginFlags_Author: root::mozilla::OriginFlags =
+            OriginFlags(4);
+        pub const OriginFlags_All: root::mozilla::OriginFlags =
+            OriginFlags(7);
+        impl ::std::ops::BitOr<root::mozilla::OriginFlags> for
+         root::mozilla::OriginFlags {
+            type
+            Output
+            =
+            Self;
+            #[inline]
+            fn bitor(self, other: Self) -> Self {
+                OriginFlags(self.0 | other.0)
+            }
+        }
+        impl ::std::ops::BitOrAssign for root::mozilla::OriginFlags {
+            #[inline]
+            fn bitor_assign(&mut self, rhs: root::mozilla::OriginFlags) {
+                self.0 |= rhs.0;
+            }
+        }
+        impl ::std::ops::BitAnd<root::mozilla::OriginFlags> for
+         root::mozilla::OriginFlags {
+            type
+            Output
+            =
+            Self;
+            #[inline]
+            fn bitand(self, other: Self) -> Self {
+                OriginFlags(self.0 & other.0)
+            }
+        }
+        impl ::std::ops::BitAndAssign for root::mozilla::OriginFlags {
+            #[inline]
+            fn bitand_assign(&mut self, rhs: root::mozilla::OriginFlags) {
+                self.0 &= rhs.0;
+            }
+        }
+        #[repr(C)]
+        #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+        pub struct OriginFlags(pub u8);
         #[test]
         fn __bindgen_test_layout_DefaultDelete_open0_RawServoStyleSet_close0_instantiation() {
             assert_eq!(::std::mem::size_of::<root::mozilla::DefaultDelete>() ,
                        1usize , concat ! (
                        "Size of template specialization: " , stringify ! (
                        root::mozilla::DefaultDelete ) ));
             assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>()
                        , 1usize , concat ! (
@@ -16680,16 +16723,17 @@ pub mod root {
         pub mUseCounters: [u64; 2usize],
         pub mChildDocumentUseCounters: [u64; 2usize],
         pub mNotifiedPageForUseCounter: [u64; 2usize],
         pub mIncCounters: u16,
         pub mUserHasInteracted: bool,
         pub mPageUnloadingEventTimeStamp: root::mozilla::TimeStamp,
         pub mDocGroup: root::RefPtr<root::mozilla::dom::DocGroup>,
         pub mTrackingScripts: [u64; 5usize],
+        pub mBufferedCSPViolations: root::nsTArray<root::nsCOMPtr>,
     }
     pub type nsIDocument_GlobalObject = root::mozilla::dom::GlobalObject;
     pub type nsIDocument_Encoding = root::mozilla::Encoding;
     pub type nsIDocument_NotNull<T> = root::mozilla::NotNull<T>;
     pub use self::super::root::mozilla::net::ReferrerPolicy as
             nsIDocument_ReferrerPolicyEnum;
     pub type nsIDocument_Element = root::mozilla::dom::Element;
     pub type nsIDocument_FullscreenRequest =
@@ -16974,17 +17018,17 @@ pub mod root {
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsIDocument_FrameRequest {
         _unused: [u8; 0],
     }
     pub const nsIDocument_kSegmentSize: usize = 128;
     #[test]
     fn bindgen_test_layout_nsIDocument() {
-        assert_eq!(::std::mem::size_of::<nsIDocument>() , 856usize , concat !
+        assert_eq!(::std::mem::size_of::<nsIDocument>() , 864usize , concat !
                    ( "Size of: " , stringify ! ( nsIDocument ) ));
         assert_eq! (::std::mem::align_of::<nsIDocument>() , 8usize , concat !
                     ( "Alignment of " , stringify ! ( nsIDocument ) ));
     }
     impl nsIDocument {
         #[inline]
         pub fn mBidiEnabled(&self) -> bool {
             let mut unit_field_val: u64 =
@@ -18843,35 +18887,34 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
-        pub fn mIsScopedStyleEnabled(&self) -> ::std::os::raw::c_uint {
-            let mut unit_field_val: u64 =
-                unsafe { ::std::mem::uninitialized() };
-            unsafe {
-                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
-                                                    as *const u8,
-                                                &mut unit_field_val as
-                                                    *mut u64 as *mut u8,
-                                                ::std::mem::size_of::<u64>())
-            };
-            let mask = 1688849860263936u64 as u64;
+        pub fn mBufferingCSPViolations(&self) -> bool {
+            let mut unit_field_val: u64 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u64 as *mut u8,
+                                                ::std::mem::size_of::<u64>())
+            };
+            let mask = 562949953421312u64 as u64;
             let val = (unit_field_val & mask) >> 49usize;
-            unsafe { ::std::mem::transmute(val as u32) }
-        }
-        #[inline]
-        pub fn set_mIsScopedStyleEnabled(&mut self,
-                                         val: ::std::os::raw::c_uint) {
-            let mask = 1688849860263936u64 as u64;
-            let val = val as u32 as u64;
+            unsafe { ::std::mem::transmute(val as u8) }
+        }
+        #[inline]
+        pub fn set_mBufferingCSPViolations(&mut self, val: bool) {
+            let mask = 562949953421312u64 as u64;
+            let val = val as u8 as u64;
             let mut unit_field_val: u64 =
                 unsafe { ::std::mem::uninitialized() };
             unsafe {
                 ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
                                                     as *const u8,
                                                 &mut unit_field_val as
                                                     *mut u64 as *mut u8,
                                                 ::std::mem::size_of::<u64>())
@@ -18882,16 +18925,55 @@ pub mod root {
                 ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
                                                     *const u8,
                                                 &mut self._bitfield_1 as
                                                     *mut _ as *mut u8,
                                                 ::std::mem::size_of::<u64>());
             }
         }
         #[inline]
+        pub fn mIsScopedStyleEnabled(&self) -> ::std::os::raw::c_uint {
+            let mut unit_field_val: u64 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u64 as *mut u8,
+                                                ::std::mem::size_of::<u64>())
+            };
+            let mask = 3377699720527872u64 as u64;
+            let val = (unit_field_val & mask) >> 50usize;
+            unsafe { ::std::mem::transmute(val as u32) }
+        }
+        #[inline]
+        pub fn set_mIsScopedStyleEnabled(&mut self,
+                                         val: ::std::os::raw::c_uint) {
+            let mask = 3377699720527872u64 as u64;
+            let val = val as u32 as u64;
+            let mut unit_field_val: u64 =
+                unsafe { ::std::mem::uninitialized() };
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&self._bitfield_1 as *const _
+                                                    as *const u8,
+                                                &mut unit_field_val as
+                                                    *mut u64 as *mut u8,
+                                                ::std::mem::size_of::<u64>())
+            };
+            unit_field_val &= !mask;
+            unit_field_val |= (val << 50usize) & mask;
+            unsafe {
+                ::std::ptr::copy_nonoverlapping(&unit_field_val as *const _ as
+                                                    *const u8,
+                                                &mut self._bitfield_1 as
+                                                    *mut _ as *mut u8,
+                                                ::std::mem::size_of::<u64>());
+            }
+        }
+        #[inline]
         pub fn new_bitfield_1(mBidiEnabled: bool, mMathMLEnabled: bool,
                               mIsInitialDocumentInWindow: bool,
                               mIgnoreDocGroupMismatches: bool,
                               mLoadedAsData: bool,
                               mLoadedAsInteractiveData: bool,
                               mMayStartLayout: bool,
                               mHaveFiredTitleChange: bool, mIsShowing: bool,
                               mVisible: bool, mHasReferrerPolicyCSP: bool,
@@ -18926,16 +19008,17 @@ pub mod root {
                               mPostedFlushUserFontSet: bool,
                               mDidFireDOMContentLoaded: bool,
                               mHasScrollLinkedEffect: bool,
                               mFrameRequestCallbacksScheduled: bool,
                               mIsTopLevelContentDocument: bool,
                               mIsContentDocument: bool,
                               mMightHaveStaleServoData: bool,
                               mDidCallBeginLoad: bool,
+                              mBufferingCSPViolations: bool,
                               mIsScopedStyleEnabled: ::std::os::raw::c_uint)
          -> u64 {
             ({
                  ({
                       ({
                            ({
                                 ({
                                      ({
@@ -18978,577 +19061,592 @@ pub mod root {
                                                                                                                                                                                                                               ({
                                                                                                                                                                                                                                    ({
                                                                                                                                                                                                                                         ({
                                                                                                                                                                                                                                              ({
                                                                                                                                                                                                                                                   ({
                                                                                                                                                                                                                                                        ({
                                                                                                                                                                                                                                                             ({
                                                                                                                                                                                                                                                                  ({
-                                                                                                                                                                                                                                                                      0
+                                                                                                                                                                                                                                                                      ({
+                                                                                                                                                                                                                                                                           0
+                                                                                                                                                                                                                                                                       }
+                                                                                                                                                                                                                                                                           |
+                                                                                                                                                                                                                                                                           ((mBidiEnabled
+                                                                                                                                                                                                                                                                                 as
+                                                                                                                                                                                                                                                                                 u8
+                                                                                                                                                                                                                                                                                 as
+                                                                                                                                                                                                                                                                                 u64)
+                                                                                                                                                                                                                                                                                <<
+                                                                                                                                                                                                                                                                                0usize)
+                                                                                                                                                                                                                                                                               &
+                                                                                                                                                                                                                                                                               (1u64
+                                                                                                                                                                                                                                                                                    as
+                                                                                                                                                                                                                                                                                    u64))
                                                                                                                                                                                                                                                                   }
                                                                                                                                                                                                                                                                       |
-                                                                                                                                                                                                                                                                      ((mBidiEnabled
+                                                                                                                                                                                                                                                                      ((mMathMLEnabled
                                                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                                                             u8
                                                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                                                             u64)
                                                                                                                                                                                                                                                                            <<
-                                                                                                                                                                                                                                                                           0usize)
+                                                                                                                                                                                                                                                                           1usize)
                                                                                                                                                                                                                                                                           &
-                                                                                                                                                                                                                                                                          (1u64
+                                                                                                                                                                                                                                                                          (2u64
                                                                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                                                                u64))
                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                  |
-                                                                                                                                                                                                                                                                 ((mMathMLEnabled
+                                                                                                                                                                                                                                                                 ((mIsInitialDocumentInWindow
                                                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                                                        u8
                                                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                                                        u64)
                                                                                                                                                                                                                                                                       <<
-                                                                                                                                                                                                                                                                      1usize)
+                                                                                                                                                                                                                                                                      2usize)
                                                                                                                                                                                                                                                                      &
-                                                                                                                                                                                                                                                                     (2u64
+                                                                                                                                                                                                                                                                     (4u64
                                                                                                                                                                                                                                                                           as
                                                                                                                                                                                                                                                                           u64))
                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                             |
-                                                                                                                                                                                                                                                            ((mIsInitialDocumentInWindow
+                                                                                                                                                                                                                                                            ((mIgnoreDocGroupMismatches
                                                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                                                   u8
                                                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                                                   u64)
                                                                                                                                                                                                                                                                  <<
-                                                                                                                                                                                                                                                                 2usize)
+                                                                                                                                                                                                                                                                 3usize)
                                                                                                                                                                                                                                                                 &
-                                                                                                                                                                                                                                                                (4u64
+                                                                                                                                                                                                                                                                (8u64
                                                                                                                                                                                                                                                                      as
                                                                                                                                                                                                                                                                      u64))
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                        |
-                                                                                                                                                                                                                                                       ((mIgnoreDocGroupMismatches
+                                                                                                                                                                                                                                                       ((mLoadedAsData
                                                                                                                                                                                                                                                              as
                                                                                                                                                                                                                                                              u8
                                                                                                                                                                                                                                                              as
                                                                                                                                                                                                                                                              u64)
                                                                                                                                                                                                                                                             <<
-                                                                                                                                                                                                                                                            3usize)
+                                                                                                                                                                                                                                                            4usize)
                                                                                                                                                                                                                                                            &
-                                                                                                                                                                                                                                                           (8u64
+                                                                                                                                                                                                                                                           (16u64
                                                                                                                                                                                                                                                                 as
                                                                                                                                                                                                                                                                 u64))
                                                                                                                                                                                                                                               }
                                                                                                                                                                                                                                                   |
-                                                                                                                                                                                                                                                  ((mLoadedAsData
+                                                                                                                                                                                                                                                  ((mLoadedAsInteractiveData
                                                                                                                                                                                                                                                         as
                                                                                                                                                                                                                                                         u8
                                                                                                                                                                                                                                                         as
                                                                                                                                                                                                                                                         u64)
                                                                                                                                                                                                                                                        <<
-                                                                                                                                                                                                                                                       4usize)
+                                                                                                                                                                                                                                                       5usize)
                                                                                                                                                                                                                                                       &
-                                                                                                                                                                                                                                                      (16u64
+                                                                                                                                                                                                                                                      (32u64
                                                                                                                                                                                                                                                            as
                                                                                                                                                                                                                                                            u64))
                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                              |
-                                                                                                                                                                                                                                             ((mLoadedAsInteractiveData
+                                                                                                                                                                                                                                             ((mMayStartLayout
                                                                                                                                                                                                                                                    as
                                                                                                                                                                                                                                                    u8
                                                                                                                                                                                                                                                    as
                                                                                                                                                                                                                                                    u64)
                                                                                                                                                                                                                                                   <<
-                                                                                                                                                                                                                                                  5usize)
+                                                                                                                                                                                                                                                  6usize)
                                                                                                                                                                                                                                                  &
-                                                                                                                                                                                                                                                 (32u64
+                                                                                                                                                                                                                                                 (64u64
                                                                                                                                                                                                                                                       as
                                                                                                                                                                                                                                                       u64))
                                                                                                                                                                                                                                     }
                                                                                                                                                                                                                                         |
-                                                                                                                                                                                                                                        ((mMayStartLayout
+                                                                                                                                                                                                                                        ((mHaveFiredTitleChange
                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                               u8
                                                                                                                                                                                                                                               as
                                                                                                                                                                                                                                               u64)
                                                                                                                                                                                                                                              <<
-                                                                                                                                                                                                                                             6usize)
+                                                                                                                                                                                                                                             7usize)
                                                                                                                                                                                                                                             &
-                                                                                                                                                                                                                                            (64u64
+                                                                                                                                                                                                                                            (128u64
                                                                                                                                                                                                                                                  as
                                                                                                                                                                                                                                                  u64))
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                    |
-                                                                                                                                                                                                                                   ((mHaveFiredTitleChange
+                                                                                                                                                                                                                                   ((mIsShowing
                                                                                                                                                                                                                                          as
                                                                                                                                                                                                                                          u8
                                                                                                                                                                                                                                          as
                                                                                                                                                                                                                                          u64)
                                                                                                                                                                                                                                         <<
-                                                                                                                                                                                                                                        7usize)
+                                                                                                                                                                                                                                        8usize)
                                                                                                                                                                                                                                        &
-                                                                                                                                                                                                                                       (128u64
+                                                                                                                                                                                                                                       (256u64
                                                                                                                                                                                                                                             as
                                                                                                                                                                                                                                             u64))
                                                                                                                                                                                                                           }
                                                                                                                                                                                                                               |
-                                                                                                                                                                                                                              ((mIsShowing
+                                                                                                                                                                                                                              ((mVisible
                                                                                                                                                                                                                                     as
                                                                                                                                                                                                                                     u8
                                                                                                                                                                                                                                     as
                                                                                                                                                                                                                                     u64)
                                                                                                                                                                                                                                    <<
-                                                                                                                                                                                                                                   8usize)
+                                                                                                                                                                                                                                   9usize)
                                                                                                                                                                                                                                   &
-                                                                                                                                                                                                                                  (256u64
+                                                                                                                                                                                                                                  (512u64
                                                                                                                                                                                                                                        as
                                                                                                                                                                                                                                        u64))
                                                                                                                                                                                                                      }
                                                                                                                                                                                                                          |
-                                                                                                                                                                                                                         ((mVisible
+                                                                                                                                                                                                                         ((mHasReferrerPolicyCSP
                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                u8
                                                                                                                                                                                                                                as
                                                                                                                                                                                                                                u64)
                                                                                                                                                                                                                               <<
-                                                                                                                                                                                                                              9usize)
+                                                                                                                                                                                                                              10usize)
                                                                                                                                                                                                                              &
-                                                                                                                                                                                                                             (512u64
+                                                                                                                                                                                                                             (1024u64
                                                                                                                                                                                                                                   as
                                                                                                                                                                                                                                   u64))
                                                                                                                                                                                                                 }
                                                                                                                                                                                                                     |
-                                                                                                                                                                                                                    ((mHasReferrerPolicyCSP
+                                                                                                                                                                                                                    ((mRemovedFromDocShell
                                                                                                                                                                                                                           as
                                                                                                                                                                                                                           u8
                                                                                                                                                                                                                           as
                                                                                                                                                                                                                           u64)
                                                                                                                                                                                                                          <<
-                                                                                                                                                                                                                         10usize)
+                                                                                                                                                                                                                         11usize)
                                                                                                                                                                                                                         &
-                                                                                                                                                                                                                        (1024u64
+                                                                                                                                                                                                                        (2048u64
                                                                                                                                                                                                                              as
                                                                                                                                                                                                                              u64))
                                                                                                                                                                                                            }
                                                                                                                                                                                                                |
-                                                                                                                                                                                                               ((mRemovedFromDocShell
+                                                                                                                                                                                                               ((mAllowDNSPrefetch
                                                                                                                                                                                                                      as
                                                                                                                                                                                                                      u8
                                                                                                                                                                                                                      as
                                                                                                                                                                                                                      u64)
                                                                                                                                                                                                                     <<
-                                                                                                                                                                                                                    11usize)
+                                                                                                                                                                                                                    12usize)
                                                                                                                                                                                                                    &
-                                                                                                                                                                                                                   (2048u64
+                                                                                                                                                                                                                   (4096u64
                                                                                                                                                                                                                         as
                                                                                                                                                                                                                         u64))
                                                                                                                                                                                                       }
                                                                                                                                                                                                           |
-                                                                                                                                                                                                          ((mAllowDNSPrefetch
+                                                                                                                                                                                                          ((mIsStaticDocument
                                                                                                                                                                                                                 as
                                                                                                                                                                                                                 u8
                                                                                                                                                                                                                 as
                                                                                                                                                                                                                 u64)
                                                                                                                                                                                                                <<
-                                                                                                                                                                                                               12usize)
+                                                                                                                                                                                                               13usize)
                                                                                                                                                                                                               &
-                                                                                                                                                                                                              (4096u64
+                                                                                                                                                                                                              (8192u64
                                                                                                                                                                                                                    as
                                                                                                                                                                                                                    u64))
                                                                                                                                                                                                  }
                                                                                                                                                                                                      |
-                                                                                                                                                                                                     ((mIsStaticDocument
+                                                                                                                                                                                                     ((mCreatingStaticClone
                                                                                                                                                                                                            as
                                                                                                                                                                                                            u8
                                                                                                                                                                                                            as
                                                                                                                                                                                                            u64)
                                                                                                                                                                                                           <<
-                                                                                                                                                                                                          13usize)
+                                                                                                                                                                                                          14usize)
                                                                                                                                                                                                          &
-                                                                                                                                                                                                         (8192u64
+                                                                                                                                                                                                         (16384u64
                                                                                                                                                                                                               as
                                                                                                                                                                                                               u64))
                                                                                                                                                                                             }
                                                                                                                                                                                                 |
-                                                                                                                                                                                                ((mCreatingStaticClone
+                                                                                                                                                                                                ((mInUnlinkOrDeletion
                                                                                                                                                                                                       as
                                                                                                                                                                                                       u8
                                                                                                                                                                                                       as
                                                                                                                                                                                                       u64)
                                                                                                                                                                                                      <<
-                                                                                                                                                                                                     14usize)
+                                                                                                                                                                                                     15usize)
                                                                                                                                                                                                     &
-                                                                                                                                                                                                    (16384u64
+                                                                                                                                                                                                    (32768u64
                                                                                                                                                                                                          as
                                                                                                                                                                                                          u64))
                                                                                                                                                                                        }
                                                                                                                                                                                            |
-                                                                                                                                                                                           ((mInUnlinkOrDeletion
+                                                                                                                                                                                           ((mHasHadScriptHandlingObject
                                                                                                                                                                                                  as
                                                                                                                                                                                                  u8
                                                                                                                                                                                                  as
                                                                                                                                                                                                  u64)
                                                                                                                                                                                                 <<
-                                                                                                                                                                                                15usize)
+                                                                                                                                                                                                16usize)
                                                                                                                                                                                                &
-                                                                                                                                                                                               (32768u64
+                                                                                                                                                                                               (65536u64
                                                                                                                                                                                                     as
                                                                                                                                                                                                     u64))
                                                                                                                                                                                   }
                                                                                                                                                                                       |
-                                                                                                                                                                                      ((mHasHadScriptHandlingObject
+                                                                                                                                                                                      ((mIsBeingUsedAsImage
                                                                                                                                                                                             as
                                                                                                                                                                                             u8
                                                                                                                                                                                             as
                                                                                                                                                                                             u64)
                                                                                                                                                                                            <<
-                                                                                                                                                                                           16usize)
+                                                                                                                                                                                           17usize)
                                                                                                                                                                                           &
-                                                                                                                                                                                          (65536u64
+                                                                                                                                                                                          (131072u64
                                                                                                                                                                                                as
                                                                                                                                                                                                u64))
                                                                                                                                                                              }
                                                                                                                                                                                  |
-                                                                                                                                                                                 ((mIsBeingUsedAsImage
+                                                                                                                                                                                 ((mIsSyntheticDocument
                                                                                                                                                                                        as
                                                                                                                                                                                        u8
                                                                                                                                                                                        as
                                                                                                                                                                                        u64)
                                                                                                                                                                                       <<
-                                                                                                                                                                                      17usize)
+                                                                                                                                                                                      18usize)
                                                                                                                                                                                      &
-                                                                                                                                                                                     (131072u64
+                                                                                                                                                                                     (262144u64
                                                                                                                                                                                           as
                                                                                                                                                                                           u64))
                                                                                                                                                                         }
                                                                                                                                                                             |
-                                                                                                                                                                            ((mIsSyntheticDocument
+                                                                                                                                                                            ((mHasLinksToUpdate
                                                                                                                                                                                   as
                                                                                                                                                                                   u8
                                                                                                                                                                                   as
                                                                                                                                                                                   u64)
                                                                                                                                                                                  <<
-                                                                                                                                                                                 18usize)
+                                                                                                                                                                                 19usize)
                                                                                                                                                                                 &
-                                                                                                                                                                                (262144u64
+                                                                                                                                                                                (524288u64
                                                                                                                                                                                      as
                                                                                                                                                                                      u64))
                                                                                                                                                                    }
                                                                                                                                                                        |
-                                                                                                                                                                       ((mHasLinksToUpdate
+                                                                                                                                                                       ((mHasLinksToUpdateRunnable
                                                                                                                                                                              as
                                                                                                                                                                              u8
                                                                                                                                                                              as
                                                                                                                                                                              u64)
                                                                                                                                                                             <<
-                                                                                                                                                                            19usize)
+                                                                                                                                                                            20usize)
                                                                                                                                                                            &
-                                                                                                                                                                           (524288u64
+                                                                                                                                                                           (1048576u64
                                                                                                                                                                                 as
                                                                                                                                                                                 u64))
                                                                                                                                                               }
                                                                                                                                                                   |
-                                                                                                                                                                  ((mHasLinksToUpdateRunnable
+                                                                                                                                                                  ((mMayHaveDOMMutationObservers
                                                                                                                                                                         as
                                                                                                                                                                         u8
                                                                                                                                                                         as
                                                                                                                                                                         u64)
                                                                                                                                                                        <<
-                                                                                                                                                                       20usize)
+                                                                                                                                                                       21usize)
                                                                                                                                                                       &
-                                                                                                                                                                      (1048576u64
+                                                                                                                                                                      (2097152u64
                                                                                                                                                                            as
                                                                                                                                                                            u64))
                                                                                                                                                          }
                                                                                                                                                              |
-                                                                                                                                                             ((mMayHaveDOMMutationObservers
+                                                                                                                                                             ((mMayHaveAnimationObservers
                                                                                                                                                                    as
                                                                                                                                                                    u8
                                                                                                                                                                    as
                                                                                                                                                                    u64)
                                                                                                                                                                   <<
-                                                                                                                                                                  21usize)
+                                                                                                                                                                  22usize)
                                                                                                                                                                  &
-                                                                                                                                                                 (2097152u64
+                                                                                                                                                                 (4194304u64
                                                                                                                                                                       as
                                                                                                                                                                       u64))
                                                                                                                                                     }
                                                                                                                                                         |
-                                                                                                                                                        ((mMayHaveAnimationObservers
+                                                                                                                                                        ((mHasMixedActiveContentLoaded
                                                                                                                                                               as
                                                                                                                                                               u8
                                                                                                                                                               as
                                                                                                                                                               u64)
                                                                                                                                                              <<
-                                                                                                                                                             22usize)
+                                                                                                                                                             23usize)
                                                                                                                                                             &
-                                                                                                                                                            (4194304u64
+                                                                                                                                                            (8388608u64
                                                                                                                                                                  as
                                                                                                                                                                  u64))
                                                                                                                                                }
                                                                                                                                                    |
-                                                                                                                                                   ((mHasMixedActiveContentLoaded
+                                                                                                                                                   ((mHasMixedActiveContentBlocked
                                                                                                                                                          as
                                                                                                                                                          u8
                                                                                                                                                          as
                                                                                                                                                          u64)
                                                                                                                                                         <<
-                                                                                                                                                        23usize)
+                                                                                                                                                        24usize)
                                                                                                                                                        &
-                                                                                                                                                       (8388608u64
+                                                                                                                                                       (16777216u64
                                                                                                                                                             as
                                                                                                                                                             u64))
                                                                                                                                           }
                                                                                                                                               |
-                                                                                                                                              ((mHasMixedActiveContentBlocked
+                                                                                                                                              ((mHasMixedDisplayContentLoaded
                                                                                                                                                     as
                                                                                                                                                     u8
                                                                                                                                                     as
                                                                                                                                                     u64)
                                                                                                                                                    <<
-                                                                                                                                                   24usize)
+                                                                                                                                                   25usize)
                                                                                                                                                   &
-                                                                                                                                                  (16777216u64
+                                                                                                                                                  (33554432u64
                                                                                                                                                        as
                                                                                                                                                        u64))
                                                                                                                                      }
                                                                                                                                          |
-                                                                                                                                         ((mHasMixedDisplayContentLoaded
+                                                                                                                                         ((mHasMixedDisplayContentBlocked
                                                                                                                                                as
                                                                                                                                                u8
                                                                                                                                                as
                                                                                                                                                u64)
                                                                                                                                               <<
-                                                                                                                                              25usize)
+                                                                                                                                              26usize)
                                                                                                                                              &
-                                                                                                                                             (33554432u64
+                                                                                                                                             (67108864u64
                                                                                                                                                   as
                                                                                                                                                   u64))
                                                                                                                                 }
                                                                                                                                     |
-                                                                                                                                    ((mHasMixedDisplayContentBlocked
+                                                                                                                                    ((mHasMixedContentObjectSubrequest
                                                                                                                                           as
                                                                                                                                           u8
                                                                                                                                           as
                                                                                                                                           u64)
                                                                                                                                          <<
-                                                                                                                                         26usize)
+                                                                                                                                         27usize)
                                                                                                                                         &
-                                                                                                                                        (67108864u64
+                                                                                                                                        (134217728u64
                                                                                                                                              as
                                                                                                                                              u64))
                                                                                                                            }
                                                                                                                                |
-                                                                                                                               ((mHasMixedContentObjectSubrequest
+                                                                                                                               ((mHasCSP
                                                                                                                                      as
                                                                                                                                      u8
                                                                                                                                      as
                                                                                                                                      u64)
                                                                                                                                     <<
-                                                                                                                                    27usize)
+                                                                                                                                    28usize)
                                                                                                                                    &
-                                                                                                                                   (134217728u64
+                                                                                                                                   (268435456u64
                                                                                                                                         as
                                                                                                                                         u64))
                                                                                                                       }
                                                                                                                           |
-                                                                                                                          ((mHasCSP
+                                                                                                                          ((mHasUnsafeEvalCSP
                                                                                                                                 as
                                                                                                                                 u8
                                                                                                                                 as
                                                                                                                                 u64)
                                                                                                                                <<
-                                                                                                                               28usize)
+                                                                                                                               29usize)
                                                                                                                               &
-                                                                                                                              (268435456u64
+                                                                                                                              (536870912u64
                                                                                                                                    as
                                                                                                                                    u64))
                                                                                                                  }
                                                                                                                      |
-                                                                                                                     ((mHasUnsafeEvalCSP
+                                                                                                                     ((mHasUnsafeInlineCSP
                                                                                                                            as
                                                                                                                            u8
                                                                                                                            as
                                                                                                                            u64)
                                                                                                                           <<
-                                                                                                                          29usize)
+                                                                                                                          30usize)
                                                                                                                          &
-                                                                                                                         (536870912u64
+                                                                                                                         (1073741824u64
                                                                                                                               as
                                                                                                                               u64))
                                                                                                             }
                                                                                                                 |
-                                                                                                                ((mHasUnsafeInlineCSP
+                                                                                                                ((mHasTrackingContentBlocked
                                                                                                                       as
                                                                                                                       u8
                                                                                                                       as
                                                                                                                       u64)
                                                                                                                      <<
-                                                                                                                     30usize)
+                                                                                                                     31usize)
                                                                                                                     &
-                                                                                                                    (1073741824u64
+                                                                                                                    (2147483648u64
                                                                                                                          as
                                                                                                                          u64))
                                                                                                        }
                                                                                                            |
-                                                                                                           ((mHasTrackingContentBlocked
+                                                                                                           ((mHasTrackingContentLoaded
                                                                                                                  as
                                                                                                                  u8
                                                                                                                  as
                                                                                                                  u64)
                                                                                                                 <<
-                                                                                                                31usize)
+                                                                                                                32usize)
                                                                                                                &
-                                                                                                               (2147483648u64
+                                                                                                               (4294967296u64
                                                                                                                     as
                                                                                                                     u64))
                                                                                                   }
                                                                                                       |
-                                                                                                      ((mHasTrackingContentLoaded
+                                                                                                      ((mBFCacheDisallowed
                                                                                                             as
                                                                                                             u8
                                                                                                             as
                                                                                                             u64)
                                                                                                            <<
-                                                                                                           32usize)
+                                                                                                           33usize)
                                                                                                           &
-                                                                                                          (4294967296u64
+                                                                                                          (8589934592u64
                                                                                                                as
                                                                                                                u64))
                                                                                              }
                                                                                                  |
-                                                                                                 ((mBFCacheDisallowed
+                                                                                                 ((mHasHadDefaultView
                                                                                                        as
                                                                                                        u8
                                                                                                        as
                                                                                                        u64)
                                                                                                       <<
-                                                                                                      33usize)
+                                                                                                      34usize)
                                                                                                      &
-                                                                                                     (8589934592u64
+                                                                                                     (17179869184u64
                                                                                                           as
                                                                                                           u64))
                                                                                         }
                                                                                             |
-                                                                                            ((mHasHadDefaultView
+                                                                                            ((mStyleSheetChangeEventsEnabled
                                                                                                   as
                                                                                                   u8
                                                                                                   as
                                                                                                   u64)
                                                                                                  <<
-                                                                                                 34usize)
+                                                                                                 35usize)
                                                                                                 &
-                                                                                                (17179869184u64
+                                                                                                (34359738368u64
                                                                                                      as
                                                                                                      u64))
                                                                                    }
                                                                                        |
-                                                                                       ((mStyleSheetChangeEventsEnabled
+                                                                                       ((mIsSrcdocDocument
                                                                                              as
                                                                                              u8
                                                                                              as
                                                                                              u64)
                                                                                             <<
-                                                                                            35usize)
+                                                                                            36usize)
                                                                                            &
-                                                                                           (34359738368u64
+                                                                                           (68719476736u64
                                                                                                 as
                                                                                                 u64))
                                                                               }
                                                                                   |
-                                                                                  ((mIsSrcdocDocument
+                                                                                  ((mDidDocumentOpen
                                                                                         as
                                                                                         u8
                                                                                         as
                                                                                         u64)
                                                                                        <<
-                                                                                       36usize)
+                                                                                       37usize)
                                                                                       &
-                                                                                      (68719476736u64
+                                                                                      (137438953472u64
                                                                                            as
                                                                                            u64))
                                                                          } |
-                                                                             ((mDidDocumentOpen
+                                                                             ((mHasDisplayDocument
                                                                                    as
                                                                                    u8
                                                                                    as
                                                                                    u64)
                                                                                   <<
-                                                                                  37usize)
+                                                                                  38usize)
                                                                                  &
-                                                                                 (137438953472u64
+                                                                                 (274877906944u64
                                                                                       as
                                                                                       u64))
                                                                     } |
-                                                                        ((mHasDisplayDocument
+                                                                        ((mFontFaceSetDirty
                                                                               as
                                                                               u8
                                                                               as
                                                                               u64)
                                                                              <<
-                                                                             38usize)
+                                                                             39usize)
                                                                             &
-                                                                            (274877906944u64
+                                                                            (549755813888u64
                                                                                  as
                                                                                  u64))
                                                                } |
-                                                                   ((mFontFaceSetDirty
+                                                                   ((mGetUserFontSetCalled
                                                                          as u8
                                                                          as
                                                                          u64)
                                                                         <<
-                                                                        39usize)
+                                                                        40usize)
                                                                        &
-                                                                       (549755813888u64
+                                                                       (1099511627776u64
                                                                             as
                                                                             u64))
                                                           } |
-                                                              ((mGetUserFontSetCalled
+                                                              ((mPostedFlushUserFontSet
                                                                     as u8 as
                                                                     u64) <<
-                                                                   40usize) &
-                                                                  (1099511627776u64
+                                                                   41usize) &
+                                                                  (2199023255552u64
                                                                        as
                                                                        u64))
                                                      } |
-                                                         ((mPostedFlushUserFontSet
+                                                         ((mDidFireDOMContentLoaded
                                                                as u8 as u64)
-                                                              << 41usize) &
-                                                             (2199023255552u64
+                                                              << 42usize) &
+                                                             (4398046511104u64
                                                                   as u64))
                                                 } |
-                                                    ((mDidFireDOMContentLoaded
+                                                    ((mHasScrollLinkedEffect
                                                           as u8 as u64) <<
-                                                         42usize) &
-                                                        (4398046511104u64 as
+                                                         43usize) &
+                                                        (8796093022208u64 as
                                                              u64))
                                            } |
-                                               ((mHasScrollLinkedEffect as u8
-                                                     as u64) << 43usize) &
-                                                   (8796093022208u64 as u64))
+                                               ((mFrameRequestCallbacksScheduled
+                                                     as u8 as u64) << 44usize)
+                                                   &
+                                                   (17592186044416u64 as u64))
                                       } |
-                                          ((mFrameRequestCallbacksScheduled as
-                                                u8 as u64) << 44usize) &
-                                              (17592186044416u64 as u64))
+                                          ((mIsTopLevelContentDocument as u8
+                                                as u64) << 45usize) &
+                                              (35184372088832u64 as u64))
                                  } |
-                                     ((mIsTopLevelContentDocument as u8 as
-                                           u64) << 45usize) &
-                                         (35184372088832u64 as u64))
+                                     ((mIsContentDocument as u8 as u64) <<
+                                          46usize) &
+                                         (70368744177664u64 as u64))
                             } |
-                                ((mIsContentDocument as u8 as u64) << 46usize)
-                                    & (70368744177664u64 as u64))
+                                ((mMightHaveStaleServoData as u8 as u64) <<
+                                     47usize) & (140737488355328u64 as u64))
                        } |
-                           ((mMightHaveStaleServoData as u8 as u64) <<
-                                47usize) & (140737488355328u64 as u64))
+                           ((mDidCallBeginLoad as u8 as u64) << 48usize) &
+                               (281474976710656u64 as u64))
                   } |
-                      ((mDidCallBeginLoad as u8 as u64) << 48usize) &
-                          (281474976710656u64 as u64))
+                      ((mBufferingCSPViolations as u8 as u64) << 49usize) &
+                          (562949953421312u64 as u64))
              } |
-                 ((mIsScopedStyleEnabled as u32 as u64) << 49usize) &
-                     (1688849860263936u64 as u64))
+                 ((mIsScopedStyleEnabled as u32 as u64) << 50usize) &
+                     (3377699720527872u64 as u64))
         }
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsCSSRuleProcessor {
         _unused: [u8; 0],
     }
     #[repr(C)]
@@ -24613,67 +24711,67 @@ pub mod root {
     pub struct nsDOMMutationObserver {
         _unused: [u8; 0],
     }
     #[repr(C)]
     #[derive(Debug, Copy, Clone)]
     pub struct nsRange {
         _unused: [u8; 0],
     }
-    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_LISTENERMANAGER;
-    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_PROPERTIES;
-    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_ANONYMOUS_ROOT;
-    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
-    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_NATIVE_ANONYMOUS_ROOT;
-    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_FORCE_XBL_BINDINGS;
-    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_MAY_BE_IN_BINDING_MNGR;
-    pub const NODE_IS_EDITABLE: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_EDITABLE;
-    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_NATIVE_ANONYMOUS;
-    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_IN_SHADOW_TREE;
-    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_EMPTY_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_SLOW_SELECTOR;
-    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_EDGE_CHILD_SELECTOR;
-    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
-    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_ALL_SELECTOR_FLAGS;
-    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_NEEDS_FRAME;
-    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_DESCENDANTS_NEED_FRAMES;
-    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_ACCESSKEY;
-    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_DIRECTION_RTL;
-    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_HAS_DIRECTION_LTR;
-    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_ALL_DIRECTION_FLAGS;
-    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_CHROME_ONLY_ACCESS;
-    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
-    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_72 =
-        _bindgen_ty_72::NODE_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_72 {
+    pub const NODE_HAS_LISTENERMANAGER: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_LISTENERMANAGER;
+    pub const NODE_HAS_PROPERTIES: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_PROPERTIES;
+    pub const NODE_IS_ANONYMOUS_ROOT: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_ANONYMOUS_ROOT;
+    pub const NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE;
+    pub const NODE_IS_NATIVE_ANONYMOUS_ROOT: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_NATIVE_ANONYMOUS_ROOT;
+    pub const NODE_FORCE_XBL_BINDINGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_FORCE_XBL_BINDINGS;
+    pub const NODE_MAY_BE_IN_BINDING_MNGR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_MAY_BE_IN_BINDING_MNGR;
+    pub const NODE_IS_EDITABLE: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_EDITABLE;
+    pub const NODE_IS_NATIVE_ANONYMOUS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_NATIVE_ANONYMOUS;
+    pub const NODE_IS_IN_SHADOW_TREE: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_IN_SHADOW_TREE;
+    pub const NODE_HAS_EMPTY_SELECTOR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_EMPTY_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_SLOW_SELECTOR;
+    pub const NODE_HAS_EDGE_CHILD_SELECTOR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_EDGE_CHILD_SELECTOR;
+    pub const NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS;
+    pub const NODE_ALL_SELECTOR_FLAGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_ALL_SELECTOR_FLAGS;
+    pub const NODE_NEEDS_FRAME: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_NEEDS_FRAME;
+    pub const NODE_DESCENDANTS_NEED_FRAMES: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_DESCENDANTS_NEED_FRAMES;
+    pub const NODE_HAS_ACCESSKEY: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_ACCESSKEY;
+    pub const NODE_HAS_DIRECTION_RTL: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_DIRECTION_RTL;
+    pub const NODE_HAS_DIRECTION_LTR: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_HAS_DIRECTION_LTR;
+    pub const NODE_ALL_DIRECTION_FLAGS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_ALL_DIRECTION_FLAGS;
+    pub const NODE_CHROME_ONLY_ACCESS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_CHROME_ONLY_ACCESS;
+    pub const NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS;
+    pub const NODE_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_84 =
+        _bindgen_ty_84::NODE_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_84 {
         NODE_HAS_LISTENERMANAGER = 4,
         NODE_HAS_PROPERTIES = 8,
         NODE_IS_ANONYMOUS_ROOT = 16,
         NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = 32,
         NODE_IS_NATIVE_ANONYMOUS_ROOT = 64,
         NODE_FORCE_XBL_BINDINGS = 128,
         NODE_MAY_BE_IN_BINDING_MNGR = 256,
         NODE_IS_EDITABLE = 512,
@@ -32145,56 +32243,56 @@ pub mod root {
     }
     #[test]
     fn bindgen_test_layout_nsISMILAttr() {
         assert_eq!(::std::mem::size_of::<nsISMILAttr>() , 8usize , concat ! (
                    "Size of: " , stringify ! ( nsISMILAttr ) ));
         assert_eq! (::std::mem::align_of::<nsISMILAttr>() , 8usize , concat !
                     ( "Alignment of " , stringify ! ( nsISMILAttr ) ));
     }
-    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_1: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_2: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_3: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_SHARED_RESTYLE_BIT_4: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_DIRTY_DESCENDANTS_FOR_SERVO: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
     pub const ELEMENT_HAS_ANIMATION_ONLY_DIRTY_DESCENDANTS_FOR_SERVO:
-              root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
-    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_1;
-    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_2;
-    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_74
-              =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_3;
+              root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_SNAPSHOT: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
+    pub const ELEMENT_HANDLED_SNAPSHOT: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_HAS_PENDING_RESTYLE: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_1;
+    pub const ELEMENT_IS_POTENTIAL_RESTYLE_ROOT: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_2;
+    pub const ELEMENT_HAS_PENDING_ANIMATION_ONLY_RESTYLE: root::_bindgen_ty_86
+              =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_3;
     pub const ELEMENT_IS_POTENTIAL_ANIMATION_ONLY_RESTYLE_ROOT:
-              root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_SHARED_RESTYLE_BIT_4;
-    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
-    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_PENDING_RESTYLE_FLAGS;
-    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
-    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_ALL_RESTYLE_FLAGS;
-    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_74 =
-        _bindgen_ty_74::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
-    #[repr(u32)]
-    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-    pub enum _bindgen_ty_74 {
+              root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_SHARED_RESTYLE_BIT_4;
+    pub const ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR;
+    pub const ELEMENT_PENDING_RESTYLE_FLAGS: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_PENDING_RESTYLE_FLAGS;
+    pub const ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS;
+    pub const ELEMENT_ALL_RESTYLE_FLAGS: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_ALL_RESTYLE_FLAGS;
+    pub const ELEMENT_TYPE_SPECIFIC_BITS_OFFSET: root::_bindgen_ty_86 =
+        _bindgen_ty_86::ELEMENT_TYPE_SPECIFIC_BITS_OFFSET;
+    #[repr(u32)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+    pub enum _bindgen_ty_86 {
         ELEMENT_SHARED_RESTYLE_BIT_1 = 8388608,
         ELEMENT_SHARED_RESTYLE_BIT_2 = 16777216,
         ELEMENT_SHARED_RESTYLE_BIT_3 = 33554432,
         ELEMENT_SHARED_RESTYLE_BIT_4 = 67108864,
         ELEMENT_IS_CONDITIONAL_RESTYLE_ANCESTOR = 134217728,
         ELEMENT_PENDING_RESTYLE_FLAGS = 41943040,
         ELEMENT_POTENTIAL_RESTYLE_ROOT_FLAGS = 83886080,
         ELEMENT_ALL_RESTYLE_FLAGS = 260046848,
@@ -33060,17 +33158,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::gfx::FontVariation>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_198181_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_224480_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsCSSSelector>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsCSSSelector> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsCSSSelector>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsCSSSelector> ) ));
@@ -33416,17 +33514,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::binding_danger::TErrorResult>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::binding_danger::TErrorResult ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_199964_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_226263_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -33577,17 +33675,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::JS::DeletePolicy ) ));
         assert_eq!(::std::mem::align_of::<root::JS::DeletePolicy>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::DeletePolicy ) ));
     }
     #[test]
-    fn __bindgen_test_layout_iterator_open0_input_iterator_tag_UniquePtr_open1_JSErrorNotes_Note_DeletePolicy_open2_JSErrorNotes_Note_close2_close1_long__bindgen_ty_id_205555__bindgen_ty_id_205562_close0_instantiation() {
+    fn __bindgen_test_layout_iterator_open0_input_iterator_tag_UniquePtr_open1_JSErrorNotes_Note_DeletePolicy_open2_JSErrorNotes_Note_close2_close1_long__bindgen_ty_id_231846__bindgen_ty_id_231853_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::std::iterator ) ));
         assert_eq!(::std::mem::align_of::<root::std::iterator>() , 1usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::std::iterator ) ));
@@ -33742,16 +33840,38 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr>>() ,
+                   8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr>>() ,
+                   8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
+                   (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
+                   ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+    }
+    #[test]
     fn __bindgen_test_layout_nsTArray_open0_RefPtr_open1_AnonymousContent_close1_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::dom::AnonymousContent>>>()
                    , 8usize , concat ! (
@@ -33803,17 +33923,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_208038_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_234329_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
@@ -33871,17 +33991,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_208340_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_234631_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
@@ -33983,17 +34103,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::URLExtraData> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::URLExtraData>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::URLExtraData> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_NotNull_open0__bindgen_ty_id_208882_close0_instantiation() {
+    fn __bindgen_test_layout_NotNull_open0__bindgen_ty_id_235173_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::mozilla::NotNull<*const root::mozilla::Encoding>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::NotNull<*const root::mozilla::Encoding> )
                    ));
         assert_eq!(::std::mem::align_of::<root::mozilla::NotNull<*const root::mozilla::Encoding>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
@@ -34306,16 +34426,38 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DocGroup> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::DocGroup>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::DocGroup> ) ));
     }
     #[test]
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_1() {
+        assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr>>() ,
+                   8usize , concat ! (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr> ) ));
+        assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr>>() ,
+                   8usize , concat ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsTArray<root::nsCOMPtr> ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_1() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
+                   (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
+                   ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+    }
+    #[test]
     fn __bindgen_test_layout_RefPtr_open0_CSSRuleListImpl_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::RefPtr<root::CSSRuleListImpl>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::CSSRuleListImpl> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::CSSRuleListImpl>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
@@ -34363,17 +34505,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::StyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_209295_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_235592_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -34453,17 +34595,17 @@ pub mod root {
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::RefPtr<root::mozilla::ServoStyleSheet>>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::RefPtr<root::mozilla::ServoStyleSheet>>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_209692_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_235989_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -34554,17 +34696,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<::nsstring::nsStringRepr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<::nsstring::nsStringRepr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_210646_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_236944_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -34643,28 +34785,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::nsCSSFontFaceRule> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::nsCSSFontFaceRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::nsCSSFontFaceRule> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_210949_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_237247_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_210954_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_237252_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -34711,17 +34853,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::CSSStyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::CSSStyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::CSSStyleSheet> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_211429_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_237727_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::StyleSheet>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::StyleSheet> ) ));
@@ -35346,17 +35488,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_214260_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_240548_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut ::std::os::raw::c_void>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut ::std::os::raw::c_void> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut ::std::os::raw::c_void>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut ::std::os::raw::c_void> ) ));
@@ -35425,17 +35567,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::mozilla::DefaultDelete ) ));
         assert_eq!(::std::mem::align_of::<root::mozilla::DefaultDelete>() ,
                    1usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::mozilla::DefaultDelete ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_220505_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_246801_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::AudioContext>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::AudioContext> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::AudioContext>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::AudioContext> ) ));
@@ -35458,28 +35600,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::CallbackObject> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::CallbackObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::CallbackObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_221666_close0_instantiation() {
+    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_247962_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_221670_close0_instantiation() {
+    fn __bindgen_test_layout_Heap_open0__bindgen_ty_id_247966_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
         assert_eq!(::std::mem::align_of::<root::JS::Heap<*mut root::JSObject>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::Heap<*mut root::JSObject> ) ));
@@ -35491,17 +35633,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_TenuredHeap_open0__bindgen_ty_id_221677_close0_instantiation() {
+    fn __bindgen_test_layout_TenuredHeap_open0__bindgen_ty_id_247973_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
         assert_eq!(::std::mem::align_of::<root::JS::TenuredHeap>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::JS::TenuredHeap ) ));
@@ -35524,39 +35666,39 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation() {
-        assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
-                   (
-                   "Size of template specialization: " , stringify ! (
-                   root::nsCOMPtr ) ));
-        assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
-                   ! (
-                   "Alignment of template specialization: " , stringify ! (
-                   root::nsCOMPtr ) ));
-    }
-    #[test]
-    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation() {
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_2() {
+        assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
+                   (
+                   "Size of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+        assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
+                   ! (
+                   "Alignment of template specialization: " , stringify ! (
+                   root::nsCOMPtr ) ));
+    }
+    #[test]
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_2() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_1() {
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_3() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
@@ -35570,17 +35712,17 @@ pub mod root {
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::CycleCollectedJSContext_RunInMetastableStateData>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::CycleCollectedJSContext_RunInMetastableStateData>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_222850_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_249043_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
@@ -35765,17 +35907,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<f64>>() , 8usize ,
                    concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<f64> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_224298_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_250491_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::dom::Element> ) ));
@@ -35870,39 +36012,39 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
         assert_eq!(::std::mem::align_of::<root::nsRefPtrHashKey<root::nsIAtom>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsRefPtrHashKey<root::nsIAtom> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_226686_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_252879_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::CounterStyle>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::CounterStyle> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::CounterStyle>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::CounterStyle> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_1() {
+    fn __bindgen_test_layout_nsTArray_open0_nsCOMPtr_open1_nsIRunnable_close1_close0_instantiation_3() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::nsCOMPtr>>() ,
                    8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::nsCOMPtr> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_2() {
+    fn __bindgen_test_layout_nsCOMPtr_open0_nsIRunnable_close0_instantiation_4() {
         assert_eq!(::std::mem::size_of::<root::nsCOMPtr>() , 8usize , concat !
                    (
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
@@ -36571,17 +36713,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::nsStyleImageRequest> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::nsStyleImageRequest>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::nsStyleImageRequest> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_229163_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_255356_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsISupports>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsISupports> ) ));
@@ -36808,28 +36950,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
         assert_eq!(::std::mem::align_of::<root::nsCOMPtr>() , 8usize , concat
                    ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsCOMPtr ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_236971_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_263164_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_236976_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_263169_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -36907,17 +37049,17 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::ShadowRoot> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::ShadowRoot>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::ShadowRoot> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_237089_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_263282_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37194,17 +37336,17 @@ pub mod root {
                    ) ));
         assert_eq!(::std::mem::align_of::<root::nsAutoPtr<root::mozilla::dom::ExplicitChildIterator>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsAutoPtr<root::mozilla::dom::ExplicitChildIterator>
                    ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_238669_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_264862_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37216,28 +37358,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
         assert_eq!(::std::mem::align_of::<root::RefPtr<root::mozilla::dom::Element>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::RefPtr<root::mozilla::dom::Element> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_238827_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_265020_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_238832_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_265025_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::nsIContent>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::nsIContent> ) ));
@@ -37359,28 +37501,28 @@ pub mod root {
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<root::mozilla::gfx::FontVariation>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<root::mozilla::gfx::FontVariation> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_240906_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_267099_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
     }
     #[test]
-    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_240912_close0_instantiation() {
+    fn __bindgen_test_layout_nsTArray_open0__bindgen_ty_id_267105_close0_instantiation() {
         assert_eq!(::std::mem::size_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Size of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
         assert_eq!(::std::mem::align_of::<root::nsTArray<*mut root::mozilla::css::DocumentRule>>()
                    , 8usize , concat ! (
                    "Alignment of template specialization: " , stringify ! (
                    root::nsTArray<*mut root::mozilla::css::DocumentRule> ) ));
--- a/servo/components/style/gecko_bindings/sugar/mod.rs
+++ b/servo/components/style/gecko_bindings/sugar/mod.rs
@@ -8,11 +8,12 @@ mod ns_com_ptr;
 mod ns_compatibility;
 mod ns_css_shadow_array;
 mod ns_css_shadow_item;
 pub mod ns_css_value;
 mod ns_style_auto_array;
 pub mod ns_style_coord;
 mod ns_t_array;
 mod ns_timing_function;
+mod origin_flags;
 pub mod ownership;
 pub mod refptr;
 mod style_complex_color;
new file mode 100644
--- /dev/null
+++ b/servo/components/style/gecko_bindings/sugar/origin_flags.rs
@@ -0,0 +1,50 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//! Helper to iterate over `OriginFlags` bits.
+
+use gecko_bindings::structs::OriginFlags;
+use gecko_bindings::structs::OriginFlags_Author;
+use gecko_bindings::structs::OriginFlags_User;
+use gecko_bindings::structs::OriginFlags_UserAgent;
+use stylesheets::Origin;
+
+impl OriginFlags {
+    /// Returns an iterator over the origins present in the `OriginFlags`,
+    /// in order from highest priority (author) to lower (user agent).
+    pub fn iter(self) -> OriginFlagsIter {
+        OriginFlagsIter {
+            origin_flags: self,
+            cur: 0,
+        }
+    }
+}
+
+/// Iterates over the origins present in an `OriginFlags`, in order from
+/// highest priority (author) to lower (user agent).
+pub struct OriginFlagsIter {
+    origin_flags: OriginFlags,
+    cur: usize,
+}
+
+impl Iterator for OriginFlagsIter {
+    type Item = Origin;
+
+    fn next(&mut self) -> Option<Origin> {
+        loop {
+            let (bit, origin) = match self.cur {
+                0 => (OriginFlags_Author, Origin::Author),
+                1 => (OriginFlags_User, Origin::User),
+                2 => (OriginFlags_UserAgent, Origin::UserAgent),
+                _ => return None,
+            };
+
+            self.cur += 1;
+
+            if (self.origin_flags & bit).0 != 0 {
+                return Some(origin);
+            }
+        }
+    }
+}
--- a/servo/components/style/invalidation/media_queries.rs
+++ b/servo/components/style/invalidation/media_queries.rs
@@ -47,16 +47,17 @@ pub trait ToMediaListKey : Sized {
 }
 
 impl ToMediaListKey for Stylesheet {}
 impl ToMediaListKey for ImportRule {}
 impl ToMediaListKey for MediaRule {}
 
 /// A struct that holds the result of a media query evaluation pass for the
 /// media queries that evaluated successfully.
+#[derive(Debug)]
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 pub struct EffectiveMediaQueryResults {
     /// The set of media lists that matched last time.
     set: FnvHashSet<MediaListKey>,
 }
 
 impl EffectiveMediaQueryResults {
     /// Trivially constructs an empty `EffectiveMediaQueryResults`.
--- a/servo/components/style/stylesheet_set.rs
+++ b/servo/components/style/stylesheet_set.rs
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 //! A centralized set of stylesheets for a document.
 
 use dom::TElement;
 use invalidation::stylesheets::StylesheetInvalidationSet;
 use shared_lock::SharedRwLockReadGuard;
 use std::slice;
-use stylesheets::StylesheetInDocument;
+use stylesheets::{Origin, PerOrigin, StylesheetInDocument};
 use stylist::Stylist;
 
 /// Entry for a StylesheetSet. We don't bother creating a constructor, because
 /// there's no sensible defaults for the member variables.
 pub struct StylesheetSetEntry<S>
 where
     S: StylesheetInDocument + PartialEq + 'static,
 {
@@ -44,165 +44,188 @@ where
 {
     /// The actual list of all the stylesheets that apply to the given document,
     /// each stylesheet associated with a unique ID.
     ///
     /// This is only a list of top-level stylesheets, and as such it doesn't
     /// include recursive `@import` rules.
     entries: Vec<StylesheetSetEntry<S>>,
 
-    /// Whether the entries list above has changed since the last restyle.
-    dirty: bool,
+    /// Per-origin stylesheet invalidation data.
+    invalidation_data: PerOrigin<InvalidationData>,
 
     /// Has author style been disabled?
     author_style_disabled: bool,
-
-    /// The style invalidations that we still haven't processed.
-    invalidations: StylesheetInvalidationSet,
 }
 
 impl<S> StylesheetSet<S>
 where
     S: StylesheetInDocument + PartialEq + 'static,
 {
     /// Create a new empty StylesheetSet.
     pub fn new() -> Self {
         StylesheetSet {
             entries: vec![],
-            dirty: false,
+            invalidation_data: Default::default(),
             author_style_disabled: false,
-            invalidations: StylesheetInvalidationSet::new(),
         }
     }
 
     /// Returns whether author styles have been disabled for the current
     /// stylesheet set.
     pub fn author_style_disabled(&self) -> bool {
         self.author_style_disabled
     }
 
     fn remove_stylesheet_if_present(&mut self, sheet: &S) {
         self.entries.retain(|entry| entry.sheet != *sheet);
     }
 
+    fn collect_invalidations_for(
+        &mut self,
+        stylist: &Stylist,
+        sheet: &S,
+        guard: &SharedRwLockReadGuard,
+    ) {
+        let origin = sheet.contents(guard).origin;
+        let data = self.invalidation_data.borrow_mut_for_origin(&origin);
+        data.invalidations.collect_invalidations_for(stylist, sheet, guard);
+        data.dirty = true;
+    }
+
     /// Appends a new stylesheet to the current set.
     pub fn append_stylesheet(
         &mut self,
         stylist: &Stylist,
         sheet: S,
         guard: &SharedRwLockReadGuard
     ) {
         debug!("StylesheetSet::append_stylesheet");
         self.remove_stylesheet_if_present(&sheet);
-        self.invalidations.collect_invalidations_for(
-            stylist,
-            &sheet,
-            guard
-        );
-        self.dirty = true;
+        self.collect_invalidations_for(stylist, &sheet, guard);
         self.entries.push(StylesheetSetEntry { sheet });
     }
 
     /// Prepend a new stylesheet to the current set.
     pub fn prepend_stylesheet(
         &mut self,
         stylist: &Stylist,
         sheet: S,
         guard: &SharedRwLockReadGuard
     ) {
         debug!("StylesheetSet::prepend_stylesheet");
         self.remove_stylesheet_if_present(&sheet);
-        self.invalidations.collect_invalidations_for(
-            stylist,
-            &sheet,
-            guard
-        );
+        self.collect_invalidations_for(stylist, &sheet, guard);
         self.entries.insert(0, StylesheetSetEntry { sheet });
-        self.dirty = true;
     }
 
     /// Insert a given stylesheet before another stylesheet in the document.
     pub fn insert_stylesheet_before(
         &mut self,
         stylist: &Stylist,
         sheet: S,
         before_sheet: S,
         guard: &SharedRwLockReadGuard
     ) {
         debug!("StylesheetSet::insert_stylesheet_before");
         self.remove_stylesheet_if_present(&sheet);
         let index = self.entries.iter().position(|entry| {
             entry.sheet == before_sheet
         }).expect("`before_sheet` stylesheet not found");
-        self.invalidations.collect_invalidations_for(
-            stylist,
-            &sheet,
-            guard
-        );
+        self.collect_invalidations_for(stylist, &sheet, guard);
         self.entries.insert(index, StylesheetSetEntry { sheet });
-        self.dirty = true;
     }
 
     /// Remove a given stylesheet from the set.
     pub fn remove_stylesheet(
         &mut self,
         stylist: &Stylist,
         sheet: S,
         guard: &SharedRwLockReadGuard,
     ) {
         debug!("StylesheetSet::remove_stylesheet");
         self.remove_stylesheet_if_present(&sheet);
-        self.dirty = true;
-        self.invalidations.collect_invalidations_for(
-            stylist,
-            &sheet,
-            guard
-        );
+        self.collect_invalidations_for(stylist, &sheet, guard);
     }
 
     /// Notes that the author style has been disabled for this document.
     pub fn set_author_style_disabled(&mut self, disabled: bool) {
         debug!("StylesheetSet::set_author_style_disabled");
         if self.author_style_disabled == disabled {
             return;
         }
         self.author_style_disabled = disabled;
-        self.dirty = true;
-        self.invalidations.invalidate_fully();
+        self.invalidation_data.author.invalidations.invalidate_fully();
+        self.invalidation_data.author.dirty = true;
     }
 
     /// Returns whether the given set has changed from the last flush.
     pub fn has_changed(&self) -> bool {
-        self.dirty
+        self.invalidation_data
+            .iter_origins()
+            .any(|(d, _)| d.dirty)
     }
 
     /// Flush the current set, unmarking it as dirty, and returns an iterator
     /// over the new stylesheet list.
     pub fn flush<E>(
         &mut self,
-        document_element: Option<E>
+        document_element: Option<E>,
     ) -> StylesheetIterator<S>
     where
         E: TElement,
     {
         debug!("StylesheetSet::flush");
-        debug_assert!(self.dirty);
+        debug_assert!(self.has_changed());
 
-        self.dirty = false;
-        self.invalidations.flush(document_element);
+        for (data, _) in self.invalidation_data.iter_mut_origins() {
+            if data.dirty {
+                data.invalidations.flush(document_element);
+                data.dirty = false;
+            }
+        }
 
         self.iter()
     }
 
     /// Returns an iterator over the current list of stylesheets.
     pub fn iter(&self) -> StylesheetIterator<S> {
         StylesheetIterator(self.entries.iter())
     }
 
     /// Mark the stylesheets as dirty, because something external may have
     /// invalidated it.
     ///
     /// FIXME(emilio): Make this more granular.
     pub fn force_dirty(&mut self) {
-        self.dirty = true;
-        self.invalidations.invalidate_fully();
+        for (data, _) in self.invalidation_data.iter_mut_origins() {
+            data.invalidations.invalidate_fully();
+            data.dirty = true;
+        }
+    }
+
+    /// Mark the stylesheets for the specified origin as dirty, because
+    /// something external may have invalidated it.
+    pub fn force_dirty_origin(&mut self, origin: &Origin) {
+        let data = self.invalidation_data.borrow_mut_for_origin(origin);
+        data.invalidations.invalidate_fully();
+        data.dirty = true;
     }
 }
+
+struct InvalidationData {
+    /// The stylesheet invalidations for this origin that we still haven't
+    /// processed.
+    invalidations: StylesheetInvalidationSet,
+
+    /// Whether the sheets for this origin in the `StylesheetSet`'s entry list
+    /// has changed since the last restyle.
+    dirty: bool,
+}
+
+impl Default for InvalidationData {
+    fn default() -> Self {
+        InvalidationData {
+            invalidations: StylesheetInvalidationSet::new(),
+            dirty: false,
+        }
+    }
+}
--- a/servo/components/style/stylesheets/mod.rs
+++ b/servo/components/style/stylesheets/mod.rs
@@ -9,16 +9,17 @@ mod document_rule;
 mod font_face_rule;
 pub mod font_feature_values_rule;
 pub mod import_rule;
 pub mod keyframes_rule;
 mod loader;
 mod media_rule;
 mod memory;
 mod namespace_rule;
+mod origin;
 mod page_rule;
 mod rule_list;
 mod rule_parser;
 mod rules_iterator;
 mod style_rule;
 mod stylesheet;
 pub mod supports_rule;
 pub mod viewport_rule;
@@ -38,16 +39,17 @@ pub use self::font_feature_values_rule::
 pub use self::import_rule::ImportRule;
 pub use self::keyframes_rule::KeyframesRule;
 pub use self::loader::StylesheetLoader;
 pub use self::media_rule::MediaRule;
 pub use self::memory::{MallocSizeOf, MallocSizeOfFn, MallocSizeOfWithGuard};
 #[cfg(feature = "gecko")]
 pub use self::memory::{MallocSizeOfWithRepeats, SizeOfState};
 pub use self::namespace_rule::NamespaceRule;
+pub use self::origin::{Origin, PerOrigin, PerOriginClear};
 pub use self::page_rule::PageRule;
 pub use self::rule_parser::{State, TopLevelRuleParser};
 pub use self::rule_list::{CssRules, CssRulesHelpers};
 pub use self::rules_iterator::{AllRules, EffectiveRules, NestedRuleIterationCondition, RulesIterator};
 pub use self::stylesheet::{Namespaces, Stylesheet, StylesheetContents, StylesheetInDocument, UserAgentStylesheets};
 pub use self::style_rule::StyleRule;
 pub use self::supports_rule::SupportsRule;
 pub use self::viewport_rule::ViewportRule;
@@ -77,32 +79,16 @@ impl UrlExtraData {
     }
 }
 
 // XXX We probably need to figure out whether we should mark Eq here.
 // It is currently marked so because properties::UnparsedValue wants Eq.
 #[cfg(feature = "gecko")]
 impl Eq for UrlExtraData {}
 
-/// Each style rule has an origin, which determines where it enters the cascade.
-///
-/// http://dev.w3.org/csswg/css-cascade/#cascading-origins
-#[derive(Clone, PartialEq, Eq, Copy, Debug)]
-#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-pub enum Origin {
-    /// http://dev.w3.org/csswg/css-cascade/#cascade-origin-ua
-    UserAgent,
-
-    /// http://dev.w3.org/csswg/css-cascade/#cascade-origin-author
-    Author,
-
-    /// http://dev.w3.org/csswg/css-cascade/#cascade-origin-user
-    User,
-}
-
 /// A CSS rule.
 ///
 /// TODO(emilio): Lots of spec links should be around.
 #[derive(Debug, Clone)]
 #[allow(missing_docs)]
 pub enum CssRule {
     // No Charset here, CSSCharsetRule has been removed from CSSOM
     // https://drafts.csswg.org/cssom/#changes-from-5-december-2013
new file mode 100644
--- /dev/null
+++ b/servo/components/style/stylesheets/origin.rs
@@ -0,0 +1,145 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+///! [CSS cascade origins](https://drafts.csswg.org/css-cascade/#cascading-origins).
+
+use std::marker::PhantomData;
+
+/// Each style rule has an origin, which determines where it enters the cascade.
+///
+/// https://drafts.csswg.org/css-cascade/#cascading-origins
+#[derive(Clone, PartialEq, Eq, Copy, Debug)]
+#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+pub enum Origin {
+    /// https://drafts.csswg.org/css-cascade/#cascade-origin-us
+    UserAgent,
+
+    /// https://drafts.csswg.org/css-cascade/#cascade-origin-user
+    User,
+
+    /// https://drafts.csswg.org/css-cascade/#cascade-origin-author
+    Author,
+}
+
+/// An object that stores a `T` for each origin of the CSS cascade.
+#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
+#[derive(Debug, Default)]
+pub struct PerOrigin<T> {
+    /// Data for `Origin::UserAgent`.
+    pub user_agent: T,
+
+    /// Data for `Origin::User`.
+    pub user: T,
+
+    /// Data for `Origin::Author`.
+    pub author: T,
+}
+
+impl<T> PerOrigin<T> {
+    /// Returns a reference to the per-origin data for the specified origin.
+    #[inline]
+    pub fn borrow_for_origin(&self, origin: &Origin) -> &T {
+        match *origin {
+            Origin::UserAgent => &self.user_agent,
+            Origin::User => &self.user,
+            Origin::Author => &self.author,
+        }
+    }
+
+    /// Returns a mutable reference to the per-origin data for the specified
+    /// origin.
+    #[inline]
+    pub fn borrow_mut_for_origin(&mut self, origin: &Origin) -> &mut T {
+        match *origin {
+            Origin::UserAgent => &mut self.user_agent,
+            Origin::User => &mut self.user,
+            Origin::Author => &mut self.author,
+        }
+    }
+
+    /// Iterates over references to per-origin extra style data, from highest
+    /// level (author) to lowest (user agent).
+    pub fn iter_origins(&self) -> PerOriginIter<T> {
+        PerOriginIter {
+            data: &self,
+            cur: 0,
+        }
+    }
+
+    /// Iterates over mutable references to per-origin extra style data, from
+    /// highest level (author) to lowest (user agent).
+    pub fn iter_mut_origins(&mut self) -> PerOriginIterMut<T> {
+        PerOriginIterMut {
+            data: self,
+            cur: 0,
+            _marker: PhantomData,
+        }
+    }
+}
+
+/// An object that can be cleared.
+pub trait PerOriginClear {
+    /// Clears the object.
+    fn clear(&mut self);
+}
+
+impl<T> PerOriginClear for PerOrigin<T> where T: PerOriginClear {
+    fn clear(&mut self) {
+        self.user_agent.clear();
+        self.user.clear();
+        self.author.clear();
+    }
+}
+
+/// Iterator over `PerOrigin<T>`, from highest level (author) to lowest
+/// (user agent).
+///
+/// We rely on this specific order for correctly looking up @font-face,
+/// @counter-style and @keyframes rules.
+pub struct PerOriginIter<'a, T: 'a> {
+    data: &'a PerOrigin<T>,
+    cur: usize,
+}
+
+impl<'a, T> Iterator for PerOriginIter<'a, T> where T: 'a {
+    type Item = (&'a T, Origin);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let result = match self.cur {
+            0 => (&self.data.author, Origin::Author),
+            1 => (&self.data.user, Origin::User),
+            2 => (&self.data.user_agent, Origin::UserAgent),
+            _ => return None,
+        };
+        self.cur += 1;
+        Some(result)
+    }
+}
+
+/// Like `PerOriginIter<T>`, but iterates over mutable references to the
+/// per-origin data.
+///
+/// We must use unsafe code here since it's not possible for the borrow
+/// checker to know that we are safely returning a different reference
+/// each time from `next()`.
+pub struct PerOriginIterMut<'a, T: 'a> {
+    data: *mut PerOrigin<T>,
+    cur: usize,
+    _marker: PhantomData<&'a mut PerOrigin<T>>,
+}
+
+impl<'a, T> Iterator for PerOriginIterMut<'a, T> where T: 'a {
+    type Item = (&'a mut T, Origin);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let result = match self.cur {
+            0 => (unsafe { &mut (*self.data).author }, Origin::Author),
+            1 => (unsafe { &mut (*self.data).user }, Origin::User),
+            2 => (unsafe { &mut (*self.data).user_agent }, Origin::UserAgent),
+            _ => return None,
+        };
+        self.cur += 1;
+        Some(result)
+    }
+}
--- a/servo/components/style/stylist.rs
+++ b/servo/components/style/stylist.rs
@@ -35,17 +35,18 @@ use selectors::visitor::SelectorVisitor;
 use servo_arc::{Arc, ArcBorrow};
 use shared_lock::{Locked, SharedRwLockReadGuard, StylesheetGuards};
 use smallvec::VecLike;
 use std::fmt::Debug;
 use style_traits::viewport::ViewportConstraints;
 #[cfg(feature = "gecko")]
 use stylesheets::{CounterStyleRule, FontFaceRule};
 use stylesheets::{CssRule, StyleRule};
-use stylesheets::{StylesheetInDocument, Origin, UserAgentStylesheets};
+use stylesheets::{StylesheetInDocument, Origin, PerOrigin, PerOriginClear};
+use stylesheets::UserAgentStylesheets;
 use stylesheets::keyframes_rule::KeyframesAnimation;
 use stylesheets::viewport_rule::{self, MaybeNew, ViewportRule};
 use thread_state;
 
 pub use ::fnv::FnvHashMap;
 
 /// This structure holds all the selectors and device characteristics
 /// for a given document. The selectors are converted into `Rule`s
@@ -68,137 +69,42 @@ pub struct Stylist {
     /// On Servo, on the other hand, the device is a really cheap representation
     /// that is recreated each time some constraint changes and calling
     /// `set_device`.
     device: Device,
 
     /// Viewport constraints based on the current device.
     viewport_constraints: Option<ViewportConstraints>,
 
-    /// Effective media query results cached from the last rebuild.
-    effective_media_query_results: EffectiveMediaQueryResults,
-
     /// If true, the quirks-mode stylesheet is applied.
     #[cfg_attr(feature = "servo", ignore_heap_size_of = "defined in selectors")]
     quirks_mode: QuirksMode,
 
     /// If true, the device has changed, and the stylist needs to be updated.
     is_device_dirty: bool,
 
-    /// If true, the stylist is in a cleared state (e.g. just-constructed, or
-    /// had clear() called on it with no following rebuild()).
-    is_cleared: bool,
-
     /// Selector maps for all of the style sheets in the stylist, after
     /// evalutaing media rules against the current device, split out per
     /// cascade level.
-    cascade_data: CascadeData,
+    cascade_data: PerOrigin<CascadeData>,
 
     /// The rule tree, that stores the results of selector matching.
     rule_tree: RuleTree,
 
     /// Applicable declarations for a given non-eagerly cascaded pseudo-element.
     /// These are eagerly computed once, and then used to resolve the new
     /// computed values on the fly on layout.
     ///
     /// FIXME(emilio): Use the rule tree!
     precomputed_pseudo_element_decls: PerPseudoElementMap<Vec<ApplicableDeclarationBlock>>,
 
-    /// A monotonically increasing counter to represent the order on which a
-    /// style rule appears in a stylesheet, needed to sort them by source order.
-    rules_source_order: u32,
-
     /// The total number of times the stylist has been rebuilt.
     num_rebuilds: usize,
 }
 
-/// This struct holds data which users of Stylist may want to extract
-/// from stylesheets which can be done at the same time as updating.
-#[cfg(feature = "gecko")]
-#[derive(Default)]
-pub struct ExtraStyleData {
-    /// Extra data from user agent stylesheets
-    user_agent: PerOriginExtraStyleData,
-    /// Extra data from author stylesheets
-    author: PerOriginExtraStyleData,
-    /// Extra data from user stylesheets
-    user: PerOriginExtraStyleData,
-}
-
-/// This struct holds data which users of Stylist may want to extract
-/// from stylesheets which can be done at the same time as updating.
-#[cfg(feature = "gecko")]
-#[derive(Default)]
-pub struct PerOriginExtraStyleData {
-    /// A list of effective font-face rules and their origin.
-    pub font_faces: Vec<Arc<Locked<FontFaceRule>>>,
-    /// A map of effective counter-style rules.
-    pub counter_styles: PrecomputedHashMap<Atom, Arc<Locked<CounterStyleRule>>>,
-}
-
-#[cfg(feature = "gecko")]
-impl ExtraStyleData {
-    /// Clear the internal data.
-    pub fn clear(&mut self) {
-        self.user_agent.clear();
-        self.author.clear();
-        self.user.clear();
-    }
-
-    /// Returns a reference to the per-origin extra style data for
-    /// the specified origin.
-    #[inline]
-    pub fn borrow_mut_for_origin(&mut self, origin: &Origin) -> &mut PerOriginExtraStyleData {
-        match *origin {
-            Origin::UserAgent => &mut self.user_agent,
-            Origin::Author => &mut self.author,
-            Origin::User => &mut self.user,
-        }
-    }
-
-    /// Iterates over the per-origin extra style data, from highest level (user)
-    /// to lowest (user agent).
-    pub fn iter_origins(&self) -> ExtraStyleDataIter {
-        ExtraStyleDataIter {
-            extra_style_data: &self,
-            cur: 0,
-        }
-    }
-}
-
-#[cfg(feature = "gecko")]
-impl PerOriginExtraStyleData {
-    /// Clears the stored @font-face and @counter-style rules.
-    fn clear(&mut self) {
-        self.font_faces.clear();
-        self.counter_styles.clear();
-    }
-
-    /// Add the given @font-face rule.
-    fn add_font_face(&mut self, rule: &Arc<Locked<FontFaceRule>>) {
-        self.font_faces.push(rule.clone());
-    }
-
-    /// Add the given @counter-style rule.
-    fn add_counter_style(&mut self, guard: &SharedRwLockReadGuard,
-                         rule: &Arc<Locked<CounterStyleRule>>) {
-        let name = rule.read_with(guard).mName.raw::<nsIAtom>().into();
-        self.counter_styles.insert(name, rule.clone());
-    }
-}
-
-#[allow(missing_docs)]
-#[cfg(feature = "servo")]
-pub struct ExtraStyleData;
-
-#[cfg(feature = "servo")]
-impl ExtraStyleData {
-    fn clear(&mut self) {}
-}
-
 /// What cascade levels to include when styling elements.
 #[derive(Copy, Clone, PartialEq)]
 pub enum RuleInclusion {
     /// Include rules for style sheets at all cascade levels.  This is the
     /// normal rule inclusion mode.
     All,
     /// Only include rules from UA and user level sheets.  Used to implement
     /// `getDefaultComputedStyle`.
@@ -220,133 +126,165 @@ impl Stylist {
     /// If more members are added here, think about whether they should
     /// be reset in clear().
     #[inline]
     pub fn new(device: Device, quirks_mode: QuirksMode) -> Self {
         Stylist {
             viewport_constraints: None,
             device: device,
             is_device_dirty: true,
-            is_cleared: true,
             quirks_mode: quirks_mode,
-            effective_media_query_results: EffectiveMediaQueryResults::new(),
 
-            cascade_data: CascadeData::new(),
+            cascade_data: Default::default(),
             precomputed_pseudo_element_decls: PerPseudoElementMap::default(),
-            rules_source_order: 0,
             rule_tree: RuleTree::new(),
             num_rebuilds: 0,
         }
 
         // FIXME: Add iso-8859-9.css when the document’s encoding is ISO-8859-8.
     }
 
     /// Returns the number of selectors.
     pub fn num_selectors(&self) -> usize {
-        self.cascade_data.iter_origins().map(|d| d.num_selectors).sum()
+        self.cascade_data.iter_origins().map(|(d, _)| d.num_selectors).sum()
     }
 
     /// Returns the number of declarations.
     pub fn num_declarations(&self) -> usize {
-        self.cascade_data.iter_origins().map(|d| d.num_declarations).sum()
+        self.cascade_data.iter_origins().map(|(d, _)| d.num_declarations).sum()
     }
 
     /// Returns the number of times the stylist has been rebuilt.
     pub fn num_rebuilds(&self) -> usize {
         self.num_rebuilds
     }
 
     /// Returns the number of revalidation_selectors.
     pub fn num_revalidation_selectors(&self) -> usize {
         self.cascade_data.iter_origins()
-            .map(|d| d.selectors_for_cache_revalidation.len()).sum()
+            .map(|(d, _)| d.selectors_for_cache_revalidation.len()).sum()
     }
 
     /// Returns the number of entries in invalidation maps.
     pub fn num_invalidations(&self) -> usize {
         self.cascade_data.iter_origins()
-            .map(|d| d.invalidation_map.len()).sum()
+            .map(|(d, _)| d.invalidation_map.len()).sum()
     }
 
     /// Invokes `f` with the `InvalidationMap` for each origin.
     ///
     /// NOTE(heycam) This might be better as an `iter_invalidation_maps`, once
     /// we have `impl trait` and can return that easily without bothering to
     /// create a whole new iterator type.
     pub fn each_invalidation_map<F>(&self, mut f: F)
         where F: FnMut(&InvalidationMap)
     {
-        for origin_cascade_data in self.cascade_data.iter_origins() {
-            f(&origin_cascade_data.invalidation_map)
+        for (data, _) in self.cascade_data.iter_origins() {
+            f(&data.invalidation_map)
         }
     }
 
     /// Clear the stylist's state, effectively resetting it to more or less
     /// the state Stylist::new creates.
     ///
     /// We preserve the state of the following members:
     ///   device: Someone might have set this on us.
     ///   quirks_mode: Again, someone might have set this on us.
     ///   num_rebuilds: clear() followed by rebuild() should just increment this
+    ///   rule_tree: So we can re-use rule nodes across rebuilds.
     ///
     /// We don't just use struct update syntax with Stylist::new(self.device)
     /// beause for some of our members we can clear them instead of creating new
     /// objects.  This does cause unfortunate code duplication with
     /// Stylist::new.
     pub fn clear(&mut self) {
-        if self.is_cleared {
-            return
+        self.cascade_data.clear();
+        self.precomputed_pseudo_element_decls.clear();
+        self.viewport_constraints = None;
+
+        // XXX(heycam) Why do this, if we are preserving the Device?
+        self.is_device_dirty = true;
+    }
+
+    /// Clear the stylist's state for the specified origin.
+    pub fn clear_origin(&mut self, origin: &Origin) {
+        self.cascade_data.borrow_mut_for_origin(origin).clear();
+
+        if *origin == Origin::UserAgent {
+            // We only collect these declarations from UA sheets.
+            self.precomputed_pseudo_element_decls.clear();
         }
 
-        self.is_cleared = true;
+        // The stored `ViewportConstraints` contains data from rules across
+        // all origins.
+        self.viewport_constraints = None;
 
-        self.effective_media_query_results.clear();
-        self.viewport_constraints = None;
-        // preserve current device
+        // XXX(heycam) Why do this, if we are preserving the Device?
         self.is_device_dirty = true;
-        // preserve current quirks_mode value
-        self.cascade_data.clear();
-        self.precomputed_pseudo_element_decls.clear();
-        self.rules_source_order = 0;
-        // We want to keep rule_tree around across stylist rebuilds.
-        // preserve num_rebuilds value, since it should stay across
-        // clear()/rebuild() cycles.
     }
 
-    /// rebuild the stylist for the given document stylesheets, and optionally
+    /// Returns whether any origin's `CascadeData` has been cleared.
+    fn any_origin_cleared(&self) -> bool {
+        self.cascade_data
+            .iter_origins()
+            .any(|(d, _)| d.is_cleared)
+    }
+
+    /// Rebuild the stylist for the given document stylesheets, and optionally
     /// with a set of user agent stylesheets.
     ///
     /// This method resets all the style data each time the stylesheets change
     /// (which is indicated by the `stylesheets_changed` parameter), or the
     /// device is dirty, which means we need to re-evaluate media queries.
     pub fn rebuild<'a, I, S>(
         &mut self,
         doc_stylesheets: I,
         guards: &StylesheetGuards,
         ua_stylesheets: Option<&UserAgentStylesheets>,
         stylesheets_changed: bool,
         author_style_disabled: bool,
-        extra_data: &mut ExtraStyleData
+        extra_data: &mut PerOrigin<ExtraStyleData>
     ) -> bool
     where
         I: Iterator<Item = &'a S> + Clone,
         S: StylesheetInDocument + ToMediaListKey + 'static,
     {
-        debug_assert!(!self.is_cleared || self.is_device_dirty);
+        debug_assert!(!self.any_origin_cleared() || self.is_device_dirty);
+
+        // Determine the origins that actually need updating.
+        //
+        // XXX(heycam): What is the relationship between `stylesheets_changed`
+        // and the `is_cleared` fields on each origin's `CascadeData`?  Can
+        // we avoid passing in `stylesheets_changed`?
+        let mut to_update: PerOrigin<bool> = Default::default();
 
-        self.is_cleared = false;
+        // If we're provided with a list of UA and user style sheets, then
+        // we must update those cascade levels. (Servo does this, but Gecko
+        // just includes the UA and User sheets in `doc_stylesheets`.)
+        if ua_stylesheets.is_some() {
+            to_update.user_agent = true;
+            to_update.user = true;
+        }
+
+        for (data, origin) in self.cascade_data.iter_mut_origins() {
+            if data.is_cleared {
+                data.is_cleared = false;
+                *to_update.borrow_mut_for_origin(&origin) = true;
+            }
+        }
 
         if !(self.is_device_dirty || stylesheets_changed) {
             return false;
         }
 
         self.num_rebuilds += 1;
 
+        // Update viewport_constraints regardless of which origins'
+        // `CascadeData` we're updating.
         self.viewport_constraints = None;
-
         if viewport_rule::enabled() {
             // TODO(emilio): This doesn't look so efficient.
             //
             // Presumably when we properly implement this we can at least have a
             // bit on the stylesheet that says whether it contains viewport
             // rules to skip it entirely?
             //
             // Processing it with the rest of rules seems tricky since it
@@ -357,39 +295,58 @@ impl Stylist {
                 declarations: viewport_rule::Cascade::from_stylesheets(
                     doc_stylesheets.clone(), guards.author, &self.device
                 ).finish()
             };
 
             self.viewport_constraints =
                 ViewportConstraints::maybe_new(&self.device,
                                                &cascaded_rule,
-                                               self.quirks_mode)
+                                               self.quirks_mode);
+
+            if let Some(ref constraints) = self.viewport_constraints {
+                self.device.account_for_viewport_rule(constraints);
+            }
         }
 
-        if let Some(ref constraints) = self.viewport_constraints {
-            self.device.account_for_viewport_rule(constraints);
+        // XXX(heycam): We should probably just move the `extra_data` to be
+        // stored on the `Stylist` instead of Gecko's `PerDocumentStyleData`.
+        // That would let us clear it inside `clear()` and `clear_origin()`.
+        for (update, origin) in to_update.iter_origins() {
+            if *update {
+                extra_data.borrow_mut_for_origin(&origin).clear();
+            }
         }
 
-        extra_data.clear();
-
         if let Some(ua_stylesheets) = ua_stylesheets {
             for stylesheet in &ua_stylesheets.user_or_user_agent_stylesheets {
+                debug_assert!(matches!(
+                    stylesheet.contents(guards.ua_or_user).origin,
+                    Origin::UserAgent | Origin::User));
                 self.add_stylesheet(stylesheet, guards.ua_or_user, extra_data);
             }
 
             if self.quirks_mode != QuirksMode::NoQuirks {
+                let stylesheet = &ua_stylesheets.quirks_mode_stylesheet;
+                debug_assert!(matches!(
+                    stylesheet.contents(guards.ua_or_user).origin,
+                    Origin::UserAgent | Origin::User));
                 self.add_stylesheet(&ua_stylesheets.quirks_mode_stylesheet,
                                     guards.ua_or_user, extra_data);
             }
         }
 
-        // Only use author stylesheets if author styles are enabled.
+        // Only add stylesheets for origins we are updating, and only add
+        // Author level sheets if author style is not disabled.
         let sheets_to_add = doc_stylesheets.filter(|s| {
-            !author_style_disabled || s.origin(guards.author) != Origin::Author
+            match s.contents(guards.author).origin {
+                Origin::UserAgent => to_update.user_agent,
+                Origin::Author => to_update.author && !author_style_disabled,
+                Origin::User => to_update.user,
+            }
         });
 
         for stylesheet in sheets_to_add {
             self.add_stylesheet(stylesheet, guards.author, extra_data);
         }
 
         self.is_device_dirty = false;
         true
@@ -399,55 +356,56 @@ impl Stylist {
     /// either clear() or rebuild(), with the latter done lazily, instead.
     pub fn update<'a, I, S>(
         &mut self,
         doc_stylesheets: I,
         guards: &StylesheetGuards,
         ua_stylesheets: Option<&UserAgentStylesheets>,
         stylesheets_changed: bool,
         author_style_disabled: bool,
-        extra_data: &mut ExtraStyleData
+        extra_data: &mut PerOrigin<ExtraStyleData>
     ) -> bool
     where
         I: Iterator<Item = &'a S> + Clone,
         S: StylesheetInDocument + ToMediaListKey + 'static,
     {
-        debug_assert!(!self.is_cleared || self.is_device_dirty);
+        debug_assert!(!self.any_origin_cleared() || self.is_device_dirty);
 
         // We have to do a dirtiness check before clearing, because if
         // we're not actually dirty we need to no-op here.
         if !(self.is_device_dirty || stylesheets_changed) {
             return false;
         }
         self.clear();
         self.rebuild(doc_stylesheets, guards, ua_stylesheets, stylesheets_changed,
                      author_style_disabled, extra_data)
     }
 
     fn add_stylesheet<S>(
         &mut self,
         stylesheet: &S,
         guard: &SharedRwLockReadGuard,
-        _extra_data: &mut ExtraStyleData
+        _extra_data: &mut PerOrigin<ExtraStyleData>
     )
     where
         S: StylesheetInDocument + ToMediaListKey + 'static,
     {
         if !stylesheet.enabled() ||
            !stylesheet.is_effective_for_device(&self.device, guard) {
             return;
         }
 
-        self.effective_media_query_results.saw_effective(stylesheet);
-
         let origin = stylesheet.origin(guard);
-
         let origin_cascade_data =
             self.cascade_data.borrow_mut_for_origin(&origin);
 
+        origin_cascade_data
+            .effective_media_query_results
+            .saw_effective(stylesheet);
+
         for rule in stylesheet.effective_rules(&self.device, guard) {
             match *rule {
                 CssRule::Style(ref locked) => {
                     let style_rule = locked.read_with(&guard);
                     origin_cascade_data.num_declarations +=
                         style_rule.block.read_with(&guard).len();
                     for selector in &style_rule.selectors.0 {
                         origin_cascade_data.num_selectors += 1;
@@ -462,17 +420,17 @@ impl Stylist {
                                     continue;
                                 }
 
                                 self.precomputed_pseudo_element_decls
                                     .get_or_insert_with(&pseudo.canonical(), Vec::new)
                                     .expect("Unexpected tree pseudo-element?")
                                     .push(ApplicableDeclarationBlock::new(
                                         StyleSource::Style(locked.clone()),
-                                        self.rules_source_order,
+                                        origin_cascade_data.rules_source_order,
                                         CascadeLevel::UANormal,
                                         selector.specificity()
                                     ));
 
                                 continue;
                             }
                             None => &mut origin_cascade_data.element_map,
                             Some(pseudo) => {
@@ -485,17 +443,17 @@ impl Stylist {
 
                         let hashes =
                             AncestorHashes::new(&selector, self.quirks_mode);
 
                         let rule = Rule::new(
                             selector.clone(),
                             hashes.clone(),
                             locked.clone(),
-                            self.rules_source_order
+                            origin_cascade_data.rules_source_order
                         );
 
                         map.insert(rule, self.quirks_mode);
 
                         origin_cascade_data
                             .invalidation_map
                             .note_selector(selector, self.quirks_mode);
                         let mut visitor = StylistSelectorVisitor {
@@ -510,28 +468,32 @@ impl Stylist {
                         selector.visit(&mut visitor);
 
                         if visitor.needs_revalidation {
                             origin_cascade_data.selectors_for_cache_revalidation.insert(
                                 RevalidationSelectorAndHashes::new(selector.clone(), hashes),
                                 self.quirks_mode);
                         }
                     }
-                    self.rules_source_order += 1;
+                    origin_cascade_data.rules_source_order += 1;
                 }
                 CssRule::Import(ref lock) => {
                     let import_rule = lock.read_with(guard);
-                    self.effective_media_query_results.saw_effective(import_rule);
+                    origin_cascade_data
+                        .effective_media_query_results
+                        .saw_effective(import_rule);
 
                     // NOTE: effective_rules visits the inner stylesheet if
                     // appropriate.
                 }
                 CssRule::Media(ref lock) => {
                     let media_rule = lock.read_with(guard);
-                    self.effective_media_query_results.saw_effective(media_rule);
+                    origin_cascade_data
+                        .effective_media_query_results
+                        .saw_effective(media_rule);
                 }
                 CssRule::Keyframes(ref keyframes_rule) => {
                     let keyframes_rule = keyframes_rule.read_with(guard);
                     debug!("Found valid keyframes rule: {:?}", *keyframes_rule);
 
                     // Don't let a prefixed keyframes animation override a non-prefixed one.
                     let needs_insertion =
                         keyframes_rule.vendor_prefix.is_none() ||
@@ -562,52 +524,52 @@ impl Stylist {
         }
     }
 
     /// Returns whether the given attribute might appear in an attribute
     /// selector of some rule in the stylist.
     pub fn might_have_attribute_dependency(&self,
                                            local_name: &LocalName)
                                            -> bool {
-        if self.is_cleared || self.is_device_dirty {
+        if self.any_origin_cleared() || self.is_device_dirty {
             // We can't tell what attributes are in our style rules until
             // we rebuild.
             true
         } else if *local_name == local_name!("style") {
             self.cascade_data
                 .iter_origins()
-                .any(|d| d.style_attribute_dependency)
+                .any(|(d, _)| d.style_attribute_dependency)
         } else {
             self.cascade_data
                 .iter_origins()
-                .any(|d| {
+                .any(|(d, _)| {
                     d.attribute_dependencies
                         .might_contain_hash(local_name.get_hash())
                 })
         }
     }
 
     /// Returns whether the given ElementState bit might be relied upon by a
     /// selector of some rule in the stylist.
     pub fn might_have_state_dependency(&self, state: ElementState) -> bool {
-        if self.is_cleared || self.is_device_dirty {
-            // If self.is_cleared is true, we can't tell what states our style
-            // rules rely on until we rebuild.
+        if self.any_origin_cleared() || self.is_device_dirty {
+            // We can't tell what states our style rules rely on until
+            // we rebuild.
             true
         } else {
             self.has_state_dependency(state)
         }
     }
 
     /// Returns whether the given ElementState bit is relied upon by a selector
     /// of some rule in the stylist.
     pub fn has_state_dependency(&self, state: ElementState) -> bool {
         self.cascade_data
             .iter_origins()
-            .any(|d| d.state_dependencies.intersects(state))
+            .any(|(d, _)| d.state_dependencies.intersects(state))
     }
 
     /// Computes the style for a given "precomputed" pseudo-element, taking the
     /// universal rules and applying them.
     ///
     /// If `inherit_all` is true, then all properties are inherited from the
     /// parent; otherwise, non-inherited properties are reset to their initial
     /// values. The flow constructor uses this flag when constructing anonymous
@@ -847,33 +809,39 @@ impl Stylist {
                             Some(layout_parent_style),
                             visited_values,
                             None,
                             font_metrics,
                             cascade_flags,
                             self.quirks_mode)
     }
 
+    fn has_rules_for_pseudo(&self, pseudo: &PseudoElement) -> bool {
+        self.cascade_data
+            .iter_origins()
+            .any(|(d, _)| d.has_rules_for_pseudo(pseudo))
+    }
+
     /// Computes the cascade inputs for a lazily-cascaded pseudo-element.
     ///
     /// See the documentation on lazy pseudo-elements in
     /// docs/components/style.md
     pub fn lazy_pseudo_rules<E>(&self,
                                 guards: &StylesheetGuards,
                                 element: &E,
                                 pseudo: &PseudoElement,
                                 is_probe: bool,
                                 rule_inclusion: RuleInclusion)
                                 -> CascadeInputs
         where E: TElement
     {
         let pseudo = pseudo.canonical();
         debug_assert!(pseudo.is_lazy());
 
-        if !self.cascade_data.has_rules_for_pseudo(&pseudo) {
+        if !self.has_rules_for_pseudo(&pseudo) {
             return CascadeInputs::default()
         }
 
         // Apply the selector flags. We should be in sequential mode
         // already, so we can directly apply the parent flags.
         let mut set_selector_flags = |element: &E, flags: ElementSelectorFlags| {
             if cfg!(feature = "servo") {
                 // Servo calls this function from the worker, but only for internal
@@ -1026,18 +994,24 @@ impl Stylist {
         use invalidation::media_queries::PotentiallyEffectiveMediaRules;
 
         debug!("Stylist::media_features_change_changed_style");
 
         for stylesheet in stylesheets {
             let effective_now =
                 stylesheet.is_effective_for_device(&self.device, guard);
 
+            let origin = stylesheet.origin(guard);
+            let origin_cascade_data =
+                self.cascade_data.borrow_for_origin(&origin);
+
             let effective_then =
-                self.effective_media_query_results.was_effective(stylesheet);
+                origin_cascade_data
+                    .effective_media_query_results
+                    .was_effective(stylesheet);
 
             if effective_now != effective_then {
                 debug!(" > Stylesheet changed -> {}, {}",
                        effective_then, effective_now);
                 return true
             }
 
             if !effective_now {
@@ -1066,34 +1040,38 @@ impl Stylist {
                         continue;
                     }
                     CssRule::Import(ref lock) => {
                         let import_rule = lock.read_with(guard);
                         let effective_now =
                             import_rule.stylesheet
                                 .is_effective_for_device(&self.device, guard);
                         let effective_then =
-                            self.effective_media_query_results.was_effective(import_rule);
+                            origin_cascade_data
+                                .effective_media_query_results
+                                .was_effective(import_rule);
                         if effective_now != effective_then {
                             debug!(" > @import rule changed {} -> {}",
                                    effective_then, effective_now);
                             return true;
                         }
 
                         if !effective_now {
                             iter.skip_children();
                         }
                     }
                     CssRule::Media(ref lock) => {
                         let media_rule = lock.read_with(guard);
                         let mq = media_rule.media_queries.read_with(guard);
                         let effective_now =
                             mq.evaluate(&self.device, self.quirks_mode);
                         let effective_then =
-                            self.effective_media_query_results.was_effective(media_rule);
+                            origin_cascade_data
+                                .effective_media_query_results
+                                .was_effective(media_rule);
                         if effective_now != effective_then {
                             debug!(" > @media rule changed {} -> {}",
                                    effective_then, effective_now);
                             return true;
                         }
 
                         if !effective_now {
                             iter.skip_children();
@@ -1319,32 +1297,32 @@ impl Stylist {
     }
 
     /// Given an id, returns whether there might be any rules for that id in any
     /// of our rule maps.
     #[inline]
     pub fn may_have_rules_for_id(&self, id: &Atom) -> bool {
         self.cascade_data
             .iter_origins()
-            .any(|d| d.mapped_ids.might_contain_hash(id.get_hash()))
+            .any(|(d, _)| d.mapped_ids.might_contain_hash(id.get_hash()))
     }
 
     /// Return whether the device is dirty, that is, whether the screen size or
     /// media type have changed (for now).
     #[inline]
     pub fn is_device_dirty(&self) -> bool {
         self.is_device_dirty
     }
 
     /// Returns the registered `@keyframes` animation for the specified name.
     #[inline]
     pub fn get_animation(&self, name: &Atom) -> Option<&KeyframesAnimation> {
         self.cascade_data
             .iter_origins()
-            .filter_map(|d| d.animations.get(name))
+            .filter_map(|(d, _)| d.animations.get(name))
             .next()
     }
 
     /// Computes the match results of a given element against the set of
     /// revalidation selectors.
     pub fn match_revalidation_selectors<E, F>(&self,
                                               element: &E,
                                               bloom: Option<&BloomFilter>,
@@ -1359,18 +1337,18 @@ impl Stylist {
             MatchingContext::new(MatchingMode::Normal, bloom, self.quirks_mode);
 
         // Note that, by the time we're revalidating, we're guaranteed that the
         // candidate and the entry have the same id, classes, and local name.
         // This means we're guaranteed to get the same rulehash buckets for all
         // the lookups, which means that the bitvecs are comparable. We verify
         // this in the caller by asserting that the bitvecs are same-length.
         let mut results = BitVec::new();
-        for origin_cascade_data in self.cascade_data.iter_origins() {
-            origin_cascade_data.selectors_for_cache_revalidation.lookup(
+        for (data, _) in self.cascade_data.iter_origins() {
+            data.selectors_for_cache_revalidation.lookup(
                 *element, self.quirks_mode, &mut |selector_and_hashes| {
                     results.push(matches_selector(&selector_and_hashes.selector,
                                                   selector_and_hashes.selector_offset,
                                                   Some(&selector_and_hashes.hashes),
                                                   element,
                                                   &mut matching_context,
                                                   flags_setter));
                     true
@@ -1426,16 +1404,54 @@ impl Stylist {
     }
 
     /// Accessor for a shared reference to the rule tree.
     pub fn rule_tree(&self) -> &RuleTree {
         &self.rule_tree
     }
 }
 
+/// This struct holds data which users of Stylist may want to extract
+/// from stylesheets which can be done at the same time as updating.
+#[derive(Default)]
+pub struct ExtraStyleData {
+    /// A list of effective font-face rules and their origin.
+    #[cfg(feature = "gecko")]
+    pub font_faces: Vec<Arc<Locked<FontFaceRule>>>,
+
+    /// A map of effective counter-style rules.
+    #[cfg(feature = "gecko")]
+    pub counter_styles: PrecomputedHashMap<Atom, Arc<Locked<CounterStyleRule>>>,
+}
+
+#[cfg(feature = "gecko")]
+impl ExtraStyleData {
+    /// Add the given @font-face rule.
+    fn add_font_face(&mut self, rule: &Arc<Locked<FontFaceRule>>) {
+        self.font_faces.push(rule.clone());
+    }
+
+    /// Add the given @counter-style rule.
+    fn add_counter_style(&mut self, guard: &SharedRwLockReadGuard,
+                         rule: &Arc<Locked<CounterStyleRule>>) {
+        let name = rule.read_with(guard).mName.raw::<nsIAtom>().into();
+        self.counter_styles.insert(name, rule.clone());
+    }
+}
+
+impl PerOriginClear for ExtraStyleData {
+    fn clear(&mut self) {
+        #[cfg(feature = "gecko")]
+        {
+            self.font_faces.clear();
+            self.counter_styles.clear();
+        }
+    }
+}
+
 /// SelectorMapEntry implementation for use in our revalidation selector map.
 #[derive(Clone, Debug)]
 struct RevalidationSelectorAndHashes {
     selector: Selector<SelectorImpl>,
     selector_offset: usize,
     hashes: AncestorHashes,
 }
 
@@ -1594,121 +1610,21 @@ impl<'a> SelectorVisitor for StylistSele
             }
             _ => {},
         }
 
         true
     }
 }
 
-/// Data resulting from performing the CSS cascade.
-#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
-#[derive(Debug)]
-struct CascadeData {
-    /// Rules from user agent stylesheets
-    user_agent: PerOriginCascadeData,
-    /// Rules from author stylesheets
-    author: PerOriginCascadeData,
-    /// Rules from user stylesheets
-    user: PerOriginCascadeData,
-}
-
-impl CascadeData {
-    fn new() -> Self {
-        CascadeData {
-            user_agent: PerOriginCascadeData::new(),
-            author: PerOriginCascadeData::new(),
-            user: PerOriginCascadeData::new(),
-        }
-    }
-
-    #[inline]
-    fn borrow_mut_for_origin(&mut self, origin: &Origin) -> &mut PerOriginCascadeData {
-        match *origin {
-            Origin::UserAgent => &mut self.user_agent,
-            Origin::Author => &mut self.author,
-            Origin::User => &mut self.user,
-        }
-    }
-
-    fn clear(&mut self) {
-        self.user_agent.clear();
-        self.author.clear();
-        self.user.clear();
-    }
-
-    fn has_rules_for_pseudo(&self, pseudo: &PseudoElement) -> bool {
-        self.iter_origins().any(|d| d.has_rules_for_pseudo(pseudo))
-    }
-
-    fn iter_origins(&self) -> CascadeDataIter {
-        CascadeDataIter {
-            cascade_data: &self,
-            cur: 0,
-        }
-    }
-}
-
-/// Iterator over `PerOriginCascadeData`, from highest level (user) to lowest
-/// (user agent).
-///
-/// We rely on this specific order for correctly looking up animations
-/// (prioritizing rules at higher cascade levels), among other things.
-struct CascadeDataIter<'a> {
-    cascade_data: &'a CascadeData,
-    cur: usize,
-}
-
-impl<'a> Iterator for CascadeDataIter<'a> {
-    type Item = &'a PerOriginCascadeData;
-
-    fn next(&mut self) -> Option<&'a PerOriginCascadeData> {
-        let result = match self.cur {
-            0 => &self.cascade_data.user,
-            1 => &self.cascade_data.author,
-            2 => &self.cascade_data.user_agent,
-            _ => return None,
-        };
-        self.cur += 1;
-        Some(result)
-    }
-}
-
-/// Iterator over `PerOriginExtraStyleData`, from highest level (user) to lowest
-/// (user agent).
-///
-/// We rely on this specific order for correctly looking up the @font-face
-/// and @counter-style rules.
-#[cfg(feature = "gecko")]
-pub struct ExtraStyleDataIter<'a> {
-    extra_style_data: &'a ExtraStyleData,
-    cur: usize,
-}
-
-#[cfg(feature = "gecko")]
-impl<'a> Iterator for ExtraStyleDataIter<'a> {
-    type Item = (&'a PerOriginExtraStyleData, Origin);
-
-    fn next(&mut self) -> Option<(&'a PerOriginExtraStyleData, Origin)> {
-        let result = match self.cur {
-            0 => (&self.extra_style_data.user, Origin::User),
-            1 => (&self.extra_style_data.author, Origin::Author),
-            2 => (&self.extra_style_data.user_agent, Origin::UserAgent),
-            _ => return None,
-        };
-        self.cur += 1;
-        Some(result)
-    }
-}
-
 /// Data resulting from performing the CSS cascade that is specific to a given
 /// origin.
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 #[derive(Debug)]
-struct PerOriginCascadeData {
+struct CascadeData {
     /// Rules from stylesheets at this `CascadeData`'s origin.
     element_map: SelectorMap<Rule>,
 
     /// Rules from stylesheets at this `CascadeData`'s origin that correspond
     /// to a given pseudo-element.
     pseudos_map: PerPseudoElementMap<SelectorMap<Rule>>,
 
     /// A map with all the animations at this `CascadeData`'s origin, indexed
@@ -1746,64 +1662,94 @@ struct PerOriginCascadeData {
     mapped_ids: NonCountingBloomFilter,
 
     /// Selectors that require explicit cache revalidation (i.e. which depend
     /// on state that is not otherwise visible to the cache, like attributes or
     /// tree-structural state like child index and pseudos).
     #[cfg_attr(feature = "servo", ignore_heap_size_of = "Arc")]
     selectors_for_cache_revalidation: SelectorMap<RevalidationSelectorAndHashes>,
 
+    /// Effective media query results cached from the last rebuild.
+    effective_media_query_results: EffectiveMediaQueryResults,
+
+    /// A monotonically increasing counter to represent the order on which a
+    /// style rule appears in a stylesheet, needed to sort them by source order.
+    rules_source_order: u32,
+
     /// The total number of selectors.
     num_selectors: usize,
 
     /// The total number of declarations.
     num_declarations: usize,
+
+    /// If true, the `CascadeData` is in a cleared state (e.g. just-constructed,
+    /// or had `clear()` called on it with no following `rebuild()` on the
+    /// `Stylist`).
+    is_cleared: bool,
 }
 
-impl PerOriginCascadeData {
+impl CascadeData {
     fn new() -> Self {
         Self {
             element_map: SelectorMap::new(),
             pseudos_map: PerPseudoElementMap::default(),
             animations: Default::default(),
             invalidation_map: InvalidationMap::new(),
             attribute_dependencies: NonCountingBloomFilter::new(),
             style_attribute_dependency: false,
             state_dependencies: ElementState::empty(),
             mapped_ids: NonCountingBloomFilter::new(),
             selectors_for_cache_revalidation: SelectorMap::new(),
+            effective_media_query_results: EffectiveMediaQueryResults::new(),
+            rules_source_order: 0,
             num_selectors: 0,
             num_declarations: 0,
+            is_cleared: true,
         }
     }
 
     #[inline]
     fn borrow_for_pseudo(&self, pseudo: Option<&PseudoElement>) -> Option<&SelectorMap<Rule>> {
         match pseudo {
             Some(pseudo) => self.pseudos_map.get(&pseudo.canonical()),
             None => Some(&self.element_map),
         }
     }
 
+    fn has_rules_for_pseudo(&self, pseudo: &PseudoElement) -> bool {
+        self.pseudos_map.get(pseudo).is_some()
+    }
+}
+
+impl PerOriginClear for CascadeData {
     fn clear(&mut self) {
+        if self.is_cleared {
+            return;
+        }
+
         self.element_map = SelectorMap::new();
         self.pseudos_map = Default::default();
         self.animations = Default::default();
         self.invalidation_map.clear();
         self.attribute_dependencies.clear();
         self.style_attribute_dependency = false;
         self.state_dependencies = ElementState::empty();
         self.mapped_ids.clear();
         self.selectors_for_cache_revalidation = SelectorMap::new();
+        self.effective_media_query_results.clear();
+        self.rules_source_order = 0;
         self.num_selectors = 0;
         self.num_declarations = 0;
+        self.is_cleared = true;
     }
+}
 
-    fn has_rules_for_pseudo(&self, pseudo: &PseudoElement) -> bool {
-        self.pseudos_map.get(pseudo).is_some()
+impl Default for CascadeData {
+    fn default() -> Self {
+        CascadeData::new()
     }
 }
 
 /// A rule, that wraps a style rule, but represents a single selector of the
 /// rule.
 #[cfg_attr(feature = "servo", derive(HeapSizeOf))]
 #[derive(Clone, Debug)]
 pub struct Rule {
--- a/servo/ports/geckolib/glue.rs
+++ b/servo/ports/geckolib/glue.rs
@@ -69,16 +69,20 @@ use style::gecko_bindings::bindings::nsT
 use style::gecko_bindings::structs;
 use style::gecko_bindings::structs::{CSSPseudoElementType, CompositeOperation, Loader};
 use style::gecko_bindings::structs::{RawServoStyleRule, ServoStyleContextStrong};
 use style::gecko_bindings::structs::{ServoStyleSheet, SheetParsingMode, nsIAtom, nsCSSPropertyID};
 use style::gecko_bindings::structs::{nsCSSFontFaceRule, nsCSSCounterStyleRule};
 use style::gecko_bindings::structs::{nsRestyleHint, nsChangeHint, PropertyValuePair};
 use style::gecko_bindings::structs::IterationCompositeOperation;
 use style::gecko_bindings::structs::MallocSizeOf;
+use style::gecko_bindings::structs::OriginFlags;
+use style::gecko_bindings::structs::OriginFlags_Author;
+use style::gecko_bindings::structs::OriginFlags_User;
+use style::gecko_bindings::structs::OriginFlags_UserAgent;
 use style::gecko_bindings::structs::RawGeckoGfxMatrix4x4;
 use style::gecko_bindings::structs::RawGeckoPresContextOwned;
 use style::gecko_bindings::structs::SeenPtrs;
 use style::gecko_bindings::structs::ServoElementSnapshotTable;
 use style::gecko_bindings::structs::ServoTraversalFlags;
 use style::gecko_bindings::structs::StyleRuleInclusion;
 use style::gecko_bindings::structs::URLExtraData;
 use style::gecko_bindings::structs::nsCSSValueSharedList;
@@ -109,16 +113,17 @@ use style::sequential;
 use style::shared_lock::{SharedRwLockReadGuard, StylesheetGuards, ToCssWithGuard, Locked};
 use style::string_cache::Atom;
 use style::style_adjuster::StyleAdjuster;
 use style::stylesheets::{CssRule, CssRules, CssRuleType, CssRulesHelpers, DocumentRule};
 use style::stylesheets::{FontFeatureValuesRule, ImportRule, KeyframesRule, MallocSizeOfWithGuard};
 use style::stylesheets::{MallocSizeOfWithRepeats, MediaRule};
 use style::stylesheets::{NamespaceRule, Origin, PageRule, SizeOfState, StyleRule, SupportsRule};
 use style::stylesheets::StylesheetContents;
+use style::stylesheets::StylesheetInDocument;
 use style::stylesheets::StylesheetLoader as StyleStylesheetLoader;
 use style::stylesheets::keyframes_rule::{Keyframe, KeyframeSelector, KeyframesStepValue};
 use style::stylesheets::supports_rule::parse_condition_or_declaration;
 use style::stylist::RuleInclusion;
 use style::thread_state;
 use style::timer::Timer;
 use style::traversal::{DomTraversal, TraversalDriver};
 use style::traversal::resolve_style;
@@ -840,22 +845,20 @@ pub extern "C" fn Servo_StyleSheet_FromU
 pub extern "C" fn Servo_StyleSet_AppendStyleSheet(
     raw_data: RawServoStyleSetBorrowed,
     sheet: *const ServoStyleSheet,
 ) {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
     let mut data = &mut *data;
     let guard = global_style_data.shared_lock.read();
-    data.stylesheets.append_stylesheet(
-        &data.stylist,
-        unsafe { GeckoStyleSheet::new(sheet) },
-        &guard
-    );
-    data.clear_stylist();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    let origin = sheet.contents(&guard).origin;
+    data.stylesheets.append_stylesheet(&data.stylist, sheet, &guard);
+    data.clear_stylist_origin(&origin);
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_StyleSet_MediumFeaturesChanged(
     raw_data: RawServoStyleSetBorrowed,
     viewport_units_used: *mut bool,
 ) -> bool {
     let global_style_data = &*GLOBAL_STYLE_DATA;
@@ -889,58 +892,56 @@ pub extern "C" fn Servo_StyleSet_MediumF
 pub extern "C" fn Servo_StyleSet_PrependStyleSheet(
     raw_data: RawServoStyleSetBorrowed,
     sheet: *const ServoStyleSheet,
 ) {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
     let mut data = &mut *data;
     let guard = global_style_data.shared_lock.read();
-    data.stylesheets.prepend_stylesheet(
-        &data.stylist,
-        unsafe { GeckoStyleSheet::new(sheet) },
-        &guard,
-    );
-    data.clear_stylist();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    let origin = sheet.contents(&guard).origin;
+    data.stylesheets.prepend_stylesheet(&data.stylist, sheet, &guard);
+    data.clear_stylist_origin(&origin);
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_StyleSet_InsertStyleSheetBefore(
     raw_data: RawServoStyleSetBorrowed,
     sheet: *const ServoStyleSheet,
     before_sheet: *const ServoStyleSheet
 ) {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
     let mut data = &mut *data;
     let guard = global_style_data.shared_lock.read();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    let origin = sheet.contents(&guard).origin;
     data.stylesheets.insert_stylesheet_before(
         &data.stylist,
-        unsafe { GeckoStyleSheet::new(sheet) },
+        sheet,
         unsafe { GeckoStyleSheet::new(before_sheet) },
         &guard,
     );
-    data.clear_stylist();
+    data.clear_stylist_origin(&origin);
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_StyleSet_RemoveStyleSheet(
     raw_data: RawServoStyleSetBorrowed,
     sheet: *const ServoStyleSheet
 ) {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
     let mut data = &mut *data;
     let guard = global_style_data.shared_lock.read();
-    data.stylesheets.remove_stylesheet(
-        &data.stylist,
-        unsafe { GeckoStyleSheet::new(sheet) },
-        &guard,
-    );
-    data.clear_stylist();
+    let sheet = unsafe { GeckoStyleSheet::new(sheet) };
+    let origin = sheet.contents(&guard).origin;
+    data.stylesheets.remove_stylesheet(&data.stylist, sheet, &guard);
+    data.clear_stylist_origin(&origin);
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_StyleSet_FlushStyleSheets(
     raw_data: RawServoStyleSetBorrowed,
     doc_element: RawGeckoElementBorrowedOrNull,
 ) {
     let global_style_data = &*GLOBAL_STYLE_DATA;
@@ -949,21 +950,24 @@ pub extern "C" fn Servo_StyleSet_FlushSt
     let doc_element = doc_element.map(GeckoElement);
     data.flush_stylesheets(&guard, doc_element);
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_StyleSet_NoteStyleSheetsChanged(
     raw_data: RawServoStyleSetBorrowed,
     author_style_disabled: bool,
+    changed_origins: OriginFlags,
 ) {
     let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
-    data.stylesheets.force_dirty();
+    for origin in changed_origins.iter() {
+        data.stylesheets.force_dirty_origin(&origin);
+        data.clear_stylist_origin(&origin);
+    }
     data.stylesheets.set_author_style_disabled(author_style_disabled);
-    data.clear_stylist();
 }
 
 #[no_mangle]
 pub extern "C" fn Servo_StyleSheet_HasRules(
     raw_contents: RawServoStyleSheetContentsBorrowed
 ) -> bool {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let guard = global_style_data.shared_lock.read();
@@ -1003,16 +1007,27 @@ pub extern "C" fn Servo_StyleSheet_SizeO
 ) -> usize {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let guard = global_style_data.shared_lock.read();
     let malloc_size_of = malloc_size_of.unwrap();
     StylesheetContents::as_arc(&sheet)
         .malloc_size_of_children(&guard, malloc_size_of)
 }
 
+#[no_mangle]
+pub extern "C" fn Servo_StyleSheet_GetOrigin(
+    sheet: RawServoStyleSheetContentsBorrowed
+) -> OriginFlags {
+    match StylesheetContents::as_arc(&sheet).origin {
+        Origin::UserAgent => OriginFlags_UserAgent,
+        Origin::User => OriginFlags_User,
+        Origin::Author => OriginFlags_Author,
+    }
+}
+
 fn read_locked_arc<T, R, F>(raw: &<Locked<T> as HasFFI>::FFIType, func: F) -> R
     where Locked<T>: HasArcFFI, F: FnOnce(&T) -> R
 {
     let global_style_data = &*GLOBAL_STYLE_DATA;
     let guard = global_style_data.shared_lock.read();
     func(Locked::<T>::as_arc(&raw).read_with(&guard))
 }
 
--- a/testing/web-platform/meta/selection/addRange-00.html.ini
+++ b/testing/web-platform/meta/selection/addRange-00.html.ini
@@ -1,1966 +1,10 @@
 [addRange-00.html]
   type: testharness
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 4 [paras[1\].firstChild, 0, paras[1\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 5 [paras[1\].firstChild, 0, paras[1\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 6 [paras[1\].firstChild, 2, paras[1\].firstChild, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 7 [paras[1\].firstChild, 2, paras[1\].firstChild, 9\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 30 [testDiv, 2, paras[4\], 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 31 [testDiv, 1, paras[2\].firstChild, 5\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 34 [document, 0, document, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 34 [document, 0, document, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 38 [paras[2\].firstChild, 4, comment, 2\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 39 [paras[3\], 1, comment, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 4 [paras[1\].firstChild, 0, paras[1\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 5 [paras[1\].firstChild, 0, paras[1\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 6 [paras[1\].firstChild, 2, paras[1\].firstChild, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 7 [paras[1\].firstChild, 2, paras[1\].firstChild, 9\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 30 [testDiv, 2, paras[4\], 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 31 [testDiv, 1, paras[2\].firstChild, 5\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 34 [document, 0, document, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 34 [document, 0, document, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 38 [paras[2\].firstChild, 4, comment, 2\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\] followed by Range 39 [paras[3\], 1, comment, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 4 [paras[1\].firstChild, 0, paras[1\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 5 [paras[1\].firstChild, 0, paras[1\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 6 [paras[1\].firstChild, 2, paras[1\].firstChild, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 7 [paras[1\].firstChild, 2, paras[1\].firstChild, 9\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 30 [testDiv, 2, paras[4\], 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 31 [testDiv, 1, paras[2\].firstChild, 5\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 34 [document, 0, document, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 34 [document, 0, document, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 38 [paras[2\].firstChild, 4, comment, 2\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 2 [paras[0\].firstChild, 2, paras[0\].firstChild, 8\] followed by Range 39 [paras[3\], 1, comment, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 1 [paras[0\].firstChild, 0, paras[0\].firstChild, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 4 [paras[1\].firstChild, 0, paras[1\].firstChild, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 5 [paras[1\].firstChild, 0, paras[1\].firstChild, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 6 [paras[1\].firstChild, 2, paras[1\].firstChild, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 7 [paras[1\].firstChild, 2, paras[1\].firstChild, 9\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 14 [document.documentElement, 0, document.documentElement, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 17 [document.head, 1, document.head, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 17 [document.head, 1, document.head, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 22 [paras[0\], 0, paras[0\], 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 30 [testDiv, 2, paras[4\], 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 31 [testDiv, 1, paras[2\].firstChild, 5\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 32 [document.documentElement, 1, document.body, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 34 [document, 0, document, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 34 [document, 0, document, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 34 [document, 0, document, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 38 [paras[2\].firstChild, 4, comment, 2\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 3 [paras[0\].firstChild, 2, paras[0\].firstChild, 9\] followed by Range 39 [paras[3\], 1, comment, 8\]: second addRange() must result in rangeCount being 1]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 8 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 8 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 8 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 8 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 9 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 9 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 9 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 9 [detachedPara1.firstChild, 0, detachedPara1.firstChild, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 10 [detachedPara1.firstChild, 2, detachedPara1.firstChild, 8\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 10 [detachedPara1.firstChild, 2, detachedPara1.firstChild, 8\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 10 [detachedPara1.firstChild, 2, detachedPara1.firstChild, 8\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 10 [detachedPara1.firstChild, 2, detachedPara1.firstChild, 8\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 11 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 11 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 11 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 11 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 12 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 12 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 12 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 12 [foreignPara1.firstChild, 0, foreignPara1.firstChild, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 13 [foreignPara1.firstChild, 2, foreignPara1.firstChild, 8\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 13 [foreignPara1.firstChild, 2, foreignPara1.firstChild, 8\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 13 [foreignPara1.firstChild, 2, foreignPara1.firstChild, 8\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 13 [foreignPara1.firstChild, 2, foreignPara1.firstChild, 8\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 19 [foreignDoc.documentElement, 0, foreignDoc.documentElement, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 19 [foreignDoc.documentElement, 0, foreignDoc.documentElement, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 19 [foreignDoc.documentElement, 0, foreignDoc.documentElement, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 19 [foreignDoc.documentElement, 0, foreignDoc.documentElement, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 20 [foreignDoc.head, 1, foreignDoc.head, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 20 [foreignDoc.head, 1, foreignDoc.head, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 20 [foreignDoc.head, 1, foreignDoc.head, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 20 [foreignDoc.head, 1, foreignDoc.head, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 21 [foreignDoc.body, 0, foreignDoc.body, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 21 [foreignDoc.body, 0, foreignDoc.body, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 21 [foreignDoc.body, 0, foreignDoc.body, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 21 [foreignDoc.body, 0, foreignDoc.body, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 24 [detachedPara1, 0, detachedPara1, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 24 [detachedPara1, 0, detachedPara1, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 24 [detachedPara1, 0, detachedPara1, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 24 [detachedPara1, 0, detachedPara1, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 25 [detachedPara1, 0, detachedPara1, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 25 [detachedPara1, 0, detachedPara1, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 25 [detachedPara1, 0, detachedPara1, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 25 [detachedPara1, 0, detachedPara1, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 33 [foreignDoc.documentElement, 1, foreignDoc.body, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 33 [foreignDoc.documentElement, 1, foreignDoc.body, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 33 [foreignDoc.documentElement, 1, foreignDoc.body, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 33 [foreignDoc.documentElement, 1, foreignDoc.body, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 40 [foreignDoc, 0, foreignDoc, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 40 [foreignDoc, 0, foreignDoc, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 40 [foreignDoc, 0, foreignDoc, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 40 [foreignDoc, 0, foreignDoc, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 41 [foreignDoc, 1, foreignComment, 2\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 41 [foreignDoc, 1, foreignComment, 2\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 41 [foreignDoc, 1, foreignComment, 2\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 41 [foreignDoc, 1, foreignComment, 2\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 42 [foreignDoc.body, 0, foreignTextNode, 36\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 42 [foreignDoc.body, 0, foreignTextNode, 36\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 42 [foreignDoc.body, 0, foreignTextNode, 36\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 42 [foreignDoc.body, 0, foreignTextNode, 36\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 43 [xmlDoc, 0, xmlDoc, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 43 [xmlDoc, 0, xmlDoc, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 43 [xmlDoc, 0, xmlDoc, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 43 [xmlDoc, 0, xmlDoc, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 44 [xmlDoc, 1, xmlComment, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 44 [xmlDoc, 1, xmlComment, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 44 [xmlDoc, 1, xmlComment, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 44 [xmlDoc, 1, xmlComment, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 45 [detachedTextNode, 0, detachedTextNode, 8\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 45 [detachedTextNode, 0, detachedTextNode, 8\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 45 [detachedTextNode, 0, detachedTextNode, 8\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 45 [detachedTextNode, 0, detachedTextNode, 8\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 46 [detachedForeignTextNode, 7, detachedForeignTextNode, 7\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 46 [detachedForeignTextNode, 7, detachedForeignTextNode, 7\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 46 [detachedForeignTextNode, 7, detachedForeignTextNode, 7\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 46 [detachedForeignTextNode, 7, detachedForeignTextNode, 7\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 47 [detachedForeignTextNode, 0, detachedForeignTextNode, 8\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 47 [detachedForeignTextNode, 0, detachedForeignTextNode, 8\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 47 [detachedForeignTextNode, 0, detachedForeignTextNode, 8\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 47 [detachedForeignTextNode, 0, detachedForeignTextNode, 8\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 48 [detachedXmlTextNode, 7, detachedXmlTextNode, 7\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 48 [detachedXmlTextNode, 7, detachedXmlTextNode, 7\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 48 [detachedXmlTextNode, 7, detachedXmlTextNode, 7\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 48 [detachedXmlTextNode, 7, detachedXmlTextNode, 7\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 49 [detachedXmlTextNode, 0, detachedXmlTextNode, 8\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 49 [detachedXmlTextNode, 0, detachedXmlTextNode, 8\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 49 [detachedXmlTextNode, 0, detachedXmlTextNode, 8\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 49 [detachedXmlTextNode, 0, detachedXmlTextNode, 8\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 50 [detachedComment, 3, detachedComment, 4\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 50 [detachedComment, 3, detachedComment, 4\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 50 [detachedComment, 3, detachedComment, 4\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 50 [detachedComment, 3, detachedComment, 4\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 51 [detachedComment, 5, detachedComment, 5\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 51 [detachedComment, 5, detachedComment, 5\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 51 [detachedComment, 5, detachedComment, 5\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 51 [detachedComment, 5, detachedComment, 5\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 52 [detachedForeignComment, 0, detachedForeignComment, 1\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 52 [detachedForeignComment, 0, detachedForeignComment, 1\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 52 [detachedForeignComment, 0, detachedForeignComment, 1\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 52 [detachedForeignComment, 0, detachedForeignComment, 1\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 53 [detachedForeignComment, 4, detachedForeignComment, 4\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 53 [detachedForeignComment, 4, detachedForeignComment, 4\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 53 [detachedForeignComment, 4, detachedForeignComment, 4\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 53 [detachedForeignComment, 4, detachedForeignComment, 4\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 54 [detachedXmlComment, 2, detachedXmlComment, 6\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 54 [detachedXmlComment, 2, detachedXmlComment, 6\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 54 [detachedXmlComment, 2, detachedXmlComment, 6\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 54 [detachedXmlComment, 2, detachedXmlComment, 6\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 55 [docfrag, 0, docfrag, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 55 [docfrag, 0, docfrag, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 55 [docfrag, 0, docfrag, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 55 [docfrag, 0, docfrag, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 56 [foreignDocfrag, 0, foreignDocfrag, 0\]: second addRange() must result in the selection's last range having the specified endpoints]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 56 [foreignDocfrag, 0, foreignDocfrag, 0\]: second addRange() must result in the selection's last range being the same object we added]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 56 [foreignDocfrag, 0, foreignDocfrag, 0\]: modifying the second added range must modify the Selection's last Range]
-    expected: FAIL
-
-  [Range 0 [paras[0\].firstChild, 0, paras[0\].firstChild, 0\] followed by Range 56 [foreignDocfrag, 0, foreignDocfrag, 0\]: modifying the Selection's last Range must modify the second added Range]
-    expected: FAIL
-